cizgile 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 <p align="center">
   <br>
-  <img src=".github/assets/cover.svg?v=1a3fd12" alt="cizgile — Zero-dependency URL slug engine" width="100%">
+  <img src=".github/assets/cover.svg?v=f85c00e" alt="cizgile — Zero-dependency URL slug engine" width="100%">
   <br><br>
   <b style="font-size: 2em;">cizgile</b>
   <br><br>
@@ -9,6 +9,7 @@
   Turn any title into a clean URL slug — in any language — and work with URLs the way RFC 3986 and RFC 3987 describe them. Pure TypeScript, works everywhere.
   <br><br>
   <a href="https://npmjs.com/package/cizgile"><img src="https://img.shields.io/npm/v/cizgile?style=flat&colorA=18181B&colorB=34d399" alt="npm version"></a>
+  <a href="https://github.com/productdevbook/cizgile/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/productdevbook/cizgile/ci.yml?style=flat&colorA=18181B&colorB=34d399" alt="ci"></a>
   <a href="https://npmjs.com/package/cizgile"><img src="https://img.shields.io/npm/dm/cizgile?style=flat&colorA=18181B&colorB=34d399" alt="npm downloads"></a>
   <a href="https://bundlephobia.com/result?p=cizgile"><img src="https://img.shields.io/bundlephobia/minzip/cizgile?style=flat&colorA=18181B&colorB=34d399" alt="bundle size"></a>
   <a href="https://github.com/productdevbook/cizgile/blob/main/LICENSE"><img src="https://img.shields.io/github/license/productdevbook/cizgile?style=flat&colorA=18181B&colorB=34d399" alt="license"></a>
@@ -34,7 +35,7 @@ No dependencies. ESM only. Node 20+, Bun, Deno, browsers, edge workers.
 ## Why cizgile
 
 - **Slugs that are correct by construction.** Every ASCII slug is a valid URL path segment (RFC 3986 `segment-nz-nc`) — no percent-encoding needed, no `.` or `..`, no accidental scheme prefix.
-- **Speaks your language.** 19 locales (`tr`, `de`, `da`, `sv`, `uk`, `bg`, …) and 7 scripts (Latin, Cyrillic, Greek, Arabic, Armenian, Georgian, Dhivehi). `ß` → `ss`, `İ` → `i`, `Щ` → `shch`.
+- **Speaks your language.** 36 locales (`tr`, `de`, `pl`, `sv`, `uk`, `ja`, `ko`, …) and 10 scripts (Latin, Cyrillic, Greek, Arabic, Armenian, Georgian, Dhivehi, Hebrew, Hangul, kana). `ß` → `ss`, `İ` → `i`, `Щ` → `shch`, `서울` → `seoul`.
 - **Unicode slugs when you want them.** `你好-world` stays readable, and `iriToUri` gives you the exact percent-encoded form for the wire.
 - **A real URL toolkit underneath.** Resolve, normalise, compare, validate and relativise URLs by the RFC, cross-checked against the WHATWG `URL` parser.
 - **Small and tree-shakeable.** `import { slugify }` ships the Latin table only; other scripts load only when you import them.
@@ -70,20 +71,23 @@ Locale ids for Latin-script languages; Cyrillic locales and other scripts come f
 
 ```ts
 import { slugify } from "cizgile"
-import { cyrillic, greek, uk, defineLocale, de } from "cizgile/transliterate"
+import { cyrillic, greek, uk, ja, ko, defineLocale, de } from "cizgile/transliterate"
 
 slugify("Çay & Simit", { locale: "tr" }) // "cay-ve-simit"
 slugify("Fisch & Chips", { locale: "de" }) // "fisch-und-chips"
 slugify("Ærø", { locale: "da" }) // "aeroe"
+slugify("Zażółć & jaźń", { locale: "pl" }) // "zazolc-i-jazn"
 slugify("Київ", { locale: uk }) // "kyiv"
 slugify("Привет мир", { transliterate: [cyrillic] }) // "privet-mir"
 slugify("Καλημέρα", { transliterate: [greek] }) // "kalimera"
+slugify("서울 & 부산", { locale: ko }) // "seoul-mit-busan"
+slugify("とうきょう", { locale: ja }) // "toukyou"
 
 const swiss = defineLocale(de, { id: "de-CH", table: { ß: "ss" } })
 slugify("Straße", { locale: swiss }) // "strasse"
 ```
 
-Locale ids: `az da de es fi fr hu it nb nl pt sv tr vi`. Locale objects: those plus `bg mk ru sr uk`.
+Locale ids: `az ca cs da de es et fi fr hr hu is it lt lv nb nl pl pt ro sk sl sv tr vi`. Locale objects: those plus `be bg kk mk ru sr uk` (Cyrillic) and `el he ja ko` (Greek, Hebrew, kana, Hangul).
 
 ### Unicode slugs
 
@@ -128,41 +132,43 @@ isSlug("hello_world", { separator: "_" }) // true
 isSlug("你好-world", { unicode: true }) // true
 ```
 
-`isSlug` accepts exactly what `slugify` would produce under the same options.
+`isSlug` accepts exactly what `slugify` would produce under the same options, `locale` included.
 
 ### All options
 
-| option                      | default   | what it does                                                                                                                  |
-| --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------- |
-| `separator`                 | `"-"`     | Joins words. Any URL-safe punctuation (`- _ . ~ !$&'()*+,;= @`) or `""`.                                                      |
-| `lowercase`                 | `true`    | `false` keeps the original case.                                                                                              |
-| `unicode`                   | `false`   | Keep letters from every script instead of transliterating to ASCII.                                                           |
-| `locale`                    | —         | Language-specific rules: a locale id or a `Locale` object.                                                                    |
-| `transliterate`             | `true`    | `false` skips the tables (accents still fold); an array adds script tables.                                                   |
-| `decamelize`                | `false`   | `fooBar` → `foo-bar`, `HTMLParser` → `html-parser`.                                                                           |
-| `replacements`              | `[]`      | `[from, to]` pairs applied first; spaces in `to` become separators.                                                           |
-| `remove`                    | `/['’]/g` | Characters to delete rather than turn into separators (`don't` → `dont`).                                                     |
-| `preserveCharacters`        | `[]`      | Extra URL-safe characters to keep, e.g. `["."]` for version numbers.                                                          |
-| `preserveLeadingUnderscore` | `false`   | `_draft` → `_draft`.                                                                                                          |
-| `preserveTrailingSeparator` | `false`   | Keep a trailing separator while the user is still typing.                                                                     |
-| `maxLength`                 | —         | Cut at a word boundary, never inside a character (emoji sequences, combining marks). Counts UTF-16 code units like `.length`. |
-| `scripts`                   | `"any"`   | Unicode mode: UTS #39 mixed-script restriction level.                                                                         |
-| `bidi`                      | `"allow"` | Unicode mode: RFC 3987 §4.2 direction rule — `"encode"` or `"throw"` on violation.                                            |
+| option                      | default   | what it does                                                                                                                          |
+| --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| `separator`                 | `"-"`     | Joins words. Any URL-safe punctuation (`- _ . ~ !$&'()*+,;= @`), several of them (`"--"`), or `""`.                                   |
+| `lowercase`                 | `true`    | `false` keeps the original case.                                                                                                      |
+| `unicode`                   | `false`   | Keep letters from every script instead of transliterating to ASCII.                                                                   |
+| `locale`                    | —         | Language-specific rules: a locale id or a `Locale` object.                                                                            |
+| `transliterate`             | `true`    | `false` skips the Latin and symbol tables (the locale table and accent folding still apply); an array adds script tables.             |
+| `decamelize`                | `false`   | `fooBar` → `foo-bar`, `HTMLParser` → `html-parser`.                                                                                   |
+| `replacements`              | `[]`      | `[from, to]` pairs applied first; spaces in `to` become separators.                                                                   |
+| `remove`                    | `/['’]/g` | A global regex of characters to delete rather than turn into separators (`don't` → `dont`); `false` keeps them.                       |
+| `preserveCharacters`        | `[]`      | Extra URL-safe single characters to keep, e.g. `["."]` for version numbers. The separator or anything outside `segment-nz-nc` throws. |
+| `preserveLeadingUnderscore` | `false`   | `_draft` → `_draft`.                                                                                                                  |
+| `preserveTrailingSeparator` | `false`   | Keep a trailing separator while the user is still typing.                                                                             |
+| `maxLength`                 | —         | Cut at a word boundary, never inside a character (emoji sequences, combining marks). Counts UTF-16 code units like `.length`.         |
+| `scripts`                   | `"any"`   | Unicode mode: UTS #39 mixed-script restriction level.                                                                                 |
+| `bidi`                      | `"allow"` | Unicode mode: RFC 3987 §4.2 direction rule — `"encode"` or `"throw"` on violation.                                                    |
 
 The pipeline runs in this order: strip control/format characters → NFC → `replacements` → NFKC → `decamelize` → transliterate (locale → your tables → Latin → symbols → strip accents) → lowercase → `remove` → separators → `maxLength` → guards. Output is idempotent: `slugify(slugify(x)) === slugify(x)`.
 
 ## Transliteration on its own
 
 ```ts
-import { transliterate, cyrillic, locales } from "cizgile/transliterate"
+import { transliterate, cyrillic, hangul, kana, locales } from "cizgile/transliterate"
 
 transliterate("Straße Ærø") // "Strasse AEro"
 transliterate("Привет", { tables: [cyrillic] }) // "Privet"
 transliterate("Ängsö", { locale: locales.sv }) // "Aengsoe"
-transliterate("你好") // "你好" — unknown scripts are kept (use unknown: "drop" to remove)
+transliterate("서울 ひらがな", { tables: [hangul, kana] }) // "seoul hiragana"
+transliterate("नमस्ते 你好") // "नमस्ते 你好" — unknown scripts are kept intact (use unknown: "drop" to remove)
+transliterate("final x² Ⅷ", { nfkc: true }) // "final x2 VIII"
 ```
 
-Tables: `latin symbols cyrillic cyrillicUk cyrillicBg cyrillicMk cyrillicSr greek arabic persian urdu pashto armenian georgian dhivehi`, plus `allScripts`. Where a letter is spelled differently at the start of a word (Armenian `ե`, Ukrainian `є ї й ю я`), the capital carries the word-initial form. `defineLocale` and `mergeTables` return new objects — nothing global is ever mutated.
+Tables: `latin symbols cyrillic cyrillicUk cyrillicBg cyrillicMk cyrillicSr greek arabic persian urdu pashto armenian georgian dhivehi hebrew hangul kana`, plus `allScripts`. Where a letter is spelled differently at the start of a word (Armenian `ե`, Ukrainian `є ї й ю я`), the capital carries the word-initial form. Hangul is romanised jamo by jamo (Revised Romanization without sound-change rules, so `한국어` is `hangukeo`), kana with Hepburn (the long-vowel mark and sokuon are dropped); kanji and Han are left as they are. `defineLocale` and `mergeTables` return new objects — nothing global is ever mutated.
 
 ## URL toolkit
 
@@ -214,7 +220,7 @@ iriToUri("http://例え.jp/résumé", { host: "punycode" }) // "http://xn--r8jz4
 `parseUri` `serializeUri` — components stay distinct from "absent"; the serializer inserts `/.` or `./` where the grammar requires it.
 `isUriReference` `isUri` `isAbsoluteUri` `isRelativeReference` `classifyReference` `pathForm` — validating parser built from the ABNF.
 `isIriReference` `isIri` `isIunreserved` `isIpchar` — the same for IRIs (RFC 3987 §2.2).
-`extractUri(text)` — Appendix C: strips `<>`, quotes, `URL:` prefixes, trailing punctuation and line-wrap whitespace.
+`extractUri(text)` — Appendix C: strips `<>`, quotes, `URL:` prefixes, trailing punctuation and line-wrap whitespace; a markdown link or an `href`/`src` attribute yields its URL.
 
 **Resolution (§5)**
 `resolveUri(base, ref, { strict, allowRelativeBase })` — every §5.4 example passes; strict by default (`http:g` stays `http:g`).
@@ -225,15 +231,15 @@ iriToUri("http://例え.jp/résumé", { host: "punycode" }) // "http://xn--r8jz4
 **Normalisation and comparison (§6)**
 `normalizeUri(uri, { defaultPorts, schemeBased, userinfo })` — case, percent-encoding, dot segments, default ports, empty path → `/`; `userinfo: "strip-password" | "strip"` for logs.
 `normalizePath(path, { trailingSlash })`.
-`equivalentUris(a, b, { level, base, ignoreFragment })` — `"simple"`, `"syntax"` or `"scheme"` (default). Never maps IRIs to URIs (RFC 3987 §5.3.1).
+`equivalentUris(a, b, { level, base, ignoreFragment, defaultPorts })` — `"simple"`, `"syntax"` or `"scheme"` (default). Never maps IRIs to URIs (RFC 3987 §5.3.1).
 
 **IRIs (RFC 3987)**
 `isUcschar` `isIprivate` `isBidiControl` `hasBidiControls`.
-`iriToUri(iri, { bidi, nfc, strict, host })` — percent-encodes without altering characters (§3.1 step 1c); `host: "punycode"` converts the domain; `strict` rejects characters no IRI may contain.
+`iriToUri(iri, { bidi, nfc, strict, host })` — percent-encodes without altering characters (§3.1 step 1c); `bidi: "throw" | "strip"` handles direction controls; `host: "punycode"` converts the domain; `strict` rejects characters no IRI may contain.
 `uriToIri(uri)` — decodes only what §3.2 allows, per component.
-`punycodeEncode` `punycodeDecode` `domainToAscii` `domainToUnicode` — RFC 3492, no dependencies.
+`punycodeEncode` `punycodeDecode` `domainToAscii` `domainToUnicode` — RFC 3492, no dependencies. `domainToAscii` maps and lowercases labels the way UTS #46 does, then rejects what no DNS name may carry: empty labels, labels over 63 octets, names over 253, leading or trailing hyphens, non-LDH characters and `xn--` labels that do not round-trip.
 
-Deliberately not implemented: RFC 6874 IPv6 zone identifiers (reverted by RFC 9844) and the network-based normalisation of §6.2.4.
+Deliberately not implemented: RFC 6874 IPv6 zone identifiers (reverted by RFC 9844), the network-based normalisation of §6.2.4, and the UTS #46 status table, CONTEXTJ/CONTEXTO and the RFC 5893 bidi rule for domains.
 
 </details>
 
@@ -244,11 +250,30 @@ If you are an assistant writing code with this library, these are the facts that
 - Import paths: `cizgile` (slugs), `cizgile/transliterate` (tables, locales), `cizgile/uri` (URLs). ESM only, no default exports, no side effects, no runtime dependencies.
 - `slugify(text, options?)` returns `""` for input with nothing usable — it never throws on ordinary text. It throws `RangeError`/`TypeError` only for invalid options (`separator: "/"`, `preserveCharacters` containing the separator, a non-global `remove` regex, a negative `maxLength`) and, in unicode mode, when `scripts` or `bidi: "throw"` rejects the result.
 - The ASCII output is always a valid path segment; put it in a URL as-is. For `unicode: true` output, call `iriToUri(slug)` before putting it on the wire.
-- Cyrillic and other non-Latin scripts are opt-in: pass `transliterate: [cyrillic]` or a locale object such as `uk` from `cizgile/transliterate`. Without them, Cyrillic text produces `""` in ASCII mode.
+- Cyrillic and other non-Latin scripts are opt-in: pass `transliterate: [cyrillic]` or a locale object such as `uk`, `ja` or `ko` from `cizgile/transliterate`. Without them, Cyrillic text produces `""` in ASCII mode. `transliterate()` keeps scripts it has no table for intact; `allScripts` loads every table.
 - `createSlugger()` is the way to get unique slugs in a document or import job; do not append counters yourself.
 - 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: ~0.9M), `removeDotSegments` at 2M,
+`percentEncode` at 0.9M on mixed text and 3.6M on a pure-ASCII segment (`encodeURIComponent`: 3.1M and 4.7M — it is native),
+`normalizeUri` at 0.37M, `iriToUri` at 0.66M.
+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` |
@@ -265,7 +290,7 @@ If you are an assistant writing code with this library, these are the facts that
 
 ## Specifications
 
-RFC 3986 (with errata 2033, 4547, 4789, 5428), RFC 3987, RFC 3492, RFC 8820, RFC 9844, the WHATWG URL Standard's percent-encode sets, Unicode UTS #39 restriction levels and UAX #29 grapheme boundaries, Google Search Central's URL guidance. The test suite runs every example those documents contain.
+RFC 3986 (with errata 2033, 4547, 4789, 5428), RFC 3987, RFC 3492 (all nineteen §7.1 sample strings), RFC 8820, RFC 9844, the UTS #46 mapping step, the WHATWG URL Standard's percent-encode sets, Unicode UTS #39 restriction levels and UAX #29 grapheme boundaries, Google Search Central's URL guidance. The test suite runs every example those documents contain.
 
 ## Development
 

package/dist/index.d.mts

@@ -1,55 +1,94 @@
-import { a as TransliterationTable, i as LocaleId, n as LatinLocaleId, r as Locale } from "./shared/types-C1iMvUXh.mjs";
+import { i as LocaleId, n as LatinLocaleId, o as TransliterationTable, r as Locale } from "./shared/types-DbyhfPRc.mjs";
 //#region src/slug/bidi.d.ts
+/** RFC 3987 section 4.2: whether `text` can be a URL component without mixing text directions in a way that renders ambiguously. */
 export declare function isBidiSafeComponent(text: string): boolean;
 //#endregion
 //#region src/slug/decamelize.d.ts
+/** Inserts spaces at camelCase and acronym boundaries: `"getHTTPResponse"` becomes `"get HTTP Response"`. */
 export declare function decamelize(input: string): string;
 //#endregion
 //#region src/slug/scripts.d.ts
+/** UTS #39 mixed-script restriction levels, from a single script (`"single"`) to no restriction (`"any"`). */
 type ScriptRestriction = "single" | "highly-restrictive" | "moderately-restrictive" | "any";
+/** The result of `checkScripts`. */
 interface ScriptCheck {
+  /** Whether the text stays within the requested restriction level. */
   readonly ok: boolean;
+  /** The Unicode scripts found in the text. */
   readonly scripts: readonly string[];
 }
+/** The Unicode script names used by `text`, ignoring Common and Inherited characters. */
 export declare function detectScripts(text: string): string[];
+/** Applies a UTS #39 restriction `level` to the scripts in `text`; `ok` is false when the mix exceeds it. */
 export declare function checkScripts(text: string, level?: ScriptRestriction): ScriptCheck;
 //#endregion
 //#region src/slug/options.d.ts
+/** Options for `slugify` and `createSlugger`. Every option has a default; an empty object is the everyday call. */
 interface SlugifyOptions {
+  /** Joins words; `"-"` by default. Any URL-safe punctuation (`- _ . ~ ! $ & ' ( ) * + , ; = @`) or `""`. */
   readonly separator?: string;
+  /** Lowercases the result; `true` by default. */
   readonly lowercase?: boolean;
+  /** Keeps letters from every script instead of transliterating to ASCII; `false` by default. */
   readonly unicode?: boolean;
+  /** Language rules: a Latin locale id such as `"tr"`, or a `Locale` object from `cizgile/transliterate`. */
   readonly locale?: LatinLocaleId | Locale;
+  /** `false` skips the Latin and symbol tables (the locale table and accent folding still apply); an array adds script tables such as `cyrillic`. */
   readonly transliterate?: boolean | readonly TransliterationTable[];
+  /** Splits camelCase before slugging: `"fooBar"` becomes `"foo-bar"`; `false` by default. */
   readonly decamelize?: boolean;
+  /** `[from, to]` pairs applied before anything else; spaces in `to` become separators. */
   readonly replacements?: ReadonlyArray<readonly [string, string]>;
+  /** A global regex of characters to delete rather than turn into separators; apostrophes by default, `false` for none. */
   readonly remove?: RegExp | false;
+  /** Extra URL-safe single characters to keep, such as `["."]` for version numbers. */
   readonly preserveCharacters?: readonly string[];
+  /** Keeps a leading `_`: `"_draft"` stays `"_draft"`. */
   readonly preserveLeadingUnderscore?: boolean;
+  /** Keeps a trailing separator, for input still being typed. */
   readonly preserveTrailingSeparator?: boolean;
+  /** Cuts at a word boundary, never inside a grapheme cluster. Counts UTF-16 code units like `.length`. */
   readonly maxLength?: number;
+  /** Unicode mode only: the UTS #39 restriction level the result must satisfy; `"any"` by default. */
   readonly scripts?: ScriptRestriction;
+  /** Unicode mode only: what to do when the result mixes text directions (RFC 3987 section 4.2); `"allow"` by default. */
   readonly bidi?: "allow" | "encode" | "throw";
 }
-type IsSlugOptions = Pick<SlugifyOptions, "separator" | "lowercase" | "unicode" | "preserveCharacters" | "preserveLeadingUnderscore" | "preserveTrailingSeparator" | "maxLength" | "scripts" | "bidi">;
+/** The `slugify` options that shape what a valid slug looks like. */
+type IsSlugOptions = Pick<SlugifyOptions, "separator" | "lowercase" | "unicode" | "locale" | "preserveCharacters" | "preserveLeadingUnderscore" | "preserveTrailingSeparator" | "maxLength" | "scripts" | "bidi">;
 //#endregion
 //#region src/slug/is-slug.d.ts
+/** Whether `input` is exactly what `slugify` would produce under the same options. */
 export declare function isSlug(input: string, options?: IsSlugOptions): boolean;
 //#endregion
 //#region src/slug/slugger.d.ts
+/** A `slugify` that remembers what it handed out; see `createSlugger`. */
 interface Slugger {
+  /** Slugifies `input`, appending `-2`, `-3`, ... when the slug was already handed out. */
   (input: string, options?: SlugifyOptions): string;
+  /** Forgets every slug handed out or reserved so far. */
   reset(): void;
+  /** Whether `slug` has already been handed out or reserved. */
   has(slug: string): boolean;
+  /** Marks `slug` as taken so it is never handed out again. */
   reserve(slug: string): void;
 }
+/** A slugger that never repeats a slug: the second `"Hello"` becomes `"hello-2"`. `defaults` apply to every call. */
 export declare function createSlugger(defaults?: SlugifyOptions): Slugger;
+/** Alias of `createSlugger`, under the name `@sindresorhus/slugify` uses. */
 export declare const slugifyWithCounter: (defaults?: SlugifyOptions) => Slugger;
 //#endregion
 //#region src/slug/slugify.d.ts
+/**
+ * Turns text into a URL slug: an RFC 3986 `segment-nz-nc` in ASCII mode, NFKC letters, digits and marks in unicode mode.
+ * Returns `""` when nothing usable remains and never throws on ordinary text.
+ * @throws {TypeError} when `input` is not a string or an option is malformed (`preserveCharacters`, a non-global `remove`, an unknown locale id).
+ * @throws {RangeError} for an invalid `separator` or `maxLength`, and in unicode mode when `scripts` or `bidi: "throw"` rejects the result.
+ */
 export declare function slugify(input: string, options?: SlugifyOptions): string;
 //#endregion
 //#region src/slug/truncate.d.ts
+/** Cuts `slug` to at most `maxLength` UTF-16 code units at a `separator` boundary, never inside a grapheme cluster. */
 export declare function truncateSlug(slug: string, maxLength: number, separator?: string): string;
 //#endregion
 export type { IsSlugOptions, LatinLocaleId, Locale, LocaleId, ScriptCheck, ScriptRestriction, Slugger, SlugifyOptions, TransliterationTable };

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { S as symbols, _ as fold, g as DEFAULT_TABLES, l as latinLocales } from "./shared/locales-latin-D8enWKzw.mjs";
-import { N as isSegmentNzNc, n as iriToUri } from "./shared/iri-CzbwHYgr.mjs";
+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 { h as isSegmentNzNc, r as percentEncode } from "./shared/percent-DG-pZhJI.mjs";
 
 //#region src/slug/bidi.ts
 const RTL = /\p{Script=Hebrew}|\p{Script=Arabic}|\p{Script=Syriac}|\p{Script=Thaana}|\p{Script=Nko}|\p{Script=Samaritan}|\p{Script=Mandaic}|\p{Script=Adlam}/u;
@@ -11,6 +11,7 @@ function isRtl(ch) {
 function isLtr(ch) {
 	return LETTER.test(ch) && !RTL.test(ch);
 }
+/** RFC 3987 section 4.2: whether `text` can be a URL component without mixing text directions in a way that renders ambiguously. */
 function isBidiSafeComponent(text) {
 	let hasRtl = false;
 	let hasLtr = false;
@@ -30,13 +31,14 @@ function isBidiSafeComponent(text) {
 
 //#endregion
 //#region src/slug/decamelize.ts
+/** Inserts spaces at camelCase and acronym boundaries: `"getHTTPResponse"` becomes `"get HTTP Response"`. */
 function decamelize(input) {
 	return input.replace(/(\p{Lu}{2,})(\p{N}+)/gu, "$1 $2").replace(/([\p{Ll}\p{N}]+)(\p{Lu}{2,})/gu, "$1 $2").replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, "$1 $2").replace(/(\p{Lu}+)(\p{Lu}[\p{Ll}\p{N}]+)/gu, (match, head, tail) => tail.length === 2 && tail.endsWith("s") ? match : `${head} ${tail}`);
 }
 
 //#endregion
 //#region src/slug/charset.ts
-function escapeRegExp(text) {
+function escapeRegExp$1(text) {
 	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function escapeClassChar(text) {
@@ -111,6 +113,7 @@ function scriptsOf(ch) {
 	for (const [name, re] of scriptMatchers()) if (re.test(ch)) out.push(name);
 	return out;
 }
+/** The Unicode script names used by `text`, ignoring Common and Inherited characters. */
 function detectScripts(text) {
 	const definite = /* @__PURE__ */ new Set();
 	const ambiguous = [];
@@ -132,6 +135,7 @@ function allowed(scripts, level) {
 	if (level === "highly-restrictive") return false;
 	return others.length === 1 && !EXCLUDED_WITH_LATIN.has(others[0] ?? "");
 }
+/** Applies a UTS #39 restriction `level` to the scripts in `text`; `ok` is false when the mix exceeds it. */
 function checkScripts(text, level = "moderately-restrictive") {
 	const scripts = detectScripts(text);
 	return {
@@ -142,7 +146,24 @@ 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;
+function lowercaseOf(text, o) {
+	if (o.unicode && o.locale?.lowercase !== void 0) return o.locale.lowercase(text);
+	return text.replaceAll("İ", "i").toLowerCase();
+}
 let cache$1;
 function resolveLocale(locale) {
 	if (locale === void 0) return void 0;
@@ -189,12 +210,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 +231,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 +299,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,14 +308,16 @@ function patternFor(options) {
 	cache.set(options, pattern);
 	return pattern;
 }
-function isSlug(input, options = {}) {
+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 !== input.toLowerCase()) 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;
 	}
@@ -287,6 +361,7 @@ 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 = "-") {
 	if (!Number.isInteger(maxLength) || maxLength < 0) throw new RangeError("truncateSlug: maxLength must be a non-negative integer");
 	if (slug.length <= maxLength) return slug;
@@ -302,64 +377,43 @@ 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();
-	const cached = compatCache.get(table);
-	if (cached !== void 0) return cached;
-	const out = [];
-	for (const [key, value] of Object.entries(table)) if (key.normalize("NFKC") !== key) out.push([key, value]);
-	compatCache.set(table, out);
-	return out;
-}
-function applyCompat(text, tables) {
-	let out = text;
-	for (const table of tables) for (const [key, value] of compatEntries(table)) if (out.includes(key)) out = out.split(key).join(value);
-	return out;
-}
-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 = {}) {
+/**
+* Turns text into a URL slug: an RFC 3986 `segment-nz-nc` in ASCII mode, NFKC letters, digits and marks in unicode mode.
+* Returns `""` when nothing usable remains and never throws on ordinary text.
+* @throws {TypeError} when `input` is not a string or an option is malformed (`preserveCharacters`, a non-global `remove`, an unknown locale id).
+* @throws {RangeError} for an invalid `separator` or `maxLength`, and in unicode mode when `scripts` or `bidi: "throw"` rejects the result.
+*/
+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;
@@ -371,7 +425,7 @@ function slugify(input, options = {}) {
 		}
 		if (o.bidi !== "allow" && !isBidiSafeComponent(s)) {
 			if (o.bidi === "throw") throw new RangeError(`slugify: ${JSON.stringify(s)} mixes text directions (RFC 3987 section 4.2)`);
-			s = iriToUri(s);
+			s = percentEncode(s, "segment-nz-nc");
 		}
 	}
 	return s;
@@ -386,6 +440,7 @@ function withSuffix(base, separator, n, maxLength) {
 	const head = room > 0 ? truncateSlug(base, room, separator) : "";
 	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. */
 function createSlugger(defaults = {}) {
 	const issued = /* @__PURE__ */ new Set();
 	const counters = /* @__PURE__ */ new Map();
@@ -424,6 +479,7 @@ function createSlugger(defaults = {}) {
 		}
 	});
 }
+/** Alias of `createSlugger`, under the name `@sindresorhus/slugify` uses. */
 const slugifyWithCounter = createSlugger;
 
 //#endregion