@email-utils/validator-syntax 0.0.1-9 → 1.0.0-rc.2

package/dist/index.mjs

@@ -0,0 +1,2307 @@
+//#region src/chars.ts
+const charCodeAt = String.prototype.charCodeAt;
+/**
+* `text.charCodeAt(i)`, through the builtin itself. Called as a method,
+* `charCodeAt` is looked up on the string, and a call site that has seen
+* enough kinds of string (one-byte and two-byte, flat, sliced, and
+* concatenated) goes megamorphic: V8 stops inlining it, and after arbitrary
+* Unicode input every scan ran 2–3× slower (validator-syntax#15).
+*/
+function codeAt(text, i) {
+	return charCodeAt.call(text, i);
+}
+const table = /* @__PURE__ */ new Uint8Array(128);
+function mark(chars, flag) {
+	for (let i = 0; i < chars.length; i++) table[codeAt(chars, i)] |= flag;
+}
+const alnum = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+mark(alnum + "!#$%&'*+-/=?^_`{|}~", 1);
+mark(alnum + "#$&'*+-/=?^_`{|}~", 2);
+mark(alnum + "!#$%&'*+-/=?^_`{|}~.", 4);
+mark(alnum + "-", 8);
+/** Whether the character with this code is in the class `flag`. */
+function inClass(code, flag) {
+	return code < 128 && (table[code] & flag) !== 0;
+}
+/** Space, tab, CR, and LF: the characters folding whitespace is made of. */
+function isWhitespace(code) {
+	return code === 32 || code === 9 || code === 13 || code === 10;
+}
+/**
+* The code units in the non-ASCII code point at `i`, before `end`: 2 for a
+* surrogate pair, 1 for anything else outside ASCII, and 0 for ASCII or a
+* lone surrogate, which no UTF-8 text can hold.
+*/
+function nonAsciiAt(text, i, end) {
+	const code = codeAt(text, i);
+	if (code < 128 || code >= 56320 && code <= 57343) return 0;
+	if (code < 55296 || code > 56319) return 1;
+	const low = i + 1 < end ? codeAt(text, i + 1) : 0;
+	return low >= 56320 && low <= 57343 ? 2 : 0;
+}
+/** The length of `text` in UTF-8 octets, the unit RFC 6531 caps a local part in. */
+function utf8Length(text) {
+	const end = text.length;
+	let octets = end;
+	for (let i = 0; i < end; i++) {
+		const code = codeAt(text, i);
+		if (code >= 2048 && (code < 55296 || code > 57343)) octets += 2;
+		else if (code >= 128) octets += 1;
+	}
+	return octets;
+}
+/**
+* The code points in `text` from `start` to `end`, which must not split a
+* surrogate pair: its length with each pair counted once.
+*/
+function codePoints(text, start, end) {
+	let count = end - start;
+	for (let i = start; i < end; i++) {
+		const code = codeAt(text, i);
+		if (code >= 56320 && code <= 57343) count--;
+	}
+	return count;
+}
+//#endregion
+//#region src/options.ts
+const presets = {
+	practical: {
+		local: 2,
+		domain: 8,
+		quotes: false,
+		literals: false,
+		comments: false,
+		obs: false,
+		localCap: 64,
+		domainCap: 253,
+		checkTld: true,
+		allowNoTld: false,
+		unicode: false,
+		idn: false,
+		maxLength: 512
+	},
+	rfc5321: {
+		local: 1,
+		domain: 8,
+		quotes: true,
+		literals: true,
+		comments: false,
+		obs: false,
+		localCap: 64,
+		domainCap: 253,
+		checkTld: false,
+		allowNoTld: false,
+		unicode: false,
+		idn: false,
+		maxLength: 512
+	},
+	rfc5322: {
+		local: 1,
+		domain: 1,
+		quotes: true,
+		literals: true,
+		comments: true,
+		obs: true,
+		localCap: Infinity,
+		domainCap: 253,
+		checkTld: false,
+		allowNoTld: false,
+		unicode: false,
+		idn: false,
+		maxLength: 512
+	},
+	html5: {
+		local: 4,
+		domain: 8,
+		quotes: false,
+		literals: false,
+		comments: false,
+		obs: false,
+		localCap: Infinity,
+		domainCap: Infinity,
+		checkTld: false,
+		allowNoTld: true,
+		unicode: false,
+		idn: false,
+		maxLength: 512
+	}
+};
+const overrides = [
+	"checkTld",
+	"allowNoTld",
+	"allowComments",
+	"allowUnicode",
+	"allowIdn",
+	"allowIpLiteral"
+];
+const unsupported = {
+	practical: [],
+	rfc5321: ["allowComments"],
+	rfc5322: [],
+	html5: [
+		"allowComments",
+		"allowUnicode",
+		"allowIdn",
+		"allowIpLiteral"
+	]
+};
+/**
+* Resolves `options` into the rules they select.
+*
+* @throws TypeError when `options` isn't an object, names an unknown option
+* or preset, gives a non-boolean override or a `maxLength` that isn't a
+* positive integer or `Infinity`, or turns on something the preset's grammar
+* has no room for.
+*/
+function resolve(options) {
+	if (options === void 0) return presets.practical;
+	if (typeof options !== "object" || options === null) throw new TypeError("Expected the options to be an object");
+	for (const key of Object.keys(options)) if (key !== "preset" && key !== "maxLength" && !overrides.includes(key)) throw new TypeError(`Unknown option: ${key}`);
+	const preset = options.preset ?? "practical";
+	if (!Object.hasOwn(presets, preset)) throw new TypeError(`Unknown preset: ${preset}`);
+	const base = presets[preset];
+	for (const key of overrides) {
+		const value = options[key];
+		if (value !== void 0 && typeof value !== "boolean") throw new TypeError(`Expected ${key} to be a boolean`);
+	}
+	const { maxLength } = options;
+	if (maxLength !== void 0 && maxLength !== Infinity && !(Number.isInteger(maxLength) && maxLength > 0)) throw new TypeError("Expected maxLength to be a positive integer or Infinity");
+	for (const key of unsupported[preset]) if (options[key] === true) throw new TypeError(`${key} can’t be true with the ${preset} preset`);
+	if (maxLength === void 0 && overrides.every((key) => options[key] === void 0)) return base;
+	return {
+		...base,
+		checkTld: options.checkTld ?? base.checkTld,
+		allowNoTld: options.allowNoTld ?? base.allowNoTld,
+		comments: options.allowComments ?? base.comments,
+		unicode: options.allowUnicode ?? base.unicode,
+		idn: options.allowIdn ?? base.idn,
+		literals: options.allowIpLiteral ?? base.literals,
+		maxLength: maxLength ?? base.maxLength
+	};
+}
+//#endregion
+//#region src/idn.ts
+const ldh = /^[\da-z-]+$/;
+/**
+* The hostname of `http://x.` and `host`, or `undefined` when the WHATWG URL
+* parser rejects it. `URL.parse` says so without the cost of throwing, a few
+* µs a time, so an address built to fail many conversions stays fast;
+* runtimes that predate it (Node before 22.1) throw instead.
+*/
+const hostnameOf = typeof URL.parse === "function" ? (host) => URL.parse(`http://x.${host}`)?.hostname : (host) => {
+	try {
+		return new URL(`http://x.${host}`).hostname;
+	} catch {
+		return;
+	}
+};
+/**
+* The A-label for a U-label, or `undefined` when UTS #46 rejects it or maps
+* it to something other than one IDN label (plain ASCII, or two labels, as
+* `。` becomes a dot).
+*
+* @remarks
+* Converts by way of the WHATWG URL host parser, which every runtime the
+* package supports has and which applies UTS #46 with its bidi and joiner
+* checks. It leaves hyphens and lengths alone, so the caller checks those.
+*/
+function toALabel(label) {
+	const aLabel = hostnameOf(label)?.slice(2);
+	return aLabel?.startsWith("xn--") === true && ldh.test(aLabel) ? aLabel : void 0;
+}
+const rtl = /[\u0590-\u08ff\u2135-\u2138\ufb1d-\ufdff\ufe70-\ufeff\u{10800}-\u{10fff}\u{1e800}-\u{1efff}]/u;
+/**
+* The A-label for each U-label in `labels`, as {@link toALabel} gives it,
+* converted as few domains as it can: one URL costs about as much as one
+* label does.
+*
+* @remarks
+* Every entry up to the first `undefined` is exact; entries after it may be
+* left `undefined` unconverted. Converted together, a right-to-left label
+* would hold the others to RFC 5893's rules too, which it doesn't alone, so
+* right-to-left labels go in a domain of their own. Converting more labels
+* at once only adds rules, so a domain that converts means every label
+* would alone; one that doesn't is narrowed down to its first label that
+* fails alone.
+*/
+function toALabels(labels) {
+	if (!labels.some((label) => rtl.test(label))) return convertGroup(labels);
+	const aLabels = labels.map(() => void 0);
+	for (const bidi of [false, true]) {
+		const members = [];
+		labels.forEach((label, k) => {
+			if (rtl.test(label) === bidi) members.push(k);
+		});
+		if (members.length > 0) convertGroup(members.map((k) => labels[k])).forEach((aLabel, j) => {
+			aLabels[members[j]] = aLabel;
+		});
+	}
+	return aLabels;
+}
+/** {@link toALabels} for labels converted together. */
+function convertGroup(labels) {
+	const all = convert(labels);
+	if (all !== void 0) return all;
+	let pass = [];
+	let failing = labels.length;
+	while (failing - pass.length > 1) {
+		const some = convert(labels.slice(0, pass.length + failing >> 1));
+		if (some === void 0) failing = pass.length + failing >> 1;
+		else pass = some;
+	}
+	const aLabels = pass;
+	for (let k = pass.length; k < labels.length; k++) {
+		const aLabel = toALabel(labels[k]);
+		aLabels.push(aLabel);
+		if (aLabel === void 0) break;
+	}
+	return aLabels;
+}
+const aLabelHost = /^x(?:\.xn--[\da-z-]+)+$/;
+/** `labels` converted as one domain, or `undefined`. */
+function convert(labels) {
+	const hostname = hostnameOf(labels.join("."));
+	if (hostname === void 0 || !aLabelHost.test(hostname)) return;
+	const aLabels = hostname.split(".");
+	aLabels.shift();
+	return aLabels.length === labels.length ? aLabels : void 0;
+}
+//#endregion
+//#region src/ip.ts
+const octet = /^\d{1,3}$/;
+const hexGroup = /^[\dA-Fa-f]{1,4}$/;
+/** An IPv4 address: four dot-separated decimal octets, each 0–255. */
+function isIPv4(text) {
+	if (text.length > 15) return false;
+	const parts = text.split(".");
+	return parts.length === 4 && parts.every((part) => octet.test(part) && Number(part) <= 255);
+}
+/**
+* An IPv6 address as RFC 5321 writes it: eight hex groups, or a `::` with no
+* more than six groups beside it, and either may end in an IPv4 address in
+* place of the last two groups.
+*/
+function isIPv6(text) {
+	if (text.length > 45) return false;
+	const colon = text.lastIndexOf(":");
+	const tail = text.slice(colon + 1);
+	if (tail.includes(".")) {
+		if (!isIPv4(tail)) return false;
+		text = `${text.slice(0, colon + 1)}0:0`;
+	}
+	const halves = text.split("::");
+	if (halves.length > 2) return false;
+	const groups = halves.flatMap((half) => half === "" ? [] : half.split(":"));
+	return groups.every((group) => hexGroup.test(group)) && (halves.length === 1 ? groups.length === 8 : groups.length <= 6);
+}
+/** The text of an RFC 5321 address literal: IPv4, or `IPv6:` and IPv6. */
+function isAddressLiteral(text) {
+	return /^IPv6:/i.test(text) ? isIPv6(text.slice(5)) : isIPv4(text);
+}
+//#endregion
+//#region node_modules/tlds/index.json
+var tlds_default = [
+	"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",
+	"goo",
+	"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",
+	"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",
+	"vermögensberater",
+	"vermögensberatung",
+	"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",
+	"wolterskluwer",
+	"woodside",
+	"work",
+	"works",
+	"world",
+	"wow",
+	"ws",
+	"wtc",
+	"wtf",
+	"xbox",
+	"xerox",
+	"xihuan",
+	"xin",
+	"xxx",
+	"xyz",
+	"yachts",
+	"yahoo",
+	"yamaxun",
+	"yandex",
+	"ye",
+	"yodobashi",
+	"yoga",
+	"yokohama",
+	"you",
+	"youtube",
+	"yt",
+	"yun",
+	"za",
+	"zappos",
+	"zara",
+	"zero",
+	"zip",
+	"zm",
+	"zone",
+	"zuerich",
+	"zw",
+	"ελ",
+	"ευ",
+	"бг",
+	"бел",
+	"дети",
+	"ею",
+	"католик",
+	"ком",
+	"мкд",
+	"мон",
+	"москва",
+	"онлайн",
+	"орг",
+	"рус",
+	"рф",
+	"сайт",
+	"срб",
+	"укр",
+	"қаз",
+	"հայ",
+	"ישראל",
+	"קום",
+	"ابوظبي",
+	"ارامكو",
+	"الاردن",
+	"البحرين",
+	"الجزائر",
+	"السعودية",
+	"العليان",
+	"المغرب",
+	"امارات",
+	"ایران",
+	"بارت",
+	"بازار",
+	"بيتك",
+	"بھارت",
+	"تونس",
+	"سودان",
+	"سورية",
+	"شبكة",
+	"عراق",
+	"عرب",
+	"عمان",
+	"فلسطين",
+	"قطر",
+	"كاثوليك",
+	"كوم",
+	"مصر",
+	"مليسيا",
+	"موريتانيا",
+	"موقع",
+	"همراه",
+	"پاکستان",
+	"ڀارت",
+	"कॉम",
+	"नेट",
+	"भारत",
+	"भारतम्",
+	"भारोत",
+	"संगठन",
+	"বাংলা",
+	"ভারত",
+	"ভাৰত",
+	"ਭਾਰਤ",
+	"ભારત",
+	"ଭାରତ",
+	"இந்தியா",
+	"இலங்கை",
+	"சிங்கப்பூர்",
+	"భారత్",
+	"ಭಾರತ",
+	"ഭാരതം",
+	"ලංකා",
+	"คอม",
+	"ไทย",
+	"ລາວ",
+	"გე",
+	"みんな",
+	"アマゾン",
+	"クラウド",
+	"グーグル",
+	"コム",
+	"ストア",
+	"セール",
+	"ファッション",
+	"ポイント",
+	"世界",
+	"中信",
+	"中国",
+	"中國",
+	"中文网",
+	"亚马逊",
+	"企业",
+	"佛山",
+	"信息",
+	"健康",
+	"八卦",
+	"公司",
+	"公益",
+	"台湾",
+	"台灣",
+	"商城",
+	"商店",
+	"商标",
+	"嘉里",
+	"嘉里大酒店",
+	"在线",
+	"大拿",
+	"天主教",
+	"娱乐",
+	"家電",
+	"广东",
+	"微博",
+	"慈善",
+	"我爱你",
+	"手机",
+	"招聘",
+	"政务",
+	"政府",
+	"新加坡",
+	"新闻",
+	"时尚",
+	"書籍",
+	"机构",
+	"淡马锡",
+	"游戏",
+	"澳門",
+	"点看",
+	"移动",
+	"组织机构",
+	"网址",
+	"网店",
+	"网站",
+	"网络",
+	"联通",
+	"谷歌",
+	"购物",
+	"通販",
+	"集团",
+	"電訊盈科",
+	"飞利浦",
+	"食品",
+	"餐厅",
+	"香格里拉",
+	"香港",
+	"닷넷",
+	"닷컴",
+	"삼성",
+	"한국"
+];
+//#endregion
+//#region src/tld.ts
+let known;
+/** Whether `tld` is in the IANA set, as a U-label or A-label, ignoring case. */
+function isKnownTld(tld) {
+	known ??= buildSet();
+	return known.has(tld.toLowerCase());
+}
+function buildSet() {
+	const set = new Set(tlds_default);
+	for (const tld of tlds_default) if (!/^[a-z\d]+$/.test(tld)) {
+		const aLabel = toALabel(tld);
+		if (aLabel !== void 0) set.add(aLabel);
+	}
+	return set;
+}
+//#endregion
+//#region src/parse.ts
+const messages = {
+	"syntax.address.empty": "The address is empty",
+	"syntax.address.no_at": "The address has no @",
+	"syntax.address.too_long": "The address is longer than 254 characters",
+	"syntax.local.empty": "Nothing comes before the @",
+	"syntax.local.too_long": "The local part is longer than 64 characters",
+	"syntax.local.invalid_char": "The local part has a character it can’t hold",
+	"syntax.local.consecutive_dots": "The local part has two dots in a row",
+	"syntax.local.unquoted_space": "The local part has whitespace outside quotes",
+	"syntax.domain.empty": "Nothing comes after the @",
+	"syntax.domain.no_dot": "The domain has no dot",
+	"syntax.domain.label_invalid": "A domain label is empty, too long, or starts or ends with a hyphen",
+	"syntax.domain.literal_invalid": "The domain literal isn’t accepted",
+	"syntax.domain.too_long": "The domain is longer than 253 characters",
+	"syntax.domain.invalid_char": "The domain has a character it can’t hold",
+	"syntax.comment.not_allowed": "Comments aren’t allowed here",
+	"syntax.comment.unterminated": "A comment is missing its closing parenthesis",
+	"syntax.tld.unknown": "The TLD isn’t in the IANA set"
+};
+function fail(reason, index) {
+	const message = messages[reason];
+	return index === void 0 ? {
+		ok: false,
+		reason,
+		message
+	} : {
+		ok: false,
+		reason,
+		message,
+		index
+	};
+}
+const NORMAL = 0;
+const QUOTED = 1;
+const COMMENT = 2;
+const LITERAL = 3;
+/**
+* Finds the `@` that splits `email`: the last one outside a quoted string,
+* comment, or domain literal, or -1 when there's none.
+*
+* @remarks
+* A quoted string opens only at the start of a word, and a literal only at
+* the start of the domain; both, and comments, take backslash escapes. One
+* left open runs to the end, taking any `@` with it.
+*/
+function findAt(email, rules) {
+	let state = NORMAL;
+	let wordStart = true;
+	let domainStart = false;
+	let depth = 0;
+	let at = -1;
+	const end = email.length;
+	for (let i = 0; i < end; i++) {
+		const code = codeAt(email, i);
+		if (state === NORMAL) {
+			if (code === 64) {
+				at = i;
+				wordStart = true;
+				domainStart = true;
+			} else if (code === 40 && rules.comments) {
+				state = COMMENT;
+				depth = 1;
+			} else if (!isWhitespace(code)) {
+				if (code === 34 && rules.quotes && wordStart) state = QUOTED;
+				else if (code === 91 && rules.literals && domainStart) state = LITERAL;
+				wordStart = code === 46;
+				domainStart = false;
+			}
+		} else if (code === 92) i++;
+		else if (state === COMMENT) {
+			if (code === 40) depth++;
+			else if (code === 41 && --depth === 0) state = NORMAL;
+		} else if (code === (state === QUOTED ? 34 : 93)) state = NORMAL;
+	}
+	return at;
+}
+/**
+* Parses `email` under `rules`.
+*
+* @throws TypeError when `email` isn't a string.
+*/
+function parse(email, rules) {
+	if (typeof email !== "string") throw new TypeError(`Expected a string, got ${typeof email}`);
+	if (email === "") return fail("syntax.address.empty");
+	if (email.length > rules.maxLength) return fail("syntax.address.too_long");
+	const at = findAt(email, rules);
+	if (at < 0) return fail("syntax.address.no_at");
+	const comments = [];
+	const local = scanLocal(email, at, rules, comments);
+	if (typeof local !== "string") return local;
+	const localSize = rules.unicode ? utf8Length(local) : local.length;
+	if (localSize > rules.localCap) return fail("syntax.local.too_long");
+	const domain = scanDomain(email, at, rules, comments);
+	if ("reason" in domain) return domain;
+	if (domain.size > rules.domainCap) return fail("syntax.domain.too_long");
+	if (localSize + 1 + domain.size > 254) return fail("syntax.address.too_long");
+	const { tld } = domain;
+	if (tld === void 0 && !domain.literal && !rules.allowNoTld) return fail("syntax.domain.no_dot");
+	if (tld !== void 0 && rules.checkTld && !isKnownTld(tld)) return fail("syntax.tld.unknown");
+	return {
+		ok: true,
+		value: tld === void 0 ? {
+			local,
+			domain: domain.domain,
+			comments
+		} : {
+			local,
+			domain: domain.domain,
+			tld,
+			comments
+		}
+	};
+}
+/**
+* Scans the local part, `email` up to `at`, and returns it without comments
+* or folding whitespace.
+*/
+function scanLocal(email, at, rules, comments) {
+	let local = "";
+	let words = 0;
+	let afterWord = false;
+	let closed = false;
+	let dot = -1;
+	let space = -1;
+	let edge = -1;
+	let trailing = comments.length;
+	let i = 0;
+	while (i < at) {
+		const code = codeAt(email, i);
+		const quote = code === 34 && rules.quotes && (rules.obs || i === 0);
+		const atom = inClass(code, rules.local);
+		if (quote || atom || rules.unicode && nonAsciiAt(email, i, at) > 0) {
+			if (edge >= 0) return fail("syntax.comment.not_allowed", edge);
+			if (afterWord) return space >= 0 ? fail("syntax.local.unquoted_space", space) : fail("syntax.local.invalid_char", i);
+			let next;
+			if (quote) {
+				next = skipQuoted(email, i, at, rules.obs, rules.unicode);
+				if (next < 0) return fail("syntax.local.invalid_char", -1 - next);
+				closed = !rules.obs;
+			} else {
+				next = atom ? i + 1 : i;
+				while (next < at && inClass(codeAt(email, next), rules.local)) next++;
+				if (rules.unicode) next = skipUnicode(email, next, at, rules.local);
+			}
+			local += unfold(email, i, next);
+			words++;
+			afterWord = true;
+			dot = -1;
+			space = -1;
+			trailing = comments.length;
+			i = next;
+		} else if (code === 46) {
+			if (edge >= 0) return fail("syntax.comment.not_allowed", edge);
+			if (!afterWord || closed) return dot >= 0 ? fail("syntax.local.consecutive_dots", i) : fail("syntax.local.invalid_char", i);
+			local += ".";
+			afterWord = false;
+			dot = i;
+			space = -1;
+			i++;
+		} else if (code === 40 && rules.comments) {
+			if (!rules.obs && words > 0) {
+				if (!afterWord) return fail("syntax.comment.not_allowed", i);
+				edge = edge < 0 ? i : edge;
+			}
+			const next = skipComment(email, i, at, rules.unicode);
+			if (next < 0) return fail("syntax.local.invalid_char", -1 - next);
+			comments.push({
+				text: email.slice(i + 1, next - 1),
+				position: words === 0 ? "before-local" : "inside-local"
+			});
+			i = next;
+		} else if (code === 40) return fail("syntax.comment.not_allowed", i);
+		else if (rules.obs && isWhitespace(code)) {
+			const next = skipSpace(email, i, at);
+			if (next < 0) return fail("syntax.local.invalid_char", i);
+			space = space < 0 ? i : space;
+			i = next;
+		} else return code === 32 ? fail("syntax.local.unquoted_space", i) : fail("syntax.local.invalid_char", i);
+	}
+	if (words === 0) return fail("syntax.local.empty");
+	if (dot >= 0) return fail("syntax.local.invalid_char", dot);
+	settle(comments, trailing, "after-local");
+	return local;
+}
+/**
+* Scans the domain, `email` after `at`, and returns it without comments or
+* folding whitespace.
+*/
+function scanDomain(email, at, rules, comments) {
+	const uLabels = [];
+	const domain = scanLabels(email, at, rules, comments, uLabels);
+	if (uLabels.length === 0) return domain;
+	const growth = checkULabels(email, uLabels, rules.domainCap);
+	if (typeof growth !== "number") return growth;
+	if (!("reason" in domain)) domain.size += growth;
+	return domain;
+}
+/**
+* Checks the U-labels at `spans`, triples of start, end, and the length of
+* the domain before it, as A-labels: each must convert, and pass the
+* hostname rules as its A-label. Returns the first failure, or what the
+* A-labels add to the domain's length: `Infinity` once it's past `cap`.
+*
+* @remarks
+* The U-labels are converted a few at a time, about 32 characters of them
+* in each URL: one URL costs about as much as one label alone, and a small
+* batch wastes little past the first failure or past `cap`. Once the
+* A-labels take the domain past `cap`, the rest aren't checked: the domain
+* fails as too long, unless the scan found something earlier. Punycode's
+* cost grows with the square of a label's length, so converting labels that
+* can't change the outcome would cost the most on input built to be slow
+* (validator-syntax#15).
+*/
+function checkULabels(email, spans, cap) {
+	let growth = 0;
+	for (let first = 0; first < spans.length;) {
+		const chunk = [];
+		let written = 0;
+		let next = first;
+		while (next < spans.length && written < 32) {
+			const label = email.slice(spans[next], spans[next + 1]);
+			chunk.push(label);
+			written += label.length;
+			next += 3;
+		}
+		const aLabels = toALabels(chunk);
+		for (let k = 0; k < chunk.length; k++) {
+			const start = spans[first + 3 * k];
+			const end = spans[first + 3 * k + 1];
+			const aLabel = aLabels[k];
+			if (aLabel === void 0) return fail("syntax.domain.label_invalid", start);
+			const bad = checkLabel(email, start, end, aLabel.length);
+			if (bad >= 0) return fail("syntax.domain.label_invalid", bad);
+			growth += aLabel.length - (end - start);
+			if (spans[first + 3 * k + 2] + (end - start) + growth > cap) return Infinity;
+		}
+		first = next;
+	}
+	return growth;
+}
+/**
+* The scan behind {@link scanDomain}, which leaves the U-labels it finds in
+* `uLabels`, as triples of start, end, and the domain's length before it,
+* unchecked but for their length.
+*/
+function scanLabels(email, at, rules, comments, uLabels) {
+	const end = email.length;
+	let domain = "";
+	let labels = 0;
+	let afterLabel = false;
+	let literal = false;
+	let dot = -1;
+	let space = -1;
+	let edge = -1;
+	let trailing = comments.length;
+	let tld = "";
+	let i = at + 1;
+	while (i < end) {
+		const code = codeAt(email, i);
+		const opensLiteral = code === 91 && rules.literals && labels === 0;
+		const ldh = inClass(code, rules.domain);
+		if (opensLiteral || ldh || rules.idn && nonAsciiAt(email, i, end) > 0) {
+			if (edge >= 0) return fail("syntax.comment.not_allowed", edge);
+			if (afterLabel) return fail("syntax.domain.invalid_char", space >= 0 ? space : i);
+			let next;
+			if (opensLiteral) {
+				next = rules.obs ? skipLiteral(email, i, end) : skipAddressLiteral(email, i, end);
+				if (next < 0) return fail("syntax.domain.literal_invalid", i);
+				literal = true;
+			} else {
+				next = ldh ? i + 1 : i;
+				while (next < end && inClass(codeAt(email, next), rules.domain)) next++;
+				const ascii = next;
+				if (rules.idn) next = skipUnicode(email, next, end, rules.domain);
+				if (next > ascii) {
+					if (codePoints(email, i, next) > 63) return fail("syntax.domain.label_invalid", i);
+					uLabels.push(i, next, domain.length);
+				} else {
+					const bad = checkLabel(email, i, next, next - i);
+					if (bad >= 0) return fail("syntax.domain.label_invalid", bad);
+				}
+			}
+			tld = unfold(email, i, next);
+			domain += tld;
+			labels++;
+			afterLabel = true;
+			dot = -1;
+			space = -1;
+			trailing = comments.length;
+			i = next;
+		} else if (code === 46) {
+			if (edge >= 0) return fail("syntax.comment.not_allowed", edge);
+			if (!afterLabel || literal) return literal ? fail("syntax.domain.invalid_char", i) : fail("syntax.domain.label_invalid", i);
+			domain += ".";
+			afterLabel = false;
+			dot = i;
+			space = -1;
+			i++;
+		} else if (code === 40 && rules.comments) {
+			if (!rules.obs && labels > 0) {
+				if (!afterLabel) return fail("syntax.comment.not_allowed", i);
+				edge = edge < 0 ? i : edge;
+			}
+			const next = skipComment(email, i, end, rules.unicode);
+			if (next < 0) return -1 - next === i ? fail("syntax.comment.unterminated", i) : fail("syntax.domain.invalid_char", -1 - next);
+			comments.push({
+				text: email.slice(i + 1, next - 1),
+				position: labels === 0 ? "before-domain" : "inside-domain"
+			});
+			i = next;
+		} else if (code === 40) return fail("syntax.comment.not_allowed", i);
+		else if (rules.obs && isWhitespace(code)) {
+			const next = skipSpace(email, i, end);
+			if (next < 0) return fail("syntax.domain.invalid_char", i);
+			space = space < 0 ? i : space;
+			i = next;
+		} else return fail("syntax.domain.invalid_char", i);
+	}
+	if (labels === 0) return fail("syntax.domain.empty");
+	if (dot >= 0) return fail("syntax.domain.label_invalid", dot);
+	settle(comments, trailing, "after-domain");
+	const size = domain.length;
+	return literal || labels === 1 ? {
+		domain,
+		literal,
+		size
+	} : {
+		domain,
+		tld,
+		literal,
+		size
+	};
+}
+/**
+* Carries an atom or label on from `i`, where its ASCII run stopped, through
+* any non-ASCII characters and the class-`flag` characters after them.
+*/
+function skipUnicode(email, i, end, flag) {
+	let width = i < end ? nonAsciiAt(email, i, end) : 0;
+	while (width > 0) {
+		i += width;
+		while (i < end && inClass(codeAt(email, i), flag)) i++;
+		width = i < end ? nonAsciiAt(email, i, end) : 0;
+	}
+	return i;
+}
+/**
+* Checks the hostname label from `start` to `end`, `size` characters long as
+* an A-label: returns the index of a leading or trailing hyphen, the start of
+* a label over 63 characters, or -1.
+*/
+function checkLabel(email, start, end, size) {
+	if (codeAt(email, start) === 45) return start;
+	if (size > 63) return start;
+	return codeAt(email, end - 1) === 45 ? end - 1 : -1;
+}
+/** Marks the comments from `from` on, which no word follows, as trailing. */
+function settle(comments, from, position) {
+	for (let c = from; c < comments.length; c++) {
+		const comment = comments[c];
+		if (comment.position.startsWith("inside")) comment.position = position;
+	}
+}
+const { indexOf, slice } = String.prototype;
+/**
+* `email` from `start` to `end`, without the CRLFs of folding whitespace,
+* keeping the space or tab after each.
+*/
+function unfold(email, start, end) {
+	const text = slice.call(email, start, end);
+	return indexOf.call(text, "\r") < 0 ? text : text.replaceAll("\r\n", "");
+}
+/**
+* Skips one character of folding whitespace: a space, a tab, or a CRLF with
+* a space or tab after it. A lone CR or LF breaks it.
+*/
+function skipSpace(email, i, end) {
+	const code = codeAt(email, i);
+	if (code === 32 || code === 9) return i + 1;
+	return code === 13 && i + 2 < end && codeAt(email, i + 1) === 10 && (codeAt(email, i + 2) === 32 || codeAt(email, i + 2) === 9) ? i + 2 : -1 - i;
+}
+/** Whether a backslash may escape `code`: any ASCII with `obs`, else VCHAR and space. */
+function escapable(code, obs) {
+	return obs ? code < 128 : code >= 32 && code <= 126;
+}
+/**
+* Skips the quoted string opening at `open`. `obs` allows folding whitespace
+* and control characters other than NUL; without it, the string follows
+* RFC 5321: printable ASCII and spaces only. `unicode` adds non-ASCII.
+*/
+function skipQuoted(email, open, end, obs, unicode) {
+	let i = open + 1;
+	while (i < end) {
+		const code = codeAt(email, i);
+		if (code === 34) return i + 1;
+		if (code === 92) {
+			if (!escapable(codeAt(email, i + 1), obs)) return -2 - i;
+			i += 2;
+		} else if (obs && isWhitespace(code)) {
+			i = skipSpace(email, i, end);
+			if (i < 0) return i;
+		} else if (obs ? code === 0 || code > 127 : code < 32 || code > 126) {
+			const width = unicode ? nonAsciiAt(email, i, end) : 0;
+			if (width === 0) return -1 - i;
+			i += width;
+		} else i++;
+	}
+	return -1 - open;
+}
+/**
+* Skips the comment opening at `open`, nested comments included. Its text
+* may hold any ASCII but NUL, with folding whitespace, and non-ASCII with
+* `unicode`; returns `-1 - open` when it never closes.
+*/
+function skipComment(email, open, end, unicode) {
+	let depth = 1;
+	let i = open + 1;
+	while (i < end) {
+		const code = codeAt(email, i);
+		if (code === 40 || code === 41) {
+			depth += code === 40 ? 1 : -1;
+			i++;
+			if (depth === 0) return i;
+		} else if (code === 92) {
+			if (i + 1 >= end) break;
+			if (!escapable(codeAt(email, i + 1), true)) return -2 - i;
+			i += 2;
+		} else if (isWhitespace(code)) {
+			i = skipSpace(email, i, end);
+			if (i < 0) return i;
+		} else if (code === 0 || code > 127) {
+			const width = unicode ? nonAsciiAt(email, i, end) : 0;
+			if (width === 0) return -1 - i;
+			i += width;
+		} else i++;
+	}
+	return -1 - open;
+}
+/**
+* Skips the RFC 5322 domain literal opening at `open`: any ASCII but NUL,
+* `[`, and `]`, with escapes and folding whitespace. Returns -1 when it's
+* malformed or never closes.
+*/
+function skipLiteral(email, open, end) {
+	let i = open + 1;
+	while (i < end) {
+		const code = codeAt(email, i);
+		if (code === 93) return i + 1;
+		if (code === 92) {
+			if (i + 1 >= end || !escapable(codeAt(email, i + 1), true)) return -1;
+			i += 2;
+		} else if (isWhitespace(code)) {
+			i = skipSpace(email, i, end);
+			if (i < 0) return -1;
+		} else if (code === 0 || code === 91 || code > 127) return -1;
+		else i++;
+	}
+	return -1;
+}
+/**
+* Skips the RFC 5321 address literal opening at `open`: an IPv4 address or
+* `IPv6:` and an IPv6 address. Returns -1 for anything else.
+*/
+function skipAddressLiteral(email, open, end) {
+	const close = email.indexOf("]", open + 1);
+	return close >= 0 && close < end && isAddressLiteral(email.slice(open + 1, close)) ? close + 1 : -1;
+}
+//#endregion
+//#region src/index.ts
+/**
+* Is the address well-formed? A quote-aware parser with four presets:
+* `practical` (the default), `rfc5321`, `rfc5322`, and `html5`.
+*
+* @packageDocumentation
+*/
+/**
+* Parses `email` into its local part, domain, TLD, and comments, or returns
+* the first check it fails.
+*
+* @remarks
+* Input longer than `maxLength` (512 UTF-16 code units by default) fails as
+* `syntax.address.too_long` before it's scanned. Otherwise the local part is
+* checked before the domain, each left to right, then the lengths, then a
+* dotless domain, then the TLD. `index`, where a failure has one, points at
+* the offending character.
+*
+* @example
+* ```ts
+* import { parseAddress } from '@email-utils/validator-syntax';
+*
+* parseAddress('ada.lovelace@example.co.uk');
+* // => { ok: true, value: { local: 'ada.lovelace', tld: 'uk' } }
+* parseAddress('ada..lovelace@example.com');
+* // => { ok: false, reason: 'syntax.local.consecutive_dots', index: 4 }
+* ```
+*
+* @throws TypeError when `email` isn't a string, or `options` are malformed.
+*/
+function parseAddress(email, options) {
+	return parse(email, resolve(options));
+}
+/**
+* Whether `email` is well-formed: exactly `parseAddress(email, options).ok`.
+*
+* @example
+* ```ts
+* import { isValidSyntax } from '@email-utils/validator-syntax';
+*
+* isValidSyntax('ada@example.com'); // => true
+* isValidSyntax('"ada"@example.com'); // => false
+* isValidSyntax('"ada"@example.com', { preset: 'rfc5321' }); // => true
+* ```
+*
+* @throws TypeError when `email` isn't a string, or `options` are malformed.
+*/
+function isValidSyntax(email, options) {
+	return parse(email, resolve(options)).ok;
+}
+/**
+* Binds `options` once, checking them up front, and returns
+* {@link parseAddress} and {@link isValidSyntax} with them applied.
+*
+* @example
+* ```ts
+* import { createSyntaxValidator } from '@email-utils/validator-syntax';
+*
+* const strict = createSyntaxValidator({ preset: 'rfc5321' });
+* strict.parse('a b@example.com');
+* // => { ok: false, reason: 'syntax.local.unquoted_space', index: 1 }
+* strict.isValid('"a b"@example.com'); // => true
+* createSyntaxValidator({ preset: 'html5', allowComments: true });
+* // => throws TypeError
+* ```
+*
+* @throws TypeError when `options` are malformed.
+*/
+function createSyntaxValidator(options) {
+	const rules = resolve(options);
+	return {
+		parse: (email) => parse(email, rules),
+		isValid: (email) => parse(email, rules).ok
+	};
+}
+//#endregion
+export { createSyntaxValidator, isValidSyntax, parseAddress };
+
+//# sourceMappingURL=index.mjs.map