cizgile 0.1.0 → 0.1.1

package/README.md

@@ -249,6 +249,24 @@ If you are an assistant writing code with this library, these are the facts that
 - Use `resolveUri`, `normalizeUri` and `equivalentUris` instead of string concatenation or `new URL()` when you need RFC behaviour (strict scheme handling, no special-scheme rewriting, no host IDNA unless you ask for it).
 - Every exported function has an explicit TypeScript signature; the `.d.mts` files in `dist/` are the authoritative API.
 
+## Performance
+
+Measured with `bun run bench` (vitest bench, Node 24, one core of a desktop CPU). Higher is better.
+
+| input                                 | cizgile        | `@sindresorhus/slugify` | `slugify` (simov) |
+| ------------------------------------- | -------------- | ----------------------- | ----------------- |
+| ASCII title (60 chars)                | **396k ops/s** | 136k                    | 147k              |
+| Latin with diacritics                 | **235k ops/s** | 96k                     | 179k              |
+| Turkish, `locale: "tr"`               | 212k ops/s     | 99k                     | **216k**          |
+| Cyrillic, `transliterate: [cyrillic]` | 179k ops/s     | 86k                     | **188k**          |
+| 2.5 KB of mixed text                  | **6.4k ops/s** | 4.3k                    | 3.4k              |
+| `isSlug`                              | 3.7M ops/s     | —                       | —                 |
+
+`resolveUri` runs at ~0.8M ops/s (the built-in `URL` parser: ~1M), `removeDotSegments` at 2M,
+`percentEncode` at 0.5M (`encodeURIComponent`: 3.3M — it is native), `normalizeUri` at 0.3M.
+Options objects are resolved once and cached structurally, so inline `{ locale: "tr" }` literals cost
+nothing after the first call.
+
 ## How it compares
 
 | input                       | cizgile              | Django `slugify` | Rails `parameterize` | `@sindresorhus/slugify` |

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { S as symbols, _ as fold, g as DEFAULT_TABLES, l as latinLocales } from "./shared/locales-latin-D8enWKzw.mjs";
+import { C as symbols, _ as compileTables, g as DEFAULT_TABLES, l as latinLocales, v as fold } from "./shared/locales-latin-DshBH0E6.mjs";
 import { N as isSegmentNzNc, n as iriToUri } from "./shared/iri-CzbwHYgr.mjs";
 
 //#region src/slug/bidi.ts
@@ -36,7 +36,7 @@ function decamelize(input) {
 
 //#endregion
 //#region src/slug/charset.ts
-function escapeRegExp(text) {
+function escapeRegExp$1(text) {
 	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function escapeClassChar(text) {
@@ -142,6 +142,19 @@ function checkScripts(text, level = "moderately-restrictive") {
 
 //#endregion
 //#region src/slug/options.ts
+let symbolOnlyCache;
+function symbolEntries(table) {
+	symbolOnlyCache ??= /* @__PURE__ */ new WeakMap();
+	const cached = symbolOnlyCache.get(table);
+	if (cached !== void 0) return cached;
+	const out = {};
+	for (const [key, value] of Object.entries(table)) if (!/[\p{L}\p{M}\p{N}]/u.test(key)) out[key] = value;
+	symbolOnlyCache.set(table, out);
+	return out;
+}
+function escapeRegExp(text) {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 const DEFAULT_REMOVE = /['’]/g;
 let cache$1;
 function resolveLocale(locale) {
@@ -189,12 +202,16 @@ function build(options) {
 	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("");
+	const tables = resolveTables(options.transliterate, unicode, locale);
+	const symbolTables = (locale === void 0 ? [symbols] : [locale.table, symbols]).map(symbolEntries);
+	const separatorRuns = separator === "" ? void 0 : new RegExp(`[${separatorChars.map(escapeClassChar).join("")}]+`, "gu");
+	const leadingMarks = unicode ? new RegExp(`(${separator === "" ? "^" : `(?:^|${escapeRegExp(separator)})`})\\p{M}+`, "gu") : void 0;
 	return {
 		separator,
 		lowercase,
 		unicode,
 		locale,
-		tables: resolveTables(options.transliterate, unicode, locale),
+		tables,
 		decamelize: options.decamelize ?? false,
 		replacements: options.replacements ?? [],
 		remove,
@@ -206,14 +223,61 @@ function build(options) {
 		bidi: options.bidi ?? "allow",
 		allowedClass,
 		wordClass,
-		disallowed: new RegExp(`[^${allowedClass}]+`, "gu")
+		disallowed: new RegExp(`[^${allowedClass}]+`, "gu"),
+		compiled: tables === void 0 ? void 0 : compileTables(tables),
+		symbolTables,
+		compiledSymbols: compileTables(symbolTables),
+		separatorRuns,
+		leadingMarks
 	};
 }
-function resolveOptions(options = {}) {
+const DEFAULT_OPTIONS$1 = {};
+let objectIds;
+let nextObjectId = 0;
+let byKey;
+function objectId(value) {
+	objectIds ??= /* @__PURE__ */ new WeakMap();
+	let id = objectIds.get(value);
+	if (id === void 0) {
+		id = nextObjectId;
+		nextObjectId += 1;
+		objectIds.set(value, id);
+	}
+	return id;
+}
+function optionsKey(options) {
+	const locale = options.locale;
+	const transliterate = options.transliterate;
+	const remove = options.remove;
+	return JSON.stringify([
+		options.separator,
+		options.lowercase,
+		options.unicode,
+		typeof locale === "object" ? `#${objectId(locale)}` : locale,
+		Array.isArray(transliterate) ? transliterate.map((t) => objectId(t)) : transliterate,
+		options.decamelize,
+		options.replacements,
+		remove instanceof RegExp ? `${remove.source}/${remove.flags}` : remove,
+		options.preserveCharacters,
+		options.preserveLeadingUnderscore,
+		options.preserveTrailingSeparator,
+		options.maxLength,
+		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 resolved = build(options);
+	byKey ??= /* @__PURE__ */ new Map();
+	const key = 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);
 	return resolved;
 }
@@ -227,7 +291,7 @@ function patternFor(options) {
 	if (cached !== void 0) return cached;
 	const o = resolveOptions(options);
 	const char = `[${o.wordClass}]`;
-	const separator = escapeRegExp(o.separator);
+	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})*`;
@@ -236,7 +300,8 @@ function patternFor(options) {
 	cache.set(options, pattern);
 	return pattern;
 }
-function isSlug(input, options = {}) {
+const DEFAULT_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;
@@ -302,16 +367,6 @@ function truncateSlug(slug, maxLength, separator = "-") {
 
 //#endregion
 //#region src/slug/slugify.ts
-let symbolOnlyCache;
-function symbolEntries(table) {
-	symbolOnlyCache ??= /* @__PURE__ */ new WeakMap();
-	const cached = symbolOnlyCache.get(table);
-	if (cached !== void 0) return cached;
-	const out = {};
-	for (const [key, value] of Object.entries(table)) if (!/[\p{L}\p{M}\p{N}]/u.test(key)) out[key] = value;
-	symbolOnlyCache.set(table, out);
-	return out;
-}
 let compatCache;
 function compatEntries(table) {
 	compatCache ??= /* @__PURE__ */ new WeakMap();
@@ -331,35 +386,37 @@ function lowercaseOf(text, o) {
 	if (o.unicode && o.locale?.lowercase !== void 0) return o.locale.lowercase(text);
 	return text.replaceAll("İ", "i").toLowerCase();
 }
-function collapse(text, separator) {
-	if (separator === "") return text;
-	const runs = new RegExp(`[${uniqueChars(separator).map(escapeClassChar).join("")}]+`, "gu");
-	let out = text.replace(runs, separator);
+const NON_ASCII = /[^\x00-\x7F]/;
+function collapse(text, o) {
+	if (o.separatorRuns === void 0) return text;
+	const separator = o.separator;
+	let out = text.replace(o.separatorRuns, separator);
 	while (out.startsWith(separator)) out = out.slice(separator.length);
 	while (out.endsWith(separator)) out = out.slice(0, -separator.length);
 	return out;
 }
-function slugify(input, options = {}) {
+function slugify(input, options) {
 	if (typeof input !== "string") throw new TypeError("slugify: input must be a string");
 	const o = resolveOptions(options);
-	let s = stripControls(input).normalize("NFC");
+	let s = stripControls(input);
+	let ascii = !NON_ASCII.test(s);
+	if (!ascii) s = s.normalize("NFC");
 	for (const [from, to] of o.replacements) if (from !== "") s = s.split(from).join(to);
-	const symbolTables = (o.locale === void 0 ? [symbols] : [o.locale.table, symbols]).map(symbolEntries);
-	s = applyCompat(s, o.tables ?? symbolTables).normalize("NFKC");
+	if (o.replacements.length > 0) ascii = !NON_ASCII.test(s);
+	if (!ascii) s = applyCompat(s, o.tables ?? o.symbolTables).normalize("NFKC");
 	if (o.decamelize) s = decamelize(s);
-	if (o.tables !== void 0) s = fold(s, o.tables, false).replace(/(?![\x00-\x7F])[\p{L}\p{M}\p{N}]/gu, "");
-	else s = fold(s, symbolTables, false, false);
+	if (o.compiled !== void 0) {
+		s = fold(s, o.compiled, false);
+		if (!ascii && NON_ASCII.test(s)) s = s.replace(/(?![\x00-\x7F])[\p{L}\p{M}\p{N}]/gu, "");
+	} else s = fold(s, o.compiledSymbols, false, false);
 	if (o.lowercase) s = lowercaseOf(s, o);
-	if (o.unicode) s = s.normalize("NFKC");
+	if (o.unicode && !ascii) s = s.normalize("NFKC");
 	if (o.remove !== void 0) s = s.replace(o.remove, "");
 	const hadLeadingUnderscore = s.startsWith("_");
 	s = s.replace(o.disallowed, o.separator);
-	if (o.unicode) {
-		const boundary = o.separator === "" ? "^" : `(?:^|${escapeRegExp(o.separator)})`;
-		s = s.replace(new RegExp(`(${boundary})\\p{M}+`, "gu"), "$1");
-	}
+	if (o.leadingMarks !== void 0 && !ascii) s = s.replace(o.leadingMarks, "$1");
 	const hadTrailingSeparator = o.separator !== "" && s.endsWith(o.separator);
-	s = collapse(s, o.separator);
+	s = collapse(s, o);
 	if (o.maxLength !== void 0) s = truncateSlug(s, o.maxLength, o.separator);
 	if (s === "." || s === "..") s = "";
 	if (o.preserveLeadingUnderscore && hadLeadingUnderscore && s !== "" && !s.startsWith("_")) s = "_" + s;

package/dist/shared/{locales-latin-D8enWKzw.mjs → locales-latin-DshBH0E6.mjs}

@@ -135,21 +135,57 @@ const symbols = {
 //#endregion
 //#region src/transliterate/core.ts
 const DEFAULT_TABLES = [latin, symbols];
-let sequenceCache;
+const NON_ASCII = /[^\x00-\x7F]/;
+let tableIds;
+let nextTableId = 0;
+let compiledByArray;
+let compiledByKey;
 function codePointCount(text) {
 	let count = 0;
 	for (const _ of text) count += 1;
 	return count;
 }
-function sequencesOf(table) {
-	sequenceCache ??= /* @__PURE__ */ new WeakMap();
-	const cached = sequenceCache.get(table);
-	if (cached !== void 0) return cached;
+function tableId(table) {
+	tableIds ??= /* @__PURE__ */ new WeakMap();
+	let id = tableIds.get(table);
+	if (id === void 0) {
+		id = nextTableId;
+		nextTableId += 1;
+		tableIds.set(table, id);
+	}
+	return id;
+}
+function build(tables) {
+	const map = /* @__PURE__ */ new Map();
 	const multi = [];
-	for (const key of Object.keys(table)) if (codePointCount(key) > 1) multi.push([key, table[key] ?? ""]);
+	for (const table of tables) for (const key of Object.keys(table)) {
+		if (map.has(key)) continue;
+		const value = table[key] ?? "";
+		map.set(key, value);
+		if (codePointCount(key) > 1) multi.push([key, value]);
+	}
 	multi.sort((a, b) => b[0].length - a[0].length);
-	sequenceCache.set(table, multi);
-	return multi;
+	const asciiKeys = [...map.keys()].filter((key) => key.length === 1 && (key.codePointAt(0) ?? 0) < 128);
+	return {
+		map,
+		sequences: multi,
+		ascii: asciiKeys.length === 0 ? void 0 : new RegExp(`[${asciiKeys.map((k) => k.replace(/[\]\\^-]/g, "\\$&")).join("")}]`, "g")
+	};
+}
+function compileTables(tables) {
+	compiledByArray ??= /* @__PURE__ */ new WeakMap();
+	const byArray = compiledByArray.get(tables);
+	if (byArray !== void 0) return byArray;
+	compiledByKey ??= /* @__PURE__ */ new Map();
+	const key = tables.map(tableId).join(",");
+	let compiled = compiledByKey.get(key);
+	if (compiled === void 0) {
+		compiled = build(tables);
+		if (compiledByKey.size > 256) compiledByKey.clear();
+		compiledByKey.set(key, compiled);
+	}
+	compiledByArray.set(tables, compiled);
+	return compiled;
 }
 function resolveTables(options) {
 	const out = [];
@@ -170,12 +206,28 @@ function lookup(tables, key) {
 function stripMarks(input) {
 	return input.normalize("NFD").replace(/\p{M}+/gu, "").normalize("NFC");
 }
+let markCache;
+function stripMarksCached(ch) {
+	markCache ??= /* @__PURE__ */ new Map();
+	let base = markCache.get(ch);
+	if (base === void 0) {
+		base = stripMarks(ch);
+		if (markCache.size > 8192) markCache.clear();
+		markCache.set(ch, base);
+	}
+	return base;
+}
 function fold(input, tables, dropUnknown, foldMarks = true) {
+	const compiled = "sequences" in tables ? tables : compileTables(tables);
+	const map = compiled.map;
 	let text = input;
-	for (const table of tables) for (const [key, value] of sequencesOf(table)) if (text.includes(key)) text = text.split(key).join(value);
+	if (!NON_ASCII.test(text)) return compiled.ascii === void 0 ? text : text.replace(compiled.ascii, (m) => map.get(m) ?? m);
+	if (compiled.sequences.length > 0) {
+		for (const [key, value] of compiled.sequences) if (text.includes(key)) text = text.split(key).join(value);
+	}
 	let out = "";
 	for (const ch of text) {
-		const direct = lookup(tables, ch);
+		const direct = map.get(ch);
 		if (direct !== void 0) {
 			out += direct;
 			continue;
@@ -184,10 +236,10 @@ function fold(input, tables, dropUnknown, foldMarks = true) {
 			out += ch;
 			continue;
 		}
-		const base = foldMarks ? stripMarks(ch) : ch;
+		const base = foldMarks ? stripMarksCached(ch) : ch;
 		if (base !== ch) {
 			if (base === "") continue;
-			out += lookup(tables, base) ?? (dropUnknown && (base.codePointAt(0) ?? 0) >= 128 ? "" : base);
+			out += map.get(base) ?? (dropUnknown && (base.codePointAt(0) ?? 0) >= 128 ? "" : base);
 			continue;
 		}
 		out += dropUnknown ? "" : ch;
@@ -369,4 +421,4 @@ const latinLocales = {
 };
 
 //#endregion
-export { latin as C, symbols as S, fold as _, fi as a, stripMarks as b, it as c, nl as d, pt as f, DEFAULT_TABLES as g, vi as h, es as i, latinLocales as l, tr as m, da as n, fr as o, sv as p, de as r, hu as s, az as t, nb as u, lookup as v, transliterate as x, resolveTables as y };
+export { symbols as C, transliterate as S, compileTables as _, fi as a, resolveTables as b, it as c, nl as d, pt as f, DEFAULT_TABLES as g, vi as h, es as i, latinLocales as l, tr as m, da as n, fr as o, sv as p, de as r, hu as s, az as t, nb as u, fold as v, latin as w, stripMarks as x, lookup as y };

package/dist/transliterate.d.mts

@@ -1,13 +1,4 @@
 import { a as TransliterationTable, i as LocaleId, n as LatinLocaleId, r as Locale, t as CyrillicLocaleId } from "./shared/types-C1iMvUXh.mjs";
-//#region src/transliterate/arabic.d.ts
-export declare const arabic: TransliterationTable;
-export declare const persian: TransliterationTable;
-export declare const urdu: TransliterationTable;
-export declare const pashto: TransliterationTable;
-//#endregion
-//#region src/transliterate/armenian.d.ts
-export declare const armenian: TransliterationTable;
-//#endregion
 //#region src/transliterate/core.d.ts
 interface TransliterateOptions {
   readonly locale?: Locale;
@@ -15,12 +6,27 @@ interface TransliterateOptions {
   readonly unknown?: "keep" | "drop";
 }
 export declare const DEFAULT_TABLES: readonly TransliterationTable[];
+type Sequences = ReadonlyArray<readonly [string, string]>;
+interface CompiledTables {
+  readonly map: ReadonlyMap<string, string>;
+  readonly sequences: Sequences;
+  readonly ascii: RegExp | undefined;
+}
 export declare function resolveTables(options: TransliterateOptions): readonly TransliterationTable[];
 export declare function lookup(tables: readonly TransliterationTable[], key: string): string | undefined;
 export declare function stripMarks(input: string): string;
-export declare function fold(input: string, tables: readonly TransliterationTable[], dropUnknown: boolean, foldMarks?: boolean): string;
+export declare function fold(input: string, tables: readonly TransliterationTable[] | CompiledTables, dropUnknown: boolean, foldMarks?: boolean): string;
 export declare function transliterate(input: string, options?: TransliterateOptions): string;
 //#endregion
+//#region src/transliterate/arabic.d.ts
+export declare const arabic: TransliterationTable;
+export declare const persian: TransliterationTable;
+export declare const urdu: TransliterationTable;
+export declare const pashto: TransliterationTable;
+//#endregion
+//#region src/transliterate/armenian.d.ts
+export declare const armenian: TransliterationTable;
+//#endregion
 //#region src/transliterate/cyrillic.d.ts
 export declare const cyrillic: TransliterationTable;
 export declare const cyrillicUk: TransliterationTable;

package/dist/transliterate.mjs

@@ -1,4 +1,4 @@
-import { C as latin, S as symbols, _ as fold, a as fi, b as stripMarks, c as it, d as nl, f as pt, g as DEFAULT_TABLES, h as vi, i as es, l as latinLocales, m as tr, n as da, o as fr, p as sv, r as de, s as hu, t as az, u as nb, v as lookup, x as transliterate, y as resolveTables } from "./shared/locales-latin-D8enWKzw.mjs";
+import { C as symbols, S as transliterate, a as fi, b as resolveTables, c as it, d as nl, f as pt, g as DEFAULT_TABLES, h as vi, i as es, l as latinLocales, m as tr, n as da, o as fr, p as sv, r as de, s as hu, t as az, u as nb, v as fold, w as latin, x as stripMarks, y as lookup } from "./shared/locales-latin-DshBH0E6.mjs";
 
 //#region src/transliterate/arabic.ts
 const arabic = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cizgile",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "RFC 3986/3987-grounded URL slugs. Transliteration, Unicode slugs, IRI to URI, percent-encoding, dot-segment removal. Zero dependencies, tree-shakeable.",
   "keywords": [
     "esm",
@@ -62,9 +62,11 @@
     "coverage": "vitest run --coverage",
     "release": "bun run test && bun run build && bumpp --commit --tag --push --all",
     "prepack": "bun run build",
-    "test:bun": "bun --bun vitest run"
+    "test:bun": "bun --bun vitest run",
+    "bench": "vitest bench --run"
   },
   "devDependencies": {
+    "@sindresorhus/slugify": "^3.0.0",
     "@types/bun": "1.4.0",
     "@vitest/coverage-v8": "4.1.11",
     "bumpp": "12.2.2",
@@ -73,6 +75,7 @@
     "oxlint-tsgolint": "7.0.2001",
     "rolldown": "1.2.6",
     "rolldown-plugin-dts": "0.28.4",
+    "slugify": "^1.6.9",
     "typescript": "7.0.2",
     "vitest": "4.1.11"
   },