@jant/core 0.6.16 → 0.7.0

package/dist/url-CbLAtlZe.js

@@ -1,900 +0,0 @@
-import limax from "limax";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-//#region src/lib/translit.ts
-/**
-* Dictionary-free transliteration helpers for slug generation.
-*
-* These converters cover the scripts limax handles poorly:
-*
-* - Korean hangul → Revised Romanization (limax strips hangul entirely)
-* - Japanese kana → Hepburn romaji (limax mangles long vowels and digraphs)
-*
-* Both are pure algorithms over Unicode code points — no dictionaries — so
-* they stay small enough for the Workers bundle and the lazy client chunk.
-* Japanese kanji is intentionally out of scope: readings are context-dependent
-* and need a morphological dictionary, which is why `slugify` falls back to a
-* random ID for kanji-heavy Japanese titles instead of guessing.
-*/ /** Matches hiragana, katakana, and the chōonpu (ー) long-vowel mark. */ var KANA_RE = /[ぁ-ゖァ-ヺー]/u;
-/** Matches precomposed hangul syllables and compatibility jamo. */ var HANGUL_RE = /[가-힣ㄱ-ㆎ]/u;
-/** Matches Han (CJK ideograph) characters. */ var HAN_RE = /\p{Script=Han}/u;
-var HANGUL_SYLLABLE_BASE = 44032;
-var HANGUL_SYLLABLE_END = 55203;
-var VOWEL_COUNT = 21;
-var FINAL_COUNT = 28;
-var RR_INITIALS = [
-	"g",
-	"kk",
-	"n",
-	"d",
-	"tt",
-	"r",
-	"m",
-	"b",
-	"pp",
-	"s",
-	"ss",
-	"",
-	"j",
-	"jj",
-	"ch",
-	"k",
-	"t",
-	"p",
-	"h"
-];
-var RR_VOWELS = [
-	"a",
-	"ae",
-	"ya",
-	"yae",
-	"eo",
-	"e",
-	"yeo",
-	"ye",
-	"o",
-	"wa",
-	"wae",
-	"oe",
-	"yo",
-	"u",
-	"wo",
-	"we",
-	"wi",
-	"yu",
-	"eu",
-	"ui",
-	"i"
-];
-var RR_FINALS = [
-	"",
-	"k",
-	"k",
-	"k",
-	"n",
-	"n",
-	"n",
-	"t",
-	"l",
-	"k",
-	"m",
-	"l",
-	"l",
-	"l",
-	"p",
-	"l",
-	"m",
-	"p",
-	"p",
-	"t",
-	"t",
-	"ng",
-	"t",
-	"t",
-	"k",
-	"t",
-	"p",
-	"t"
-];
-var RR_LIAISON = [
-	["", ""],
-	["", "g"],
-	["", "kk"],
-	["k", "s"],
-	["", "n"],
-	["n", "j"],
-	["n", ""],
-	["", "d"],
-	["", "r"],
-	["l", "g"],
-	["l", "m"],
-	["l", "b"],
-	["l", "s"],
-	["l", "t"],
-	["l", "p"],
-	["l", ""],
-	["", "m"],
-	["", "b"],
-	["p", "s"],
-	["", "s"],
-	["", "ss"],
-	["ng", ""],
-	["", "j"],
-	["", "ch"],
-	["", "k"],
-	["", "t"],
-	["", "p"],
-	["", ""]
-];
-var COMPAT_JAMO = {
-	ㄱ: "g",
-	ㄲ: "kk",
-	ㄴ: "n",
-	ㄷ: "d",
-	ㄸ: "tt",
-	ㄹ: "r",
-	ㅁ: "m",
-	ㅂ: "b",
-	ㅃ: "pp",
-	ㅅ: "s",
-	ㅆ: "ss",
-	ㅇ: "ng",
-	ㅈ: "j",
-	ㅉ: "jj",
-	ㅊ: "ch",
-	ㅋ: "k",
-	ㅌ: "t",
-	ㅍ: "p",
-	ㅎ: "h",
-	ㅏ: "a",
-	ㅐ: "ae",
-	ㅑ: "ya",
-	ㅒ: "yae",
-	ㅓ: "eo",
-	ㅔ: "e",
-	ㅕ: "yeo",
-	ㅖ: "ye",
-	ㅗ: "o",
-	ㅘ: "wa",
-	ㅙ: "wae",
-	ㅚ: "oe",
-	ㅛ: "yo",
-	ㅜ: "u",
-	ㅝ: "wo",
-	ㅞ: "we",
-	ㅟ: "wi",
-	ㅠ: "yu",
-	ㅡ: "eu",
-	ㅢ: "ui",
-	ㅣ: "i"
-};
-function decomposeHangul(codePoint) {
-	if (codePoint < HANGUL_SYLLABLE_BASE || codePoint > HANGUL_SYLLABLE_END) return null;
-	const index = codePoint - HANGUL_SYLLABLE_BASE;
-	return {
-		initial: Math.floor(index / (VOWEL_COUNT * FINAL_COUNT)),
-		vowel: Math.floor(index / FINAL_COUNT) % VOWEL_COUNT,
-		final: index % FINAL_COUNT
-	};
-}
-/**
-* Transliterates Korean hangul to Latin using Revised Romanization.
-*
-* Handles precomposed syllables with basic liaison (a final consonant before
-* a silent-ㅇ syllable carries over as its initial) and standalone
-* compatibility jamo. Assimilation sound rules (e.g. 종로 → "Jongno") are
-* intentionally skipped — slugs need recognizable output, not phonetic
-* perfection. Non-hangul characters pass through unchanged.
-*
-* @param text - Input text, possibly mixing hangul with other characters
-* @returns Text with hangul replaced by its romanization
-*
-* @example
-* ```ts
-* hangulToLatin("안녕하세요"); // "annyeonghaseyo"
-* hangulToLatin("한국어");     // "hangugeo" (liaison)
-* hangulToLatin("개발 일지");  // "gaebal ilji"
-* ```
-*/ function hangulToLatin(text) {
-	const chars = [...text];
-	let out = "";
-	let carried = null;
-	for (const [i, char] of chars.entries()) {
-		const syllable = decomposeHangul(char.codePointAt(0) ?? 0);
-		if (!syllable) {
-			carried = null;
-			out += COMPAT_JAMO[char] ?? char;
-			continue;
-		}
-		const initial = carried ?? RR_INITIALS[syllable.initial] ?? "";
-		carried = null;
-		const next = decomposeHangul(chars[i + 1]?.codePointAt(0) ?? 0);
-		let final = RR_FINALS[syllable.final] ?? "";
-		if (syllable.final !== 0 && next && RR_INITIALS[next.initial] === "") {
-			const [remains, carry] = RR_LIAISON[syllable.final] ?? ["", ""];
-			final = remains;
-			carried = carry;
-		}
-		out += initial + (RR_VOWELS[syllable.vowel] ?? "") + final;
-	}
-	return out;
-}
-var KANA_BASE = {
-	あ: "a",
-	い: "i",
-	う: "u",
-	え: "e",
-	お: "o",
-	か: "ka",
-	き: "ki",
-	く: "ku",
-	け: "ke",
-	こ: "ko",
-	さ: "sa",
-	し: "shi",
-	す: "su",
-	せ: "se",
-	そ: "so",
-	た: "ta",
-	ち: "chi",
-	つ: "tsu",
-	て: "te",
-	と: "to",
-	な: "na",
-	に: "ni",
-	ぬ: "nu",
-	ね: "ne",
-	の: "no",
-	は: "ha",
-	ひ: "hi",
-	ふ: "fu",
-	へ: "he",
-	ほ: "ho",
-	ま: "ma",
-	み: "mi",
-	む: "mu",
-	め: "me",
-	も: "mo",
-	や: "ya",
-	ゆ: "yu",
-	よ: "yo",
-	ら: "ra",
-	り: "ri",
-	る: "ru",
-	れ: "re",
-	ろ: "ro",
-	わ: "wa",
-	ゐ: "i",
-	ゑ: "e",
-	を: "o",
-	ん: "n",
-	が: "ga",
-	ぎ: "gi",
-	ぐ: "gu",
-	げ: "ge",
-	ご: "go",
-	ざ: "za",
-	じ: "ji",
-	ず: "zu",
-	ぜ: "ze",
-	ぞ: "zo",
-	だ: "da",
-	ぢ: "ji",
-	づ: "zu",
-	で: "de",
-	ど: "do",
-	ば: "ba",
-	び: "bi",
-	ぶ: "bu",
-	べ: "be",
-	ぼ: "bo",
-	ぱ: "pa",
-	ぴ: "pi",
-	ぷ: "pu",
-	ぺ: "pe",
-	ぽ: "po",
-	ゔ: "vu",
-	ぁ: "a",
-	ぃ: "i",
-	ぅ: "u",
-	ぇ: "e",
-	ぉ: "o",
-	ゃ: "ya",
-	ゅ: "yu",
-	ょ: "yo",
-	ゎ: "wa"
-};
-var KANA_COMBO = {
-	きゃ: "kya",
-	きゅ: "kyu",
-	きょ: "kyo",
-	ぎゃ: "gya",
-	ぎゅ: "gyu",
-	ぎょ: "gyo",
-	しゃ: "sha",
-	しゅ: "shu",
-	しょ: "sho",
-	じゃ: "ja",
-	じゅ: "ju",
-	じょ: "jo",
-	ちゃ: "cha",
-	ちゅ: "chu",
-	ちょ: "cho",
-	ぢゃ: "ja",
-	ぢゅ: "ju",
-	ぢょ: "jo",
-	にゃ: "nya",
-	にゅ: "nyu",
-	にょ: "nyo",
-	ひゃ: "hya",
-	ひゅ: "hyu",
-	ひょ: "hyo",
-	びゃ: "bya",
-	びゅ: "byu",
-	びょ: "byo",
-	ぴゃ: "pya",
-	ぴゅ: "pyu",
-	ぴょ: "pyo",
-	みゃ: "mya",
-	みゅ: "myu",
-	みょ: "myo",
-	りゃ: "rya",
-	りゅ: "ryu",
-	りょ: "ryo",
-	ふぁ: "fa",
-	ふぃ: "fi",
-	ふぇ: "fe",
-	ふぉ: "fo",
-	てぃ: "ti",
-	でぃ: "di",
-	とぅ: "tu",
-	どぅ: "du",
-	うぃ: "wi",
-	うぇ: "we",
-	うぉ: "wo",
-	ゔぁ: "va",
-	ゔぃ: "vi",
-	ゔぇ: "ve",
-	ゔぉ: "vo",
-	ちぇ: "che",
-	しぇ: "she",
-	じぇ: "je",
-	つぁ: "tsa",
-	つぃ: "tsi",
-	つぇ: "tse",
-	つぉ: "tso",
-	いぇ: "ye"
-};
-var KATAKANA_START = 12449;
-var KATAKANA_END = 12534;
-var KATAKANA_TO_HIRAGANA_SHIFT = 96;
-var SOKUON = "っ";
-var CHOONPU = "ー";
-function normalizeToHiragana(char) {
-	const codePoint = char.codePointAt(0) ?? 0;
-	if (codePoint >= KATAKANA_START && codePoint <= KATAKANA_END) return String.fromCodePoint(codePoint - KATAKANA_TO_HIRAGANA_SHIFT);
-	return char;
-}
-/**
-* Transliterates Japanese kana to macron-less Hepburn romaji.
-*
-* Handles hiragana and katakana, digraphs (きゃ → "kya"), extended katakana
-* loan combos (ファ → "fa"), sokuon gemination (まっちゃ → "matcha"), and
-* drops the chōonpu long-vowel mark (ハンバーガー → "hanbaga"), matching how
-* macrons are conventionally stripped in URLs. Kanji and other non-kana
-* characters pass through unchanged.
-*
-* @param text - Input text, possibly mixing kana with other characters
-* @returns Text with kana replaced by romaji
-*
-* @example
-* ```ts
-* kanaToRomaji("カタカナタイトル"); // "katakanataitoru"
-* kanaToRomaji("ハンバーガー");     // "hanbaga"
-* kanaToRomaji("まっちゃ");         // "matcha"
-* ```
-*/ function kanaToRomaji(text) {
-	const chars = [...text].map(normalizeToHiragana);
-	let out = "";
-	let geminate = false;
-	for (let i = 0; i < chars.length; i++) {
-		const char = chars[i] ?? "";
-		if (char === SOKUON) {
-			geminate = true;
-			continue;
-		}
-		if (char === CHOONPU) {
-			geminate = false;
-			continue;
-		}
-		const combo = KANA_COMBO[char + (chars[i + 1] ?? "")];
-		const romaji = combo ?? KANA_BASE[char];
-		if (combo) i++;
-		if (romaji === void 0) {
-			geminate = false;
-			out += char;
-			continue;
-		}
-		if (geminate) {
-			geminate = false;
-			if (/^[^aeiou]/.test(romaji)) out += romaji.startsWith("ch") ? "t" : romaji[0] ?? "";
-		}
-		out += romaji;
-	}
-	return out;
-}
-//#endregion
-//#region src/lib/url.ts
-/**
-* URL Utilities
-*/ var url_exports = /* @__PURE__ */ __exportAll({
-	buildSiteUrl: () => buildSiteUrl,
-	extractDisplayDomain: () => extractDisplayDomain,
-	extractDomain: () => extractDomain,
-	getSiteOrigin: () => getSiteOrigin,
-	getSitePathPrefix: () => getSitePathPrefix,
-	isFullUrl: () => isFullUrl,
-	isSafeAbsoluteUrl: () => isSafeAbsoluteUrl,
-	isSafeInternalRedirect: () => isSafeInternalRedirect,
-	normalizePath: () => normalizePath,
-	normalizeSitePathPrefix: () => normalizeSitePathPrefix,
-	normalizeSiteUrl: () => normalizeSiteUrl,
-	sanitizeRichTextHref: () => sanitizeRichTextHref,
-	sanitizeUrl: () => sanitizeUrl,
-	slugify: () => slugify,
-	stripSitePathPrefix: () => stripSitePathPrefix,
-	toAbsoluteAssetUrl: () => toAbsoluteAssetUrl,
-	toAbsoluteSiteUrl: () => toAbsoluteSiteUrl,
-	toPublicHref: () => toPublicHref,
-	toPublicPath: () => toPublicPath,
-	toSameSitePath: () => toSameSitePath
-});
-function normalizeSitePathname(pathname) {
-	if (pathname === "/" || pathname === "") return "";
-	const trimmed = pathname.replace(/\/+$/, "");
-	return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-}
-/**
-* Normalize a configured public site path prefix.
-*
-* @param sitePathPrefix - Prefix such as `/blog` or `blog`
-* @returns Normalized prefix like `/blog`, or an empty string when rooted
-*/ function normalizeSitePathPrefix(sitePathPrefix) {
-	return normalizeSitePathname(sitePathPrefix);
-}
-/**
-* Extracts the hostname (domain) from a URL string.
-*
-* Parses a full URL and returns just the hostname portion (e.g., "example.com" from
-* "https://example.com/path"). Returns `null` if the URL is malformed or cannot be parsed.
-*
-* @param url - The full URL string to extract the domain from
-* @returns The hostname/domain if valid, or `null` if parsing fails
-*
-* @example
-* ```ts
-* const domain = extractDomain("https://www.example.com/path");
-* // Returns: "www.example.com"
-*
-* const invalid = extractDomain("not-a-url");
-* // Returns: null
-* ```
-*/ function extractDomain(url) {
-	try {
-		return new URL(url).hostname;
-	} catch {
-		return null;
-	}
-}
-/**
-* Normalizes a path by removing slashes and converting to lowercase.
-*
-* Trims whitespace, converts to lowercase, removes leading and trailing slashes,
-* and collapses multiple consecutive slashes into single slashes. Used to create
-* consistent path representations for routing and storage.
-*
-* @param path - The path string to normalize
-* @returns The normalized path string
-*
-* @example
-* ```ts
-* const normalized = normalizePath("  /About/Contact//  ");
-* // Returns: "about/contact"
-* ```
-*/ function normalizePath(path) {
-	return path.trim().toLowerCase().replace(/^\/+|\/+$/g, "").replace(/\/+/g, "/");
-}
-/**
-* Checks if a string is a full URL with HTTP or HTTPS protocol.
-*
-* Validates whether a string starts with "http://" or "https://", indicating it's
-* a full URL rather than a relative path. Useful for distinguishing between internal
-* paths and external URLs.
-*
-* @param str - The string to check
-* @returns `true` if the string starts with http:// or https://, `false` otherwise
-*
-* @example
-* ```ts
-* isFullUrl("https://example.com");  // Returns: true
-* isFullUrl("/about");               // Returns: false
-* isFullUrl("example.com");          // Returns: false
-* ```
-*/ function isFullUrl(str) {
-	return str.startsWith("http://") || str.startsWith("https://");
-}
-/**
-* If a full URL points at the site's own host, return its same-site path
-* (`pathname` + `search` + `hash`). Returns `null` when the input is not a full
-* URL, is unparseable, or points at a different host.
-*
-* Self-referential absolute links — e.g. a nav item set to
-* `https://example.com/about` on `example.com` — should behave like the
-* internal path `/about`: no external-link icon, no `target="_blank"`.
-*
-* Matching is by **hostname**, not full origin: scheme and port differences are
-* treated as same-site. This keeps the check intuitive ("same domain") and
-* robust in dev, where the site is often served over `http://host:<port>` while
-* a nav link stores the canonical `https://host` URL. In production (canonical
-* https + default port) hostname match is equivalent to origin match.
-*
-* @param url - Candidate URL (full URL or relative path)
-* @param siteOrigin - The site's own origin, e.g. `https://example.com`
-* @returns The same-site path, or `null` when the URL is external/non-absolute
-*
-* @example
-* ```ts
-* toSameSitePath("https://example.com/about", "https://example.com");    // "/about"
-* toSameSitePath("https://example.com/about", "http://example.com:8787"); // "/about"
-* toSameSitePath("https://other.com/about", "https://example.com");      // null
-* toSameSitePath("/about", "https://example.com");                       // null
-* ```
-*/ function toSameSitePath(url, siteOrigin) {
-	if (!siteOrigin || !isFullUrl(url)) return null;
-	let parsed;
-	let reference;
-	try {
-		parsed = new URL(url);
-		reference = new URL(siteOrigin);
-	} catch {
-		return null;
-	}
-	if (parsed.hostname !== reference.hostname) return null;
-	return `${parsed.pathname}${parsed.search}${parsed.hash}` || "/";
-}
-var HAN_GLOBAL_RE = /\p{Script=Han}/gu;
-var CONTENT_CHAR_RE = /[\p{L}\p{N}]/u;
-var ASCII_ALNUM_RE = /[a-zA-Z0-9]/;
-/**
-* Minimum fraction of a title's letters/digits the transliteration pipeline
-* must handle for the result to be usable. Below this, too much meaning is
-* lost (e.g. mixed kanji+kana Japanese where the semantic core is kanji, or
-* scripts limax drops entirely) and `slugify` returns "" so callers fall back
-* to their random-ID path instead of shipping a garbled slug.
-*/ var SLUG_COVERAGE_THRESHOLD = .75;
-/** Per-character limax probe cache: does this char transliterate to anything? */ var charCoverageCache = /* @__PURE__ */ new Map();
-function isCharCovered(char) {
-	if (ASCII_ALNUM_RE.test(char)) return true;
-	let covered = charCoverageCache.get(char);
-	if (covered === void 0) {
-		covered = limax(char, { tone: false }).length > 0;
-		charCoverageCache.set(char, covered);
-	}
-	return covered;
-}
-function slugCoverage(text, japanese) {
-	let content = 0;
-	let covered = 0;
-	for (const char of text) {
-		if (!CONTENT_CHAR_RE.test(char)) continue;
-		content++;
-		if (KANA_RE.test(char) || HANGUL_RE.test(char)) covered++;
-		else if (japanese && HAN_RE.test(char)) {} else if (isCharCovered(char)) covered++;
-	}
-	return content === 0 ? 0 : covered / content;
-}
-/**
-* Converts text to a URL-friendly slug.
-*
-* Transliterates i18n text to Latin before slugifying: Korean hangul via
-* Revised Romanization, Japanese kana via Hepburn romaji (both in-house, see
-* `translit.ts`), everything else (Han → pinyin, Cyrillic, accents, …) via
-* limax. When the title contains kana it is treated as Japanese and Han
-* characters are dropped rather than misread as Chinese pinyin; Han without
-* kana is treated as Chinese.
-*
-* Returns `""` when transliteration would lose too much of the title (see
-* `SLUG_COVERAGE_THRESHOLD`) — every caller treats an empty base as "no
-* usable title" and falls back to a random ID, which beats publishing a
-* garbled slug.
-*
-* @param text - The text to convert to a slug
-* @returns The slugified string, or `""` when no usable slug can be derived
-*
-* @example
-* ```ts
-* slugify("Hello World! This is a Test.");
-* // Returns: "hello-world-this-is-a-test"
-*
-* slugify("书评");
-* // Returns: "shu-ping"
-*
-* slugify("안녕하세요 세계");
-* // Returns: "annyeonghaseyo-segye"
-*
-* slugify("ハンバーガー");
-* // Returns: "hanbaga"
-*
-* slugify("日本語のタイトルです");
-* // Returns: "" (kanji carries the meaning and can't be transliterated)
-* ```
-*/ function slugify(text) {
-	const japanese = KANA_RE.test(text);
-	let pre = text;
-	if (japanese) pre = kanaToRomaji(pre.replace(HAN_GLOBAL_RE, " "));
-	if (HANGUL_RE.test(pre)) pre = hangulToLatin(pre);
-	const base = limax(pre, { tone: false }).replace(/_/g, "-");
-	if (!base) return "";
-	return slugCoverage(text, japanese) >= SLUG_COVERAGE_THRESHOLD ? base : "";
-}
-/**
-* Extracts a human-friendly domain name from a URL for display purposes.
-*
-* Parses the URL, strips common prefixes (`www.`, `m.`, `mobile.`), and returns
-* a clean domain. Returns `null` if the URL is malformed.
-*
-* @param url - The full URL string
-* @returns A display-friendly domain string, or `null` if parsing fails
-*
-* @example
-* ```ts
-* extractDisplayDomain("https://www.example.com/path");
-* // Returns: "example.com"
-*
-* extractDisplayDomain("https://m.wikipedia.org/wiki/Test");
-* // Returns: "wikipedia.org"
-*
-* extractDisplayDomain("https://blog.example.com");
-* // Returns: "blog.example.com"
-* ```
-*/ function extractDisplayDomain(url) {
-	const hostname = extractDomain(url);
-	if (!hostname) return null;
-	return hostname.replace(/^(?:www|m|mobile)\./, "");
-}
-var SAFE_URL_PROTOCOLS = new Set([
-	"http:",
-	"https:",
-	"mailto:"
-]);
-var SAFE_RICH_TEXT_HREF_PROTOCOLS = new Set([
-	...SAFE_URL_PROTOCOLS,
-	"tel:",
-	"sms:"
-]);
-function sanitizeUrlWithProtocols(url, protocols) {
-	try {
-		const parsed = new URL(url, "https://placeholder.invalid");
-		if (protocols.has(parsed.protocol)) return url;
-		return "";
-	} catch {
-		return "";
-	}
-}
-/**
-* Checks whether a string is a safe absolute URL.
-*
-* Accepts absolute URLs that use `http:`, `https:`, or `mailto:`. Relative
-* paths are rejected because external post/source URLs must be fully qualified.
-*
-* @param url - The URL string to validate
-* @returns `true` when the URL is absolute and uses an allowed protocol
-*
-* @example
-* ```ts
-* isSafeAbsoluteUrl("https://example.com"); // true
-* isSafeAbsoluteUrl("mailto:hello@example.com"); // true
-* isSafeAbsoluteUrl("example.com"); // false
-* ```
-*/ function isSafeAbsoluteUrl(url) {
-	const trimmed = url.trim();
-	if (!trimmed) return false;
-	try {
-		const parsed = new URL(trimmed);
-		return SAFE_URL_PROTOCOLS.has(parsed.protocol);
-	} catch {
-		return false;
-	}
-}
-/**
-* Sanitizes a URL by ensuring it uses a safe protocol.
-*
-* Returns the URL unchanged if it uses an allowed protocol (http:, https:, mailto:)
-* or is a relative path. Returns an empty string for dangerous protocols like
-* `javascript:`, `data:`, or `vbscript:`.
-*
-* @param url - The URL string to sanitize
-* @returns The original URL if safe, or an empty string if the protocol is disallowed
-*
-* @example
-* ```ts
-* sanitizeUrl("https://example.com");       // "https://example.com"
-* sanitizeUrl("/about");                     // "/about"
-* sanitizeUrl("javascript:alert(1)");        // ""
-* sanitizeUrl("data:text/html,<h1>Hi</h1>"); // ""
-* ```
-*/ function sanitizeUrl(url) {
-	return sanitizeUrlWithProtocols(url, SAFE_URL_PROTOCOLS);
-}
-/**
-* Sanitizes a rich-text link destination.
-*
-* In addition to safe web and email URLs, rich-text links may launch the
-* device's phone or messaging app through `tel:` and `sms:`. Relative links
-* remain valid, while executable and resource-only protocols are rejected.
-*
-* @param url - The link destination to sanitize
-* @returns The original URL if safe for an anchor, or an empty string otherwise
-*
-* @example
-* ```ts
-* sanitizeRichTextHref("sms:+15551234567"); // "sms:+15551234567"
-* sanitizeRichTextHref("javascript:alert(1)"); // ""
-* ```
-*/ function sanitizeRichTextHref(url) {
-	return sanitizeUrlWithProtocols(url, SAFE_RICH_TEXT_HREF_PROTOCOLS);
-}
-/**
-* Normalize a public site URL by stripping any trailing slash from the path.
-*
-* @param siteUrl - Full site URL, optionally with a path prefix
-* @returns Normalized site URL, or an empty string when not configured
-*/ function normalizeSiteUrl(siteUrl) {
-	const trimmed = siteUrl.trim();
-	if (!trimmed) return "";
-	const parsed = new URL(trimmed);
-	parsed.pathname = normalizeSitePathname(parsed.pathname) || "/";
-	if (parsed.pathname !== "/") parsed.pathname = parsed.pathname.replace(/\/+$/, "");
-	return parsed.toString().replace(/\/$/, parsed.pathname === "/" ? "/" : "");
-}
-/**
-* Extract the public path prefix from a full site URL.
-*
-* @param siteUrl - Full site URL
-* @returns Prefix like `/blog`, or an empty string when the site is rooted
-*/ function getSitePathPrefix(siteUrl) {
-	if (!siteUrl.trim()) return "";
-	return normalizeSitePathname(new URL(siteUrl).pathname);
-}
-/**
-* Extract the origin from a full site URL.
-*
-* @param siteUrl - Full site URL
-* @returns Origin like `https://example.com`, or an empty string when missing
-*/ function getSiteOrigin(siteUrl) {
-	if (!siteUrl.trim()) return "";
-	return new URL(siteUrl).origin;
-}
-/**
-* Build a normalized public site URL from an origin and optional path prefix.
-*
-* @param siteOrigin - Public site origin, such as `https://example.com`
-* @param sitePathPrefix - Public site path prefix, such as `/blog`
-* @returns Normalized site URL, or an empty string when no origin is configured
-*/ function buildSiteUrl(siteOrigin, sitePathPrefix = "") {
-	const trimmedOrigin = siteOrigin.trim();
-	if (!trimmedOrigin) return "";
-	const origin = new URL(trimmedOrigin).origin;
-	return normalizeSiteUrl(`${origin}${normalizeSitePathPrefix(sitePathPrefix) || "/"}`);
-}
-/**
-* Prefix an internal app path with the public site path prefix.
-*
-* Internal paths are always rooted at `/` and never include the deployment
-* prefix. This helper converts them to public-facing paths.
-*
-* @param path - Internal app path, such as `/settings`
-* @param sitePathPrefix - Public site path prefix, such as `/blog`
-* @returns Public path
-*/ function toPublicPath(path, sitePathPrefix = "") {
-	if (!path) return sitePathPrefix || "/";
-	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-	if (!sitePathPrefix) return normalizedPath;
-	if (normalizedPath === sitePathPrefix || normalizedPath.startsWith(`${sitePathPrefix}/`)) return normalizedPath;
-	if (normalizedPath === "/") return sitePathPrefix;
-	return `${sitePathPrefix}${normalizedPath}`;
-}
-/**
-* Convert an app-local href to its public path while leaving external URLs
-* unchanged.
-*
-* @param href - Internal app path or external URL
-* @param sitePathPrefix - Public site path prefix
-* @returns Public-facing href
-*/ function toPublicHref(href, sitePathPrefix = "") {
-	if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//") || href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("#")) return href;
-	return toPublicPath(href, sitePathPrefix);
-}
-/**
-* Check whether a path is a safe same-origin redirect target.
-*
-* Accepts only paths that start with a single `/` (no protocol-relative
-* `//host`, no scheme, no control characters). Callers should use this to
-* validate user-supplied `redirect` query parameters before issuing a
-* `Location` header.
-*
-* @param path - Candidate redirect path
-* @returns `true` when the path is safe to use as an internal redirect
-*
-* @example
-* ```ts
-* isSafeInternalRedirect("/settings") // true
-* isSafeInternalRedirect("//evil.example") // false
-* isSafeInternalRedirect("https://evil.example") // false
-* ```
-*/ function isSafeInternalRedirect(path) {
-	if (typeof path !== "string") return false;
-	if (!path.startsWith("/")) return false;
-	if (path.startsWith("//")) return false;
-	if (path.startsWith("/\\")) return false;
-	for (let i = 0; i < path.length; i += 1) {
-		const code = path.charCodeAt(i);
-		if (code < 32 || code === 127) return false;
-	}
-	return true;
-}
-/**
-* Remove the site path prefix from a public request pathname.
-*
-* @param pathname - Public request pathname
-* @param sitePathPrefix - Configured public site path prefix
-* @returns Internal pathname, or `null` when the request is outside the site
-*/ function stripSitePathPrefix(pathname, sitePathPrefix) {
-	if (!sitePathPrefix) return pathname || "/";
-	if (pathname === sitePathPrefix) return "/";
-	if (pathname.startsWith(`${sitePathPrefix}/`)) return pathname.slice(sitePathPrefix.length) || "/";
-	return null;
-}
-/**
-* Convert an internal or public path into an absolute site URL.
-*
-* @param path - Internal app path or already-public path
-* @param siteUrl - Normalized site URL
-* @param sitePathPrefix - Public site path prefix
-* @returns Absolute URL when siteUrl is configured, otherwise the original path
-*/ function toAbsoluteSiteUrl(path, siteUrl, sitePathPrefix = "") {
-	if (!siteUrl) return toPublicPath(path, sitePathPrefix);
-	return new URL(toPublicPath(path, sitePathPrefix), siteUrl).toString();
-}
-/**
-* Resolve a possibly-relative asset URL to an absolute URL, leaving
-* already-absolute (`http(s):`) and protocol-relative (`//host`) URLs
-* untouched. Use for assets — like media — whose stored URL may be either an
-* app-local path or a full CDN URL.
-*
-* @param url - Asset URL: an internal path or an already-absolute URL
-* @param siteUrl - Normalized site URL
-* @param sitePathPrefix - Public site path prefix
-* @returns Absolute URL, or the original value when it is already absolute
-*
-* @example
-* ```ts
-* toAbsoluteAssetUrl("/m/a.png", "https://site.com");   // "https://site.com/m/a.png"
-* toAbsoluteAssetUrl("https://cdn.example/a.png", "x"); // "https://cdn.example/a.png"
-* ```
-*/ function toAbsoluteAssetUrl(url, siteUrl, sitePathPrefix = "") {
-	if (isFullUrl(url) || url.startsWith("//")) return url;
-	return toAbsoluteSiteUrl(url, siteUrl, sitePathPrefix);
-}
-//#endregion
-export { toPublicHref as _, getSitePathPrefix as a, url_exports as b, normalizePath as c, sanitizeRichTextHref as d, sanitizeUrl as f, toAbsoluteSiteUrl as g, toAbsoluteAssetUrl as h, getSiteOrigin as i, normalizeSitePathPrefix as l, stripSitePathPrefix as m, extractDisplayDomain as n, isFullUrl as o, slugify as p, extractDomain as r, isSafeInternalRedirect as s, buildSiteUrl as t, normalizeSiteUrl as u, toPublicPath as v, __exportAll as x, toSameSitePath as y };