@agulbra/uts58 0.2.3

package/LICENSE

@@ -0,0 +1,23 @@
+
+Copyright (c) 2025, ICANN
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,257 @@
+# uts58
+
+A JavaScript implementation of [UTS58](https://www.unicode.org/reports/tr58/),
+the Unicode spec for finding links in running text. Given a chunk of text, it
+returns the URLs in it along with their UTF-16 offsets. This is a port of
+the [Ruby `uts58` gem](https://github.com/arnt/uts58); the test suite is the
+same, with very minor differences.
+
+Tested extensively on relevant OSes: [![CI](https://github.com/arnt/uts58/actions/workflows/javascript.yml/badge.svg)](https://github.com/arnt/uts58/actions/workflows/javascript.yml)
+
+## Install
+
+```sh
+npm install @agulbra/uts58
+```
+
+ESM-only; Node 18+ (uses Unicode property escapes and lookbehinds).
+
+## Usage
+
+```js
+import { extractUrls, extractUrlsWithIndices } from '@agulbra/uts58';
+
+extractUrlsWithIndices('see https://example.com/ for details');
+// => [{ url: 'https://example.com/', indices: [4, 24] }]
+
+extractUrls('see https://example.com/ for details');
+// => ['https://example.com/']
+```
+
+The API mirrors `twitter-text`'s `Extractor#extractUrlsWithIndices` closely;
+it was written to provide what Mastodon-style consumers need. The two
+top-level functions above also strip partly overlapping matches via
+`Extractor#removeOverlappingEntities`: candidates are sorted by start
+offset and anything that begins inside an earlier survivor's span is
+dropped. Length doesn't enter into it — the earlier-starting candidate
+wins even if a later one is longer. Import `Extractor` directly if you'd
+rather merge with other extractors (mentions, hashtags, …) and resolve
+overlap across all of them yourself.
+
+Unlike `twitter-text`, the functions take no options object. What counts as
+a link is fixed by [UTS58](https://www.unicode.org/reports/tr58/); there is
+no `extractUrlsWithoutProtocol`-style switch, because the spec already says
+how scheme-less input is handled (see below).
+
+Input without a scheme is recognised, and `https://` is prepended in the
+returned `url`:
+
+```js
+extractUrlsWithIndices('blogspot.com is still a thing');
+// => [{ url: 'https://blogspot.com', indices: [0, 12] }]
+```
+
+IDNs are decoded to use UTF-8 in the output, for better readability:
+
+```js
+extractUrls('xn-----ctdbabcfhu9c2b9l1acccr4c.xn--mgbah1a3hjkrd')[0];
+// => 'https://تجربة-القبول-الشامل.موريتانيا'
+```
+
+(Admittedly that output isn't very readable if you can't read Arabic. But
+the input wasn't readable to anyone, no matter what languages they can read.)
+
+Trailing punctuation, balanced brackets, ports, paths, queries and
+fragments are handled per the spec. Indices in the output are UTF-16
+code unit offsets — the units used by `String.prototype.slice`,
+`String#length`, the DOM, and text editors — so `text.slice(start,
+end)` returns the matched substring directly, even across characters
+outside the BMP. (The Ruby gem reports codepoint offsets instead, which
+are idiomatic for Ruby strings; `example.com/🐪/#camel` is a good test
+of the difference, since the emoji is one codepoint but two UTF-16
+units.)
+
+## Email addresses
+
+```js
+import {
+  extractEmailAddresses,
+  extractEmailAddressesWithIndices,
+  extractEntities,
+  extractEntitiesWithIndices,
+} from '@agulbra/uts58';
+
+extractEmailAddressesWithIndices('contact info@grå.org today');
+// => [{ email: 'info@grå.org', url: 'mailto:info@grå.org', indices: [8, 20] }]
+
+extractEmailAddresses('contact info@grå.org today');
+// => ['info@grå.org']
+```
+
+Each result carries both the bare `email` and a `mailto:` `url`, so it
+drops straight into anything that already renders a `url` entity. The
+domain is IDN-decoded the same way as in `extractUrls`, and a leading
+`mailto:` in the input is absorbed into `indices` per UTS58 5.2.
+
+A plain address overlaps the bare domain that `extractUrls` would find
+after the `@`. `extractEntitiesWithIndices` runs both extractors,
+sorts by start offset, and removes overlaps — the earlier-starting
+email wins over the domain inside it:
+
+```js
+extractEntities('mail arnt@grå.org or see blogspot.com');
+// => ['mailto:arnt@grå.org', 'https://blogspot.com']
+```
+
+## Choosing the public-suffix check
+
+To decide whether `something.example` is a plausible link, the extractor
+checks the host against a public-suffix table. Which table is a bundle-time
+choice — pick the entry point that fits, and your bundler ships only that
+table:
+
+| import | table | gzipped |
+| --- | --- | --- |
+| `@agulbra/uts58` (default) | Public Suffix List, ICANN section | ~5 KB |
+| `@agulbra/uts58/iana` | IANA root-zone TLDs | ~5 KB |
+| `@agulbra/uts58/core` | none — you supply the check | 0 KB |
+
+All three expose the same API. The two tables are about the same size and
+agree on nearly every host — the difference is how strict the check is for
+the handful of TLDs that only register at the second level. `@agulbra/uts58/iana`
+asks only "is the rightmost label a real TLD": enough to tell `blogspot.jp`
+from `blogspot.exe` and to reject typos like `example.cmo`, but it treats a
+bare `foo.za` as plausible. The default `@agulbra/uts58` carries the PSL, which knows
+South Africa registers under `co.za` / `org.za` and so rejects a bare
+`foo.za`. If that distinction doesn't matter to you, the tables are
+interchangeable.
+
+Neither reproduces the PSL's wildcard/exception rules: the question here is
+"could this be a link", not "where is the exact registrable boundary", so a
+flat membership test is all it does. The PSL table is folded accordingly —
+`!` exceptions dropped, `*.foo` collapsed to `foo`, and any suffix made
+redundant by a shorter one removed (with `no` present, `møre-og-romsdal.no`
+is dropped). That folding is what keeps it down to ~5 KB.
+
+`@agulbra/uts58/core` bundles no table at all. Bring your own check — over a suffix
+set, or wrapping a library you already depend on:
+
+```js
+import { Extractor } from '@agulbra/uts58/core';
+import { parse } from 'tldts';
+
+const ex = new Extractor({
+  isPlausibleHost: (host) => {
+    const p = parse(host);
+    return !!p.domain && p.isIcann && p.publicSuffix !== 'invalid';
+  },
+});
+ex.extractUrls('see example.com here');
+```
+
+That route is also how you get exact PSL semantics back, at the cost of a
+dependency you choose rather than one this package forces on you. (`@agulbra/uts58`
+itself depends only on `punycode`.)
+
+## Suggested test cases and notable behaviour
+
+A few sharp edges worth covering in your own tests if you're swapping
+`twitter-text` out, or just using this from scratch.
+
+**The `href` and the visible text are not the same string.** For
+`see example.com here`, the `indices` span
+`example.com`, but `url` is the longer `https://example.com`.
+Use `url` for the `href` attribute, slice the original text by
+`indices` for the visible content. A test that compares
+`text.slice(start, end) === url` will fail on every scheme-less input,
+and on every IDN where A-labels were decoded.
+
+**No options object.** There is no `extractUrlsWithoutProtocol: false`
+switch. If you want only scheme-bearing URLs, filter on the matched
+substring (not on `url`, which always carries `https://`):
+
+```js
+extractUrlsWithIndices(text)
+  .filter((r) => /^https?:\/\//i.test(text.slice(...r.indices)));
+```
+
+**No `autoLink`.** This package extracts; it doesn't render. There's
+no equivalent of `twitter-text`'s `autoLink`, `autoLinkUrlsCustom`,
+`htmlEscape`, etc. — building HTML is the caller's job, which keeps
+escaping decisions where they belong.
+
+**No mentions, hashtags, cashtags, replies.** UTS58 doesn't define
+them, so this package doesn't either. If you need them, run
+`twitter-text` (or another extractor) for those alongside this one and
+merge with `Extractor#removeOverlappingEntities`.
+
+**Overlap resolution is start-wins, not longest-wins.** Worth a test
+when you merge entities from multiple extractors. `ask
+alice@example.com/02074960909 for details` shows why. The raw
+extractors find both email `alice@example.com` at `[4, 21]` and url
+`https://example.com/02074960909` at `[10, 33]`. Start-wins keeps
+`alice@example.com`, which is what a reader would call right, at least
+one who reads 02074960909 as a phone number.
+Longest-wins would keep the longer `https://example.com/02074960909`.
+
+**`maxLength` measures the matched input span.** Not the returned URL.
+A 12-codepoint cap keeps `blogspot.com` (12) and drops
+`https://example.com`, even though the input span and `url` happen to
+be identical there. The asymmetry shows up the other way for
+`example.com` (11 input cp, 19 in `url`) — the cap of 12 keeps it.
+
+Even though most of the API counts in terms of UTF-16, like the String
+class, maxLength uses codepoints. The reason is that most of the API
+is for software developers, but maxLength is for end-users, and
+codepoints are closer to what end-users see. "☺" and "😀" are both one
+codepoint long. (This isn't quite perfect: "é" may be either one or
+two codepoints long and "🇳🇴" is two. Life is hard.)
+
+**`mailto:` is absorbed into `indices`.** Per UTS58 5.2, the input
+`mailto:abcd@example.com` returns an entity whose span covers the
+whole 23-codepoint run, not just the address. The `email` field still
+holds the bare address. If your link-rendering code assumes the span
+starts at the local-part, mailto inputs will surprise it.
+
+## What's not here
+
+- **Link validation.** Recognised URLs are not fetched, normalised
+  beyond IDN decoding, or their hostnames checked in the DNS. There is
+  no attempt at checking for possible attacks (`Мышκин.рф` and
+  `Мышкин.рф` are both detected, note the Greek kappa in the middle of
+  the prince's name).
+
+## Regenerating the generated tables
+
+`src/constants.js` (the link-termination and bracket tables) is packed from
+the Ruby reference's `constants.rb`:
+
+```sh
+npm run maketables
+```
+
+That reads `../ruby/lib/uts58/constants.rb` by default; pass a path to point
+it elsewhere. `constants.rb` is itself generated on the Ruby side, where
+`tools/maketables.rb` downloads the UTS58 data files (`LinkTerm.txt` and
+`LinkBracket.txt`) straight from unicode.org — so the source of truth is
+Unicode's published data, not a copy kept in this repo.
+
+`src/tlds-iana.js` and `src/suffixes-psl.js` are the public-suffix tables.
+With no arguments they're fetched from their canonical sources
+([IANA](https://data.iana.org/TLD/tlds-alpha-by-domain.txt),
+[PSL](https://publicsuffix.org/list/public_suffix_list.dat)); pass local
+paths to regenerate offline:
+
+```sh
+npm run maketlds
+npm run maketlds -- /path/to/tlds-alpha-by-domain.txt /path/to/public_suffix_list.dat
+```
+
+## License
+
+BSD-2-Clause. See `LICENSE`.
+
+FWIW, I wrote this as part of my work at ICANN and will maintain it as
+part of the same work. (I resolve problems relating to Unicode in
+domains, email addresses and similar, so more people, more
+communities, can use the internet in the way they prefer.)

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@agulbra/uts58",
+  "version": "0.2.3",
+  "description": "UTS #58 web-link extraction for JavaScript.",
+  "type": "module",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./iana": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index-iana.js"
+    },
+    "./core": {
+      "types": "./src/core.d.ts",
+      "default": "./src/core.js"
+    }
+  },
+  "files": ["src"],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "maketables": "node tools/maketables.js",
+    "maketlds": "node tools/maketlds.js",
+    "prepack": "cp ../LICENSE LICENSE",
+    "postpack": "rm -f LICENSE"
+  },
+  "keywords": ["uts58", "url", "extractor", "idn", "twitter-text"],
+  "author": "Arnt Gulbrandsen <arnt@gulbrandsen.priv.no>",
+  "license": "BSD-2-Clause",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arnt/uts58.git",
+    "directory": "javascript"
+  },
+  "bugs": {
+    "url": "https://github.com/arnt/uts58/issues"
+  },
+  "homepage": "https://github.com/arnt/uts58#readme",
+  "dependencies": {
+    "punycode": "^2.3.1"
+  }
+}

package/src/api.js

@@ -0,0 +1,37 @@
+// The six module-level convenience functions, built over one shared
+// Extractor. Factored out so each entry point (default/PSL, /iana, and a
+// caller's own /core instance) gets the identical wrappers without copying
+// them. Each wrapper drops overlapping candidates, keeping the
+// earlier-starting one.
+
+export function makeApi(shared) {
+  const extractUrlsWithIndices = (text) =>
+    shared.removeOverlappingEntities(shared.extractUrlsWithIndices(text));
+
+  const extractUrls = (text) =>
+    extractUrlsWithIndices(text).map((r) => r.url);
+
+  const extractEmailAddressesWithIndices = (text) =>
+    shared.removeOverlappingEntities(shared.extractEmailAddressesWithIndices(text));
+
+  const extractEmailAddresses = (text) =>
+    extractEmailAddressesWithIndices(text).map((r) => r.email);
+
+  const extractEntitiesWithIndices = (text) =>
+    shared.removeOverlappingEntities([
+      ...shared.extractUrlsWithIndices(text),
+      ...shared.extractEmailAddressesWithIndices(text),
+    ]);
+
+  const extractEntities = (text) =>
+    extractEntitiesWithIndices(text).map((e) => e.url);
+
+  return {
+    extractUrlsWithIndices,
+    extractUrls,
+    extractEmailAddressesWithIndices,
+    extractEmailAddresses,
+    extractEntitiesWithIndices,
+    extractEntities,
+  };
+}

package/src/constants.js

@@ -0,0 +1,103 @@
+// Generated by tools/maketables.js from the Ruby reference's constants.rb.
+// Do not edit by hand; rerun the generator instead.
+
+export const OPENERS = new Map([
+  [0x29, 0x28],
+  [0x3e, 0x3c],
+  [0x5d, 0x5b],
+  [0x7d, 0x7b],
+  [0xf3b, 0xf3a],
+  [0xf3d, 0xf3c],
+  [0x169c, 0x169b],
+  [0x2046, 0x2045],
+  [0x207e, 0x207d],
+  [0x208e, 0x208d],
+  [0x2309, 0x2308],
+  [0x230b, 0x230a],
+  [0x2769, 0x2768],
+  [0x276b, 0x276a],
+  [0x276d, 0x276c],
+  [0x276f, 0x276e],
+  [0x2771, 0x2770],
+  [0x2773, 0x2772],
+  [0x2775, 0x2774],
+  [0x27c6, 0x27c5],
+  [0x27e7, 0x27e6],
+  [0x27e9, 0x27e8],
+  [0x27eb, 0x27ea],
+  [0x27ed, 0x27ec],
+  [0x27ef, 0x27ee],
+  [0x2984, 0x2983],
+  [0x2986, 0x2985],
+  [0x2988, 0x2987],
+  [0x298a, 0x2989],
+  [0x298c, 0x298b],
+  [0x298e, 0x298f],
+  [0x2990, 0x298d],
+  [0x2992, 0x2991],
+  [0x2994, 0x2993],
+  [0x2996, 0x2995],
+  [0x2998, 0x2997],
+  [0x29d9, 0x29d8],
+  [0x29db, 0x29da],
+  [0x29fd, 0x29fc],
+  [0x2e23, 0x2e22],
+  [0x2e25, 0x2e24],
+  [0x2e27, 0x2e26],
+  [0x2e29, 0x2e28],
+  [0x2e56, 0x2e55],
+  [0x2e58, 0x2e57],
+  [0x2e5a, 0x2e59],
+  [0x2e5c, 0x2e5b],
+  [0x3009, 0x3008],
+  [0x300b, 0x300a],
+  [0x300d, 0x300c],
+  [0x300f, 0x300e],
+  [0x3011, 0x3010],
+  [0x3015, 0x3014],
+  [0x3017, 0x3016],
+  [0x3019, 0x3018],
+  [0x301b, 0x301a],
+  [0xfe5a, 0xfe59],
+  [0xfe5c, 0xfe5b],
+  [0xfe5e, 0xfe5d],
+  [0xff09, 0xff08],
+  [0xff3d, 0xff3b],
+  [0xff5d, 0xff5b],
+  [0xff60, 0xff5f],
+  [0xff63, 0xff62],
+]);
+
+const KIND_INCLUDE = 0, KIND_SOFT = 1, KIND_OPEN = 2, KIND_CLOSE = 3;
+export const TERMINATION_KIND = Object.freeze({
+  include: KIND_INCLUDE, soft: KIND_SOFT, open: KIND_OPEN, close: KIND_CLOSE,
+});
+
+const _startsB64 = "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";
+const _packedB64 = "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";
+
+function _decode(b64) {
+  const bin = Buffer.from(b64, 'base64');
+  return new Uint32Array(bin.buffer, bin.byteOffset, bin.byteLength / 4);
+}
+
+const STARTS = _decode(_startsB64);
+const PACKED = _decode(_packedB64);
+
+// Returns one of KIND_INCLUDE/SOFT/OPEN/CLOSE for cp, or -1 when cp has no
+// entry — which means Hard, the UTS58 @missing default. Binary search over a
+// flat run-length encoding; generated from constants.rb so the answers match
+// the Ruby reference implementation.
+export function terminationKind(cp) {
+  let lo = 0, hi = STARTS.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >>> 1;
+    const s = STARTS[mid];
+    const p = PACKED[mid];
+    const end = p >>> 2;
+    if (cp < s) hi = mid - 1;
+    else if (cp > end) lo = mid + 1;
+    else return p & 3;
+  }
+  return -1;
+}

package/src/core.d.ts

@@ -0,0 +1,32 @@
+// Types for 'uts58/core' — the extractor with no public-suffix table.
+
+import type { UrlEntity, EmailEntity, Entity } from './index.js';
+
+export {
+  Extractor,
+  type ExtractorOptions,
+  type UrlEntity,
+  type EmailEntity,
+  type Entity,
+  type Indices,
+} from './index.js';
+
+/** The six convenience wrappers bound to one extractor. */
+export interface Api {
+  extractUrlsWithIndices(text: string): UrlEntity[];
+  extractUrls(text: string): string[];
+  extractEmailAddressesWithIndices(text: string): EmailEntity[];
+  extractEmailAddresses(text: string): string[];
+  extractEntitiesWithIndices(text: string): Entity[];
+  extractEntities(text: string): string[];
+}
+
+/** Build a host-plausibility predicate over a flat set of public suffixes
+ * (lower-cased, A-label folded). A host passes when some trailing run of its
+ * labels is in the set and at least one label sits in front of it. */
+export declare function makeHostChecker(
+  suffixes: Set<string>,
+): (host: string) => boolean;
+
+/** Build the six convenience functions over a shared extractor instance. */
+export declare function makeApi(shared: import('./index.js').Extractor): Api;

package/src/core.js

@@ -0,0 +1,21 @@
+// 'uts58/core': the extractor with no public-suffix table bundled. Bring
+// your own host validator: either build one over a suffix set with
+// makeHostChecker, or wrap a library you already depend on:
+//
+//   import { Extractor } from 'uts58/core';
+//   import { parse } from 'tldts';
+//   const ex = new Extractor({
+//     isPlausibleHost: (h) => {
+//       const p = parse(h);
+//       return !!p.domain && p.isIcann && p.publicSuffix !== 'invalid';
+//     },
+//   });
+//   ex.extractUrls('see example.com here');
+//
+// With no `isPlausibleHost`, any host that clears the syntax rules (≥2
+// labels, length, etc.) is accepted. This is useful when some later stage
+// does the real validation, perhaps using an actual DNS lookup.
+
+export { Extractor } from './extractor.js';
+export { makeHostChecker } from './plausible.js';
+export { makeApi } from './api.js';

package/src/extractor.js

@@ -0,0 +1,383 @@
+// JavaScript port of the Ruby `Uts58::Extractor`. UTS58 link
+// extraction; see https://github.com/arnt/uts58 Ruby
+// implementation. Behavioural notes that differ from the Ruby are
+// flagged inline; everything else is meant to match.
+
+import punycode from 'punycode/punycode.js';
+import {
+  OPENERS,
+  TERMINATION_KIND,
+  terminationKind,
+} from './constants.js';
+
+const PATH_CLOSERS = new Set([0x23, 0x2f, 0x3f]); // # / ?
+const QUERY_CLOSERS = new Set([0x23]);            // #
+const FRAGMENT_CLOSERS = new Set();
+const NO_SEPARATORS = new Set();
+const QUERY_SEPARATORS = new Set([0x3d, 0x26]);          // = &
+const DIRECTIVE_SEPARATORS = new Set([0x2c, 0x3d, 0x26]); // , = &
+
+// The Ruby `\p{Alnum}` class is letters + numbers only; JS doesn't
+// ship that as a single property escape, so we spell it out.
+const ALNUM = '\\p{L}\\p{N}';
+const LNM = '\\p{L}\\p{N}\\p{M}';
+const SEP_EXTRAS = '\\u00DF\\u03C2\\u06FD\\u06FE\\u0F0B\\u3007';
+
+// The '@' in the negative lookbehind is non-obvious: UTS58 has no
+// userinfo, so a host that immediately follows an '@' may be part of
+// an email address (or perhaps a bluesky/mastodon address) but it cannot
+// be a http(s) URL. The rest of the set just keeps a trigger from
+// firing inside a word, number, or path.
+const TRIGGER_RE = new RegExp(
+  `(?<![-${ALNUM}\\p{M}.\\/@])(?=[${ALNUM}][-${LNM}${SEP_EXTRAS}]*[.:。])`,
+  'gu',
+);
+
+const SCHEME_RE = new RegExp(
+  '^([\\p{Script=Han}\\p{Script=Hiragana}\\p{Script=Katakana}\\p{Script=Hangul}\\p{Script=Thai}\\p{Script=Lao}\\p{Script=Khmer}\\p{Script=Myanmar}]*?)(https?:\\/\\/)',
+  'iu',
+);
+
+const PREFIX_RE = new RegExp(
+  `^(?:[-${LNM}${SEP_EXTRAS}]+[.。]){1,4}[-${LNM}]+(?![-${LNM}])`,
+  'u',
+);
+
+const PORT_RE = /^:(\d+)/;
+
+// The widest slice we ever hand to an anchored host/scheme match. A host is
+// rejected past 254 cp and a scheme is tiny, so nothing legitimate reaches
+// this limit. This protects the server against malevolent input.
+const MAX_HOST_SCAN_CP = 262;
+
+// One local-part character. We walk left from an '@' testing this rather
+// than slicing the whole preceding text and matching it anchored, which was
+// O(prefix) per '@'. XID_Continue covers the letters/digits/marks UTS58
+// allows; the punctuation set is the dot-atom-plus-extras from the spec.
+const LP_CHAR = new RegExp("[\\p{XID_Continue}.!#$%&'*+\\-/=?^_`{|}~]", 'u');
+
+// RFC5321 caps a local-part at 64 octets. If a candidate is longer,
+// we reject the whole candidate, rather than assume that some suffix
+// is an address.
+const MAX_LOCALPART_CP = 64;
+
+// Convert a UTF-16 string into an array of codepoint strings, so the
+// rest of the pipeline can index by codepoint exactly like the Ruby
+// version. Each element holds one full codepoint (1 or 2 UTF-16
+// units).
+function toCodepoints(s) {
+  return Array.from(s);
+}
+
+function cpSlice(cps, start, end) {
+  return cps.slice(start, end).join('');
+}
+
+// Codepoint index → UTF-16 offset, as a prefix sum of codepoint widths. The
+// scan runs in codepoints to mirror the Ruby, but the public indices are
+// UTF-16 so they drop straight into String.prototype.slice, the DOM, and
+// editors. (Ruby keeps codepoint offsets, idiomatic for Ruby strings.)
+function utf16Offsets(cps) {
+  const off = new Int32Array(cps.length + 1);
+  for (let c = 0; c < cps.length; c++) off[c + 1] = off[c] + cps[c].length;
+  return off;
+}
+
+// Returns true if a soft terminator at position i is followed only by
+// more soft terminators and then a hard one (or end of input). Used
+// to decide whether trailing punctuation belongs to the URL or to the
+// surrounding prose.
+function followedByHard(cps, i) {
+  let j = i;
+  while (j < cps.length) {
+    const k = terminationKind(cps[j].codePointAt(0));
+    if (k !== TERMINATION_KIND.soft) break;
+    j++;
+  }
+  if (j >= cps.length) return true;
+  return terminationKind(cps[j].codePointAt(0)) === -1; // -1 == Hard (default)
+}
+
+// Walks one path/query/fragment segment, honouring bracket pairing
+// and the spec's soft/hard terminator distinction. Returns the
+// codepoint index in `cps` at which the segment ends (i.e. the first
+// codepoint not consumed); the caller passes that index back in as
+// the new `start` for the next segment.
+function skipComponent(cps, start, extraClosers, separators = NO_SEPARATORS, directiveSeparators = null) {
+  let openers = [];
+  let seps = separators;
+  for (let i = start; i < cps.length; i++) {
+    if (i === start) continue; // the lead-in character (e.g. '/', '?', '#')
+    const cp = cps[i].codePointAt(0);
+    if (extraClosers.has(cp)) return i;
+    // ':~:' begins a fragment text directive; its own separators take over
+    // and bracket pairing restarts (the directive is a fresh part).
+    if (directiveSeparators && cp === 0x3a && cps[i + 1] === '~' && cps[i + 2] === ':') {
+      openers = [];
+      seps = directiveSeparators;
+      i += 2;
+      continue;
+    }
+    // A separator ends one part of the component. UTS58 pairs brackets per
+    // part, so the open-bracket stack restarts here, but the link continues.
+    if (seps.has(cp)) {
+      openers = [];
+      continue;
+    }
+    const k = terminationKind(cp);
+    if (k === TERMINATION_KIND.include) continue; // part of the link
+    if (k === TERMINATION_KIND.soft) {
+      if (followedByHard(cps, i)) return i;
+    } else if (k === TERMINATION_KIND.close) {
+      const want = OPENERS.get(cp);
+      if (openers.length && openers[openers.length - 1] === want) {
+        openers.pop();
+      } else {
+        return i;
+      }
+    } else if (k === TERMINATION_KIND.open) {
+      openers.push(cp);
+    } else {
+      return i; // -1 (uncovered) == Hard, the UTS58 default: link ends here
+    }
+  }
+  return cps.length;
+}
+
+// IDN A-label → U-label decoding. punycode.toUnicode does the lookup
+// per label, so '.' separation is enough; the caller has already
+// translated the ideographic full stop '。' to '.'.
+function idnToUnicode(host) {
+  try {
+    return punycode.toUnicode(host);
+  } catch {
+    return host;
+  }
+}
+
+// A label may not start or end with a hyphen (the LDH rule), so a host like
+// -foo.example-.com is not a link at all. PREFIX_RE already rejects empty
+// labels; xn-- A-labels pass, since they neither start nor end with '-'.
+function validLabels(host) {
+  return host.split('.').every((label) =>
+    !label.startsWith('-') && !label.endsWith('-'));
+}
+
+export class Extractor {
+  // `isPlausibleHost(host)` decides whether a candidate hostname is
+  // real enough to linkify. Most users want to determine this
+  // locally, without performing e.g. a DNS lookup, but details
+  // vary. This is injected so the table (IANA, PSL, or a tldts-backed
+  // predicate the caller provides) is a bundle-time choice; the entry
+  // points in index.js / index-iana.js wire in a default.
+  //
+  // With no predicate, any host that matches earlier checks is
+  // accepted, which is the table-free 'core' behaviour.
+
+
+  constructor({ isPlausibleHost = () => true } = {}) {
+    this.isPlausibleHost = isPlausibleHost;
+    // Maximum allowed length of the matched text, in input codepoints,
+    // since for a human user, the lengths of ☺ and 😀 ought to be the
+    // same. null means no limit.
+    this.maxLength = null;
+  }
+
+  extractUrlsWithIndices(text) {
+    const cps = toCodepoints(text);
+    const u16 = utf16Offsets(cps); // codepoint index → UTF-16 offset for output
+    const joined = cps.join(''); // identical to text in content, but we
+                                 // also need a UTF-16 → codepoint index map.
+    // Build a map from UTF-16 offset to codepoint index. cpAt[u] is the
+    // number of codepoints starting strictly before UTF-16 offset u.
+    const cpAt = new Int32Array(joined.length + 1);
+    {
+      let cp = 0;
+      for (let u = 0; u < joined.length; u++) {
+        cpAt[u] = cp;
+        const code = joined.charCodeAt(u);
+        // a high surrogate consumes two UTF-16 units for one codepoint
+        if (code >= 0xd800 && code <= 0xdbff && u + 1 < joined.length) {
+          cpAt[u + 1] = cp;
+          u++;
+        }
+        cp++;
+      }
+      cpAt[joined.length] = cp;
+    }
+
+    const result = [];
+    TRIGGER_RE.lastIndex = 0;
+    let m;
+    while ((m = TRIGGER_RE.exec(joined)) !== null) {
+      // Zero-width lookahead match: advance lastIndex by one UTF-16
+      // unit (or one codepoint) so we don't loop forever.
+      const triggerU16 = m.index;
+      const triggerCp = cpAt[triggerU16];
+      {
+        const code = joined.charCodeAt(triggerU16);
+        TRIGGER_RE.lastIndex = triggerU16 +
+          (code >= 0xd800 && code <= 0xdbff ? 2 : 1);
+      }
+
+      // post_match: everything from the trigger onward, as a
+      // codepoint-indexed view. We'll work in codepoint indices and
+      // build the result substring from `cps`.
+      const postStart = triggerCp;
+
+      // Allow letter/mark/number characters between the trigger and a
+      // scheme like "http://". post_match string for SCHEME_RE:
+      const postStr = cpSlice(cps, postStart,
+        Math.min(cps.length, postStart + MAX_HOST_SCAN_CP));
+      let schemeOffset = 0; // codepoints between trigger and the actual link start
+      let proto = 'https://';
+      let prefixStart = postStart;
+      const sm = SCHEME_RE.exec(postStr);
+      if (sm) {
+        schemeOffset = toCodepoints(sm[1]).length;
+        proto = sm[2];
+        prefixStart = postStart + schemeOffset + toCodepoints(sm[2]).length;
+      }
+
+      // Prefix: the candidate hostname.
+      const prefixStr = cpSlice(cps, prefixStart,
+        Math.min(cps.length, prefixStart + MAX_HOST_SCAN_CP));
+      const pm = PREFIX_RE.exec(prefixStr);
+      if (!pm) continue;
+      const prefixCpLen = toCodepoints(pm[0]).length;
+      if (prefixCpLen >= 254) continue;
+
+      const hostRaw = pm[0].replace(/。/g, '.');
+      if (!validLabels(hostRaw)) continue;
+      const hn = idnToUnicode(hostRaw);
+      if (!this.isPlausibleHost(hn)) continue;
+
+      // Walk an optional trailing root-label dot, the optional port, then any
+      // number of path segments, then an optional query, then an optional
+      // fragment.
+      let i = prefixStart + prefixCpLen;
+      // "example.com." keeps its trailing dot only when a path, query, or
+      // fragment follows; at the end of a sentence the dot is prose (UTS58).
+      if (cps[i] === '.' &&
+          (cps[i + 1] === '/' || cps[i + 1] === '?' || cps[i + 1] === '#')) {
+        i++;
+      }
+      const restStr = () => cpSlice(cps, i, Math.min(cps.length, i + 8));
+
+      const pmPort = PORT_RE.exec(restStr());
+      if (pmPort) {
+        const n = parseInt(pmPort[1], 10);
+        if (n < 1 || n > 65535) continue;
+        i += pmPort[0].length; // ASCII digits + colon, so length == cp count
+      }
+
+      while (cps[i] === '/') i = skipComponent(cps, i, PATH_CLOSERS);
+      if (cps[i] === '?') i = skipComponent(cps, i, QUERY_CLOSERS, QUERY_SEPARATORS);
+      if (cps[i] === '#') i = skipComponent(cps, i, FRAGMENT_CLOSERS, NO_SEPARATORS, DIRECTIVE_SEPARATORS);
+
+      const restLen = i - (prefixStart + prefixCpLen);
+      // Length of the matched span in the *input*, measured in
+      // codepoints from the start of the link (after any scheme
+      // offset) to wherever we stopped.
+      const matchLength = (i - postStart) - schemeOffset;
+      if (this.maxLength != null && matchLength > this.maxLength) continue;
+
+      const start = postStart + schemeOffset;
+      const tail = cpSlice(cps, prefixStart + prefixCpLen, prefixStart + prefixCpLen + restLen);
+      result.push({
+        url: `${proto}${hn}${tail}`,
+        indices: [u16[start], u16[start + matchLength]],
+      });
+    }
+    return result;
+  }
+
+  extractUrls(text) {
+    return this.extractUrlsWithIndices(text).map((r) => r.url);
+  }
+
+  // Returns every email address found in `text` as a list of objects:
+  //
+  //   { email: String, url: String, indices: [start, end] }
+  //
+  // `email` is the bare address ("info@example.com"); `url` is the same
+  // thing as a mailto: URL, so the result drops straight into anything
+  // that already renders a `url` entity. Both carry the IDN-decoded
+  // domain. `indices` are UTF-16 offsets, `end` exclusive, and absorb a
+  // leading "mailto:" if the input had one (UTS58 5.2).
+  extractEmailAddressesWithIndices(text) {
+    const cps = toCodepoints(text);
+    const u16 = utf16Offsets(cps); // codepoint index → UTF-16 offset for output
+    const result = [];
+    for (let at = 0; at < cps.length; at++) {
+      if (cps[at] !== '@') continue;
+
+      // Walk left over the run of local-part characters. We stop one past
+      // the RFC 5321 limit and bail: a run longer than that means this isn't
+      // an address, not that its last 64 characters are one. Scanning
+      // (rather than slicing the whole prefix and matching anchored) is what
+      // keeps '@'-dense input from going O(n²).
+      let localStart = at;
+      while (localStart > 0 &&
+             LP_CHAR.test(cps[localStart - 1]) &&
+             at - localStart < MAX_LOCALPART_CP + 1) {
+        localStart--;
+      }
+      const localLen = at - localStart;
+      if (localLen === 0 || localLen > MAX_LOCALPART_CP) continue;
+      const local = cpSlice(cps, localStart, at);
+      if (local.startsWith('.') || local.endsWith('.') || local.includes('..')) {
+        continue;
+      }
+
+      const afterStr = cpSlice(cps, at + 1,
+        Math.min(cps.length, at + 1 + MAX_HOST_SCAN_CP));
+      const pm = PREFIX_RE.exec(afterStr);
+      if (!pm) continue;
+      const prefixCpLen = toCodepoints(pm[0]).length;
+      if (prefixCpLen >= 254) continue;
+
+      const hostRaw = pm[0].replace(/。/g, '.');
+      if (!validLabels(hostRaw)) continue;
+      const hn = idnToUnicode(hostRaw);
+      if (!this.isPlausibleHost(hn)) continue;
+
+      const endPos = at + 1 + prefixCpLen;
+      // UTS58 5.2 step 6: absorb a leading "mailto:" into the span.
+      if (localStart >= 7 &&
+          cpSlice(cps, localStart - 7, localStart).toLowerCase() === 'mailto:') {
+        localStart -= 7;
+      }
+      if (this.maxLength != null && (endPos - localStart) > this.maxLength) {
+        continue;
+      }
+      result.push({
+        email: `${local}@${hn}`,
+        url: `mailto:${local}@${hn}`,
+        indices: [u16[localStart], u16[endPos]],
+      });
+    }
+    return result;
+  }
+
+  extractEmailAddresses(text) {
+    return this.extractEmailAddressesWithIndices(text).map((r) => r.email);
+  }
+
+  // Sorts `entities` by start offset and drops any whose [start, end)
+  // overlaps the survivor before it. The earlier-starting entity wins;
+  // length plays no part, so a long candidate is dropped if it begins
+  // inside a shorter earlier one. Ties on start are broken by input
+  // order. Doesn't mutate `entities`.
+  removeOverlappingEntities(entities) {
+    const sorted = [...entities].sort((a, b) => a.indices[0] - b.indices[0]);
+    const out = [];
+    let prev = null;
+    for (const e of sorted) {
+      if (prev && prev.indices[1] > e.indices[0]) continue;
+      out.push(e);
+      prev = e;
+    }
+    return out;
+  }
+}

package/src/index-iana.js

@@ -0,0 +1,27 @@
+// 'uts58/iana': same API as the default entry, but hosts are checked only
+// against the IANA root-zone TLD list (~5 KB gz vs ~27 KB for the PSL). The
+// rightmost label must be a real TLD; that distinguishes blogspot.jp from
+// blogspot.exe and rejects typos like example.cmo, while accepting a bare
+// co.uk / kawasaki.jp as plausible. The smallest sensible table for the
+// browser.
+
+import { Extractor as CoreExtractor } from './extractor.js';
+import { isPlausibleHost } from './tlds-iana.js';
+import { makeApi } from './api.js';
+
+export class Extractor extends CoreExtractor {
+  constructor(options = {}) {
+    super({ isPlausibleHost, ...options });
+  }
+}
+
+const _shared = new Extractor();
+
+export const {
+  extractUrlsWithIndices,
+  extractUrls,
+  extractEmailAddressesWithIndices,
+  extractEmailAddresses,
+  extractEntitiesWithIndices,
+  extractEntities,
+} = makeApi(_shared);

package/src/index.d.ts

@@ -0,0 +1,73 @@
+// Type declarations for uts58 (the default and /iana entries; /core has its
+// own core.d.ts). Hand-written to match the sources; keep them in sync by
+// hand (there's no build step).
+
+/** A `[start, end)` span in UTF-16 code units — the same units as
+ * `String.prototype.slice`, `String#length`, the DOM, and editors — so
+ * `text.slice(start, end)` returns the matched substring directly. (The Ruby
+ * port reports codepoint offsets instead, idiomatic for Ruby strings.) */
+export type Indices = [start: number, end: number];
+
+/** A web link found in the text. `url` carries the IDN-decoded host and a
+ * scheme (`https://` is prepended when the input had none). */
+export interface UrlEntity {
+  url: string;
+  indices: Indices;
+}
+
+/** An email address found in the text. `email` is the bare address;
+ * `url` is the same address as a `mailto:` URL, so the result drops into
+ * anything that already renders a `url` entity. Both carry the IDN-decoded
+ * domain. */
+export interface EmailEntity {
+  email: string;
+  url: string;
+  indices: Indices;
+}
+
+/** Either kind of entity, as returned by the combined extractors. Narrow on
+ * the presence of `email` to tell them apart. */
+export type Entity = UrlEntity | EmailEntity;
+
+export interface ExtractorOptions {
+  /** Decides whether a candidate hostname is real enough to linkify — the
+   * public-suffix check. The default and /iana entries inject one; on /core
+   * it defaults to accepting any host that clears the shape rules. */
+  isPlausibleHost?: (host: string) => boolean;
+}
+
+/** The underlying extractor. The module-level functions wrap a shared
+ * instance; construct your own to set `maxLength`, swap the host check, or
+ * get the raw, possibly-overlapping list before merging with other
+ * extractors. */
+export declare class Extractor {
+  constructor(options?: ExtractorOptions);
+
+  /** Maximum length of a matched span, in input codepoints, so that
+   *  "☺" "😀" are equal in length. `null` (the * default) means no
+   *  limit. Candidates longer than this are dropped. */
+
+  maxLength: number | null;
+
+  isPlausibleHost: (host: string) => boolean;
+
+  extractUrlsWithIndices(text: string): UrlEntity[];
+  extractUrls(text: string): string[];
+  extractEmailAddressesWithIndices(text: string): EmailEntity[];
+  extractEmailAddresses(text: string): string[];
+
+  /** Drops every entity whose span overlaps an earlier one. Stable; the
+   * earlier-starting entity wins. Does not mutate the input. */
+  removeOverlappingEntities<T extends { indices: Indices }>(entities: T[]): T[];
+}
+
+export declare function extractUrlsWithIndices(text: string): UrlEntity[];
+export declare function extractUrls(text: string): string[];
+export declare function extractEmailAddressesWithIndices(text: string): EmailEntity[];
+export declare function extractEmailAddresses(text: string): string[];
+
+/** Both URLs and email addresses, sorted by start offset with overlaps
+ * removed — an email beats the bare domain that sits inside it after the
+ * `@`. Email addresses appear in their `mailto:` form under `url`. */
+export declare function extractEntitiesWithIndices(text: string): Entity[];
+export declare function extractEntities(text: string): string[];

package/src/index.js

@@ -0,0 +1,34 @@
+// Default entry point: UTS58 web-link extraction, with hosts validated
+// against the Public Suffix List (ICANN section). The six functions are thin
+// wrappers around a shared Extractor; they also drop overlapping candidates,
+// keeping the earlier-starting one.
+//
+//   import { extractUrls, extractUrlsWithIndices } from 'uts58';
+//   extractUrls("see example.com here")              // ["https://example.com"]
+//   extractUrlsWithIndices("see example.com here")   // [{ url: "https://example.com", indices: [4, 15] }]
+//
+// For a smaller table import 'uts58/iana' (root-zone TLDs only); to bring
+// your own validator (e.g. tldts) import { Extractor } from 'uts58/core'.
+
+import { Extractor as CoreExtractor } from './extractor.js';
+import { isPlausibleHost } from './suffixes-psl.js';
+import { makeApi } from './api.js';
+
+// Extractor pre-wired with the PSL check, so `new Extractor()` from this
+// entry validates the same way the module-level functions do.
+export class Extractor extends CoreExtractor {
+  constructor(options = {}) {
+    super({ isPlausibleHost, ...options });
+  }
+}
+
+const _shared = new Extractor();
+
+export const {
+  extractUrlsWithIndices,
+  extractUrls,
+  extractEmailAddressesWithIndices,
+  extractEmailAddresses,
+  extractEntitiesWithIndices,
+  extractEntities,
+} = makeApi(_shared);

package/src/plausible.js

@@ -0,0 +1,29 @@
+// Host-plausibility check over a flat set of public suffixes. The
+// question this answers is "could this be a link?", not "what is the
+// exact registrable domain?". Therefore a flat membership test is
+// enough, and the tabble can be much smaller than if we needed PSL's
+// full wildcard/exception machinery.
+
+// The tables are pre-folded for plausibility; see tools/maketlds.js).
+
+import punycode from 'punycode/punycode.js';
+
+// Build a `(host) => boolean` predicate. A host is plausible when
+// some trailing run of its labels is a known suffix AND has at least
+// one label before the suffix.
+export function makeHostChecker(suffixes) {
+  return (host) => {
+    const folded = host.normalize('NFC').toLowerCase();
+    let ascii;
+    try {
+      ascii = punycode.toASCII(folded);
+    } catch {
+      ascii = folded;
+    }
+    const labels = ascii.split('.');
+    for (let i = labels.length - 1; i >= 1; i--) {
+      if (suffixes.has(labels.slice(i).join('.'))) return true;
+    }
+    return false;
+  };
+}

package/src/suffixes-psl.js

@@ -0,0 +1,9 @@
+// Generated by tools/maketlds.js. Do not edit by hand; rerun the generator.
+// Public Suffix List, ICANN section, folded for plausibility.
+import { makeHostChecker } from './plausible.js';
+
+const SUFFIXES = new Set(
+  "aaa aarp abb abbott abbvie abc able abogado abudhabi ac ac.za academy accenture accountant accountants aco actor ad ads adult ae aeg aero aetna af afl africa ag agakhan agency agric.za ai aig airbus airforce airtel akdn al alibaba alipay allfinanz allstate ally alsace alstom alt.za am amazon americanexpress americanfamily amex amfam amica amsterdam analytics android anquan anz ao aol apartments app apple aq aquarelle ar arab aramco archi army arpa art arte as asda asia associates at athleta attorney au auction audi audible audio auspost author auto autos aw aws ax axa az azure ba baby baidu banamex band bank bar barcelona barclaycard barclays barefoot bargains baseball basketball bauhaus bayern bb bbc bbt bbva bcg bcn bd be beats beauty beer berlin best bestbuy bet bf bg bh bharti bi bible bid bike bing bingo bio biz bj black blackfriday blockbuster blog bloomberg blue bm bms bmw bn bnpparibas bo boats boehringer bofa bom bond boo book booking bosch bostik boston bot boutique box br bradesco bridgestone broadway broker brother brussels bs bt build builders business buy buzz bv bw by bz bzh ca cab cafe cal call calvinklein cam camera camp canon capetown capital capitalone car caravan cards care career careers cars casa case cash casino cat catering catholic cba cbn cbre cc cd center ceo cern cf cfa cfd cg ch chanel channel charity chase chat cheap chintai christmas chrome church ci cipriani circle cisco citadel citi citic city ck cl claims cleaning click clinic clinique clothing cloud club clubmed cm cn co co.za coach codes coffee college cologne com commbank community company compare computer comsec condos construction consulting contact contractors cooking cool coop corsica country coupon coupons courses cpa cr credit creditcard creditunion cricket crown crs cruise cruises cu cuisinella cv cw cx cy cymru cyou cz dad dance data date dating datsun day dclk dds de deal dealer deals degree delivery dell deloitte delta democrat dental dentist desi design dev dhl diamonds diet digital direct directory discount discover dish diy dj dk dm dnp do docs doctor dog domains dot download drive dtv dubai dupont durban dvag dvr dz earth eat ec eco edeka edu edu.za education ee eg email emerck energy engineer engineering enterprises epson equipment er ericsson erni es esq estate et eu eurovision eus events exchange expert exposed express extraspace fage fail fairwinds faith family fan fans farm farmers fashion fast fedex feedback ferrari ferrero fi fidelity fido film final finance financial fire firestone firmdale fish fishing fit fitness fj fk flickr flights flir florist flowers fly fm fo foo food football ford forex forsale forum foundation fox fr free fresenius frl frogans frontier ftr fujitsu fun fund furniture futbol fyi ga gal gallery gallo gallup game games gap garden gay gb gbiz gd gdn ge gea gent genting george gf gg ggee gh gi gift gifts gives giving gl glass gle global globo gm gmail gmbh gmo gmx gn godaddy gold goldpoint golf goodyear goog google gop got gov gov.za gp gq gr grainger graphics gratis green gripe grocery grondar.za group gs gt gu gucci guge guide guitars guru gw gy hair hamburg hangout haus hbo hdfc hdfcbank health healthcare help helsinki here hermes hiphop hisamitsu hitachi hiv hk hkt hm hn hockey holdings holiday homedepot homegoods homes homesense honda horse hospital host hosting hot hotel hotels hotmail house how hr hsbc ht hu hughes hyatt hyundai ibm icbc ice icu id ie ieee ifm ikano il im imamat imdb immo immobilien in inc industries infiniti info ing ink institute insurance insure int international intuit investments io ipiranga iq ir irish is ismaili ist istanbul it itau itv jaguar java jcb je jeep jetzt jewelry jio jll jm jmp jnj jo jobs joburg jot joy jp jpmorgan jprs juegos juniper kaufen kddi ke kerryhotels kerryproperties kfh kg kh ki kia kids kim kindle kitchen kiwi km kn koeln komatsu kosher kp kpmg kpn kr krd kred kuokgroup kw ky kyoto kz la lacaixa lamborghini lamer land landrover lanxess lasalle lat latino latrobe law law.za lawyer lb lc lds lease leclerc lefrak legal lego lexus lgbt li lidl life lifeinsurance lifestyle lighting like lilly limited limo lincoln link live living lk llc llp loan loans locker locus lol london lotte lotto love lpl lplfinancial lr ls lt ltd ltda lu lundbeck luxe luxury lv ly ma madrid maif maison makeup man management mango map market marketing markets marriott marshalls mattel mba mc mckinsey md me med media meet melbourne meme memorial men menu merck merckmsd mg mh miami microsoft mil mil.za mini mint mit mitsubishi mk ml mlb mls mm mma mn mo mobi mobile moda moe moi mom monash money monster mormon mortgage moscow moto motorcycles mov movie mp mq mr ms msd mt mtn mtr mu museum music mv mw mx my mz na nab nagoya name navy nba nc ne nec net net.za netbank netflix network neustar new news next nextdirect nexus nf nfl ng ngo ngo.za nhk ni nic.za nico nike nikon ninja nis.za nissan nissay nl no nokia nom.za norton now nowruz nowtv np nr nra nrw ntt nu nyc nz obi observer office okinawa olayan olayangroup ollo om omega one ong onion onl online ooo open oracle orange org org.za organic origins osaka otsuka ott ovh pa page panasonic paris pars partners parts party pay pccw pe pet pf pfizer pg ph pharmacy phd philips phone photo photography photos physio pics pictet pictures pid pin ping pink pioneer pizza pk pl place play playstation plumbing plus pm pn pnc pohl poker politie porn post pr praxi press prime pro prod productions prof progressive promo properties property protection pru prudential ps pt pub pw pwc py qa qpon quebec quest racing radio re read realestate realtor realty recipes red redumbrella rehab reise reisen reit reliance ren rent rentals repair report republican rest restaurant review reviews rexroth rich richardli ricoh ril rio rip ro rocks rodeo rogers room rs rsvp ru rugby ruhr run rw rwe ryukyu sa saarland safe safety sakura sale salon samsclub samsung sandvik sandvikcoromant sanofi sap sarl sas save saxo sb sbi sbs sc scb schaeffler schmidt scholarships school school.za schule schwarz science scot sd se search seat secure security seek select sener services seven sew sex sexy sfr sg sh shangrila sharp shell shia shiksha shoes shop shopping shouji show si silk sina singles site sj sk ski skin sky skype sl sling sm smart smile sn sncf so soccer social softbank software sohu solar solutions song sony soy spa space sport spot sr srl ss st stada staples star statebank statefarm stc stcgroup stockholm storage store stream studio study style su sucks supplies supply support surf surgery suzuki sv swatch swiss sx sy sydney systems sz tab taipei talk taobao target tatamotors tatar tattoo tax taxi tc tci td tdk team tech technology tel temasek tennis teva tf tg th thd theater theatre tiaa tickets tienda tips tires tirol tj tjmaxx tjx tk tkmaxx tl tm tm.za tmall tn to today tokyo tools top toray toshiba total tours town toyota toys tr trade trading training travel travelers travelersinsurance trust trv tt tube tui tunes tushu tv tvs tw tz ua ubank ubs ug uk unicom university uno uol ups us uy uz va vacations vana vanguard vc ve vegas ventures verisign versicherung vet vg vi viajes video vig viking villas vin vip virgin visa vision viva vivo vlaanderen vn vodka volvo vote voting voto voyage vu wales walmart walter wang wanggou watch watches weather weatherchannel web.za webcam weber website wed wedding weibo weir wf whoswho wien wiki williamhill win windows wine winners wme woodside work works world wow ws wtc wtf xbox xerox xihuan xin xn--11b4c3d xn--1ck2e1b xn--1qqw23a xn--2scrj9c xn--30rr7y xn--3bst00m xn--3ds443g xn--3e0b707e xn--3hcrj9c xn--3pxu8k xn--42c2d9a xn--45br5cyl xn--45brj9c xn--45q11c xn--4dbrk0ce xn--4gbrim xn--54b7fta0cc xn--55qw42g xn--55qx5d xn--5su34j936bgsg xn--5tzm5g xn--6frz82g xn--6qq986b3xl xn--80adxhks xn--80ao21a xn--80aqecdr1a xn--80asehdb xn--80aswg xn--8y0a063a xn--90a3ac xn--90ae xn--90ais xn--9dbq2a xn--9et52u xn--9krt00a xn--b4w605ferd xn--bck1b9a5dre4c xn--c1avg xn--c2br7g xn--cck2b3b xn--cckwcxetd xn--cg4bki xn--clchc0ea0b2g2a9gcd xn--czr694b xn--czrs0t xn--czru2d xn--d1acj3b xn--d1alf xn--e1a4c xn--eckvdtc9d xn--efvy88h xn--fct429k xn--fhbei xn--fiq228c5hs xn--fiq64b xn--fiqs8s xn--fiqz9s xn--fjq720a xn--flw351e xn--fpcrj9c3d xn--fzc2c9e2c xn--fzys8d69uvgm xn--g2xx48c xn--gckr3f0f xn--gecrj9c xn--gk3at1e xn--h2breg3eve xn--h2brj9c xn--h2brj9c8c xn--hxt814e xn--i1b6b1a6a2e xn--imr513n xn--io0a7i xn--j1aef xn--j1amh xn--j6w193g xn--jlq480n2rg xn--jvr189m xn--kcrx77d1x4a xn--kprw13d xn--kpry57d xn--kput3i xn--l1acc xn--lgbbat1ad8j xn--mgb2ddes xn--mgb9awbf xn--mgba3a3ejt xn--mgba3a4f16a xn--mgba3a4fra xn--mgba7c0bbn0a xn--mgbaam7a8h xn--mgbab2bd xn--mgbah1a3hjkrd xn--mgbai9a5eva00b xn--mgbai9azgqp6j xn--mgbayh7gpa xn--mgbbh1a xn--mgbbh1a71e xn--mgbc0a9azcg xn--mgbca7dzdo xn--mgbcpq6gpa1a xn--mgberp4a5d4a87g xn--mgberp4a5d4ar xn--mgbgu82a xn--mgbi4ecexp xn--mgbpl2fh xn--mgbqly7c0a67fbc xn--mgbqly7cvafr xn--mgbt3dhd xn--mgbtf8fl xn--mgbtx2b xn--mgbx4cd0ab xn--mix082f xn--mix891f xn--mk1bu44c xn--mxtq1m xn--ngbc5azd xn--ngbe9e0a xn--ngbrx xn--nnx388a xn--node xn--nqv7f xn--nqv7fs00ema xn--nyqy26a xn--o3cw4h xn--ogbpf8fl xn--otu796d xn--p1acf xn--p1ai xn--pgbs0dh xn--pssy2u xn--q7ce6a xn--q9jyb4c xn--qcka1pmc xn--qxa6a xn--qxam xn--rhqv96g xn--rovu88b xn--rvc1e0am3e xn--s9brj9c xn--ses554g xn--t60b56a xn--tckwe xn--tiq49xqyj xn--unup4y xn--vermgensberater-ctb xn--vermgensberatung-pwb xn--vhquv xn--vuq861b xn--w4r85el8fhu5dnra xn--w4rs40l xn--wgbh1c xn--wgbl6a xn--xhq521b xn--xkc2al3hye2a xn--xkc2dl3a5ee0h xn--y9a3aq xn--yfro4i67o xn--ygbi2ammx xn--zfr164b xxx xyz yachts yahoo yamaxun yandex ye yodobashi yoga yokohama you youtube yt yun zappos zara zero zip zm zone zuerich zw".split(' '),
+);
+
+export const isPlausibleHost = makeHostChecker(SUFFIXES);

package/src/tlds-iana.js

@@ -0,0 +1,9 @@
+// Generated by tools/maketlds.js. Do not edit by hand; rerun the generator.
+// IANA root-zone TLDs: the rightmost label must be a real TLD.
+import { makeHostChecker } from './plausible.js';
+
+const TLDS = new Set(
+  "aaa aarp abb abbott abbvie abc able abogado abudhabi ac academy accenture accountant accountants aco actor ad ads adult ae aeg aero aetna af afl africa ag agakhan agency ai aig airbus airforce airtel akdn al alibaba alipay allfinanz allstate ally alsace alstom am amazon americanexpress americanfamily amex amfam amica amsterdam analytics android anquan anz ao aol apartments app apple aq aquarelle ar arab aramco archi army arpa art arte as asda asia associates at athleta attorney au auction audi audible audio auspost author auto autos aw aws ax axa az azure ba baby baidu banamex band bank bar barcelona barclaycard barclays barefoot bargains baseball basketball bauhaus bayern bb bbc bbt bbva bcg bcn bd be beats beauty beer berlin best bestbuy bet bf bg bh bharti bi bible bid bike bing bingo bio biz bj black blackfriday blockbuster blog bloomberg blue bm bms bmw bn bnpparibas bo boats boehringer bofa bom bond boo book booking bosch bostik boston bot boutique box br bradesco bridgestone broadway broker brother brussels bs bt build builders business buy buzz bv bw by bz bzh ca cab cafe cal call calvinklein cam camera camp canon capetown capital capitalone car caravan cards care career careers cars casa case cash casino cat catering catholic cba cbn cbre cc cd center ceo cern cf cfa cfd cg ch chanel channel charity chase chat cheap chintai christmas chrome church ci cipriani circle cisco citadel citi citic city ck cl claims cleaning click clinic clinique clothing cloud club clubmed cm cn co coach codes coffee college cologne com commbank community company compare computer comsec condos construction consulting contact contractors cooking cool coop corsica country coupon coupons courses cpa cr credit creditcard creditunion cricket crown crs cruise cruises cu cuisinella cv cw cx cy cymru cyou cz dad dance data date dating datsun day dclk dds de deal dealer deals degree delivery dell deloitte delta democrat dental dentist desi design dev dhl diamonds diet digital direct directory discount discover dish diy dj dk dm dnp do docs doctor dog domains dot download drive dtv dubai dupont durban dvag dvr dz earth eat ec eco edeka edu education ee eg email emerck energy engineer engineering enterprises epson equipment er ericsson erni es esq estate et eu eurovision eus events exchange expert exposed express extraspace fage fail fairwinds faith family fan fans farm farmers fashion fast fedex feedback ferrari ferrero fi fidelity fido film final finance financial fire firestone firmdale fish fishing fit fitness fj fk flickr flights flir florist flowers fly fm fo foo food football ford forex forsale forum foundation fox fr free fresenius frl frogans frontier ftr fujitsu fun fund furniture futbol fyi ga gal gallery gallo gallup game games gap garden gay gb gbiz gd gdn ge gea gent genting george gf gg ggee gh gi gift gifts gives giving gl glass gle global globo gm gmail gmbh gmo gmx gn godaddy gold goldpoint golf goodyear goog google gop got gov gp gq gr grainger graphics gratis green gripe grocery group gs gt gu gucci guge guide guitars guru gw gy hair hamburg hangout haus hbo hdfc hdfcbank health healthcare help helsinki here hermes hiphop hisamitsu hitachi hiv hk hkt hm hn hockey holdings holiday homedepot homegoods homes homesense honda horse hospital host hosting hot hotels hotmail house how hr hsbc ht hu hughes hyatt hyundai ibm icbc ice icu id ie ieee ifm ikano il im imamat imdb immo immobilien in inc industries infiniti info ing ink institute insurance insure int international intuit investments io ipiranga iq ir irish is ismaili ist istanbul it itau itv jaguar java jcb je jeep jetzt jewelry jio jll jm jmp jnj jo jobs joburg jot joy jp jpmorgan jprs juegos juniper kaufen kddi ke kerryhotels kerryproperties kfh kg kh ki kia kids kim kindle kitchen kiwi km kn koeln komatsu kosher kp kpmg kpn kr krd kred kuokgroup kw ky kyoto kz la lacaixa lamborghini lamer land landrover lanxess lasalle lat latino latrobe law lawyer lb lc lds lease leclerc lefrak legal lego lexus lgbt li lidl life lifeinsurance lifestyle lighting like lilly limited limo lincoln link live living lk llc llp loan loans locker locus lol london lotte lotto love lpl lplfinancial lr ls lt ltd ltda lu lundbeck luxe luxury lv ly ma madrid maif maison makeup man management mango map market marketing markets marriott marshalls mattel mba mc mckinsey md me med media meet melbourne meme memorial men menu merck merckmsd mg mh miami microsoft mil mini mint mit mitsubishi mk ml mlb mls mm mma mn mo mobi mobile moda moe moi mom monash money monster mormon mortgage moscow moto motorcycles mov movie mp mq mr ms msd mt mtn mtr mu museum music mv mw mx my mz na nab nagoya name navy nba nc ne nec net netbank netflix network neustar new news next nextdirect nexus nf nfl ng ngo nhk ni nico nike nikon ninja nissan nissay nl no nokia norton now nowruz nowtv np nr nra nrw ntt nu nyc nz obi observer office okinawa olayan olayangroup ollo om omega one ong onl online ooo open oracle orange org organic origins osaka otsuka ott ovh pa page panasonic paris pars partners parts party pay pccw pe pet pf pfizer pg ph pharmacy phd philips phone photo photography photos physio pics pictet pictures pid pin ping pink pioneer pizza pk pl place play playstation plumbing plus pm pn pnc pohl poker politie porn post pr praxi press prime pro prod productions prof progressive promo properties property protection pru prudential ps pt pub pw pwc py qa qpon quebec quest racing radio re read realestate realtor realty recipes red redumbrella rehab reise reisen reit reliance ren rent rentals repair report republican rest restaurant review reviews rexroth rich richardli ricoh ril rio rip ro rocks rodeo rogers room rs rsvp ru rugby ruhr run rw rwe ryukyu sa saarland safe safety sakura sale salon samsclub samsung sandvik sandvikcoromant sanofi sap sarl sas save saxo sb sbi sbs sc scb schaeffler schmidt scholarships school schule schwarz science scot sd se search seat secure security seek select sener services seven sew sex sexy sfr sg sh shangrila sharp shell shia shiksha shoes shop shopping shouji show si silk sina singles site sj sk ski skin sky skype sl sling sm smart smile sn sncf so soccer social softbank software sohu solar solutions song sony soy spa space sport spot sr srl ss st stada staples star statebank statefarm stc stcgroup stockholm storage store stream studio study style su sucks supplies supply support surf surgery suzuki sv swatch swiss sx sy sydney systems sz tab taipei talk taobao target tatamotors tatar tattoo tax taxi tc tci td tdk team tech technology tel temasek tennis teva tf tg th thd theater theatre tiaa tickets tienda tips tires tirol tj tjmaxx tjx tk tkmaxx tl tm tmall tn to today tokyo tools top toray toshiba total tours town toyota toys tr trade trading training travel travelers travelersinsurance trust trv tt tube tui tunes tushu tv tvs tw tz ua ubank ubs ug uk unicom university uno uol ups us uy uz va vacations vana vanguard vc ve vegas ventures verisign versicherung vet vg vi viajes video vig viking villas vin vip virgin visa vision viva vivo vlaanderen vn vodka volvo vote voting voto voyage vu wales walmart walter wang wanggou watch watches weather weatherchannel webcam weber website wed wedding weibo weir wf whoswho wien wiki williamhill win windows wine winners wme woodside work works world wow ws wtc wtf xbox xerox xihuan xin xn--11b4c3d xn--1ck2e1b xn--1qqw23a xn--2scrj9c xn--30rr7y xn--3bst00m xn--3ds443g xn--3e0b707e xn--3hcrj9c xn--3pxu8k xn--42c2d9a xn--45br5cyl xn--45brj9c xn--45q11c xn--4dbrk0ce xn--4gbrim xn--54b7fta0cc xn--55qw42g xn--55qx5d xn--5su34j936bgsg xn--5tzm5g xn--6frz82g xn--6qq986b3xl xn--80adxhks xn--80ao21a xn--80aqecdr1a xn--80asehdb xn--80aswg xn--8y0a063a xn--90a3ac xn--90ae xn--90ais xn--9dbq2a xn--9et52u xn--9krt00a xn--b4w605ferd xn--bck1b9a5dre4c xn--c1avg xn--c2br7g xn--cck2b3b xn--cckwcxetd xn--cg4bki xn--clchc0ea0b2g2a9gcd xn--czr694b xn--czrs0t xn--czru2d xn--d1acj3b xn--d1alf xn--e1a4c xn--eckvdtc9d xn--efvy88h xn--fct429k xn--fhbei xn--fiq228c5hs xn--fiq64b xn--fiqs8s xn--fiqz9s xn--fjq720a xn--flw351e xn--fpcrj9c3d xn--fzc2c9e2c xn--fzys8d69uvgm xn--g2xx48c xn--gckr3f0f xn--gecrj9c xn--gk3at1e xn--h2breg3eve xn--h2brj9c xn--h2brj9c8c xn--hxt814e xn--i1b6b1a6a2e xn--imr513n xn--io0a7i xn--j1aef xn--j1amh xn--j6w193g xn--jlq480n2rg xn--jvr189m xn--kcrx77d1x4a xn--kprw13d xn--kpry57d xn--kput3i xn--l1acc xn--lgbbat1ad8j xn--mgb9awbf xn--mgba3a3ejt xn--mgba3a4f16a xn--mgba7c0bbn0a xn--mgbaam7a8h xn--mgbab2bd xn--mgbah1a3hjkrd xn--mgbai9azgqp6j xn--mgbayh7gpa xn--mgbbh1a xn--mgbbh1a71e xn--mgbc0a9azcg xn--mgbca7dzdo xn--mgbcpq6gpa1a xn--mgberp4a5d4ar xn--mgbgu82a xn--mgbi4ecexp xn--mgbpl2fh xn--mgbt3dhd xn--mgbtx2b xn--mgbx4cd0ab xn--mix891f xn--mk1bu44c xn--mxtq1m xn--ngbc5azd xn--ngbe9e0a xn--ngbrx xn--node xn--nqv7f xn--nqv7fs00ema xn--nyqy26a xn--o3cw4h xn--ogbpf8fl xn--otu796d xn--p1acf xn--p1ai xn--pgbs0dh xn--pssy2u xn--q7ce6a xn--q9jyb4c xn--qcka1pmc xn--qxa6a xn--qxam xn--rhqv96g xn--rovu88b xn--rvc1e0am3e xn--s9brj9c xn--ses554g xn--t60b56a xn--tckwe xn--tiq49xqyj xn--unup4y xn--vermgensberater-ctb xn--vermgensberatung-pwb xn--vhquv xn--vuq861b xn--w4r85el8fhu5dnra xn--w4rs40l xn--wgbh1c xn--wgbl6a xn--xhq521b xn--xkc2al3hye2a xn--xkc2dl3a5ee0h xn--y9a3aq xn--yfro4i67o xn--ygbi2ammx xn--zfr164b xxx xyz yachts yahoo yamaxun yandex ye yodobashi yoga yokohama you youtube yt yun za zappos zara zero zip zm zone zuerich zw".split(' '),
+);
+
+export const isPlausibleHost = makeHostChecker(TLDS);