@stll/stdnum 2.1.0 → 2.1.2

package/src/creditcard.ts

@@ -1,194 +0,0 @@
-/**
- * Credit card number validation (Luhn algorithm).
- *
- * Validates card numbers using the Luhn checksum
- * (ISO/IEC 7812-1). Supports Visa, Mastercard,
- * Amex, Discover, and other networks (13-19
- * digits).
- *
- * @see https://www.iso.org/standard/70484.html
- */
-
-import type {
-  ValidateResult,
-  GlobalValidator,
-} from "./types";
-
-import {
-  luhnChecksum,
-  luhnValidate,
-} from "#checksums/luhn";
-import { clean } from "#util/clean";
-import { randomDigits, randomInt } from "#util/generate";
-import { err } from "#util/result";
-import { isdigits } from "#util/strings";
-
-/**
- * Card network identifiers returned by
- * {@link detectNetwork}.
- */
-type CardNetwork =
-  | "visa"
-  | "mastercard"
-  | "amex"
-  | "discover"
-  | "diners"
-  | "jcb"
-  | "unionpay"
-  | "maestro";
-
-const compact = (value: string): string =>
-  clean(value, " -.");
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-  if (v.length < 13 || v.length > 19) {
-    return err(
-      "INVALID_LENGTH",
-      "Credit card number must be 13-19 digits",
-    );
-  }
-  if (!isdigits(v)) {
-    return err(
-      "INVALID_FORMAT",
-      "Credit card number must contain only digits",
-    );
-  }
-  if (!luhnValidate(v)) {
-    return err(
-      "INVALID_CHECKSUM",
-      "Credit card number fails Luhn check",
-    );
-  }
-  return { valid: true, compact: v };
-};
-
-const format = (value: string): string => {
-  const v = compact(value);
-  // Amex: 4-6-5 grouping
-  if (v.length === 15 && v[0] === "3") {
-    return `${v.slice(0, 4)} ${v.slice(4, 10)} ${v.slice(10)}`;
-  }
-  // Standard: groups of 4
-  const groups: string[] = [];
-  for (let i = 0; i < v.length; i += 4) {
-    groups.push(v.slice(i, i + 4));
-  }
-  return groups.join(" ");
-};
-
-const MAESTRO_PREFIXES = new Set([
-  5018, 5020, 5038, 5893, 6304, 6759, 6761, 6762, 6763,
-]);
-
-/**
- * Detect the card network from the BIN/IIN prefix.
- *
- * Accepts both formatted ("4111 1111 1111 1111")
- * and compact ("4111111111111111") inputs.
- * Returns null for unrecognized prefixes.
- */
-const detectNetwork = (
-  value: string,
-): CardNetwork | null => {
-  const v = compact(value);
-  if (v.length === 0) return null;
-  if (!isdigits(v)) return null;
-
-  const d2 = Number(v.slice(0, 2));
-  const d3 = Number(v.slice(0, 3));
-  const d4 = Number(v.slice(0, 4));
-  const d6 = Number(v.slice(0, 6));
-
-  // Amex: 34, 37
-  if (d2 === 34 || d2 === 37) return "amex";
-
-  // Diners Club: 300-305, 36, 38
-  if (d2 === 36 || d2 === 38) return "diners";
-  if (d3 >= 300 && d3 <= 305) return "diners";
-
-  // JCB: 3528-3589
-  if (d4 >= 3528 && d4 <= 3589) return "jcb";
-
-  // Visa: starts with 4
-  if (v[0] === "4") return "visa";
-
-  // Maestro (check before Mastercard; some share
-  // the 50xx prefix space)
-  if (MAESTRO_PREFIXES.has(d4)) return "maestro";
-
-  // Mastercard: 51-55 or 2221-2720
-  if (d2 >= 51 && d2 <= 55) return "mastercard";
-  if (d4 >= 2221 && d4 <= 2720) return "mastercard";
-
-  // Discover: 6011, 622126-622925, 644-649, 65
-  if (d4 === 6011) return "discover";
-  if (d6 >= 622126 && d6 <= 622925) return "discover";
-  if (d3 >= 644 && d3 <= 649) return "discover";
-  if (d2 === 65) return "discover";
-
-  // UnionPay: starts with 62 (excluding Discover
-  // ranges already matched above)
-  if (d2 === 62) return "unionpay";
-
-  return null;
-};
-
-/**
- * Visa/Mastercard IIN prefixes. Each entry is
- * [prefix, totalLength].
- */
-const CARD_PREFIXES = [
-  ["4", 16], // Visa
-  ["51", 16], // Mastercard
-  ["52", 16], // Mastercard
-  ["53", 16], // Mastercard
-  ["54", 16], // Mastercard
-  ["55", 16], // Mastercard
-] as const;
-
-/**
- * Generate a random valid Visa or Mastercard
- * number (16 digits, Luhn-valid).
- */
-const generate = (): string => {
-  const idx = randomInt(0, CARD_PREFIXES.length - 1);
-  const [prefix, length] = CARD_PREFIXES[
-    idx
-  ] as (typeof CARD_PREFIXES)[number];
-  const remaining = length - prefix.length - 1;
-  const payload = `${prefix}${randomDigits(remaining)}`;
-  const partial = `${payload}0`;
-  const remainder = luhnChecksum(partial);
-  const check = (10 - remainder) % 10;
-  return `${payload}${String(check)}`;
-};
-
-/** Credit Card Number (Luhn). */
-const creditCard: GlobalValidator = {
-  scope: "global",
-  name: "Credit Card Number",
-  localName: "Credit Card Number",
-  abbreviation: "CC",
-  aliases: [
-    "credit card",
-    "card number",
-    "kreditní karta",
-    "Kreditkarte",
-  ] as const,
-  candidatePattern: "(?:\\d[\\s-]?){13,19}",
-  entityType: "any",
-  sourceUrl: "https://www.iso.org/standard/70484.html",
-  examples: [
-    "4111111111111111",
-    "5500000000000004",
-  ] as const,
-  compact,
-  format,
-  validate,
-  generate,
-};
-
-export default creditCard;
-export { compact, detectNetwork, format, validate };
-export type { CardNetwork };

package/src/crypto/btcbase58.ts

@@ -1,144 +0,0 @@
-/**
- * Bitcoin Base58Check address.
- *
- * Validates legacy mainnet P2PKH and P2SH Bitcoin
- * addresses, including the double-SHA-256 checksum.
- */
-
-import type {
-  GlobalValidator,
-  ValidateResult,
-} from "../types";
-
-import { sha256 } from "#checksums/sha256";
-import { clean } from "#util/clean";
-import { err } from "#util/result";
-
-const BASE58_ALPHABET =
-  "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-
-const MIN_LENGTH = 26;
-const MAX_LENGTH = 35;
-const DECODED_ADDRESS_LENGTH = 25;
-const CHECKSUM_LENGTH = 4;
-const MAINNET_P2PKH_VERSION = 0x00;
-const MAINNET_P2SH_VERSION = 0x05;
-
-const compact = (value: string): string =>
-  clean(value, " ");
-
-const decodeBase58 = (value: string): Uint8Array | null => {
-  let decoded = 0n;
-  for (const ch of value) {
-    const digit = BASE58_ALPHABET.indexOf(ch);
-    if (digit === -1) return null;
-    decoded = decoded * 58n + BigInt(digit);
-  }
-
-  const bytes: number[] = [];
-  while (decoded > 0n) {
-    bytes.push(Number(decoded & 0xffn));
-    decoded >>= 8n;
-  }
-  bytes.reverse();
-
-  let leadingZeros = 0;
-  while (value.charAt(leadingZeros) === "1") {
-    leadingZeros += 1;
-  }
-
-  const result = new Uint8Array(
-    leadingZeros + bytes.length,
-  );
-  result.set(bytes, leadingZeros);
-  return result;
-};
-
-const hasValidChecksum = (decoded: Uint8Array): boolean => {
-  if (decoded.length <= CHECKSUM_LENGTH) return false;
-
-  const payload = decoded.slice(0, -CHECKSUM_LENGTH);
-  const checksum = decoded.slice(-CHECKSUM_LENGTH);
-  const digest = sha256(sha256(payload));
-
-  for (let i = 0; i < CHECKSUM_LENGTH; i += 1) {
-    if (checksum[i] !== digest[i]) return false;
-  }
-  return true;
-};
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-  if (v.length < MIN_LENGTH || v.length > MAX_LENGTH) {
-    return err(
-      "INVALID_LENGTH",
-      "Bitcoin Base58Check address must be 26-35 characters",
-    );
-  }
-  if (!/^[13]/.test(v)) {
-    return err(
-      "INVALID_COMPONENT",
-      "Bitcoin Base58Check address must start with 1 or 3",
-    );
-  }
-
-  const decoded = decodeBase58(v);
-  if (decoded === null) {
-    return err(
-      "INVALID_FORMAT",
-      "Bitcoin Base58Check address contains invalid characters",
-    );
-  }
-  if (decoded.length !== DECODED_ADDRESS_LENGTH) {
-    return err(
-      "INVALID_LENGTH",
-      "Bitcoin Base58Check address decoded payload must be 25 bytes",
-    );
-  }
-
-  const version = decoded[0];
-  if (
-    version !== MAINNET_P2PKH_VERSION &&
-    version !== MAINNET_P2SH_VERSION
-  ) {
-    return err(
-      "INVALID_COMPONENT",
-      "Bitcoin Base58Check address has an unsupported version",
-    );
-  }
-
-  if (!hasValidChecksum(decoded)) {
-    return err(
-      "INVALID_CHECKSUM",
-      "Bitcoin Base58Check address fails checksum validation",
-    );
-  }
-
-  return { valid: true, compact: v };
-};
-
-const format = (value: string): string => compact(value);
-
-const btcBase58: GlobalValidator = {
-  scope: "global",
-  name: "Bitcoin Base58Check Address",
-  localName: "Bitcoin Base58Check Address",
-  abbreviation: "BTC",
-  aliases: [
-    "Bitcoin address",
-    "Bitcoin legacy address",
-    "Base58Check address",
-  ] as const,
-  candidatePattern: "[13][1-9A-HJ-NP-Za-km-z]{25,34}",
-  entityType: "any",
-  examples: [
-    "1BoatSLRHtKNngkdXEeobR76b53LETtpyT",
-    "3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy",
-  ] as const,
-  compact,
-  format,
-  validate,
-};
-
-export default btcBase58;
-export { compact, decodeBase58, format, validate };

package/src/crypto/btcbech32.ts

@@ -1,210 +0,0 @@
-/**
- * Bitcoin Bech32/Bech32m address.
- *
- * Validates mainnet SegWit addresses with the
- * Bech32 checksum for v0 and Bech32m for v1+.
- */
-
-import type {
-  GlobalValidator,
-  ValidateResult,
-} from "../types";
-
-import { clean } from "#util/clean";
-import { err } from "#util/result";
-
-const CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
-const GENERATORS = [
-  0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd,
-  0x2a1462b3,
-] as const;
-const BECH32_CONST = 1;
-const BECH32M_CONST = 0x2bc830a3;
-const CHECKSUM_LENGTH = 6;
-const MIN_DATA_LENGTH = 11;
-const MAX_DATA_LENGTH = 71;
-const BC_HRP_EXPANSION = [3, 3, 0, 2, 3] as const;
-
-const compact = (value: string): string =>
-  clean(value, " ").toLowerCase();
-
-const polymod = (values: readonly number[]): number => {
-  let chk = 1;
-  for (const value of values) {
-    const top = chk >>> 25;
-    chk = (((chk & 0x1ffffff) << 5) ^ value) >>> 0;
-    for (let i = 0; i < GENERATORS.length; i += 1) {
-      const generator = GENERATORS[i] ?? 0;
-      if (((top >>> i) & 1) === 1) {
-        chk = (chk ^ generator) >>> 0;
-      }
-    }
-  }
-  return chk >>> 0;
-};
-
-const dataValues = (data: string): number[] | null => {
-  const values: number[] = [];
-  for (const ch of data) {
-    const value = CHARSET.indexOf(ch);
-    if (value === -1) return null;
-    values.push(value);
-  }
-  return values;
-};
-
-const convertBits = (
-  values: readonly number[],
-  fromBits: number,
-  toBits: number,
-): number[] | null => {
-  let accumulator = 0;
-  let bits = 0;
-  const maxValue = (1 << toBits) - 1;
-  const result: number[] = [];
-
-  for (const value of values) {
-    if (value < 0 || value >>> fromBits !== 0) return null;
-    accumulator = (accumulator << fromBits) | value;
-    bits += fromBits;
-    while (bits >= toBits) {
-      bits -= toBits;
-      result.push((accumulator >>> bits) & maxValue);
-    }
-  }
-
-  if (bits >= fromBits) return null;
-  if (((accumulator << (toBits - bits)) & maxValue) !== 0) {
-    return null;
-  }
-
-  return result;
-};
-
-type Bech32Validation =
-  | { valid: true }
-  | {
-      valid: false;
-      code: "format" | "checksum" | "component";
-    };
-
-const validateBech32 = (
-  rawValue: string,
-): Bech32Validation => {
-  const hasLower = /[a-z]/.test(rawValue);
-  const hasUpper = /[A-Z]/.test(rawValue);
-  if (hasLower && hasUpper)
-    return { valid: false, code: "format" };
-
-  const v = rawValue.toLowerCase();
-  if (!v.startsWith("bc1"))
-    return { valid: false, code: "component" };
-
-  const data = v.slice(3);
-  if (
-    data.length < MIN_DATA_LENGTH ||
-    data.length > MAX_DATA_LENGTH
-  ) {
-    return { valid: false, code: "format" };
-  }
-
-  const values = dataValues(data);
-  if (values === null)
-    return { valid: false, code: "format" };
-
-  const expanded: number[] = Array.from(BC_HRP_EXPANSION);
-  for (const value of values) {
-    expanded.push(value);
-  }
-  const check = polymod(expanded);
-
-  const version = values[0];
-  if (version === undefined || version > 16) {
-    return { valid: false, code: "component" };
-  }
-
-  if (version === 0 && check !== BECH32_CONST) {
-    return { valid: false, code: "checksum" };
-  }
-  if (version > 0 && check !== BECH32M_CONST) {
-    return { valid: false, code: "checksum" };
-  }
-
-  const programValues = values.slice(1, -CHECKSUM_LENGTH);
-  const program = convertBits(programValues, 5, 8);
-  if (
-    program === null ||
-    program.length < 2 ||
-    program.length > 40
-  ) {
-    return { valid: false, code: "component" };
-  }
-
-  if (
-    version === 0 &&
-    program.length !== 20 &&
-    program.length !== 32
-  ) {
-    return { valid: false, code: "component" };
-  }
-
-  return { valid: true };
-};
-
-const validate = (value: string): ValidateResult => {
-  const v = compact(value);
-  const result = validateBech32(clean(value, " "));
-  if (result.valid) return { valid: true, compact: v };
-
-  if (result.code === "component") {
-    return err(
-      "INVALID_COMPONENT",
-      "Bitcoin Bech32 address has an unsupported component",
-    );
-  }
-  if (result.code === "checksum") {
-    return err(
-      "INVALID_CHECKSUM",
-      "Bitcoin Bech32 address fails checksum validation",
-    );
-  }
-  return err(
-    "INVALID_FORMAT",
-    "Bitcoin Bech32 address has an invalid format",
-  );
-};
-
-const format = (value: string): string => compact(value);
-
-const btcBech32: GlobalValidator = {
-  scope: "global",
-  name: "Bitcoin Bech32 Address",
-  localName: "Bitcoin Bech32 Address",
-  abbreviation: "BTC",
-  aliases: [
-    "Bitcoin address",
-    "Bitcoin SegWit address",
-    "Bech32 address",
-    "Bech32m address",
-  ] as const,
-  candidatePattern:
-    "(?:bc1[ac-hj-np-z02-9]{11,71}|BC1[AC-HJ-NP-Z02-9]{11,71})",
-  entityType: "any",
-  examples: [
-    "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4",
-    "bc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qccfmv3",
-  ] as const,
-  compact,
-  format,
-  validate,
-};
-
-export default btcBech32;
-export {
-  compact,
-  convertBits,
-  format,
-  polymod,
-  validate,
-  validateBech32,
-};

package/src/crypto/eth.ts

@@ -1,114 +0,0 @@
-/**
- * Ethereum address.
- *
- * Validates the canonical 0x-prefixed 20-byte
- * hexadecimal address shape. The compact form is
- * lowercased so checksummed and non-checksummed
- * variants of the same address compare equal.
- */
-
-import type {
-  GlobalValidator,
-  ValidateResult,
-} from "../types";
-
-import { keccak256 } from "#checksums/keccak";
-import { clean } from "#util/clean";
-import { err } from "#util/result";
-
-const ETH_ADDRESS_LENGTH = 42;
-const HEX_PREFIX_LENGTH = 2;
-
-const compact = (value: string): string =>
-  clean(value, " ").toLowerCase();
-
-const asciiBytes = (value: string): Uint8Array => {
-  const bytes = new Uint8Array(value.length);
-  for (let i = 0; i < value.length; i += 1) {
-    bytes[i] = value.charCodeAt(i);
-  }
-  return bytes;
-};
-
-const hexBytes = (bytes: Uint8Array): string => {
-  let result = "";
-  for (const byte of bytes) {
-    result += byte.toString(16).padStart(2, "0");
-  }
-  return result;
-};
-
-const isMixedCase = (value: string): boolean =>
-  /[a-f]/.test(value) && /[A-F]/.test(value);
-
-const hasValidEip55Checksum = (
-  address: string,
-): boolean => {
-  const body = address.slice(HEX_PREFIX_LENGTH);
-  if (!isMixedCase(body)) return true;
-
-  const lower = body.toLowerCase();
-  const hash = hexBytes(keccak256(asciiBytes(lower)));
-
-  for (let i = 0; i < body.length; i += 1) {
-    const ch = body.charAt(i);
-    if (/\d/.test(ch)) continue;
-
-    const nibble = Number.parseInt(hash.charAt(i), 16);
-    const expected =
-      nibble >= 8 ? ch.toUpperCase() : ch.toLowerCase();
-    if (ch !== expected) return false;
-  }
-
-  return true;
-};
-
-const validate = (value: string): ValidateResult => {
-  const raw = clean(value, " ");
-  const v = raw.toLowerCase();
-  if (v.length !== ETH_ADDRESS_LENGTH) {
-    return err(
-      "INVALID_LENGTH",
-      "Ethereum address must be 42 characters",
-    );
-  }
-  if (!/^0x[0-9a-f]{40}$/i.test(raw)) {
-    return err(
-      "INVALID_FORMAT",
-      "Ethereum address must be 0x followed by 40 hexadecimal characters",
-    );
-  }
-  if (!hasValidEip55Checksum(raw)) {
-    return err(
-      "INVALID_CHECKSUM",
-      "Ethereum address fails EIP-55 checksum validation",
-    );
-  }
-  return { valid: true, compact: v };
-};
-
-const format = (value: string): string => compact(value);
-
-const eth: GlobalValidator = {
-  scope: "global",
-  name: "Ethereum Address",
-  localName: "Ethereum Address",
-  abbreviation: "ETH",
-  aliases: [
-    "Ethereum address",
-    "EVM address",
-    "crypto wallet",
-  ] as const,
-  candidatePattern: "0x[0-9A-Fa-f]{40}",
-  entityType: "any",
-  examples: [
-    "0xde709f2102306220921060314715629080e2fb77",
-  ] as const,
-  lengths: [ETH_ADDRESS_LENGTH] as const,
-  compact,
-  format,
-  validate,
-};
-
-export default eth;
-export { compact, format, hasValidEip55Checksum, validate };

package/src/crypto/mod.ts

@@ -1,4 +0,0 @@
-export { default as btcbase58 } from "./btcbase58";
-export { default as btcbech32 } from "./btcbech32";
-export { default as eth } from "./eth";
-export { default as wallet } from "./wallet";