@budiauktioner/buildi-primitives 0.1.1 → 0.2.1

package/dist/cjs/measurement/data-size-unit.js

@@ -0,0 +1,208 @@
+"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 data_size_unit_exports = {};
+__export(data_size_unit_exports, {
+  DataSizeUnit: () => DataSizeUnit
+});
+module.exports = __toCommonJS(data_size_unit_exports);
+var import_decimal = require("../internal/decimal.js");
+var import_measurement_unit = require("../internal/measurement-unit.js");
+function factor(literal) {
+  const parsed = import_decimal.Decimal.parse(literal);
+  if (parsed === null) throw new Error(`Invalid conversion factor: ${literal}`);
+  return parsed;
+}
+class DataSizeUnit extends import_measurement_unit.MeasurementUnit {
+  static typeInfo = Object.freeze({
+    englishName: "Data Size Unit",
+    localizedName: "Datastorleksenhet",
+    emoji: "\u{1F4BE}",
+    sources: Object.freeze([])
+  });
+  static Byte = new DataSizeUnit({
+    symbol: "B",
+    englishName: "byte",
+    localizedName: "byte",
+    pluralEnglish: "bytes",
+    pluralSwedish: "byte",
+    toBaseUnitFactor: factor("1"),
+    aliases: ["byte", "bytes"]
+  });
+  static Kilobyte = new DataSizeUnit({
+    symbol: "KB",
+    englishName: "kilobyte",
+    localizedName: "kilobyte",
+    pluralEnglish: "kilobytes",
+    pluralSwedish: "kilobyte",
+    toBaseUnitFactor: factor("1000"),
+    aliases: ["kilobyte", "kilobytes"]
+  });
+  static Megabyte = new DataSizeUnit({
+    symbol: "MB",
+    englishName: "megabyte",
+    localizedName: "megabyte",
+    pluralEnglish: "megabytes",
+    pluralSwedish: "megabyte",
+    toBaseUnitFactor: factor("1000000"),
+    aliases: ["megabyte", "megabytes"]
+  });
+  static Gigabyte = new DataSizeUnit({
+    symbol: "GB",
+    englishName: "gigabyte",
+    localizedName: "gigabyte",
+    pluralEnglish: "gigabytes",
+    pluralSwedish: "gigabyte",
+    toBaseUnitFactor: factor("1000000000"),
+    aliases: ["gigabyte", "gigabytes"]
+  });
+  static Terabyte = new DataSizeUnit({
+    symbol: "TB",
+    englishName: "terabyte",
+    localizedName: "terabyte",
+    pluralEnglish: "terabytes",
+    pluralSwedish: "terabyte",
+    toBaseUnitFactor: factor("1000000000000"),
+    aliases: ["terabyte", "terabytes"]
+  });
+  static Petabyte = new DataSizeUnit({
+    symbol: "PB",
+    englishName: "petabyte",
+    localizedName: "petabyte",
+    pluralEnglish: "petabytes",
+    pluralSwedish: "petabyte",
+    toBaseUnitFactor: factor("1000000000000000"),
+    aliases: ["petabyte", "petabytes"]
+  });
+  static Exabyte = new DataSizeUnit({
+    symbol: "EB",
+    englishName: "exabyte",
+    localizedName: "exabyte",
+    pluralEnglish: "exabytes",
+    pluralSwedish: "exabyte",
+    toBaseUnitFactor: factor("1000000000000000000"),
+    aliases: ["exabyte", "exabytes"]
+  });
+  static Kibibyte = new DataSizeUnit({
+    symbol: "KiB",
+    englishName: "kibibyte",
+    localizedName: "kibibyte",
+    pluralEnglish: "kibibytes",
+    pluralSwedish: "kibibyte",
+    toBaseUnitFactor: factor("1024"),
+    aliases: ["kibibyte", "kibibytes"]
+  });
+  static Mebibyte = new DataSizeUnit({
+    symbol: "MiB",
+    englishName: "mebibyte",
+    localizedName: "mebibyte",
+    pluralEnglish: "mebibytes",
+    pluralSwedish: "mebibyte",
+    toBaseUnitFactor: factor("1048576"),
+    aliases: ["mebibyte", "mebibytes"]
+  });
+  static Gibibyte = new DataSizeUnit({
+    symbol: "GiB",
+    englishName: "gibibyte",
+    localizedName: "gibibyte",
+    pluralEnglish: "gibibytes",
+    pluralSwedish: "gibibyte",
+    toBaseUnitFactor: factor("1073741824"),
+    aliases: ["gibibyte", "gibibytes"]
+  });
+  static Tebibyte = new DataSizeUnit({
+    symbol: "TiB",
+    englishName: "tebibyte",
+    localizedName: "tebibyte",
+    pluralEnglish: "tebibytes",
+    pluralSwedish: "tebibyte",
+    toBaseUnitFactor: factor("1099511627776"),
+    aliases: ["tebibyte", "tebibytes"]
+  });
+  static Pebibyte = new DataSizeUnit({
+    symbol: "PiB",
+    englishName: "pebibyte",
+    localizedName: "pebibyte",
+    pluralEnglish: "pebibytes",
+    pluralSwedish: "pebibyte",
+    toBaseUnitFactor: factor("1125899906842624"),
+    aliases: ["pebibyte", "pebibytes"]
+  });
+  static Exbibyte = new DataSizeUnit({
+    symbol: "EiB",
+    englishName: "exbibyte",
+    localizedName: "exbibyte",
+    pluralEnglish: "exbibytes",
+    pluralSwedish: "exbibyte",
+    toBaseUnitFactor: factor("1152921504606846976"),
+    aliases: ["exbibyte", "exbibytes"]
+  });
+  /** @internal Shared lookup and natural-scale walk. */
+  static index = new import_measurement_unit.MeasurementUnitIndex(
+    [
+      DataSizeUnit.Byte,
+      DataSizeUnit.Kilobyte,
+      DataSizeUnit.Megabyte,
+      DataSizeUnit.Gigabyte,
+      DataSizeUnit.Terabyte,
+      DataSizeUnit.Petabyte,
+      DataSizeUnit.Exabyte,
+      DataSizeUnit.Kibibyte,
+      DataSizeUnit.Mebibyte,
+      DataSizeUnit.Gibibyte,
+      DataSizeUnit.Tebibyte,
+      DataSizeUnit.Pebibyte,
+      DataSizeUnit.Exbibyte
+    ],
+    DataSizeUnit.Byte,
+    [
+      DataSizeUnit.Byte,
+      DataSizeUnit.Kilobyte,
+      DataSizeUnit.Megabyte,
+      DataSizeUnit.Gigabyte,
+      DataSizeUnit.Terabyte,
+      DataSizeUnit.Petabyte,
+      DataSizeUnit.Exabyte
+    ]
+  );
+  static get all() {
+    return DataSizeUnit.index.all;
+  }
+  /** The base unit: B. */
+  static get baseUnit() {
+    return DataSizeUnit.index.baseUnit;
+  }
+  /** Units ordered small to large, used to auto-scale display. */
+  static get naturalScale() {
+    return DataSizeUnit.index.naturalScale;
+  }
+  /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+  static tryParse(input) {
+    return DataSizeUnit.index.tryParse(input);
+  }
+  static parse(input) {
+    const result = DataSizeUnit.tryParse(input);
+    if (result === null) throw new Error("Unknown data size unit.");
+    return result;
+  }
+  /** Returns the most human-readable unit for a value in B. */
+  static getNatural(baseValue) {
+    return DataSizeUnit.index.getNatural(baseValue);
+  }
+}
+//# sourceMappingURL=data-size-unit.js.map

package/dist/cjs/measurement/data-size-unit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/data-size-unit.ts"],
+  "sourcesContent": ["import { Decimal } from \"../internal/decimal.js\";\nimport { MeasurementUnit, MeasurementUnitIndex } from \"../internal/measurement-unit.js\";\nimport type { PrimitiveTypeInfo } from \"../primitive-type-info.js\";\n\nfunction factor(literal: string): Decimal {\n  const parsed = Decimal.parse(literal);\n  /* c8 ignore next */\n  if (parsed === null) throw new Error(`Invalid conversion factor: ${literal}`);\n  return parsed;\n}\n\n/**\n * A unit of data size identified by its symbol.\n * Each unit carries English and Swedish names, singular and plural forms, and an\n * exact conversion factor to the base unit.\n */\nexport class DataSizeUnit extends MeasurementUnit {\n  declare private readonly __dataSizeUnitBrand: void;\n\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Data Size Unit\",\n    localizedName: \"Datastorleksenhet\",\n    emoji: \"\uD83D\uDCBE\",\n    sources: Object.freeze([]),\n  });\n\n  static readonly Byte = new DataSizeUnit({\n    symbol: \"B\",\n    englishName: \"byte\",\n    localizedName: \"byte\",\n    pluralEnglish: \"bytes\",\n    pluralSwedish: \"byte\",\n    toBaseUnitFactor: factor(\"1\"),\n    aliases: [\"byte\", \"bytes\"],\n  });\n\n  static readonly Kilobyte = new DataSizeUnit({\n    symbol: \"KB\",\n    englishName: \"kilobyte\",\n    localizedName: \"kilobyte\",\n    pluralEnglish: \"kilobytes\",\n    pluralSwedish: \"kilobyte\",\n    toBaseUnitFactor: factor(\"1000\"),\n    aliases: [\"kilobyte\", \"kilobytes\"],\n  });\n\n  static readonly Megabyte = new DataSizeUnit({\n    symbol: \"MB\",\n    englishName: \"megabyte\",\n    localizedName: \"megabyte\",\n    pluralEnglish: \"megabytes\",\n    pluralSwedish: \"megabyte\",\n    toBaseUnitFactor: factor(\"1000000\"),\n    aliases: [\"megabyte\", \"megabytes\"],\n  });\n\n  static readonly Gigabyte = new DataSizeUnit({\n    symbol: \"GB\",\n    englishName: \"gigabyte\",\n    localizedName: \"gigabyte\",\n    pluralEnglish: \"gigabytes\",\n    pluralSwedish: \"gigabyte\",\n    toBaseUnitFactor: factor(\"1000000000\"),\n    aliases: [\"gigabyte\", \"gigabytes\"],\n  });\n\n  static readonly Terabyte = new DataSizeUnit({\n    symbol: \"TB\",\n    englishName: \"terabyte\",\n    localizedName: \"terabyte\",\n    pluralEnglish: \"terabytes\",\n    pluralSwedish: \"terabyte\",\n    toBaseUnitFactor: factor(\"1000000000000\"),\n    aliases: [\"terabyte\", \"terabytes\"],\n  });\n\n  static readonly Petabyte = new DataSizeUnit({\n    symbol: \"PB\",\n    englishName: \"petabyte\",\n    localizedName: \"petabyte\",\n    pluralEnglish: \"petabytes\",\n    pluralSwedish: \"petabyte\",\n    toBaseUnitFactor: factor(\"1000000000000000\"),\n    aliases: [\"petabyte\", \"petabytes\"],\n  });\n\n  static readonly Exabyte = new DataSizeUnit({\n    symbol: \"EB\",\n    englishName: \"exabyte\",\n    localizedName: \"exabyte\",\n    pluralEnglish: \"exabytes\",\n    pluralSwedish: \"exabyte\",\n    toBaseUnitFactor: factor(\"1000000000000000000\"),\n    aliases: [\"exabyte\", \"exabytes\"],\n  });\n\n  static readonly Kibibyte = new DataSizeUnit({\n    symbol: \"KiB\",\n    englishName: \"kibibyte\",\n    localizedName: \"kibibyte\",\n    pluralEnglish: \"kibibytes\",\n    pluralSwedish: \"kibibyte\",\n    toBaseUnitFactor: factor(\"1024\"),\n    aliases: [\"kibibyte\", \"kibibytes\"],\n  });\n\n  static readonly Mebibyte = new DataSizeUnit({\n    symbol: \"MiB\",\n    englishName: \"mebibyte\",\n    localizedName: \"mebibyte\",\n    pluralEnglish: \"mebibytes\",\n    pluralSwedish: \"mebibyte\",\n    toBaseUnitFactor: factor(\"1048576\"),\n    aliases: [\"mebibyte\", \"mebibytes\"],\n  });\n\n  static readonly Gibibyte = new DataSizeUnit({\n    symbol: \"GiB\",\n    englishName: \"gibibyte\",\n    localizedName: \"gibibyte\",\n    pluralEnglish: \"gibibytes\",\n    pluralSwedish: \"gibibyte\",\n    toBaseUnitFactor: factor(\"1073741824\"),\n    aliases: [\"gibibyte\", \"gibibytes\"],\n  });\n\n  static readonly Tebibyte = new DataSizeUnit({\n    symbol: \"TiB\",\n    englishName: \"tebibyte\",\n    localizedName: \"tebibyte\",\n    pluralEnglish: \"tebibytes\",\n    pluralSwedish: \"tebibyte\",\n    toBaseUnitFactor: factor(\"1099511627776\"),\n    aliases: [\"tebibyte\", \"tebibytes\"],\n  });\n\n  static readonly Pebibyte = new DataSizeUnit({\n    symbol: \"PiB\",\n    englishName: \"pebibyte\",\n    localizedName: \"pebibyte\",\n    pluralEnglish: \"pebibytes\",\n    pluralSwedish: \"pebibyte\",\n    toBaseUnitFactor: factor(\"1125899906842624\"),\n    aliases: [\"pebibyte\", \"pebibytes\"],\n  });\n\n  static readonly Exbibyte = new DataSizeUnit({\n    symbol: \"EiB\",\n    englishName: \"exbibyte\",\n    localizedName: \"exbibyte\",\n    pluralEnglish: \"exbibytes\",\n    pluralSwedish: \"exbibyte\",\n    toBaseUnitFactor: factor(\"1152921504606846976\"),\n    aliases: [\"exbibyte\", \"exbibytes\"],\n  });\n\n  /** @internal Shared lookup and natural-scale walk. */\n  static readonly index: MeasurementUnitIndex<DataSizeUnit> =\n    new MeasurementUnitIndex<DataSizeUnit>(\n      [\n        DataSizeUnit.Byte,\n        DataSizeUnit.Kilobyte,\n        DataSizeUnit.Megabyte,\n        DataSizeUnit.Gigabyte,\n        DataSizeUnit.Terabyte,\n        DataSizeUnit.Petabyte,\n        DataSizeUnit.Exabyte,\n        DataSizeUnit.Kibibyte,\n        DataSizeUnit.Mebibyte,\n        DataSizeUnit.Gibibyte,\n        DataSizeUnit.Tebibyte,\n        DataSizeUnit.Pebibyte,\n        DataSizeUnit.Exbibyte,\n      ],\n      DataSizeUnit.Byte,\n      [\n        DataSizeUnit.Byte,\n        DataSizeUnit.Kilobyte,\n        DataSizeUnit.Megabyte,\n        DataSizeUnit.Gigabyte,\n        DataSizeUnit.Terabyte,\n        DataSizeUnit.Petabyte,\n        DataSizeUnit.Exabyte,\n      ],\n    );\n\n  static get all(): readonly DataSizeUnit[] {\n    return DataSizeUnit.index.all;\n  }\n\n  /** The base unit: B. */\n  static get baseUnit(): DataSizeUnit {\n    return DataSizeUnit.index.baseUnit;\n  }\n\n  /** Units ordered small to large, used to auto-scale display. */\n  static get naturalScale(): readonly DataSizeUnit[] {\n    return DataSizeUnit.index.naturalScale;\n  }\n\n  /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */\n  static tryParse(input: string | null | undefined): DataSizeUnit | null {\n    return DataSizeUnit.index.tryParse(input);\n  }\n\n  static parse(input: string): DataSizeUnit {\n    const result = DataSizeUnit.tryParse(input);\n    if (result === null) throw new Error(\"Unknown data size unit.\");\n    return result;\n  }\n\n  /** Returns the most human-readable unit for a value in B. */\n  static getNatural(baseValue: Decimal): DataSizeUnit {\n    return DataSizeUnit.index.getNatural(baseValue);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/measurement/data-size.js

@@ -0,0 +1,207 @@
+"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 data_size_exports = {};
+__export(data_size_exports, {
+  DataSize: () => DataSize,
+  maskDataSize: () => maskDataSize
+});
+module.exports = __toCommonJS(data_size_exports);
+var import_decimal = require("../internal/decimal.js");
+var import_quantity = require("../internal/quantity.js");
+var import_text_candidate = require("../text-scanning/text-candidate.js");
+var import_text_candidate_category = require("../text-scanning/text-candidate-category.js");
+var import_text_match_confidence = require("../text-scanning/text-match-confidence.js");
+var import_data_size_unit = require("./data-size-unit.js");
+const SCAN_PATTERN = new RegExp(
+  String.raw`(?<![\p{L}\p{N}_])(?:[+-]\s*)?\d+[0-9 .,]*\s*(?:exbibytes|exbibyte|exabytes|exabyte|pebibytes|pebibyte|petabytes|petabyte|tebibytes|tebibyte|terabytes|terabyte|gibibytes|gibibyte|gigabytes|gigabyte|mebibytes|mebibyte|megabytes|megabyte|kibibytes|kibibyte|kilobytes|kilobyte|EiB|PiB|TiB|GiB|MiB|KiB|EB|PB|TB|GB|MB|KB|bytes|byte|B)(?![\p{L}\p{N}_])`,
+  "giu"
+);
+class DataSize extends import_quantity.Quantity {
+  static typeInfo = Object.freeze({
+    englishName: "Data Size",
+    localizedName: "Datastorlek",
+    emoji: "\u{1F4BE}",
+    sources: Object.freeze([
+      "https://www.bipm.org/en/publications/si-brochure",
+      "https://www.iec.ch/standardsonline/iec-standard/iec-60027-2"
+    ])
+  });
+  get units() {
+    return import_data_size_unit.DataSizeUnit.index;
+  }
+  withBaseValue(baseValue, unit) {
+    return new DataSize(baseValue, unit);
+  }
+  get bytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Byte);
+  }
+  get kilobytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Kilobyte);
+  }
+  get megabytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Megabyte);
+  }
+  get gigabytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Gigabyte);
+  }
+  get terabytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Terabyte);
+  }
+  get petabytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Petabyte);
+  }
+  get exabytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Exabyte);
+  }
+  get kibibytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Kibibyte);
+  }
+  get mebibytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Mebibyte);
+  }
+  get gibibytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Gibibyte);
+  }
+  get tebibytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Tebibyte);
+  }
+  get pebibytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Pebibyte);
+  }
+  get exbibytes() {
+    return this.in(import_data_size_unit.DataSizeUnit.Exbibyte);
+  }
+  /** Creates a data size from a value and unit. */
+  static create(value, unit) {
+    import_data_size_unit.DataSizeUnit.index.assertOwns(unit);
+    const amount = value instanceof import_decimal.Decimal ? value : DataSize.decimalOf(value);
+    return new DataSize(unit.toBase(amount), unit);
+  }
+  static fromBytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Byte);
+  }
+  static fromKilobytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Kilobyte);
+  }
+  static fromMegabytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Megabyte);
+  }
+  static fromGigabytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Gigabyte);
+  }
+  static fromTerabytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Terabyte);
+  }
+  static fromPetabytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Petabyte);
+  }
+  static fromExabytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Exabyte);
+  }
+  static fromKibibytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Kibibyte);
+  }
+  static fromMebibytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Mebibyte);
+  }
+  static fromGibibytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Gibibyte);
+  }
+  static fromTebibytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Tebibyte);
+  }
+  static fromPebibytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Pebibyte);
+  }
+  static fromExbibytes(value) {
+    return DataSize.create(value, import_data_size_unit.DataSizeUnit.Exbibyte);
+  }
+  static tryParse(input) {
+    const parsed = (0, import_quantity.tryParseQuantity)(input, import_data_size_unit.DataSizeUnit.index);
+    return parsed === null ? null : new DataSize(parsed.baseValue, parsed.unit);
+  }
+  static parse(input) {
+    const result = DataSize.tryParse(input);
+    if (result === null) throw new Error("Invalid data size.");
+    return result;
+  }
+  static isValid(input) {
+    return DataSize.tryParse(input) !== null;
+  }
+  /** Display form in the parsed unit, or `null` when the input is invalid. */
+  static format(input, options) {
+    const parsed = DataSize.tryParse(input);
+    if (parsed !== null) {
+      if (options?.unit !== void 0 || options?.decimals !== void 0) {
+        return parsed.toStringInUnit(options.unit ?? parsed.originalUnit, options.decimals);
+      }
+      return parsed.toString();
+    }
+    return DataSize.fallback(input, options);
+  }
+  /** The value in bytes, or `null` when the input is invalid. */
+  static normalize(input, options) {
+    const parsed = DataSize.tryParse(input);
+    if (parsed !== null) return parsed.toNormalizedString();
+    return DataSize.fallback(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && DataSize.normalize(input) === input;
+  }
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    const pattern = new RegExp(SCAN_PATTERN.source, SCAN_PATTERN.flags);
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const value = DataSize.tryParse(match[0]);
+      if (value === null) continue;
+      out.push(
+        new import_text_candidate.TextCandidate({
+          startIndex: match.index,
+          length: match[0].length,
+          originalText: match[0],
+          typeName: "DataSize",
+          category: import_text_candidate_category.TextCandidateCategory.Measurement,
+          normalizedForm: value.toNormalizedString(),
+          formattedForm: value.toString(),
+          maskedForm: maskDataSize(value),
+          confidence: import_text_match_confidence.TextMatchConfidence.Medium,
+          value
+        })
+      );
+    }
+    return out;
+  }
+  static fallback(input, options) {
+    if (options?.fallbackToTrimmedInputWhenInvalid !== true) return null;
+    if (input == null) return null;
+    const trimmed = input.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  static decimalOf(value) {
+    const parsed = import_decimal.Decimal.fromNumber(value);
+    if (parsed === null) throw new Error(`Value cannot be represented as a data size: ${value}`);
+    return parsed;
+  }
+}
+function maskDataSize(value) {
+  return `*** ${value.originalUnit.symbol}`;
+}
+//# sourceMappingURL=data-size.js.map

package/dist/cjs/measurement/data-size.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/data-size.ts"],
+  "sourcesContent": ["import { Decimal } from \"../internal/decimal.js\";\nimport type { MeasurementUnitIndex } from \"../internal/measurement-unit.js\";\nimport { Quantity, tryParseQuantity } from \"../internal/quantity.js\";\nimport type { PrimitiveTypeInfo } from \"../primitive-type-info.js\";\nimport { TextCandidate } from \"../text-scanning/text-candidate.js\";\nimport { TextCandidateCategory } from \"../text-scanning/text-candidate-category.js\";\nimport { TextMatchConfidence } from \"../text-scanning/text-match-confidence.js\";\nimport { DataSizeUnit } from \"./data-size-unit.js\";\n\n/** Options for {@link DataSize.format} and {@link DataSize.normalize}. */\nexport interface DataSizeFormatOptions {\n  fallbackToTrimmedInputWhenInvalid?: boolean;\n  /** Convert to this unit instead of preserving the parsed one. */\n  unit?: DataSizeUnit;\n  /** Round to this many fractional digits, away from zero. */\n  decimals?: number;\n}\n\nconst SCAN_PATTERN = new RegExp(\n  String.raw`(?<![\\p{L}\\p{N}_])(?:[+-]\\s*)?\\d+[0-9 .,]*\\s*(?:exbibytes|exbibyte|exabytes|exabyte|pebibytes|pebibyte|petabytes|petabyte|tebibytes|tebibyte|terabytes|terabyte|gibibytes|gibibyte|gigabytes|gigabyte|mebibytes|mebibyte|megabytes|megabyte|kibibytes|kibibyte|kilobytes|kilobyte|EiB|PiB|TiB|GiB|MiB|KiB|EB|PB|TB|GB|MB|KB|bytes|byte|B)(?![\\p{L}\\p{N}_])`,\n  \"giu\",\n);\n\n/**\n * A data size stored internally in bytes,\n * parsed from any supported unit and convertible between all of them.\n */\nexport class DataSize extends Quantity<DataSizeUnit> {\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Data Size\",\n    localizedName: \"Datastorlek\",\n    emoji: \"\uD83D\uDCBE\",\n    sources: Object.freeze([\n      \"https://www.bipm.org/en/publications/si-brochure\",\n      \"https://www.iec.ch/standardsonline/iec-standard/iec-60027-2\",\n    ]),\n  });\n\n  protected get units(): MeasurementUnitIndex<DataSizeUnit> {\n    return DataSizeUnit.index;\n  }\n\n  protected withBaseValue(baseValue: Decimal, unit: DataSizeUnit): this {\n    return new DataSize(baseValue, unit) as this;\n  }\n\n  get bytes(): number {\n    return this.in(DataSizeUnit.Byte);\n  }\n  get kilobytes(): number {\n    return this.in(DataSizeUnit.Kilobyte);\n  }\n  get megabytes(): number {\n    return this.in(DataSizeUnit.Megabyte);\n  }\n  get gigabytes(): number {\n    return this.in(DataSizeUnit.Gigabyte);\n  }\n  get terabytes(): number {\n    return this.in(DataSizeUnit.Terabyte);\n  }\n  get petabytes(): number {\n    return this.in(DataSizeUnit.Petabyte);\n  }\n  get exabytes(): number {\n    return this.in(DataSizeUnit.Exabyte);\n  }\n  get kibibytes(): number {\n    return this.in(DataSizeUnit.Kibibyte);\n  }\n  get mebibytes(): number {\n    return this.in(DataSizeUnit.Mebibyte);\n  }\n  get gibibytes(): number {\n    return this.in(DataSizeUnit.Gibibyte);\n  }\n  get tebibytes(): number {\n    return this.in(DataSizeUnit.Tebibyte);\n  }\n  get pebibytes(): number {\n    return this.in(DataSizeUnit.Pebibyte);\n  }\n  get exbibytes(): number {\n    return this.in(DataSizeUnit.Exbibyte);\n  }\n\n  /** Creates a data size from a value and unit. */\n  static create(value: number | Decimal, unit: DataSizeUnit): DataSize {\n    DataSizeUnit.index.assertOwns(unit);\n    const amount = value instanceof Decimal ? value : DataSize.decimalOf(value);\n    return new DataSize(unit.toBase(amount), unit);\n  }\n\n  static fromBytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Byte);\n  }\n  static fromKilobytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Kilobyte);\n  }\n  static fromMegabytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Megabyte);\n  }\n  static fromGigabytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Gigabyte);\n  }\n  static fromTerabytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Terabyte);\n  }\n  static fromPetabytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Petabyte);\n  }\n  static fromExabytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Exabyte);\n  }\n  static fromKibibytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Kibibyte);\n  }\n  static fromMebibytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Mebibyte);\n  }\n  static fromGibibytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Gibibyte);\n  }\n  static fromTebibytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Tebibyte);\n  }\n  static fromPebibytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Pebibyte);\n  }\n  static fromExbibytes(value: number | Decimal): DataSize {\n    return DataSize.create(value, DataSizeUnit.Exbibyte);\n  }\n\n  static tryParse(input: string | null | undefined): DataSize | null {\n    const parsed = tryParseQuantity(input, DataSizeUnit.index);\n    return parsed === null ? null : new DataSize(parsed.baseValue, parsed.unit);\n  }\n\n  static parse(input: string): DataSize {\n    const result = DataSize.tryParse(input);\n    if (result === null) throw new Error(\"Invalid data size.\");\n    return result;\n  }\n\n  static isValid(input: string | null | undefined): boolean {\n    return DataSize.tryParse(input) !== null;\n  }\n\n  /** Display form in the parsed unit, or `null` when the input is invalid. */\n  static format(input: string | null | undefined, options?: DataSizeFormatOptions): string | null {\n    const parsed = DataSize.tryParse(input);\n    if (parsed !== null) {\n      if (options?.unit !== undefined || options?.decimals !== undefined) {\n        return parsed.toStringInUnit(options.unit ?? parsed.originalUnit, options.decimals);\n      }\n      return parsed.toString();\n    }\n    return DataSize.fallback(input, options);\n  }\n\n  /** The value in bytes, or `null` when the input is invalid. */\n  static normalize(\n    input: string | null | undefined,\n    options?: DataSizeFormatOptions,\n  ): string | null {\n    const parsed = DataSize.tryParse(input);\n    if (parsed !== null) return parsed.toNormalizedString();\n    return DataSize.fallback(input, options);\n  }\n\n  static isNormalized(input: string | null | undefined): boolean {\n    return input != null && DataSize.normalize(input) === input;\n  }\n\n  static findCandidatesInText(text: string): readonly TextCandidate<DataSize>[] {\n    if (!text) return [];\n\n    const out: TextCandidate<DataSize>[] = [];\n    const pattern = new RegExp(SCAN_PATTERN.source, SCAN_PATTERN.flags);\n    let match: RegExpExecArray | null;\n\n    while ((match = pattern.exec(text)) !== null) {\n      const value = DataSize.tryParse(match[0]);\n      if (value === null) continue;\n      out.push(\n        new TextCandidate<DataSize>({\n          startIndex: match.index,\n          length: match[0].length,\n          originalText: match[0],\n          typeName: \"DataSize\",\n          category: TextCandidateCategory.Measurement,\n          normalizedForm: value.toNormalizedString(),\n          formattedForm: value.toString(),\n          maskedForm: maskDataSize(value),\n          confidence: TextMatchConfidence.Medium,\n          value,\n        }),\n      );\n    }\n\n    return out;\n  }\n\n  private static fallback(\n    input: string | null | undefined,\n    options?: DataSizeFormatOptions,\n  ): string | null {\n    if (options?.fallbackToTrimmedInputWhenInvalid !== true) return null;\n    if (input == null) return null;\n    const trimmed = input.trim();\n    return trimmed.length > 0 ? trimmed : null;\n  }\n\n  private static decimalOf(value: number): Decimal {\n    const parsed = Decimal.fromNumber(value);\n    if (parsed === null) throw new Error(`Value cannot be represented as a data size: ${value}`);\n    return parsed;\n  }\n}\n\n/** Returns a masked data size, e.g. `10 B` becomes `*** B`. */\nexport function maskDataSize(value: DataSize): string {\n  return `*** ${value.originalUnit.symbol}`;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/measurement/electric-charge-unit.js

@@ -0,0 +1,109 @@
+"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 electric_charge_unit_exports = {};
+__export(electric_charge_unit_exports, {
+  ElectricChargeUnit: () => ElectricChargeUnit
+});
+module.exports = __toCommonJS(electric_charge_unit_exports);
+var import_decimal = require("../internal/decimal.js");
+var import_measurement_unit = require("../internal/measurement-unit.js");
+function factor(literal) {
+  const parsed = import_decimal.Decimal.parse(literal);
+  if (parsed === null) throw new Error(`Invalid conversion factor: ${literal}`);
+  return parsed;
+}
+class ElectricChargeUnit extends import_measurement_unit.MeasurementUnit {
+  static typeInfo = Object.freeze({
+    englishName: "Electric Charge Unit",
+    localizedName: "Laddningsenhet",
+    emoji: "\u{1F50B}",
+    sources: Object.freeze([])
+  });
+  static MilliampereHour = new ElectricChargeUnit({
+    symbol: "mAh",
+    englishName: "milliampere-hour",
+    localizedName: "milliamperetimme",
+    pluralEnglish: "milliampere-hours",
+    pluralSwedish: "milliamperetimmar",
+    toBaseUnitFactor: factor("0.001"),
+    aliases: ["milliampere hour", "milliampere hours", "milliamperehour", "milliamperehours"]
+  });
+  static AmpereHour = new ElectricChargeUnit({
+    symbol: "Ah",
+    englishName: "ampere-hour",
+    localizedName: "amperetimme",
+    pluralEnglish: "ampere-hours",
+    pluralSwedish: "amperetimmar",
+    toBaseUnitFactor: factor("1"),
+    aliases: [
+      "ampere hour",
+      "ampere hours",
+      "amperehour",
+      "amperehours",
+      "amp-hour",
+      "amp-hours",
+      "amp hour",
+      "amp hours"
+    ]
+  });
+  static Coulomb = new ElectricChargeUnit({
+    symbol: "C",
+    englishName: "coulomb",
+    localizedName: "coulomb",
+    pluralEnglish: "coulombs",
+    pluralSwedish: "coulomb",
+    toBaseUnitFactor: factor("0.0002777777777777777777777778"),
+    exactRatio: [factor("1"), factor("3600")]
+  });
+  /** @internal Shared lookup and natural-scale walk. */
+  static index = new import_measurement_unit.MeasurementUnitIndex(
+    [
+      ElectricChargeUnit.MilliampereHour,
+      ElectricChargeUnit.AmpereHour,
+      ElectricChargeUnit.Coulomb
+    ],
+    ElectricChargeUnit.AmpereHour,
+    [ElectricChargeUnit.MilliampereHour, ElectricChargeUnit.AmpereHour]
+  );
+  static get all() {
+    return ElectricChargeUnit.index.all;
+  }
+  /** The base unit: Ah. */
+  static get baseUnit() {
+    return ElectricChargeUnit.index.baseUnit;
+  }
+  /** Units ordered small to large, used to auto-scale display. */
+  static get naturalScale() {
+    return ElectricChargeUnit.index.naturalScale;
+  }
+  /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */
+  static tryParse(input) {
+    return ElectricChargeUnit.index.tryParse(input);
+  }
+  static parse(input) {
+    const result = ElectricChargeUnit.tryParse(input);
+    if (result === null) throw new Error("Unknown electric charge unit.");
+    return result;
+  }
+  /** Returns the most human-readable unit for a value in Ah. */
+  static getNatural(baseValue) {
+    return ElectricChargeUnit.index.getNatural(baseValue);
+  }
+}
+//# sourceMappingURL=electric-charge-unit.js.map

package/dist/cjs/measurement/electric-charge-unit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/measurement/electric-charge-unit.ts"],
+  "sourcesContent": ["import { Decimal } from \"../internal/decimal.js\";\nimport { MeasurementUnit, MeasurementUnitIndex } from \"../internal/measurement-unit.js\";\nimport type { PrimitiveTypeInfo } from \"../primitive-type-info.js\";\n\nfunction factor(literal: string): Decimal {\n  const parsed = Decimal.parse(literal);\n  /* c8 ignore next */\n  if (parsed === null) throw new Error(`Invalid conversion factor: ${literal}`);\n  return parsed;\n}\n\n/**\n * A unit of electric charge identified by its symbol.\n * Each unit carries English and Swedish names, singular and plural forms, and an\n * exact conversion factor to the base unit.\n */\nexport class ElectricChargeUnit extends MeasurementUnit {\n  declare private readonly __electricChargeUnitBrand: void;\n\n  static readonly typeInfo: PrimitiveTypeInfo = Object.freeze({\n    englishName: \"Electric Charge Unit\",\n    localizedName: \"Laddningsenhet\",\n    emoji: \"\uD83D\uDD0B\",\n    sources: Object.freeze([]),\n  });\n\n  static readonly MilliampereHour = new ElectricChargeUnit({\n    symbol: \"mAh\",\n    englishName: \"milliampere-hour\",\n    localizedName: \"milliamperetimme\",\n    pluralEnglish: \"milliampere-hours\",\n    pluralSwedish: \"milliamperetimmar\",\n    toBaseUnitFactor: factor(\"0.001\"),\n    aliases: [\"milliampere hour\", \"milliampere hours\", \"milliamperehour\", \"milliamperehours\"],\n  });\n\n  static readonly AmpereHour = new ElectricChargeUnit({\n    symbol: \"Ah\",\n    englishName: \"ampere-hour\",\n    localizedName: \"amperetimme\",\n    pluralEnglish: \"ampere-hours\",\n    pluralSwedish: \"amperetimmar\",\n    toBaseUnitFactor: factor(\"1\"),\n    aliases: [\n      \"ampere hour\",\n      \"ampere hours\",\n      \"amperehour\",\n      \"amperehours\",\n      \"amp-hour\",\n      \"amp-hours\",\n      \"amp hour\",\n      \"amp hours\",\n    ],\n  });\n\n  static readonly Coulomb = new ElectricChargeUnit({\n    symbol: \"C\",\n    englishName: \"coulomb\",\n    localizedName: \"coulomb\",\n    pluralEnglish: \"coulombs\",\n    pluralSwedish: \"coulomb\",\n    toBaseUnitFactor: factor(\"0.0002777777777777777777777778\"),\n    exactRatio: [factor(\"1\"), factor(\"3600\")],\n  });\n\n  /** @internal Shared lookup and natural-scale walk. */\n  static readonly index: MeasurementUnitIndex<ElectricChargeUnit> =\n    new MeasurementUnitIndex<ElectricChargeUnit>(\n      [\n        ElectricChargeUnit.MilliampereHour,\n        ElectricChargeUnit.AmpereHour,\n        ElectricChargeUnit.Coulomb,\n      ],\n      ElectricChargeUnit.AmpereHour,\n      [ElectricChargeUnit.MilliampereHour, ElectricChargeUnit.AmpereHour],\n    );\n\n  static get all(): readonly ElectricChargeUnit[] {\n    return ElectricChargeUnit.index.all;\n  }\n\n  /** The base unit: Ah. */\n  static get baseUnit(): ElectricChargeUnit {\n    return ElectricChargeUnit.index.baseUnit;\n  }\n\n  /** Units ordered small to large, used to auto-scale display. */\n  static get naturalScale(): readonly ElectricChargeUnit[] {\n    return ElectricChargeUnit.index.naturalScale;\n  }\n\n  /** Resolves a unit from a symbol, name, plural or alias, case-insensitively. */\n  static tryParse(input: string | null | undefined): ElectricChargeUnit | null {\n    return ElectricChargeUnit.index.tryParse(input);\n  }\n\n  static parse(input: string): ElectricChargeUnit {\n    const result = ElectricChargeUnit.tryParse(input);\n    if (result === null) throw new Error(\"Unknown electric charge unit.\");\n    return result;\n  }\n\n  /** Returns the most human-readable unit for a value in Ah. */\n  static getNatural(baseValue: Decimal): ElectricChargeUnit {\n    return ElectricChargeUnit.index.getNatural(baseValue);\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAwB;AACxB,8BAAsD;AAGtD,SAAS,OAAO,SAA0B;AACxC,QAAM,SAAS,uBAAQ,MAAM,OAAO;AAEpC,MAAI,WAAW,KAAM,OAAM,IAAI,MAAM,8BAA8B,OAAO,EAAE;AAC5E,SAAO;AACT;AAOO,MAAM,2BAA2B,wCAAgB;AAAA,EAGtD,OAAgB,WAA8B,OAAO,OAAO;AAAA,IAC1D,aAAa;AAAA,IACb,eAAe;AAAA,IACf,OAAO;AAAA,IACP,SAAS,OAAO,OAAO,CAAC,CAAC;AAAA,EAC3B,CAAC;AAAA,EAED,OAAgB,kBAAkB,IAAI,mBAAmB;AAAA,IACvD,QAAQ;AAAA,IACR,aAAa;AAAA,IACb,eAAe;AAAA,IACf,eAAe;AAAA,IACf,eAAe;AAAA,IACf,kBAAkB,OAAO,OAAO;AAAA,IAChC,SAAS,CAAC,oBAAoB,qBAAqB,mBAAmB,kBAAkB;AAAA,EAC1F,CAAC;AAAA,EAED,OAAgB,aAAa,IAAI,mBAAmB;AAAA,IAClD,QAAQ;AAAA,IACR,aAAa;AAAA,IACb,eAAe;AAAA,IACf,eAAe;AAAA,IACf,eAAe;AAAA,IACf,kBAAkB,OAAO,GAAG;AAAA,IAC5B,SAAS;AAAA,MACP;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC;AAAA,EAED,OAAgB,UAAU,IAAI,mBAAmB;AAAA,IAC/C,QAAQ;AAAA,IACR,aAAa;AAAA,IACb,eAAe;AAAA,IACf,eAAe;AAAA,IACf,eAAe;AAAA,IACf,kBAAkB,OAAO,gCAAgC;AAAA,IACzD,YAAY,CAAC,OAAO,GAAG,GAAG,OAAO,MAAM,CAAC;AAAA,EAC1C,CAAC;AAAA;AAAA,EAGD,OAAgB,QACd,IAAI;AAAA,IACF;AAAA,MACE,mBAAmB;AAAA,MACnB,mBAAmB;AAAA,MACnB,mBAAmB;AAAA,IACrB;AAAA,IACA,mBAAmB;AAAA,IACnB,CAAC,mBAAmB,iBAAiB,mBAAmB,UAAU;AAAA,EACpE;AAAA,EAEF,WAAW,MAAqC;AAC9C,WAAO,mBAAmB,MAAM;AAAA,EAClC;AAAA;AAAA,EAGA,WAAW,WAA+B;AACxC,WAAO,mBAAmB,MAAM;AAAA,EAClC;AAAA;AAAA,EAGA,WAAW,eAA8C;AACvD,WAAO,mBAAmB,MAAM;AAAA,EAClC;AAAA;AAAA,EAGA,OAAO,SAAS,OAA6D;AAC3E,WAAO,mBAAmB,MAAM,SAAS,KAAK;AAAA,EAChD;AAAA,EAEA,OAAO,MAAM,OAAmC;AAC9C,UAAM,SAAS,mBAAmB,SAAS,KAAK;AAChD,QAAI,WAAW,KAAM,OAAM,IAAI,MAAM,+BAA+B;AACpE,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,WAAW,WAAwC;AACxD,WAAO,mBAAmB,MAAM,WAAW,SAAS;AAAA,EACtD;AACF;",
+  "names": []
+}