@jant/core 0.6.15 → 0.6.16

package/dist/{url-BMYO-Zlt.js → url-CbLAtlZe.js}

@@ -11,6 +11,429 @@ var __exportAll = (all, no_symbols) => {
 	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
@@ -26,6 +449,7 @@ var __exportAll = (all, no_symbols) => {
 	normalizePath: () => normalizePath,
 	normalizeSitePathPrefix: () => normalizeSitePathPrefix,
 	normalizeSiteUrl: () => normalizeSiteUrl,
+	sanitizeRichTextHref: () => sanitizeRichTextHref,
 	sanitizeUrl: () => sanitizeUrl,
 	slugify: () => slugify,
 	stripSitePathPrefix: () => stripSitePathPrefix,
@@ -148,14 +572,54 @@ function normalizeSitePathname(pathname) {
 	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.
 *
-* Transforms text into a lowercase, hyphen-separated slug using limax for
-* i18n-aware transliteration (CJK → Pinyin, Japanese → Romaji, accented → ASCII).
+* 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
+* @returns The slugified string, or `""` when no usable slug can be derived
 *
 * @example
 * ```ts
@@ -164,9 +628,24 @@ function normalizeSitePathname(pathname) {
 *
 * 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) {
-	return limax(text, { tone: false }).replace(/_/g, "-");
+	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.
@@ -198,6 +677,20 @@ var SAFE_URL_PROTOCOLS = new Set([
 	"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.
 *
@@ -241,13 +734,25 @@ var SAFE_URL_PROTOCOLS = new Set([
 * sanitizeUrl("data:text/html,<h1>Hi</h1>"); // ""
 * ```
 */ function sanitizeUrl(url) {
-	try {
-		const parsed = new URL(url, "https://placeholder.invalid");
-		if (SAFE_URL_PROTOCOLS.has(parsed.protocol)) return url;
-		return "";
-	} catch {
-		return "";
-	}
+	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.
@@ -392,4 +897,4 @@ var SAFE_URL_PROTOCOLS = new Set([
 	return toAbsoluteSiteUrl(url, siteUrl, sitePathPrefix);
 }
 //#endregion
-export { toPublicPath as _, getSitePathPrefix as a, __exportAll as b, normalizePath as c, sanitizeUrl as d, slugify as f, toPublicHref as g, toAbsoluteSiteUrl as h, getSiteOrigin as i, normalizeSitePathPrefix as l, toAbsoluteAssetUrl as m, extractDisplayDomain as n, isFullUrl as o, stripSitePathPrefix as p, extractDomain as r, isSafeInternalRedirect as s, buildSiteUrl as t, normalizeSiteUrl as u, toSameSitePath as v, url_exports as y };
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jant/core",
-  "version": "0.6.15",
+  "version": "0.6.16",
   "description": "A modern, open-source microblogging platform built on Cloudflare Workers",
   "type": "module",
   "exports": {

package/src/__tests__/mise-config.test.ts

@@ -0,0 +1,22 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+import { parse } from "smol-toml";
+
+interface MiseConfig {
+  tasks?: Record<
+    string,
+    {
+      env?: Record<string, string>;
+    }
+  >;
+}
+
+describe("mise tasks", () => {
+  it("enables environment proxy support before the Node dev runtime starts", () => {
+    const configPath = resolve(import.meta.dirname, "../../../../mise.toml");
+    const config = parse(readFileSync(configPath, "utf8")) as MiseConfig;
+
+    expect(config.tasks?.["dev-node"]?.env?.NODE_USE_ENV_PROXY).toBe("1");
+  });
+});