@askeleven/sms-guard 0.1.0

package/src/phone.js

@@ -0,0 +1,213 @@
+import { NANP_AREA_CODES } from './data/nanp.js'
+import { COUNTRY_CODES } from './data/countries.js'
+
+/**
+ * @typedef {object} ParsedNumber
+ * @property {string} e164 The number as +<digits>.
+ * @property {string} countryCode '1' for NANP, otherwise as matched in the country
+ *   table, or an empty string when no row matches.
+ * @property {boolean} assumedNanp True when the number had no + and was read as a
+ *   US or Canadian number because it had 10 digits (or 11 starting with 1).
+ *
+ * @typedef {object} ZoneLookup
+ * @property {string | null} region State, province or country, when known.
+ * @property {string[]} zones IANA zones. None means unknown; more than one, ambiguous.
+ * @property {string} basis What the zones were worked out from, in plain English.
+ */
+
+/** Formatting people type around a phone number, stripped before parsing. */
+const FORMATTING = /[\s().\-/\u00A0]/g
+
+/**
+ * Reads a phone number. Accepts E.164 with or without formatting (+1 (305) 555-0100,
+ * +44 20 7946 0000). Without a leading +, only a 10-digit number, or an 11-digit
+ * number starting with 1, is accepted, and it is read as NANP (US, Canada and the
+ * rest of +1). Anything else without a + is refused rather than guessed at.
+ *
+ * @param {string} raw
+ * @returns {{ ok: true, number: ParsedNumber } | { ok: false, error: string }}
+ */
+export function parseNumber(raw) {
+  const input = String(raw).trim()
+  const hasPlus = input.startsWith('+')
+  const rest = (hasPlus ? input.slice(1) : input).replace(FORMATTING, '')
+  if (!/^\d+$/.test(rest)) {
+    return { ok: false, error: `${input || 'An empty string'} is not a phone number.` }
+  }
+
+  let digits = rest
+  let assumedNanp = false
+  if (!hasPlus) {
+    if (digits.length === 10) {
+      digits = `1${digits}`
+      assumedNanp = true
+    } else if (digits.length === 11 && digits.startsWith('1')) {
+      assumedNanp = true
+    } else {
+      return {
+        ok: false,
+        error:
+          `${input} has no country code. Write it in E.164, starting with + and the ` +
+          'country code, such as +44 20 7946 0000.',
+      }
+    }
+  }
+
+  if (digits.length < 7 || digits.length > 15) {
+    return { ok: false, error: `${input} is not a valid E.164 number (7 to 15 digits).` }
+  }
+  if (digits.startsWith('1')) {
+    if (!/^1[2-9]\d{2}[2-9]\d{6}$/.test(digits)) {
+      return {
+        ok: false,
+        error: `${input} is not a valid US or Canadian number: +1, then 10 digits.`,
+      }
+    }
+    return { ok: true, number: { e164: `+${digits}`, countryCode: '1', assumedNanp } }
+  }
+  const countryCode =
+    [3, 2, 1].map((n) => digits.slice(0, n)).find((prefix) => COUNTRY_CODES.has(prefix)) ?? null
+  return {
+    ok: true,
+    number: { e164: `+${digits}`, countryCode: countryCode ?? '', assumedNanp },
+  }
+}
+
+/**
+ * The time zone, or zones, a number could be in.
+ *
+ * @param {ParsedNumber} number
+ * @returns {ZoneLookup}
+ */
+export function zonesFor(number) {
+  if (number.countryCode === '1') {
+    const areaCode = number.e164.slice(2, 5)
+    const entry = NANP_AREA_CODES.get(areaCode)
+    if (!entry) {
+      return {
+        region: null,
+        zones: [],
+        basis: `Area code ${areaCode} is not a geographic area code sms-guard knows.`,
+      }
+    }
+    return { region: entry.region, zones: entry.zones, basis: `area code ${areaCode}` }
+  }
+  const entry = number.countryCode ? COUNTRY_CODES.get(number.countryCode) : undefined
+  if (!entry) {
+    return {
+      region: null,
+      zones: [],
+      basis: `The country for ${number.e164} is not in sms-guard's table.`,
+    }
+  }
+  return { region: entry.region, zones: entry.zones, basis: `country code +${number.countryCode}` }
+}
+
+/**
+ * @typedef {object} Window
+ * @property {number} start Minutes after local midnight, inclusive.
+ * @property {number} end Minutes after local midnight, exclusive.
+ * @property {string} label As given, HH:MM-HH:MM.
+ */
+
+/**
+ * Parses HH:MM-HH:MM. The start is inclusive and the end exclusive, so 08:00-21:00
+ * allows 08:00 and 20:59 but not 21:00. A window that wraps midnight (22:00-06:00)
+ * is allowed.
+ *
+ * @param {string} window
+ * @returns {Window | null}
+ */
+export function parseWindow(window) {
+  const m = /^(\d{1,2}):(\d{2})-(\d{1,2}):(\d{2})$/.exec(String(window).trim())
+  if (!m) return null
+  const [sh, sm, eh, em] = m.slice(1).map(Number)
+  if (sm > 59 || em > 59 || sh > 23 || eh > 24 || (eh === 24 && em > 0)) return null
+  const start = sh * 60 + sm
+  const end = eh * 60 + em
+  if (start === end) return null
+  const pad = (/** @type {number} */ n) => String(n).padStart(2, '0')
+  return { start, end, label: `${pad(sh)}:${pad(sm)}-${pad(eh)}:${pad(em)}` }
+}
+
+/**
+ * @param {number} minutes Minutes after local midnight.
+ * @param {Window} window
+ * @returns {boolean}
+ */
+export function inWindow(minutes, window) {
+  return window.start < window.end
+    ? minutes >= window.start && minutes < window.end
+    : minutes >= window.start || minutes < window.end
+}
+
+/**
+ * @typedef {object} LocalTime
+ * @property {string} timezone
+ * @property {string} time Local wall-clock time, YYYY-MM-DDTHH:MM.
+ * @property {string} label Such as "Sun 19:30 EDT".
+ * @property {number} minutes Minutes after local midnight.
+ */
+
+/** @type {Map<string, Intl.DateTimeFormat>} */
+const formatters = new Map()
+
+/**
+ * The wall-clock time in a zone, from the runtime's own time zone data.
+ *
+ * @param {Date} date
+ * @param {string} timezone
+ * @returns {LocalTime}
+ */
+export function localTime(date, timezone) {
+  let format = formatters.get(timezone)
+  if (!format) {
+    format = new Intl.DateTimeFormat('en-US', {
+      timeZone: timezone,
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      hourCycle: 'h23',
+      weekday: 'short',
+      timeZoneName: 'short',
+    })
+    formatters.set(timezone, format)
+  }
+  /** @type {Record<string, string>} */
+  const p = {}
+  for (const part of format.formatToParts(date)) p[part.type] = part.value
+  const hour = p.hour === '24' ? '00' : p.hour
+  return {
+    timezone,
+    time: `${p.year}-${p.month}-${p.day}T${hour}:${p.minute}`,
+    label: `${p.weekday} ${hour}:${p.minute} ${p.timeZoneName}`,
+    minutes: Number(hour) * 60 + Number(p.minute),
+  }
+}
+
+/**
+ * The first minute at or after `from` when it is inside the window in every one of
+ * the zones, or null if there is none in the next two days.
+ *
+ * @param {Date} from
+ * @param {string[]} zones
+ * @param {Window} window
+ * @returns {Date | null}
+ */
+export function nextWindowStart(from, zones, window) {
+  const MINUTE = 60_000
+  const ok = (/** @type {number} */ t) =>
+    zones.every((z) => inWindow(localTime(new Date(t), z).minutes, window))
+  const start = Math.ceil(from.getTime() / MINUTE) * MINUTE
+  const limit = start + 2 * 24 * 60 * MINUTE
+  // Coarse steps to find the opening, then minute by minute back from it.
+  for (let t = start; t <= limit; t += 15 * MINUTE) {
+    if (!ok(t)) continue
+    let first = t
+    while (first - MINUTE >= start && ok(first - MINUTE)) first -= MINUTE
+    return new Date(first)
+  }
+  return null
+}

package/src/report.js

@@ -0,0 +1,165 @@
+/**
+ * @typedef {import('./index.js').Result} Result
+ * @typedef {import('./index.js').ReasonCode} ReasonCode
+ * @typedef {import('./index.js').Verdict} Verdict
+ * @typedef {import('./split.js').Part} Part
+ */
+
+const COLOURS = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  green: '\x1b[32m',
+}
+
+/** Headings for each reason. */
+const REASON_TITLES = /** @type {Record<ReasonCode, string>} */ ({
+  empty: 'Empty message',
+  too_many_segments: 'Too many segments',
+  invalid_number: 'Not a valid phone number',
+  quiet_hours: 'Outside allowed hours',
+  timezone_ambiguous: 'Time zone ambiguous',
+  timezone_unknown: 'Time zone unknown',
+  url_shortener: 'Public link shortener',
+  no_opt_out: 'No opt-out wording',
+  ucs2: 'Sent as UCS-2',
+})
+
+const HEADLINES = /** @type {Record<Verdict, string>} */ ({
+  keep: 'OK to send',
+  review: 'A person should look at this before it is sent',
+  fail: 'Do not send this as it stands',
+})
+
+/**
+ * @param {boolean} enabled
+ * @returns {(code: string, text: string) => string}
+ */
+function painter(enabled) {
+  return (code, text) => (enabled ? `${code}${text}${COLOURS.reset}` : text)
+}
+
+/**
+ * @param {string} text
+ * @param {number} width
+ * @param {string} indent
+ * @returns {string}
+ */
+function wrap(text, width, indent) {
+  /** @type {string[]} */
+  const lines = []
+  let line = ''
+  for (const word of text.split(/\s+/)) {
+    if (line && line.length + word.length + 1 > width) {
+      lines.push(line)
+      line = word
+    } else {
+      line = line ? `${line} ${word}` : word
+    }
+  }
+  if (line) lines.push(line)
+  return lines.map((l) => indent + l).join('\n')
+}
+
+/**
+ * @param {Result} result
+ * @param {{ colour?: boolean, width?: number }} [options]
+ * @returns {string}
+ */
+export function formatText(result, options = {}) {
+  const { colour = true, width = 76 } = options
+  const paint = painter(colour)
+  const { facts } = result
+  const lines = ['']
+
+  const label = { keep: 'PASS', review: 'REVIEW', fail: 'FAIL' }[result.verdict]
+  const tint = { keep: COLOURS.green, review: COLOURS.yellow, fail: COLOURS.red }[result.verdict]
+  lines.push(`${paint(tint, label)}  ${paint(COLOURS.bold, HEADLINES[result.verdict])}`)
+  lines.push('')
+
+  const row = (/** @type {string} */ name, /** @type {string} */ value) =>
+    lines.push(`      ${paint(COLOURS.dim, name.padEnd(12))} ${value}`)
+  row('Encoding', facts.encoding)
+  row(
+    'Length',
+    `${facts.characters} character${facts.characters === 1 ? '' : 's'}, ${facts.units} ` +
+      (facts.encoding === 'GSM-7' ? 'septets' : 'UTF-16 units'),
+  )
+  const over = facts.segments > facts.maxSegments
+  row(
+    'Segments',
+    `${over ? paint(COLOURS.red, String(facts.segments)) : facts.segments} of up to ${facts.perSegment} ` +
+      `units each (limit ${facts.maxSegments})`,
+  )
+  const r = facts.recipient
+  if (r) {
+    const where = [r.number ?? r.input, r.region, r.timezone].filter(Boolean).join(', ')
+    row('Recipient', where)
+    if (r.local.length > 0) {
+      for (const [i, t] of r.local.entries()) {
+        const mark = t.inWindow ? 'inside' : paint(COLOURS.red, 'outside')
+        const zone = r.local.length > 1 ? ` in ${t.timezone}` : ''
+        row(i === 0 ? 'Local time' : '', `${t.label}${zone}, ${mark} ${facts.window}`)
+      }
+    }
+  } else {
+    row('Recipient', paint(COLOURS.dim, 'not given, send time not checked'))
+  }
+
+  for (const verdict of /** @type {const} */ (['fail', 'review', 'keep'])) {
+    const reasons = result.reasons.filter((x) => x.verdict === verdict)
+    if (reasons.length === 0) continue
+    lines.push('')
+    lines.push(
+      verdict === 'fail'
+        ? paint(COLOURS.red, 'FAIL')
+        : verdict === 'review'
+          ? paint(COLOURS.yellow, 'REVIEW')
+          : paint(COLOURS.dim, 'NOTE'),
+    )
+    for (const reason of reasons) {
+      lines.push(`  ${paint(COLOURS.bold, REASON_TITLES[reason.code])}`)
+      lines.push(wrap(reason.detail, width - 6, '      '))
+    }
+  }
+
+  if (result.notes.length) {
+    lines.push('')
+    for (const note of result.notes) lines.push(paint(COLOURS.dim, wrap(note, width - 2, '  ')))
+  }
+
+  lines.push('')
+  return lines.join('\n')
+}
+
+/**
+ * @param {Part[]} parts
+ * @param {{ maxSegments: number, colour?: boolean }} options
+ * @returns {string}
+ */
+export function formatSplit(parts, options) {
+  const { maxSegments, colour = true } = options
+  const paint = painter(colour)
+  const lines = ['']
+  const n = parts.length
+  lines.push(
+    `${paint(COLOURS.green, 'PASS')}  ${paint(COLOURS.bold, `${n} message${n === 1 ? '' : 's'}`)}` +
+      paint(COLOURS.dim, `, each within ${maxSegments} segment${maxSegments === 1 ? '' : 's'}. Send them in order.`),
+  )
+  for (const [i, part] of parts.entries()) {
+    lines.push('')
+    lines.push(
+      `  ${paint(COLOURS.bold, `${i + 1}/${n}`)}  ` +
+        paint(
+          COLOURS.dim,
+          `${part.segments} segment${part.segments === 1 ? '' : 's'}, ${part.encoding}, ` +
+            `${part.characters} characters`,
+        ),
+    )
+    for (const line of part.text.split('\n')) lines.push(`      ${line}`)
+  }
+  lines.push('')
+  return lines.join('\n')
+}

package/src/segments.js

@@ -0,0 +1,139 @@
+import { GSM_BASIC, GSM_EXTENSION, GSM_REPLACEMENTS } from './data/gsm.js'
+
+/**
+ * @typedef {'GSM-7'|'UCS-2'} Encoding
+ *
+ * @typedef {object} SegmentCount
+ * @property {Encoding} encoding
+ * @property {number} characters Unicode code points, what a person would count.
+ * @property {number} units What the network counts: septets for GSM-7 (an extension
+ *   character is two), UTF-16 code units for UCS-2 (an emoji is usually two).
+ * @property {number} segments Parts the message is sent as. 0 for an empty message.
+ * @property {number} perSegment Units that fit in each part: 160 or 70 alone, 153 or
+ *   67 once a message is split, since the rest of each part carries the header that
+ *   joins them back together.
+ *
+ * @typedef {object} Ucs2Character
+ * @property {string} char
+ * @property {string} codePoint As U+XXXX.
+ * @property {number} count Times it appears.
+ * @property {string | null} replacement A GSM-7 equivalent, offered only for
+ *   typographic characters such as curly quotes, dashes and odd spaces.
+ */
+
+/** Units per message: [single, per part once concatenated]. */
+export const LIMITS = {
+  'GSM-7': { single: 160, part: 153 },
+  'UCS-2': { single: 70, part: 67 },
+}
+
+/**
+ * GSM-7 when every character is in the default alphabet or its extension table,
+ * UCS-2 otherwise. One character outside both is enough to switch the whole message.
+ *
+ * @param {string} text
+ * @returns {Encoding}
+ */
+export function encodingOf(text) {
+  for (const char of text) {
+    if (!GSM_BASIC.has(char) && !GSM_EXTENSION.has(char)) return 'UCS-2'
+  }
+  return 'GSM-7'
+}
+
+/**
+ * What one character costs in the given encoding.
+ *
+ * @param {string} char One code point.
+ * @param {Encoding} encoding
+ * @returns {number}
+ */
+export function unitCost(char, encoding) {
+  if (encoding === 'GSM-7') return GSM_EXTENSION.has(char) ? 2 : 1
+  return char.length // 2 for anything outside the Basic Multilingual Plane
+}
+
+/**
+ * Counts segments the way the network does. A GSM-7 escape pair, or a UTF-16
+ * surrogate pair, is never cut across two parts: when it does not fit in what is left
+ * of a part, the part is sent short and the pair starts the next one.
+ *
+ * @param {string} text
+ * @returns {SegmentCount}
+ */
+export function countSegments(text) {
+  const encoding = encodingOf(text)
+  const { single, part } = LIMITS[encoding]
+  let characters = 0
+  let units = 0
+  /** @type {number[]} */
+  const costs = []
+  for (const char of text) {
+    const cost = unitCost(char, encoding)
+    characters++
+    units += cost
+    costs.push(cost)
+  }
+
+  if (units === 0) return { encoding, characters, units, segments: 0, perSegment: single }
+  if (units <= single) return { encoding, characters, units, segments: 1, perSegment: single }
+
+  let segments = 1
+  let used = 0
+  for (const cost of costs) {
+    if (used + cost > part) {
+      segments++
+      used = cost
+    } else {
+      used += cost
+    }
+  }
+  return { encoding, characters, units, segments, perSegment: part }
+}
+
+/**
+ * The characters that force a message into UCS-2, each once, in order of first
+ * appearance, with a GSM-7 replacement where one reads the same.
+ *
+ * @param {string} text
+ * @returns {Ucs2Character[]}
+ */
+export function ucs2Characters(text) {
+  /** @type {Map<string, Ucs2Character>} */
+  const found = new Map()
+  for (const char of text) {
+    if (GSM_BASIC.has(char) || GSM_EXTENSION.has(char)) continue
+    const entry = found.get(char)
+    if (entry) {
+      entry.count++
+    } else {
+      found.set(char, {
+        char,
+        codePoint: codePointOf(char),
+        count: 1,
+        replacement: GSM_REPLACEMENTS.get(char) ?? null,
+      })
+    }
+  }
+  return [...found.values()]
+}
+
+/**
+ * Applies the typographic replacements, and nothing else.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function replaceTypographic(text) {
+  let out = ''
+  for (const char of text) out += GSM_REPLACEMENTS.get(char) ?? char
+  return out
+}
+
+/**
+ * @param {string} char
+ * @returns {string}
+ */
+export function codePointOf(char) {
+  return `U+${(char.codePointAt(0) ?? 0).toString(16).toUpperCase().padStart(4, '0')}`
+}

package/src/split.js

@@ -0,0 +1,127 @@
+import { countSegments } from './segments.js'
+
+/**
+ * @typedef {import('./segments.js').Encoding} Encoding
+ *
+ * @typedef {object} Part
+ * @property {string} text
+ * @property {Encoding} encoding Worked out for this part alone: a part with no
+ *   accented letters can go back to GSM-7.
+ * @property {number} characters
+ * @property {number} units
+ * @property {number} segments
+ *
+ * @typedef {object} SplitOptions
+ * @property {number} [maxSegments] Most segments any one part may use. Default 5.
+ */
+
+export const DEFAULT_MAX_SEGMENTS = 5
+
+/**
+ * Where a message may be broken, from the most natural to the last resort, and what
+ * goes back between two pieces when they are packed into the same part.
+ *
+ * @type {Array<{ split: (text: string) => string[], join: string }>}
+ */
+const LEVELS = [
+  { split: (t) => t.split(/\n[ \t]*\n\s*/), join: '\n\n' }, // paragraphs
+  { split: (t) => t.split(/\n/), join: '\n' }, // lines
+  { split: (t) => t.split(/(?<=[.!?\u2026])\s+/), join: ' ' }, // sentences
+  { split: (t) => t.split(/\s+/), join: ' ' }, // words
+]
+
+/**
+ * Splits a message into parts that each fit within maxSegments, to be sent in order
+ * as separate texts. Breaks at a blank line where it can, then a line, then a
+ * sentence, then a word, and only cuts inside a word when a single word is too long.
+ * Parts are packed greedily, so there are as few as the breaks allow. Whitespace at
+ * each break is dropped. A GSM-7 escape pair or a surrogate pair is never cut, since
+ * the text is only ever cut between whole characters.
+ *
+ * @param {string} text
+ * @param {SplitOptions} [options]
+ * @returns {Part[]} Empty for a message with nothing but whitespace.
+ */
+export function splitMessage(text, options = {}) {
+  const { maxSegments = DEFAULT_MAX_SEGMENTS } = options
+  if (!Number.isInteger(maxSegments) || maxSegments < 1) {
+    throw new RangeError(`maxSegments must be a whole number of 1 or more, got ${maxSegments}`)
+  }
+  const fits = (/** @type {string} */ t) => countSegments(t).segments <= maxSegments
+  const body = String(text).trim()
+  if (!body) return []
+  return pack(body, 0, fits).map(describe)
+}
+
+/**
+ * @param {string} text Trimmed, not empty.
+ * @param {number} level
+ * @param {(text: string) => boolean} fits
+ * @returns {string[]}
+ */
+function pack(text, level, fits) {
+  if (fits(text)) return [text]
+  if (level >= LEVELS.length) return hardSplit(text, fits)
+
+  const { split, join } = LEVELS[level]
+  const pieces = split(text)
+    .map((p) => p.trim())
+    .filter(Boolean)
+  if (pieces.length <= 1) return pack(text, level + 1, fits)
+
+  /** @type {string[]} */
+  const out = []
+  /** @type {string | null} */
+  let current = null
+  for (const piece of pieces) {
+    if (!fits(piece)) {
+      if (current !== null) out.push(current)
+      const sub = pack(piece, level + 1, fits)
+      out.push(...sub.slice(0, -1))
+      current = sub[sub.length - 1]
+      continue
+    }
+    if (current === null) {
+      current = piece
+    } else if (fits(current + join + piece)) {
+      current = current + join + piece
+    } else {
+      out.push(current)
+      current = piece
+    }
+  }
+  if (current !== null) out.push(current)
+  return out
+}
+
+/**
+ * Cuts between characters, filling each part as far as it goes.
+ *
+ * @param {string} text
+ * @param {(text: string) => boolean} fits
+ * @returns {string[]}
+ */
+function hardSplit(text, fits) {
+  /** @type {string[]} */
+  const out = []
+  let current = ''
+  for (const char of text) {
+    if (current && !fits(current + char)) {
+      out.push(current)
+      current = char
+    } else {
+      current += char
+    }
+  }
+  if (current) out.push(current)
+  return out.map((p) => p.trim()).filter(Boolean)
+}
+
+/**
+ * @param {string} text
+ * @returns {Part}
+ */
+function describe(text) {
+  const { encoding, characters, units, segments } = countSegments(text)
+  return { text, encoding, characters, units, segments }
+}

package/src/version.js

@@ -0,0 +1,6 @@
+import { readFileSync } from 'node:fs'
+
+/** The published version, read from package.json so there is one place to bump it. */
+export const VERSION = /** @type {{ version: string }} */ (
+  JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'))
+).version

package/types/data/countries.d.ts

@@ -0,0 +1,2 @@
+/** @type {Map<string, import('./nanp.js').ZoneEntry>} */
+export const COUNTRY_CODES: Map<string, import("./nanp.js").ZoneEntry>;

package/types/data/gsm.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The GSM 03.38 default alphabet (3GPP TS 23.038), in code order, without the escape
+ * at 0x1B. Non-ASCII characters are written as escapes so no lookalike can creep in.
+ * Note that it is not ASCII: 0x24 is the currency sign, and the backtick is missing.
+ */
+export const GSM_BASIC: Set<string>;
+/**
+ * The extension table: each is sent as the escape plus one septet, so it costs two.
+ */
+export const GSM_EXTENSION: Set<string>;
+/**
+ * Typographic characters with a GSM-7 equivalent that reads the same. Only these are
+ * ever offered as replacements. Accented letters are real text and are left alone.
+ *
+ * @type {Map<string, string>}
+ */
+export const GSM_REPLACEMENTS: Map<string, string>;

package/types/data/nanp.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @typedef {object} ZoneEntry
+ * @property {string} region State, province, territory or country.
+ * @property {string[]} zones IANA zones. More than one means ambiguous.
+ */
+/** @type {Map<string, ZoneEntry>} */
+export const NANP_AREA_CODES: Map<string, ZoneEntry>;
+export type ZoneEntry = {
+    /**
+     * State, province, territory or country.
+     */
+    region: string;
+    /**
+     * IANA zones. More than one means ambiguous.
+     */
+    zones: string[];
+};

package/types/data/shorteners.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Public URL shorteners. Carriers filter links on shared shortener domains, because
+ * anyone can hide any destination behind one. Matched exactly, and on subdomains.
+ */
+export const SHORTENER_DOMAINS: Set<string>;