lazycodex-ai 5.1.44 → 5.1.45

package/packages/omo-codex/plugin/skills/ulw-research/scripts/particles-ko.mjs

@@ -0,0 +1,108 @@
+// Korean particle normalization after a filled value: read the value's final sound, then pick the
+// particle form. Hangul and the particle table are \u escapes (this directory ships no Hangul).
+
+// Unit token -> reading of its Korean name. Duplicated from the planned units.koreanReadingOf so this
+// module has no dependency on a sibling not yet landed; the units module reconciles the two tables.
+// Hangul unit words (won, dalleo, jo, eok, ...) need no row: they are read by code point.
+const UNIT_READINGS = new Map([
+	["%", "open"], // peosenteu
+	["%p", "open"], // peosenteu pointeu
+	["pp", "open"], // peosenteu pointeu
+	["m", "open"], // miteo
+	["mm", "open"], // millimiteo
+	["cm", "open"], // sentimiteo
+	["km", "open"], // killomiteo
+	["kg", "closed"], // killogeuraem
+	["g", "closed"], // geuraem
+	["t", "closed"], // ton
+	["s", "open"], // cho
+	["ms", "open"], // millicho
+	["min", "closed"], // bun
+	["h", "closed"], // sigan
+	["B", "open"], // baiteu
+	["KB", "open"], // killobaiteu
+	["MB", "open"], // megabaiteu
+	["GB", "open"], // gigabaiteu
+	["TB", "open"], // terabaiteu
+	["C", "open"], // do
+	["\u00B0C", "open"], // do
+	["F", "open"], // do
+	["\u00B0F", "open"], // do
+	["USD", "open"], // dalleo
+	["$", "open"], // dalleo
+	["KRW", "closed"], // won
+	["EUR", "open"], // yuro
+	["JPY", "closed"], // en
+	["x", "open"], // bae
+	["\u00D7", "open"], // bae
+])
+
+// Sino-Korean digit readings: yeong il i sam sa o yuk chil pal gu.
+const DIGIT_READINGS = Object.freeze(["closed", "l", "open", "closed", "open", "open", "closed", "l", "l", "open"])
+
+// Spoken ending of a power of ten beyond the units digit: sip baek cheon, then the 10^4 group markers
+// man eok jo gyeong. Only jo (10^12) is open.
+const TEN_POWER_READINGS = Object.freeze(["closed", "closed", "closed"])
+const GROUP_READINGS = Object.freeze({ 4: "closed", 8: "closed", 12: "open", 16: "closed" })
+
+// [particle, form after an open vowel, form after final l, form after another final consonant]
+const PARTICLES = Object.freeze([
+	Object.freeze(["\uC73C\uB85C", "\uB85C", "\uB85C", "\uC73C\uB85C"]),
+	Object.freeze(["\uB85C", "\uB85C", "\uB85C", "\uC73C\uB85C"]),
+	Object.freeze(["\uC740", "\uB294", "\uC740", "\uC740"]),
+	Object.freeze(["\uB294", "\uB294", "\uC740", "\uC740"]),
+	Object.freeze(["\uC774", "\uAC00", "\uC774", "\uC774"]),
+	Object.freeze(["\uAC00", "\uAC00", "\uC774", "\uC774"]),
+	Object.freeze(["\uC744", "\uB97C", "\uC744", "\uC744"]),
+	Object.freeze(["\uB97C", "\uB97C", "\uC744", "\uC744"]),
+	Object.freeze(["\uC640", "\uC640", "\uACFC", "\uACFC"]),
+	Object.freeze(["\uACFC", "\uC640", "\uACFC", "\uACFC"]),
+])
+const FORM_INDEX = Object.freeze({ open: 1, l: 2, closed: 3 })
+
+const HANGUL_FIRST = 0xac00
+const HANGUL_LAST = 0xd7a3
+const BOUNDARY = /^[\s\p{P}]/u
+const TRAILING_DIGITS = /([0-9][0-9,]*)(?:\.([0-9]+))?$/
+
+function hangulReading(char) {
+	const code = char.codePointAt(0)
+	if (code === undefined || code < HANGUL_FIRST || code > HANGUL_LAST) return null
+	const finalConsonant = (code - HANGUL_FIRST) % 28
+	if (finalConsonant === 0) return "open"
+	return finalConsonant === 8 ? "l" : "closed"
+}
+
+function numberReading(text) {
+	const match = TRAILING_DIGITS.exec(text)
+	if (!match) return null
+	// Decimals read digit by digit: 6.50 ends on yeong, so a trailing 0 after the point is closed.
+	if (match[2] !== undefined) return DIGIT_READINGS[Number(match[2].at(-1))]
+	const digits = match[1].replaceAll(",", "")
+	const trailingZeros = digits.length - digits.replace(/0+$/, "").length
+	if (trailingZeros === 0 || trailingZeros === digits.length) return DIGIT_READINGS[Number(digits.at(-1))]
+	// From 10^4 up the spoken end is the last non-zero group word (sipjo ends on jo), not sip/baek/cheon.
+	if (trailingZeros >= 4) return GROUP_READINGS[trailingZeros - (trailingZeros % 4)] ?? null
+	return TEN_POWER_READINGS[trailingZeros - 1]
+}
+
+export function finalReading(valueText, unitToken) {
+	if (unitToken !== null && unitToken !== undefined) return UNIT_READINGS.get(unitToken) ?? hangulReading(unitToken.at(-1) ?? "")
+	const text = valueText.trimEnd()
+	const last = text.at(-1)
+	if (last === undefined) return null
+	const hangul = hangulReading(last)
+	if (hangul !== null) return hangul
+	if (last >= "0" && last <= "9") return numberReading(text)
+	const token = /[^\s0-9.,]+$/u.exec(text)?.[0] ?? ""
+	return UNIT_READINGS.get(token) ?? null
+}
+
+export function rewriteParticle(following, reading) {
+	const entry = PARTICLES.find(([particle]) => following.startsWith(particle))
+	if (entry === undefined) return { text: following, applied: false, candidate: false }
+	const rest = following.slice(entry[0].length)
+	const index = FORM_INDEX[reading]
+	if ((rest !== "" && !BOUNDARY.test(rest)) || index === undefined) return { text: following, applied: false, candidate: true }
+	return { text: entry[index] + rest, applied: true, candidate: true }
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/rational.mjs

@@ -0,0 +1,139 @@
+// rational.mjs - exact rational arithmetic over BigInt numerator/denominator pairs.
+//
+// A rational is { num: bigint, den: bigint }, reduced, with den > 0. Numerals enter as decimal
+// strings and never pass through Number(), so no value is ever rounded by floating point.
+// Plain Node ESM, no imports.
+
+const DECIMAL = /^([+-]?)(\d+)(?:\.(\d+))?$/
+
+const abs = (n) => (n < 0n ? -n : n)
+
+function gcd(a, b) {
+	let x = abs(a)
+	let y = abs(b)
+	while (y !== 0n) [x, y] = [y, x % y]
+	return x
+}
+
+function make(num, den) {
+	if (den === 0n) throw new RangeError("rational: zero denominator")
+	const sign = den < 0n ? -1n : 1n
+	const g = gcd(num, den) || 1n
+	return Object.freeze({ num: (sign * num) / g, den: (sign * den) / g })
+}
+
+/** Accepts a rational, a bigint, a safe integer, or a decimal string. */
+function coerce(value) {
+	if (typeof value === "bigint") return make(value, 1n)
+	if (typeof value === "number") {
+		if (!Number.isSafeInteger(value)) throw new TypeError(`rational: ${value} is not a safe integer; pass a decimal string`)
+		return make(BigInt(value), 1n)
+	}
+	if (typeof value === "string") return fromDecimal(value)
+	if (value && typeof value.num === "bigint" && typeof value.den === "bigint") return make(value.num, value.den)
+	throw new TypeError("rational: expected a rational, bigint, integer, or decimal string")
+}
+
+/** "12.50" -> 25/2. Accepts an optional sign, digits, and an optional fraction; nothing else. */
+export function fromDecimal(str) {
+	const match = DECIMAL.exec(String(str).trim())
+	if (!match) throw new SyntaxError(`rational: "${str}" is not a plain decimal`)
+	const [, sign, whole, frac = ""] = match
+	const num = BigInt(whole + frac) * (sign === "-" ? -1n : 1n)
+	return make(num, 10n ** BigInt(frac.length))
+}
+
+export function add(a, b) {
+	const x = coerce(a)
+	const y = coerce(b)
+	return make(x.num * y.den + y.num * x.den, x.den * y.den)
+}
+
+export function sub(a, b) {
+	const x = coerce(a)
+	const y = coerce(b)
+	return make(x.num * y.den - y.num * x.den, x.den * y.den)
+}
+
+export function mul(a, b) {
+	const x = coerce(a)
+	const y = coerce(b)
+	return make(x.num * y.num, x.den * y.den)
+}
+
+export function div(a, b) {
+	const x = coerce(a)
+	const y = coerce(b)
+	if (y.num === 0n) throw new RangeError("rational: division by zero")
+	return make(x.num * y.den, x.den * y.num)
+}
+
+export function eq(a, b) {
+	const x = coerce(a)
+	const y = coerce(b)
+	return x.num === y.num && x.den === y.den
+}
+
+/** Digits of a non-negative integer scaled by 10^-scale, as a decimal string. */
+function placeDecimal(digits, scale) {
+	if (scale <= 0) return digits + "0".repeat(-scale)
+	const padded = digits.padStart(scale + 1, "0")
+	return `${padded.slice(0, padded.length - scale)}.${padded.slice(padded.length - scale)}`
+}
+
+/** Exact decimal; throws RangeError when the expansion does not terminate. */
+function exactDecimal(r) {
+	let den = r.den
+	let twos = 0
+	let fives = 0
+	while (den % 2n === 0n) [den, twos] = [den / 2n, twos + 1]
+	while (den % 5n === 0n) [den, fives] = [den / 5n, fives + 1]
+	if (den !== 1n) throw new RangeError(`rational: ${r.num}/${r.den} has no finite decimal; pass sigFigs`)
+	const scale = Math.max(twos, fives)
+	const digits = (abs(r.num) * 10n ** BigInt(scale)) / r.den
+	return (r.num < 0n ? "-" : "") + placeDecimal(digits.toString(), scale)
+}
+
+/** Number of decimal digits in the integer part of |num/den| (0 when below 1). */
+function integerDigits(num, den) {
+	const whole = num / den
+	if (whole > 0n) return whole.toString().length
+	let exp = 0
+	let scaled = num
+	while (scaled < den) [scaled, exp] = [scaled * 10n, exp - 1]
+	return exp + 1
+}
+
+/**
+ * Decimal string. Without sigFigs the value must terminate and is rendered exactly. With sigFigs it
+ * is rounded half away from zero to that many significant figures; integers are never written
+ * with an exponent, so 319999 at 2 figures renders "320000".
+ */
+export function toDecimal(value, sigFigs) {
+	const r = coerce(value)
+	if (sigFigs === undefined) return exactDecimal(r)
+	if (!Number.isInteger(sigFigs) || sigFigs < 1) throw new RangeError("rational: sigFigs must be a positive integer")
+	if (r.num === 0n) return sigFigs > 1 ? `0.${"0".repeat(sigFigs - 1)}` : "0"
+	const num = abs(r.num)
+	const scale = sigFigs - integerDigits(num, r.den)
+	const numer = scale >= 0 ? num * 10n ** BigInt(scale) : num
+	const denom = scale >= 0 ? r.den : r.den * 10n ** BigInt(-scale)
+	let digits = numer / denom
+	let places = scale
+	if ((numer % denom) * 2n >= denom) digits += 1n
+	if (digits.toString().length > sigFigs) [digits, places] = [digits / 10n, places - 1]
+	return (r.num < 0n ? "-" : "") + placeDecimal(digits.toString(), places)
+}
+
+/**
+ * Significant figures of a decimal string. With a decimal point: digits from the first nonzero
+ * digit to the end, trailing zeros included ("3.2" -> 2, "0.050" -> 2). Without one: every digit
+ * after leading zeros counts ("320" -> 3, "100" -> 3, "20" -> 2).
+ */
+export function sigFigsOf(decimalStr) {
+	const match = DECIMAL.exec(String(decimalStr).trim())
+	if (!match) throw new SyntaxError(`rational: "${decimalStr}" is not a plain decimal`)
+	const [, , whole, frac] = match
+	const digits = (whole + (frac ?? "")).replace(/^0+/, "")
+	return Math.max(digits.length, 1)
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/report-tools-commands.mjs

@@ -5,7 +5,7 @@ import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import { dirname, join, resolve } from "node:path"
 
 import { CliError, parseArgs, readJsonFile, writeJsonAtomic } from "./cli-support.mjs"
-import { REPAIR_DEFAULTS } from "./contracts.mjs"
+import { GATE_NAMES, GATE_STATUSES, REPAIR_DEFAULTS } from "./contracts.mjs"
 import { parseLineageMode, parsePalette, renderDesignSpec } from "./design-spec.mjs"
 import { extractFromHtml, extractFromPath, fetchHtml } from "./format-extract.mjs"
 import { checkLayout } from "./gates-layout.mjs"
@@ -149,7 +149,7 @@ export function runOutcome(argv) {
 		}
 		case "gate": {
 			const [gate, status] = args.positionals
-			if (!gate || !status) throw new CliError("usage: outcome gate <static|layout|visual|proofread> <pass|fail|not_run>")
+			if (!gate || !status) throw new CliError(`usage: outcome gate <${GATE_NAMES.join("|")}> <${GATE_STATUSES.join("|")}>`)
 			outcome.writeManifest(file, outcome.setGate(outcome.readManifest(file), gate, status))
 			return { json: { command: "outcome gate", gate, status }, exitCode: 0 }
 		}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/sentence-split.mjs

@@ -0,0 +1,77 @@
+// sentence-split.mjs - deterministic sentence index for snapshot text.
+//
+// splitSentences(text) returns [{ sid, start, end, text }] with sid "s<k>" (1-based) and
+// start/end as offsets into the raw text, so text.slice(start, end) === record.text.
+// Boundaries: a line break; ". ! ?" followed by whitespace or end of line (known
+// abbreviations such as "e.g." excepted); and the Korean endings da. yo. nida. kka? even
+// with no following space, unless closing punctuation follows (quoted speech such as
+// '...da."rago' then needs whitespace like any other terminator). "no." is an abbreviation
+// only before a number ("No. 5"). Plain Node ESM, no dependencies.
+
+import { normalizeText } from "./text-normalize.mjs"
+
+const TERMINATORS = ".!?"
+const CLOSERS = "\"')]}\u201D\u2019\u00BB\u300D\u300F"
+const KOREAN_PERIOD_ENDINGS = new Set(["\uB2E4", "\uC694"]) // da, yo (nida ends in da)
+const KOREAN_QUESTION_ENDING = "\uAE4C" // kka
+const ABBREVIATIONS = new Set([
+	"e.g", "i.e", "etc", "vs", "cf", "approx", "al", "fig", "no", "mr", "mrs", "ms", "dr", "prof", "inc", "ltd", "jr", "sr",
+])
+const SPACE = /\s/u
+
+function isKoreanEnding(line, at) {
+	const prev = line[at - 1]
+	if (line[at] === ".") return KOREAN_PERIOD_ENDINGS.has(prev)
+	return line[at] === "?" && prev === KOREAN_QUESTION_ENDING
+}
+
+function isAbbreviation(line, from, at) {
+	let k = at
+	while (k > from && !SPACE.test(line[k - 1])) k--
+	const word = line.slice(k, at).replace(/^[("'[]+/u, "").toLowerCase()
+	if (word === "no") return /^\s*\d/u.test(line.slice(at + 1))
+	return ABBREVIATIONS.has(word)
+}
+
+function pushSegment(line, base, from, to, out) {
+	let start = from
+	let end = to
+	while (start < end && SPACE.test(line[start])) start++
+	while (end > start && SPACE.test(line[end - 1])) end--
+	const text = line.slice(start, end)
+	if (normalizeText(text) === "") return
+	out.push({ sid: `s${out.length + 1}`, start: base + start, end: base + end, text })
+}
+
+function splitLine(line, base, out) {
+	let from = 0
+	for (let i = 0; i < line.length; i++) {
+		if (!TERMINATORS.includes(line[i])) continue
+		let j = i + 1
+		while (j < line.length && (TERMINATORS.includes(line[j]) || CLOSERS.includes(line[j]))) j++
+		const atBreak = j >= line.length || SPACE.test(line[j])
+		const closed = [...line.slice(i + 1, j)].some((c) => CLOSERS.includes(c))
+		const korean = !closed && isKoreanEnding(line, i)
+		const abbreviation = line[i] === "." && !korean && isAbbreviation(line, from, i)
+		if ((atBreak || korean) && !abbreviation) {
+			pushSegment(line, base, from, j, out)
+			from = j
+		}
+		i = j - 1
+	}
+	pushSegment(line, base, from, line.length, out)
+}
+
+export function splitSentences(text) {
+	const source = String(text ?? "")
+	const out = []
+	let base = 0
+	while (base <= source.length) {
+		const newline = source.indexOf("\n", base)
+		const stop = newline === -1 ? source.length : newline
+		splitLine(source.slice(base, stop), base, out)
+		if (newline === -1) break
+		base = newline + 1
+	}
+	return out
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/text-normalize.mjs

@@ -0,0 +1,82 @@
+// text-normalize.mjs - text normalization and raw-offset matching for fidelity checks.
+//
+// normalizeText applies NFC, maps curly and CJK quote glyphs to straight quotes, collapses
+// whitespace runs to one space, and trims. findNormalized matches a needle against the
+// normalized haystack and returns offsets into the RAW haystack through an offset map built
+// during normalization. Plain Node ESM, no dependencies.
+
+const DOUBLE_QUOTES = new Set([
+	"\u201C", "\u201D", "\u201E", "\u201F", "\u00AB", "\u00BB", "\u300C", "\u300D", "\u300E", "\u300F",
+	"\u301D", "\u301E", "\u301F", "\uFF02", "\u2033",
+])
+const SINGLE_QUOTES = new Set(["\u2018", "\u2019", "\u201A", "\u201B", "\u2039", "\u203A", "\uFF07", "\u2032"])
+// Combining marks and conjoining Hangul medial/final jamo attach to the preceding code point,
+// so a decomposed syllable is normalized as one unit.
+const JOINS_PREVIOUS = /^[\p{M}\u1160-\u11FF\uD7B0-\uD7FF]$/u
+const WHITESPACE = /^\s+$/u
+const TOKEN_SEPARATOR = /[^\p{L}\p{N}\p{M}]+/u
+
+function mapQuote(ch) {
+	if (DOUBLE_QUOTES.has(ch)) return '"'
+	if (SINGLE_QUOTES.has(ch)) return "'"
+	return ch
+}
+
+function clusters(raw) {
+	const out = []
+	let at = 0
+	for (const ch of raw) {
+		const last = out[out.length - 1]
+		if (last && JOINS_PREVIOUS.test(ch)) last[1] += ch.length
+		else out.push([at, at + ch.length])
+		at += ch.length
+	}
+	return out
+}
+
+// Returns { text, starts, ends }: text[k] came from raw.slice(starts[k], ends[k]).
+function normalizeWithMap(raw) {
+	const source = String(raw ?? "")
+	let text = ""
+	const starts = []
+	const ends = []
+	for (const [start, end] of clusters(source)) {
+		const piece = Array.from(source.slice(start, end).normalize("NFC"), mapQuote).join("")
+		if (WHITESPACE.test(piece)) {
+			if (text !== "" && !text.endsWith(" ")) {
+				text += " "
+				starts.push(start)
+				ends.push(end)
+			}
+			continue
+		}
+		for (let k = 0; k < piece.length; k++) {
+			starts.push(start)
+			ends.push(end)
+		}
+		text += piece
+	}
+	if (text.endsWith(" ")) {
+		text = text.slice(0, -1)
+		starts.pop()
+		ends.pop()
+	}
+	return { text, starts, ends }
+}
+
+export function normalizeText(s) {
+	return normalizeWithMap(s).text
+}
+
+export function tokenize(s) {
+	return normalizeText(s).split(TOKEN_SEPARATOR).filter((token) => token !== "")
+}
+
+export function findNormalized(hay, needle) {
+	const target = normalizeText(needle)
+	if (target === "") return null
+	const map = normalizeWithMap(hay)
+	const at = map.text.indexOf(target)
+	if (at === -1) return null
+	return { start: map.starts[at], end: map.ends[at + target.length - 1] }
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/text-similarity.mjs

@@ -0,0 +1,28 @@
+// text-similarity.mjs - similarity in [0, 1] from normalized Levenshtein distance.
+//
+// Both inputs go through normalizeText first (NFC, quote glyphs, whitespace), then the
+// edit distance is computed over code points and divided by the longer length.
+// Plain Node ESM, no dependencies.
+
+import { normalizeText } from "./text-normalize.mjs"
+
+function levenshtein(a, b) {
+	let previous = Array.from({ length: b.length + 1 }, (_, k) => k)
+	for (let i = 1; i <= a.length; i++) {
+		const current = [i]
+		for (let k = 1; k <= b.length; k++) {
+			const cost = a[i - 1] === b[k - 1] ? 0 : 1
+			current.push(Math.min(previous[k] + 1, current[k - 1] + 1, previous[k - 1] + cost))
+		}
+		previous = current
+	}
+	return previous[b.length]
+}
+
+export function similarity(a, b) {
+	const left = Array.from(normalizeText(a))
+	const right = Array.from(normalizeText(b))
+	const longest = Math.max(left.length, right.length)
+	if (longest === 0) return 1
+	return 1 - levenshtein(left, right) / longest
+}

package/packages/omo-codex/plugin/skills/ulw-research/scripts/units.mjs

@@ -0,0 +1,105 @@
+// units.mjs - unit table: normalization, dimensions, exact conversion factors, Korean readings.
+//
+// normalizeUnit maps a raw unit (any spacing or spelling variant) to one canonical token. Each token
+// has a dimension, an exact factor to the dimension's base unit (base = value * factor + offset), and
+// the final-sound class of its Korean reading for the particle rule: "open" (no final consonant),
+// "l" (final rieul), or "closed". Currency is its own dimension per currency, so no exchange rate is
+// ever implied. Data units are decimal (1 KB = 1000 B). Plain Node ESM, sibling imports only.
+
+import { div, fromDecimal, sub } from "./rational.mjs"
+
+/** [token, dimension, factor, reading, aliases, offset?]; the Korean reading is noted per row. */
+const TABLE = [
+	["mm", "length", "0.001", "open", ["millimeter", "millimeters", "\uBC00\uB9AC\uBBF8\uD130"]], // millimiteo
+	["cm", "length", "0.01", "open", ["centimeter", "centimeters", "\uC13C\uD2F0\uBBF8\uD130"]], // sentimiteo
+	["m", "length", "1", "open", ["meter", "meters", "metre", "metres", "\uBBF8\uD130"]], // miteo
+	["km", "length", "1000", "open", ["kilometer", "kilometers", "\uD0AC\uB85C\uBBF8\uD130"]], // killomiteo
+	["g", "mass", "1", "closed", ["gram", "grams", "\uADF8\uB7A8"]], // geuraem
+	["kg", "mass", "1000", "closed", ["kilogram", "kilograms", "\uD0AC\uB85C\uADF8\uB7A8"]], // killogeuraem
+	["t", "mass", "1000000", "closed", ["ton", "tons", "tonne", "tonnes", "\uD1A4"]], // ton
+	["ms", "time", "0.001", "open", ["millisecond", "milliseconds", "\uBC00\uB9AC\uCD08"]], // millicho
+	["s", "time", "1", "open", ["sec", "secs", "second", "seconds", "\uCD08"]], // cho
+	["min", "time", "60", "closed", ["mins", "minute", "minutes", "\uBD84"]], // bun
+	["h", "time", "3600", "closed", ["hr", "hrs", "hour", "hours", "\uC2DC\uAC04"]], // sigan
+	["B", "data", "1", "open", ["byte", "bytes", "\uBC14\uC774\uD2B8"]], // baiteu
+	["KB", "data", "1000", "open", ["\uD0AC\uB85C\uBC14\uC774\uD2B8"]],
+	["MB", "data", "1000000", "open", ["\uBA54\uAC00\uBC14\uC774\uD2B8"]],
+	["GB", "data", "1000000000", "open", ["\uAE30\uAC00\uBC14\uC774\uD2B8"]],
+	["TB", "data", "1000000000000", "open", ["\uD14C\uB77C\uBC14\uC774\uD2B8"]],
+	["C", "temperature", "1", "open", ["\u00B0C", "\u2103", "celsius", "\uC12D\uC528"], "0"], // do
+	["F", "temperature", "5/9", "open", ["\u00B0F", "\u2109", "fahrenheit", "\uD654\uC528"], "-160/9"], // do
+	["%", "percent", "1", "open", ["percent", "\uD37C\uC13C\uD2B8", "\uD504\uB85C"]], // peosenteu
+	["\u2030", "percent", "0.1", "l", ["permille", "\uD37C\uBC00"]], // peomil
+	["%p", "percentage-point", "1", "open", ["pp", "%pt", "percentage point", "percentage points", "\uD37C\uC13C\uD2B8\uD3EC\uC778\uD2B8", "%\uD3EC\uC778\uD2B8"]],
+	["x", "multiple", "1", "open", ["\u00D7", "times", "\uBC30"]], // bae
+	["e3", "scale", "1000", "closed", ["k", "thousand", "\uCC9C"]], // cheon
+	["e4", "scale", "10000", "closed", ["\uB9CC"]], // man
+	["e6", "scale", "1000000", "closed", ["M", "million", "\uBC31\uB9CC"]], // baengman
+	["e8", "scale", "100000000", "closed", ["\uC5B5"]], // eok
+	["e9", "scale", "1000000000", "closed", ["bn", "billion", "\uC2ED\uC5B5"]], // sibeok
+	["e12", "scale", "1000000000000", "open", ["trillion", "\uC870"]], // jo
+	["person", "count:person", "1", "closed", ["persons", "people", "\uBA85"]], // myeong
+	["case", "count:case", "1", "closed", ["cases", "\uAC74"]], // geon
+	["KRW", "currency:KRW", "1", "closed", ["\uC6D0", "\u20A9", "won"]], // won
+	["KRW-e3", "currency:KRW", "1000", "closed", ["\uCC9C\uC6D0"]],
+	["KRW-e4", "currency:KRW", "10000", "closed", ["\uB9CC\uC6D0"]],
+	["KRW-e8", "currency:KRW", "100000000", "closed", ["\uC5B5\uC6D0"]],
+	["KRW-e12", "currency:KRW", "1000000000000", "closed", ["\uC870\uC6D0"]],
+	["USD", "currency:USD", "1", "open", ["$", "US$", "dollar", "dollars", "\uB2EC\uB7EC"]], // dalleo
+	["EUR", "currency:EUR", "1", "open", ["\u20AC", "euro", "euros", "\uC720\uB85C"]], // yuro
+	["JPY", "currency:JPY", "1", "closed", ["\u00A5", "yen", "\uC5D4"]], // en
+	["GBP", "currency:GBP", "1", "open", ["\u00A3", "pound", "pounds", "\uD30C\uC6B4\uB4DC"]], // paundeu
+]
+
+const parse = (text) => (text.includes("/") ? div(fromDecimal(text.split("/")[0]), fromDecimal(text.split("/")[1])) : fromDecimal(text))
+const squash = (raw) => raw.replace(/\s+/g, "")
+
+const ENTRIES = new Map()
+/** Exact-case keys: every token and alias with whitespace removed. */
+const EXACT = new Map()
+/** Case-insensitive keys: multi-letter ASCII aliases only, so m/M and B/b never collide. */
+const WORD = new Map()
+for (const [token, dimension, factor, reading, aliases, offset] of TABLE) {
+	const entry = Object.freeze({ token, dimension, factor: parse(factor), offset: parse(offset ?? "0"), reading })
+	ENTRIES.set(token, entry)
+	for (const alias of [token, ...aliases]) {
+		const key = squash(alias)
+		EXACT.set(key, entry)
+		if (key.length > 1 && /^[A-Za-z]+$/.test(key) && !WORD.has(key.toLowerCase())) WORD.set(key.toLowerCase(), entry)
+	}
+}
+
+function entryOf(raw) {
+	if (typeof raw !== "string") return null
+	const key = squash(raw)
+	if (!key) return null
+	return EXACT.get(key) ?? WORD.get(key.toLowerCase()) ?? null
+}
+
+/** Canonical token for a raw unit, or null when the unit is not in the table. */
+export function normalizeUnit(raw) {
+	return entryOf(raw)?.token ?? null
+}
+
+/** Dimension of a unit ("length", "currency:KRW", ...), or null. */
+export function dimensionOf(token) {
+	return entryOf(token)?.dimension ?? null
+}
+
+/**
+ * Exact factor from one unit to another of the same dimension: to = from * num / den (+ offset for
+ * affine scales). Null across dimensions, across currencies, or for an unknown unit.
+ */
+export function convertFactor(from, to) {
+	const a = entryOf(from)
+	const b = entryOf(to)
+	if (!a || !b || a.dimension !== b.dimension) return null
+	const { num, den } = div(a.factor, b.factor)
+	const offset = div(sub(a.offset, b.offset), b.factor)
+	return offset.num === 0n ? { num, den } : { num, den, offset: { num: offset.num, den: offset.den } }
+}
+
+/** Final-sound class of the unit's Korean reading: "open", "closed", or "l"; null when unknown. */
+export function koreanReadingOf(token) {
+	return entryOf(token)?.reading ?? null
+}