cizgile 0.2.0 → 1.0.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { A as fold, D as DEFAULT_TABLES, F as symbols, O as applyCompat, k as compileTables, m as latinLocales } from "./shared/locales-latin-Bm94HAeL.mjs";
+import { M as applyCompat, N as compileTables, P as fold, j as DEFAULT_TABLES, n as registeredLocale, r as registryVersion, v as latinLocales, z as symbols } from "./shared/registry-D787niCh.mjs";
 import { h as isSegmentNzNc, r as percentEncode } from "./shared/percent-DG-pZhJI.mjs";
 
 //#region src/slug/bidi.ts
@@ -168,14 +168,15 @@ let cache$1;
 function resolveLocale(locale) {
 	if (locale === void 0) return void 0;
 	if (typeof locale === "string") {
-		const found = latinLocales[locale];
-		if (found === void 0) throw new TypeError(`slugify: unknown locale "${locale}"; pass a Locale object exported by cizgile/transliterate`);
+		const found = latinLocales[locale] ?? registeredLocale(locale);
+		if (found === void 0) throw new TypeError(`slugify: unknown locale "${locale}"; pass a Locale object exported by cizgile/transliterate, or register it with registerLocale()`);
 		return found;
 	}
 	return locale;
 }
 function resolveTables(option, unicode, locale) {
 	if (unicode) return void 0;
+	if (option === "none") return (locale === void 0 ? [symbols] : [locale.table, symbols]).map(symbolEntries);
 	const out = [];
 	if (locale !== void 0) {
 		out.push(locale.table);
@@ -207,6 +208,15 @@ function build(options) {
 	}
 	const maxLength = options.maxLength;
 	if (maxLength !== void 0 && (!Number.isInteger(maxLength) || maxLength < 0)) throw new RangeError("slugify: maxLength must be a non-negative integer");
+	const maxLengthUnit = options.maxLengthUnit ?? "units";
+	if (![
+		"units",
+		"code-points",
+		"graphemes",
+		"bytes"
+	].includes(maxLengthUnit)) throw new TypeError(`slugify: unknown maxLengthUnit ${JSON.stringify(maxLengthUnit)}`);
+	const fallback = options.fallback;
+	if (fallback !== void 0 && typeof fallback !== "string" && typeof fallback !== "function") throw new TypeError("slugify: fallback must be a string or a function");
 	const wordExtra = preserveCharacters.map(escapeClassChar).join("");
 	const wordClass = unicode ? `\\p{L}\\p{N}\\p{M}${wordExtra}` : `a-z0-9${lowercase ? "" : "A-Z"}${wordExtra}`;
 	const allowedClass = wordClass + separatorChars.map(escapeClassChar).join("");
@@ -227,6 +237,8 @@ function build(options) {
 		preserveLeadingUnderscore: options.preserveLeadingUnderscore ?? false,
 		preserveTrailingSeparator: options.preserveTrailingSeparator ?? false,
 		maxLength,
+		maxLengthUnit,
+		fallback,
 		scripts: options.scripts ?? "any",
 		bidi: options.bidi ?? "allow",
 		allowedClass,
@@ -257,6 +269,7 @@ function optionsKey(options) {
 	const locale = options.locale;
 	const transliterate = options.transliterate;
 	const remove = options.remove;
+	const fallback = options.fallback;
 	return JSON.stringify([
 		options.separator,
 		options.lowercase,
@@ -270,60 +283,31 @@ function optionsKey(options) {
 		options.preserveLeadingUnderscore,
 		options.preserveTrailingSeparator,
 		options.maxLength,
+		options.maxLengthUnit,
+		typeof fallback === "function" ? `#${objectId(fallback)}` : fallback,
 		options.scripts,
 		options.bidi
 	]);
 }
 function resolveOptions(options = DEFAULT_OPTIONS$1) {
 	cache$1 ??= /* @__PURE__ */ new WeakMap();
-	const cached = cache$1.get(options);
-	if (cached !== void 0) return cached;
+	const registered = typeof options.locale === "string" && !(options.locale in latinLocales);
+	if (!registered) {
+		const cached = cache$1.get(options);
+		if (cached !== void 0) return cached;
+	}
 	byKey ??= /* @__PURE__ */ new Map();
-	const key = optionsKey(options);
+	const key = registered ? `${registryVersion()}:${optionsKey(options)}` : optionsKey(options);
 	let resolved = byKey.get(key);
 	if (resolved === void 0) {
 		resolved = build(options);
 		if (byKey.size > 512) byKey.clear();
 		byKey.set(key, resolved);
 	}
-	cache$1.set(options, resolved);
+	if (!registered) cache$1.set(options, resolved);
 	return resolved;
 }
 
-//#endregion
-//#region src/slug/is-slug.ts
-let cache;
-function patternFor(options) {
-	cache ??= /* @__PURE__ */ new WeakMap();
-	const cached = cache.get(options);
-	if (cached !== void 0) return cached;
-	const o = resolveOptions(options);
-	const char = `[${o.wordClass}]`;
-	const separator = escapeRegExp$1(o.separator);
-	const lead = o.preserveLeadingUnderscore ? "_?" : "";
-	const word = o.unicode ? `(?!\\p{M})${char}+` : `${char}+`;
-	const body = o.separator === "" ? word : `${word}(?:${separator}${word})*`;
-	const tail = o.preserveTrailingSeparator && o.separator !== "" ? `(?:${separator})?` : "";
-	const pattern = new RegExp(`^${lead}${body}${tail}$`, "u");
-	cache.set(options, pattern);
-	return pattern;
-}
-const DEFAULT_OPTIONS = {};
-/** Whether `input` is exactly what `slugify` would produce under the same options. */
-function isSlug(input, options = DEFAULT_OPTIONS) {
-	if (typeof input !== "string" || input === "" || input === "." || input === "..") return false;
-	const o = resolveOptions(options);
-	if (o.maxLength !== void 0 && input.length > o.maxLength) return false;
-	if (o.separator !== "" && input.includes(o.separator + o.separator)) return false;
-	if (o.unicode) {
-		if (input !== input.normalize("NFKC")) return false;
-		if (o.lowercase && input !== lowercaseOf(input, o)) return false;
-		if (o.scripts !== "any" && !checkScripts(input, o.scripts).ok) return false;
-		if (o.bidi !== "allow" && !isBidiSafeComponent(input)) return false;
-	}
-	return patternFor(options).test(input);
-}
-
 //#endregion
 //#region src/slug/truncate.ts
 let segmenter;
@@ -339,6 +323,53 @@ function isJoinerBefore(text, index) {
 function isClusterExtender(cp) {
 	return cp >= 56320 && cp <= 57343 || cp === 8205 || cp >= 65024 && cp <= 65039 || cp >= 127995 && cp <= 127999 || cp >= 4448 && cp <= 4607 || cp >= 917536 && cp <= 917631 || /\p{M}/u.test(String.fromCodePoint(cp));
 }
+function utf8Length(cp) {
+	return cp < 128 ? 1 : cp < 2048 ? 2 : cp < 65536 ? 3 : 4;
+}
+/** The length of `text` in the given unit. */
+function measure(text, unit = "units") {
+	if (unit === "units") return text.length;
+	let count = 0;
+	if (unit === "graphemes") {
+		const seg = graphemeSegmenter();
+		if (seg !== void 0) {
+			for (const _ of seg.segment(text)) count += 1;
+			return count;
+		}
+		let index = 0;
+		for (const ch of text) {
+			if (!(isClusterExtender(ch.codePointAt(0) ?? 0) || isJoinerBefore(text, index)) || index === 0) count += 1;
+			index += ch.length;
+		}
+		return count;
+	}
+	for (const ch of text) count += unit === "bytes" ? utf8Length(ch.codePointAt(0) ?? 0) : 1;
+	return count;
+}
+function prefixEnd(text, limit, unit) {
+	if (unit === "units") return Math.min(limit, text.length);
+	let used = 0;
+	if (unit === "graphemes") {
+		const seg = graphemeSegmenter();
+		if (seg !== void 0) {
+			let end = 0;
+			for (const { index, segment } of seg.segment(text)) {
+				if (used === limit) break;
+				used += 1;
+				end = index + segment.length;
+			}
+			return end;
+		}
+	}
+	let end = 0;
+	for (const ch of text) {
+		const cost = unit === "bytes" ? utf8Length(ch.codePointAt(0) ?? 0) : 1;
+		if (used + cost > limit) break;
+		used += cost;
+		end += ch.length;
+	}
+	return unit === "graphemes" ? graphemeBoundary(text, end, { fallback: true }) : end;
+}
 function graphemeBoundary(text, limit, options = {}) {
 	const seg = options.fallback === true ? void 0 : graphemeSegmenter();
 	if (seg !== void 0) {
@@ -361,13 +392,14 @@ function stripTrailingSeparator(text, separator) {
 	for (let k = separator.length - 1; k > 0; k--) if (out.endsWith(separator.slice(0, k))) return out.slice(0, -k);
 	return out;
 }
-/** Cuts `slug` to at most `maxLength` UTF-16 code units at a `separator` boundary, never inside a grapheme cluster. */
-function truncateSlug(slug, maxLength, separator = "-") {
+/** Cuts `slug` to at most `maxLength` in the given `unit` (UTF-16 code units by default) at a `separator` boundary, never inside a grapheme cluster. */
+function truncateSlug(slug, maxLength, separator = "-", unit = "units") {
 	if (!Number.isInteger(maxLength) || maxLength < 0) throw new RangeError("truncateSlug: maxLength must be a non-negative integer");
-	if (slug.length <= maxLength) return slug;
+	if (measure(slug, unit) <= maxLength) return slug;
 	if (maxLength === 0) return "";
-	let cut = slug.slice(0, maxLength);
-	if (separator !== "" && !slug.startsWith(separator, maxLength)) {
+	const limit = prefixEnd(slug, maxLength, unit);
+	let cut = slug.slice(0, limit);
+	if (separator !== "" && !slug.startsWith(separator, limit)) {
 		const last = cut.lastIndexOf(separator);
 		if (last > 0) cut = cut.slice(0, last);
 	}
@@ -375,6 +407,40 @@ function truncateSlug(slug, maxLength, separator = "-") {
 	return stripTrailingSeparator(cut, separator);
 }
 
+//#endregion
+//#region src/slug/is-slug.ts
+let cache;
+function patternFor(options) {
+	cache ??= /* @__PURE__ */ new WeakMap();
+	const cached = cache.get(options);
+	if (cached !== void 0) return cached;
+	const o = resolveOptions(options);
+	const char = `[${o.wordClass}]`;
+	const separator = escapeRegExp$1(o.separator);
+	const lead = o.preserveLeadingUnderscore ? "_?" : "";
+	const word = o.unicode ? `(?!\\p{M})${char}+` : `${char}+`;
+	const body = o.separator === "" ? word : `${word}(?:${separator}${word})*`;
+	const tail = o.preserveTrailingSeparator && o.separator !== "" ? `(?:${separator})?` : "";
+	const pattern = new RegExp(`^${lead}${body}${tail}$`, "u");
+	cache.set(options, pattern);
+	return pattern;
+}
+const DEFAULT_OPTIONS = {};
+/** Whether `input` is exactly what `slugify` would produce under the same options. */
+function isSlug(input, options = DEFAULT_OPTIONS) {
+	if (typeof input !== "string" || input === "" || input === "." || input === "..") return false;
+	const o = resolveOptions(options);
+	if (o.maxLength !== void 0 && measure(input, o.maxLengthUnit) > o.maxLength) return false;
+	if (o.separator !== "" && input.includes(o.separator + o.separator)) return false;
+	if (o.unicode) {
+		if (input !== input.normalize("NFKC")) return false;
+		if (o.lowercase && input !== lowercaseOf(input, o)) return false;
+		if (o.scripts !== "any" && !checkScripts(input, o.scripts).ok) return false;
+		if (o.bidi !== "allow" && !isBidiSafeComponent(input)) return false;
+	}
+	return patternFor(options).test(input);
+}
+
 //#endregion
 //#region src/slug/slugify.ts
 const NON_ASCII = /[^\x00-\x7F]/;
@@ -414,10 +480,15 @@ function slugify(input, options) {
 	if (o.leadingMarks !== void 0 && !ascii) s = s.replace(o.leadingMarks, "$1");
 	const hadTrailingSeparator = o.separator !== "" && s.endsWith(o.separator);
 	s = collapse(s, o);
-	if (o.maxLength !== void 0) s = truncateSlug(s, o.maxLength, o.separator);
+	if (o.maxLength !== void 0) s = truncateSlug(s, o.maxLength, o.separator, o.maxLengthUnit);
 	if (s === "." || s === "..") s = "";
 	if (o.preserveLeadingUnderscore && hadLeadingUnderscore && s !== "" && !s.startsWith("_")) s = "_" + s;
 	if (o.preserveTrailingSeparator && hadTrailingSeparator && s !== "") s += o.separator;
+	if (s === "" && o.fallback !== void 0) {
+		const text = typeof o.fallback === "string" ? o.fallback : o.fallback(input);
+		const { fallback: _fallback, ...rest } = options ?? {};
+		return slugify(text, rest);
+	}
 	if (o.unicode && s !== "") {
 		if (o.scripts !== "any") {
 			const check = checkScripts(s, o.scripts);
@@ -433,11 +504,11 @@ function slugify(input, options) {
 
 //#endregion
 //#region src/slug/slugger.ts
-function withSuffix(base, separator, n, maxLength) {
+function withSuffix(base, separator, n, maxLength, unit) {
 	const suffix = separator + String(n);
-	if (maxLength === void 0 || base.length + suffix.length <= maxLength) return base + suffix;
-	const room = maxLength - suffix.length;
-	const head = room > 0 ? truncateSlug(base, room, separator) : "";
+	if (maxLength === void 0 || measure(base + suffix, unit) <= maxLength) return base + suffix;
+	const room = maxLength - measure(suffix, unit);
+	const head = room > 0 ? truncateSlug(base, room, separator, unit) : "";
 	return head === "" ? String(n).slice(0, maxLength) : head + suffix;
 }
 /** A slugger that never repeats a slug: the second `"Hello"` becomes `"hello-2"`. `defaults` apply to every call. */
@@ -460,7 +531,7 @@ function createSlugger(defaults = {}) {
 		let candidate;
 		do {
 			n += 1;
-			candidate = withSuffix(base, separator, n, merged.maxLength);
+			candidate = withSuffix(base, separator, n, merged.maxLength, merged.maxLengthUnit ?? "units");
 		} while (issued.has(candidate));
 		counters.set(base, n);
 		issued.add(candidate);
@@ -483,4 +554,4 @@ function createSlugger(defaults = {}) {
 const slugifyWithCounter = createSlugger;
 
 //#endregion
-export { checkScripts, createSlugger, decamelize, detectScripts, isBidiSafeComponent, isSlug, slugify, slugifyWithCounter, truncateSlug };
+export { checkScripts, createSlugger, decamelize, detectScripts, isBidiSafeComponent, isSlug, measure, slugify, slugifyWithCounter, truncateSlug };

package/dist/shared/punycode-MAFJqHdd.mjs

@@ -0,0 +1,180 @@
+//#region src/uri/punycode.ts
+const BASE = 36;
+const T_MIN = 1;
+const T_MAX = 26;
+const SKEW = 38;
+const DAMP = 700;
+const INITIAL_BIAS = 72;
+const INITIAL_N = 128;
+const DELIMITER = "-";
+const PREFIX = "xn--";
+const MAX_INT = 2147483647;
+const LABEL_SEPARATORS = /[.\u3002\uFF0E\uFF61]/;
+function adapt(delta, numPoints, firstTime) {
+	let d = firstTime ? Math.floor(delta / DAMP) : delta >> 1;
+	d += Math.floor(d / numPoints);
+	let k = 0;
+	while (d > 455) {
+		d = Math.floor(d / 35);
+		k += BASE;
+	}
+	return k + Math.floor(36 * d / (d + SKEW));
+}
+function digit(value) {
+	return String.fromCodePoint(value + (value < 26 ? 97 : 22));
+}
+function digitValue(cp) {
+	if (cp >= 48 && cp <= 57) return cp - 22;
+	if (cp >= 65 && cp <= 90) return cp - 65;
+	if (cp >= 97 && cp <= 122) return cp - 97;
+	return -1;
+}
+/** RFC 3492 Punycode encoding of one label, without the `xn--` prefix. */
+function punycodeEncode(input) {
+	const points = Array.from(input, (ch) => ch.codePointAt(0) ?? 0);
+	let out = "";
+	for (const cp of points) if (cp < 128) out += String.fromCodePoint(cp);
+	const basicCount = out.length;
+	let handled = basicCount;
+	if (basicCount > 0) out += DELIMITER;
+	let n = INITIAL_N;
+	let delta = 0;
+	let bias = INITIAL_BIAS;
+	while (handled < points.length) {
+		let m = 1114112;
+		for (const cp of points) if (cp >= n && cp < m) m = cp;
+		delta += (m - n) * (handled + 1);
+		n = m;
+		for (const cp of points) {
+			if (cp < n) delta += 1;
+			if (cp === n) {
+				let q = delta;
+				for (let k = BASE;; k += BASE) {
+					const t = k <= bias ? T_MIN : k >= bias + T_MAX ? T_MAX : k - bias;
+					if (q < t) break;
+					out += digit(t + (q - t) % (BASE - t));
+					q = Math.floor((q - t) / (BASE - t));
+				}
+				out += digit(q);
+				bias = adapt(delta, handled + 1, handled === basicCount);
+				delta = 0;
+				handled += 1;
+			}
+		}
+		delta += 1;
+		n += 1;
+	}
+	return out;
+}
+/**
+* RFC 3492 Punycode decoding of one label, without the `xn--` prefix.
+* @throws {RangeError} on malformed input.
+*/
+function punycodeDecode(input) {
+	const output = [];
+	const last = input.lastIndexOf(DELIMITER);
+	const basicEnd = last > 0 ? last : 0;
+	for (let i = 0; i < basicEnd; i++) {
+		const cp = input.codePointAt(i) ?? 0;
+		if (cp >= 128) throw new RangeError("punycodeDecode: invalid basic code point");
+		output.push(cp);
+	}
+	let n = INITIAL_N;
+	let bias = INITIAL_BIAS;
+	let i = 0;
+	let index = basicEnd > 0 ? basicEnd + 1 : 0;
+	while (index < input.length) {
+		const oldI = i;
+		let w = 1;
+		for (let k = BASE;; k += BASE) {
+			if (index >= input.length) throw new RangeError("punycodeDecode: truncated input");
+			const d = digitValue(input.codePointAt(index) ?? 0);
+			index += 1;
+			if (d < 0) throw new RangeError("punycodeDecode: invalid digit");
+			i += d * w;
+			if (i > MAX_INT) throw new RangeError("punycodeDecode: overflow");
+			const t = k <= bias ? T_MIN : k >= bias + T_MAX ? T_MAX : k - bias;
+			if (d < t) break;
+			w *= BASE - t;
+		}
+		const count = output.length + 1;
+		bias = adapt(i - oldI, count, oldI === 0);
+		n += Math.floor(i / count);
+		i %= count;
+		if (n > 1114111) throw new RangeError("punycodeDecode: code point out of range");
+		output.splice(i, 0, n);
+		i += 1;
+	}
+	return String.fromCodePoint(...output);
+}
+function isAsciiLabel(label) {
+	for (const ch of label) if ((ch.codePointAt(0) ?? 0) >= 128) return false;
+	return true;
+}
+function lowercaseCodePoints(text) {
+	let out = "";
+	for (const ch of text) out += ch.toLowerCase();
+	return out;
+}
+function mapLabel(label) {
+	return lowercaseCodePoints(label.replace(/\p{Cf}/gu, "").normalize("NFKC")).normalize("NFC");
+}
+function invalid(fn, label, reason) {
+	return /* @__PURE__ */ new RangeError(`${fn}: label ${JSON.stringify(label)} ${reason}`);
+}
+function decodeLabel(fn, label) {
+	let decoded;
+	try {
+		decoded = punycodeDecode(label.slice(4));
+	} catch {
+		throw invalid(fn, label, "is not valid Punycode");
+	}
+	if (decoded === "" || isAsciiLabel(decoded) || /[\p{C}\p{Z}]/u.test(decoded) || mapLabel(decoded) !== decoded || PREFIX + punycodeEncode(decoded) !== label) throw invalid(fn, label, "is not a valid A-label");
+	return decoded;
+}
+function checkAsciiLabel(fn, label, original) {
+	if (label.length > 63) throw invalid(fn, original, "exceeds 63 octets");
+	if (!/^[a-z0-9-]*$/.test(label)) throw invalid(fn, original, "contains characters outside letters, digits and hyphen");
+	if (label.startsWith("-") || label.endsWith("-")) throw invalid(fn, original, "may not start or end with a hyphen");
+	if (label.startsWith(PREFIX)) decodeLabel(fn, label);
+	else if (label.slice(2, 4) === "--") throw invalid(fn, original, "has hyphens in positions 3 and 4");
+	return label;
+}
+function checkDomain(fn, labels, host) {
+	if (labels.length > 1 && labels[labels.length - 1] === "") labels = labels.slice(0, -1);
+	for (const label of labels) if (label === "") throw invalid(fn, host, "contains an empty label");
+	const out = labels.join(".");
+	if (out.length > 253) throw new RangeError(`${fn}: ${JSON.stringify(host)} exceeds 253 octets`);
+	return out;
+}
+/**
+* Converts a domain to its A-label form: maps and lowercases each label the way UTS #46 does, punycodes the non-ASCII ones, and validates lengths, hyphens and existing `xn--` labels. IP literals pass through.
+* @throws {RangeError} when a label or the domain is not valid.
+*/
+function domainToAscii(host) {
+	if (host === "" || host.startsWith("[")) return host;
+	const out = checkDomain("domainToAscii", host.split(LABEL_SEPARATORS).flatMap((label) => {
+		if (isAsciiLabel(label)) return [checkAsciiLabel("domainToAscii", label.toLowerCase(), label)];
+		const mapped = mapLabel(label);
+		if (mapped.includes(".")) return domainToAscii(mapped).split(".");
+		if (isAsciiLabel(mapped)) return [checkAsciiLabel("domainToAscii", mapped, label)];
+		return [checkAsciiLabel("domainToAscii", PREFIX + punycodeEncode(mapped), label)];
+	}), host);
+	return host.endsWith(".") && out !== "" ? `${out}.` : out;
+}
+/**
+* Converts the `xn--` labels of a domain back to Unicode and lowercases the rest.
+* @throws {RangeError} when an `xn--` label does not decode to a valid U-label.
+*/
+function domainToUnicode(host) {
+	if (host === "" || host.startsWith("[")) return host;
+	const out = checkDomain("domainToUnicode", host.split(".").map((label) => {
+		const lower = label.toLowerCase();
+		if (!isAsciiLabel(lower)) return lower;
+		return lower.startsWith(PREFIX) ? decodeLabel("domainToUnicode", lower) : lower;
+	}), host);
+	return host.endsWith(".") && out !== "" ? `${out}.` : out;
+}
+
+//#endregion
+export { punycodeEncode as i, domainToUnicode as n, punycodeDecode as r, domainToAscii as t };