hangul-lube 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 2.1.0
+
+- **`typeLetter(text, letter)` and `eraseLetter(text)` type and erase one key of a two-set keyboard.**
+  `typeLetter` composes a compatibility jamo into the last character of `text`: a consonant and a
+  vowel make a syllable, two vowels join (`ㅗ` and `ㅏ` into `ㅘ`), a consonant becomes the final
+  and may join the final before it (`ㄹ` and `ㄱ` into `ㄺ`), and a vowel after a final moves it
+  to a new syllable (`값` and `ㅏ` give `갑사`). Two lone consonants join too (`ㄱ` and `ㅅ` into
+  `ㄳ`), and the same key twice never makes a double consonant. `eraseLetter` is one backspace
+  that undoes the last key (`갉` into `갈`, `과` into `고`, `가` into `ㄱ`).
+- **`particle(word, notation)` gives the Korean particle that follows a word.** The notation is
+  `"은(는)"`, `"이(가)"`, `"을(를)"`, `"과(와)"`, `"아(야)"`, `"(이)"` or `"(으)"`, and any other
+  throws a `TypeError`. The form follows the final consonant of the last Hangul syllable, the
+  Korean reading of a number (`3` is 삼), the Korean names of the letters of a Latin capital word
+  (`URL` ends in ㄹ) or the spelling of a lower-case one, and marks at the end are passed over.
+  `"(으)"` gives `""` after ㄹ too, as `(으)로` needs: `"서울" + particle("서울", "(으)") + "로"` is `서울로`.
+
 ## 2.0.0
 
 ### Breaking

package/README.md

@@ -65,6 +65,39 @@ pattern("1+1") //=> "1\\+1"
 
 `searcher(query)?.source` is the source a database can run case-insensitively: `~*` in PostgreSQL, `REGEXP_LIKE(column, searcher_source, 'i')` in MySQL or `$regex` with `$options: "i"` in MongoDB. Use it, not `pattern(query)`, wherever the search box is what the row must match: `pattern` keeps the white space and the invisible characters of the query and lets nothing stand between its letters, so `"도쿄하네다"` misses `"도쿄 하네다"` and a pasted byte order mark makes it match nothing. Such a query reads every row, since a regular expression cannot use an index.
 
+### Particle
+```ts
+import { particle } from "hangul-lube"
+
+"사과" + particle("사과", "이(가)") //=> "사과가"
+"밤" + particle("밤", "은(는)") //=> "밤은"
+"HP" + particle("HP", "을(를)") //=> "HP를"
+"서울" + particle("서울", "(으)") + "로" //=> "서울로"
+"3" + particle("3", "과(와)") //=> "3과"
+particle("밤", "(으)") //=> "으"
+```
+- The notation is one of `"은(는)"`, `"이(가)"`, `"을(를)"`, `"과(와)"`, `"아(야)"`, `"(이)"` and `"(으)"`; any other throws a `TypeError`. `"(이)"` and `"(으)"` give the syllable that goes before the next word (`이에요`, `으로`) and `""` after a vowel; `"(으)"` gives `""` after ㄹ too.
+- The final consonant comes from the last Hangul syllable. A number is read in Korean (`1` is 일, `3` is 삼, `10` is 십, `1,000` is 천), a Latin capital word by the Korean names of its letters (`URL` ends in ㄹ, `HP` in a vowel), and a lower-case word by its spelling (`l` is ㄹ, `m`, `n` and `ng` a consonant).
+- Marks at the end, such as quotes and `!`, are passed over, and anything else reads as ending in a vowel.
+
+### Typing automaton
+```ts
+import { eraseLetter, typeLetter } from "hangul-lube"
+
+typeLetter("ㄱ", "ㅏ") //=> "가"
+typeLetter("가", "ㄱ") //=> "각"
+typeLetter("각", "ㅏ") //=> "가가"
+typeLetter("갑", "ㅅ") //=> "값"
+typeLetter("값", "ㅏ") //=> "갑사"
+eraseLetter("값") //=> "갑"
+eraseLetter("각") //=> "가"
+eraseLetter("가") //=> "ㄱ"
+```
+- `typeLetter(text, letter)` types one key of a two-set (dubeolsik) keyboard into the last character of `text`. `letter` is a compatibility jamo (`ㄱ`, `ㅏ`, and `ㄲ`, `ㅒ` from the shift key); anything else is appended as it is.
+- Two vowels join (`ㅗ` and `ㅏ` into `ㅘ`), a consonant after a syllable becomes its final and joins the final before it into a compound one (`ㄹ` and `ㄱ` into `ㄺ`), and a vowel after a final moves it to a new syllable, a compound final moving only its second consonant. Two lone consonants join the same way (`ㄱ` and `ㅅ` into `ㄳ`) and a vowel splits them again.
+- The same key never makes a double consonant: `ㄱ` after `각` is appended, since `ㄲ` needs the shift key.
+- `eraseLetter(text)` is one backspace: it takes back the last key, so a compound final loses its second consonant, a joined vowel splits back, and a syllable with a simple vowel and no final leaves its initial. Anything else loses its last code point, and `""` stays `""`.
+
 ### Typing rules
 - A consonant matches itself and every syllable it starts, and the last syllable matches the syllables it grows into while typing: `된자` matches `된장찌개` and `도` matches `돼지국밥`. A lone letter grows the same way: `ㄱ` matches `ㄳ` and `ㅗ` matches `ㅘ`.
 - Every earlier syllable is finished and matches only itself: `오리` matches `오리털` but not `올리브`, while `ㅇ리` and `ㅇㄹ` match both.

package/package.json

@@ -4,9 +4,6 @@
     "url": "https://github.com/artxe/lube-series/issues"
   },
   "description": "Simplify Korean Consonant Search in JavaScript",
-  "devDependencies": {
-    "@typescript/native": "npm:typescript@^7.0.2"
-  },
   "engines": {
     "node": ">=14"
   },
@@ -27,8 +24,10 @@
     "choseong",
     "hangul",
     "hangul-lube",
+    "josa",
     "korean",
     "lube",
+    "particle",
     "regexp",
     "search",
     "syntax sugar",
@@ -45,10 +44,10 @@
   "sideEffects": false,
   "type": "module",
   "types": "types/index.d.ts",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "scripts": {
     "dts": "node ../../scripts/tsc_with_clean.js hangul-lube",
     "lint": "pnpm -w lint",
-    "test": "pnpm -w exec vitest run --coverage test/hangul-lube"
+    "test": "pnpm -w exec vitest run test/hangul-lube"
   }
 }

package/src/erase_letter.js

@@ -0,0 +1,52 @@
+import compound_consonant_letters from "./compound_consonant_letters.js"
+import {
+	final_letters,
+	initial_letters,
+	medial_letters,
+	parts_of,
+	split_vowels,
+	syllable
+} from "./jamo.js"
+/**
+ * Takes back one key on a two-set (dubeolsik) Korean keyboard: returns the text after one
+ * backspace, undoing what `typeLetter` composed. A compound final loses its second consonant, a
+ * single final goes, a joined vowel splits back into its first vowel, a syllable with a simple
+ * vowel and no final leaves its initial consonant, and a lone joined vowel or compound consonant
+ * loses its second part. Anything else loses its last code point, so an emoji goes whole.
+ * @param {string} text
+ * @returns {string}
+ * @example eraseLetter("갉") //=> "갈"
+ *
+ * eraseLetter("각") //=> "가"
+ *
+ * eraseLetter("과") //=> "고"
+ *
+ * eraseLetter("가") //=> "ㄱ"
+ *
+ * eraseLetter("ㅘ") //=> "ㅗ"
+ */
+export default function(text) {
+	const chars = Array.from(text)
+	const last = chars.pop() ?? ""
+	const head = chars.join("")
+	const parts = parts_of(last)
+	if (parts) {
+		if (parts.final > 0) {
+			const pair = compound_consonant_letters[final_letters.charAt(parts.final - 1)]
+			return head + syllable(
+				parts.initial,
+				parts.medial,
+				pair ? pair[0] : ""
+			)
+		}
+		const split = split_vowels[medial_letters.charAt(parts.medial)]
+		return head + (split
+			? syllable(
+				parts.initial,
+				medial_letters.indexOf(split[0]),
+				""
+			)
+			: initial_letters.charAt(parts.initial))
+	}
+	return head + (split_vowels[last]?.[0] ?? compound_consonant_letters[last]?.[0] ?? "")
+}

package/src/get_letter_range.js

@@ -20,10 +20,16 @@ export default function(letter, gap, last) {
 	}
 	const consonant = first_consonant_letters[letter]
 	const growth = letter_growths[letter]
-	if (consonant || growth) return `[${letter}${growth ?? ""}${consonant ?? ""}]`
+	if (consonant || growth) {
+		return `[${letter}${growth ?? ""}${consonant ?? ""}]`
+	}
 	const code = letter.charCodeAt(0)
-	if (code < 0xAC00 || code > 0xD7A3) return special_character_regex.test(letter) ? "\\" + letter : letter
-	if (!last) return letter
+	if (code < 0xAC00 || code > 0xD7A3) {
+		return special_character_regex.test(letter) ? "\\" + letter : letter
+	}
+	if (!last) {
+		return letter
+	}
 	const syllable = code - 0xAC00
 	const final = syllable % 28
 	if (!final) {

package/src/index.js

@@ -1,2 +1,5 @@
+export { default as eraseLetter } from "./erase_letter.js"
+export { default as particle } from "./particle.js"
 export { default as pattern } from "./pattern.js"
-export { default as searcher } from "./searcher.js"
+export { default as searcher } from "./searcher.js"
+export { default as typeLetter } from "./type_letter.js"

package/src/jamo.js

@@ -0,0 +1,58 @@
+import compound_consonant_letters from "./compound_consonant_letters.js"
+const HANGUL = 0xac00
+const HANGUL_END = 0xd7a3
+export const final_letters = "ㄱㄲㄳㄴㄵㄶㄷㄹㄺㄻㄼㄽㄾㄿㅀㅁㅂㅄㅅㅆㅇㅈㅊㅋㅌㅍㅎ"
+export const initial_letters = "ㄱㄲㄴㄷㄸㄹㅁㅂㅃㅅㅆㅇㅈㅉㅊㅋㅌㅍㅎ"
+export const medial_letters = "ㅏㅐㅑㅒㅓㅔㅕㅖㅗㅘㅙㅚㅛㅜㅝㅞㅟㅠㅡㅢㅣ"
+/** @type {Record<string, string | undefined>} */
+export const joined_finals = Object.fromEntries(
+	Object.entries(compound_consonant_letters).flatMap(
+		([ joined, pair ]) => pair ? [ [ pair.join(""), joined ] ] : []
+	)
+)
+/** @type {Record<string, string | undefined>} */
+export const joined_vowels = {
+	ㅗㅏ: "ㅘ",
+	ㅗㅐ: "ㅙ",
+	ㅗㅣ: "ㅚ",
+	ㅜㅓ: "ㅝ",
+	ㅜㅔ: "ㅞ",
+	ㅜㅣ: "ㅟ",
+	ㅡㅣ: "ㅢ"
+}
+/** @type {Record<string, [ first: string, second: string ] | undefined>} */
+export const split_vowels = Object.fromEntries(
+	Object.entries(joined_vowels).map(
+		([ pair, joined ]) => [
+			joined,
+			[ pair.charAt(0), pair.charAt(1) ]
+		]
+	)
+)
+/**
+ * @param {string} char
+ * @returns {{ final: number, initial: number, medial: number } | null}
+ */
+export function parts_of(char) {
+	const code = char.charCodeAt(0)
+	if (!(code >= HANGUL && code <= HANGUL_END)) {
+		return null
+	}
+	const index = code - HANGUL
+	return {
+		final: index % 28,
+		initial: Math.floor(index / 28 / 21),
+		medial: Math.floor(index / 28) % 21
+	}
+}
+/**
+ * @param {number} initial
+ * @param {number} medial
+ * @param {string} final
+ * @returns {string}
+ */
+export function syllable(initial, medial, final) {
+	return String.fromCharCode(
+		HANGUL + (initial * 21 + medial) * 28 + (final ? final_letters.indexOf(final) + 1 : 0)
+	)
+}

package/src/letters_of.js

@@ -1,5 +1,4 @@
-const final_letters = "ㄱㄲㄳㄴㄵㄶㄷㄹㄺㄻㄼㄽㄾㄿㅀㅁㅂㅄㅅㅆㅇㅈㅊㅋㅌㅍㅎ"
-const initial_letters = "ㄱㄲㄴㄷㄸㄹㅁㅂㅃㅅㅆㅇㅈㅉㅊㅋㅌㅍㅎ"
+import { final_letters, initial_letters } from "./jamo.js"
 /**
  * @param {string} text
  * @returns {string[]}

package/src/particle.js

@@ -0,0 +1,112 @@
+const CONSONANT = 1
+const DIGIT_SOUNDS = "1201001220"
+/** @type {Record<string, [ after_consonant: string, after_vowel: string ]>} */
+const FORMS = {
+	"(으)": [ "으", "" ],
+	"(이)": [ "이", "" ],
+	"과(와)": [ "과", "와" ],
+	"아(야)": [ "아", "야" ],
+	"은(는)": [ "은", "는" ],
+	"을(를)": [ "을", "를" ],
+	"이(가)": [ "이", "가" ]
+}
+const GYEONG_ZEROS = 16
+const HANGUL = 0xac00
+const HANGUL_END = 0xd7a3
+const JO_ZEROS = 12
+const LATIN_END = /[A-Za-z]+$/
+const NAMED_CONSONANT = "MN"
+const NAMED_RIEUL = "LR"
+const NUMBER_END = /(\d\.)?([\d,]*\d)$/
+const RIEUL = 2
+const RIEUL_FINAL = 8
+const SEPARATORS = /,/g
+const SPELLED_CONSONANT = /(?:m|n|ng)$/
+const TRAILING_MARKS = /[^\p{L}\p{N}]+$/u
+const TRAILING_ZEROS = /0+$/
+const VOWEL = 0
+/**
+ * @param {string} digits
+ * @returns {number}
+ */
+function digit_sound(digits) {
+	return Number(
+		DIGIT_SOUNDS[Number(digits.slice(-1))]
+	)
+}
+/**
+ * @param {string} text
+ * @returns {number}
+ */
+function final_sound(text) {
+	const word = text.replace(TRAILING_MARKS, "")
+	const number = NUMBER_END.exec(word)
+	if (number) {
+		const digits = /** @type {string} */(number[2])/**/.replace(SEPARATORS, "")
+		const zeros = digits.length - digits.replace(TRAILING_ZEROS, "").length
+		if (number[1] || zeros == 0 || zeros == digits.length) {
+			return digit_sound(digits)
+		}
+		return zeros >= JO_ZEROS && zeros < GYEONG_ZEROS ? VOWEL : CONSONANT
+	}
+	const code = word.charCodeAt(word.length - 1)
+	if (code >= HANGUL && code <= HANGUL_END) {
+		const final = (code - HANGUL) % 28
+		return final == 0
+			? VOWEL
+			: final == RIEUL_FINAL
+				? RIEUL
+				: CONSONANT
+	}
+	const latin = LATIN_END.exec(word)
+	if (!latin) {
+		return VOWEL
+	}
+	const run = latin[0]
+	if (run.length == 1 || run == run.toUpperCase()) {
+		const letter = run.slice(-1).toUpperCase()
+		return NAMED_RIEUL.includes(letter)
+			? RIEUL
+			: NAMED_CONSONANT.includes(letter)
+				? CONSONANT
+				: VOWEL
+	}
+	const lower = run.toLowerCase()
+	return lower.endsWith("l")
+		? RIEUL
+		: SPELLED_CONSONANT.test(lower)
+			? CONSONANT
+			: VOWEL
+}
+/**
+ * The Korean particle that follows a word, chosen by how the word is read aloud: by the final
+ * consonant of its last Hangul syllable, by the Korean reading of a number (`1` is 일, `3` is 삼,
+ * `10` is 십), and by the Korean name of a Latin letter (`HP` is 에이치피, `URL` ends in ㄹ) or,
+ * for a word spelled in lower case, by how its spelling ends (`l` is ㄹ, `m`, `n` and `ng` a consonant).
+ * Marks at the end of the word are passed over. Anything else reads as ending in a vowel.
+ * The notation is one of `"은(는)"`, `"이(가)"`, `"을(를)"`, `"과(와)"`, `"아(야)"`, `"(이)"` and `"(으)"`;
+ * the last two give the syllable that goes between the word and the next one, and nothing after a vowel.
+ * `"(으)"` gives nothing after ㄹ too, as `(으)로` needs. Any other notation throws a `TypeError`.
+ * @param {string} word
+ * @param {string} notation
+ * @returns {string}
+ * @example particle("사과", "이(가)") //=> "가"
+ *
+ * particle("밤", "은(는)") //=> "은"
+ *
+ * "서울" + particle("서울", "(으)") + "로" //=> "서울로"
+ *
+ * "HP" + particle("HP", "을(를)") //=> "HP를"
+ */
+export default function(word, notation) {
+	if (!Object.prototype.hasOwnProperty.call(FORMS, notation)) {
+		throw new TypeError(
+			`Unknown notation ${JSON.stringify(notation)}, expected one of ${Object.keys(FORMS).join(", ")}`
+		)
+	}
+	const sound = final_sound(word)
+	const [ after_consonant, after_vowel ] = /** @type {[ string, string ]} */(FORMS[notation])/**/
+	return sound == VOWEL || sound == RIEUL && notation == "(으)"
+		? after_vowel
+		: after_consonant
+}

package/src/searcher.js

@@ -21,10 +21,16 @@ function gap(letters) {
  * @returns {string}
  */
 function separator(letter) {
-	if (!non_word_letter_regex.test(letter)) return non_word_separator
-	if (letter.length > 1) return `(?:(?!${letter})[${non_word_class}])*?`
+	if (!non_word_letter_regex.test(letter)) {
+		return non_word_separator
+	}
+	if (letter.length > 1) {
+		return `(?:(?!${letter})[${non_word_class}])*?`
+	}
 	const compound = compound_consonant_letters[letter]
-	if (compound) return gap(letter + compound[0])
+	if (compound) {
+		return gap(letter + compound[0])
+	}
 	return gap(
 		`${class_special_character_regex.test(letter) ? "\\" : ""}${letter}${letter_growths[letter] ?? ""}`
 	)
@@ -52,11 +58,15 @@ export default function(text) {
 	const letters = letters_of(text).filter(
 		letter => !ignored_regex.test(letter)
 	)
-	if (letters.length > max_letters) return RegExp(never_source, "i")
+	if (letters.length > max_letters) {
+		return RegExp(never_source, "i")
+	}
 	const last = letters.length - 1
 	let source = ""
 	for (const [ index, letter ] of letters.entries()) {
-		if (index) source += separator(letter)
+		if (index) {
+			source += separator(letter)
+		}
 		source += get_letter_range(letter, gap, index == last)
 	}
 	return source ? RegExp(source, "i") : null

package/src/type_letter.js

@@ -0,0 +1,103 @@
+import compound_consonant_letters from "./compound_consonant_letters.js"
+import {
+	final_letters,
+	initial_letters,
+	joined_finals,
+	joined_vowels,
+	medial_letters,
+	parts_of,
+	syllable
+} from "./jamo.js"
+/**
+ * @param {string} head
+ * @param {{ final: number, initial: number, medial: number }} parts
+ * @param {number} medial
+ * @returns {string}
+ */
+function moved_final(head, parts, medial) {
+	const final = /** @type {string} */(final_letters[parts.final - 1])/**/
+	const [ keep, move ] = compound_consonant_letters[final] ?? [ "", final ]
+	return head + syllable(parts.initial, parts.medial, keep) + syllable(
+		initial_letters.indexOf(move),
+		medial,
+		""
+	)
+}
+/**
+ * Types one key on a two-set (dubeolsik) Korean keyboard: returns the text with the key composed into
+ * its last character, as an input method does. `letter` is a compatibility jamo (`ㄱ`, `ㅏ`, and
+ * the double `ㄲ`, `ㅒ` that the shift key gives); any other string is appended as it is.
+ * A consonant and a vowel make a syllable, two vowels join (`ㅗ` and `ㅏ` into `ㅘ`), a consonant
+ * after a syllable becomes its final and joins the final before it when the two make a compound
+ * final (`ㄹ` and `ㄱ` into `ㄺ`), and a vowel after a final moves it onto a new syllable (a compound
+ * final moves only its second consonant). Two lone consonants join the same way (`ㄱ` and `ㅅ` into
+ * `ㄳ`), and a vowel splits them again. The same key never makes a double consonant: `ㄱ` after
+ * `각` is appended, since `ㄲ` needs the shift key.
+ * @param {string} text
+ * @param {string} letter
+ * @returns {string}
+ * @example typeLetter("ㄱ", "ㅏ") //=> "가"
+ *
+ * typeLetter("가", "ㄱ") //=> "각"
+ *
+ * typeLetter("각", "ㅏ") //=> "가가"
+ *
+ * typeLetter("고", "ㅏ") //=> "과"
+ *
+ * typeLetter("갈", "ㄱ") //=> "갉"
+ */
+export default function(text, letter) {
+	const chars = Array.from(text)
+	const last = chars.pop() ?? ""
+	const head = chars.join("")
+	const parts = parts_of(last)
+	const single = letter.length == 1
+	const medial = single ? medial_letters.indexOf(letter) : -1
+	if (medial >= 0 && last) {
+		if (initial_letters.includes(last)) {
+			return head + syllable(
+				initial_letters.indexOf(last),
+				medial,
+				""
+			)
+		}
+		const pair = compound_consonant_letters[last]
+		if (pair) {
+			return head + pair[0] + syllable(
+				initial_letters.indexOf(pair[1]),
+				medial,
+				""
+			)
+		}
+		if (parts && parts.final > 0) {
+			return moved_final(head, parts, medial)
+		}
+		const joined = joined_vowels[(parts ? medial_letters.charAt(parts.medial) : last) + letter]
+		if (joined) {
+			return head + (parts
+				? syllable(
+					parts.initial,
+					medial_letters.indexOf(joined),
+					""
+				)
+				: joined)
+		}
+	} else if (single && initial_letters.includes(letter) && last) {
+		if (parts) {
+			const final = parts.final > 0
+				? joined_finals[final_letters.charAt(parts.final - 1) + letter]
+				: final_letters.includes(letter)
+					? letter
+					: undefined
+			if (final) {
+				return head + syllable(parts.initial, parts.medial, final)
+			}
+		} else {
+			const joined = joined_finals[last + letter]
+			if (joined) {
+				return head + joined
+			}
+		}
+	}
+	return text + letter
+}

package/types/erase_letter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Takes back one key on a two-set (dubeolsik) Korean keyboard: returns the text after one
+ * backspace, undoing what `typeLetter` composed. A compound final loses its second consonant, a
+ * single final goes, a joined vowel splits back into its first vowel, a syllable with a simple
+ * vowel and no final leaves its initial consonant, and a lone joined vowel or compound consonant
+ * loses its second part. Anything else loses its last code point, so an emoji goes whole.
+ * @param {string} text
+ * @returns {string}
+ * @example eraseLetter("갉") //=> "갈"
+ *
+ * eraseLetter("각") //=> "가"
+ *
+ * eraseLetter("과") //=> "고"
+ *
+ * eraseLetter("가") //=> "ㄱ"
+ *
+ * eraseLetter("ㅘ") //=> "ㅗ"
+ */
+export default function (text: string): string;
+//# sourceMappingURL=erase_letter.d.ts.map

package/types/erase_letter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erase_letter.d.ts","sourceRoot":"","sources":["../src/erase_letter.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,OAAO,WAAU,IAAI,EAZjB,MAYiB,GAXf,MAAM,CAmClB"}

package/types/get_letter_range.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get_letter_range.d.ts","sourceRoot":"","sources":["../src/get_letter_range.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,MAAM,CAAC,OAAO,WAAU,MAAM,EALnB,MAKmB,EAAE,GAAG,EAJxB,CAAC,OAAO,EAAE,MAAM,KAAK,MAIG,EAAE,IAAI,EAH9B,OAG8B,GAF5B,MAAM,CA8BlB"}
+{"version":3,"file":"get_letter_range.d.ts","sourceRoot":"","sources":["../src/get_letter_range.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,MAAM,CAAC,OAAO,WAAU,MAAM,EALnB,MAKmB,EAAE,GAAG,EAJxB,CAAC,OAAO,EAAE,MAAM,KAAK,MAIG,EAAE,IAAI,EAH9B,OAG8B,GAF5B,MAAM,CAoClB"}

package/types/index.d.ts

@@ -1,3 +1,6 @@
+export { default as eraseLetter } from "./erase_letter.js";
+export { default as particle } from "./particle.js";
 export { default as pattern } from "./pattern.js";
 export { default as searcher } from "./searcher.js";
+export { default as typeLetter } from "./type_letter.js";
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC1D,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAA"}

package/types/jamo.d.ts

@@ -0,0 +1,26 @@
+export declare const final_letters = "\u3131\u3132\u3133\u3134\u3135\u3136\u3137\u3139\u313A\u313B\u313C\u313D\u313E\u313F\u3140\u3141\u3142\u3144\u3145\u3146\u3147\u3148\u314A\u314B\u314C\u314D\u314E";
+export declare const initial_letters = "\u3131\u3132\u3134\u3137\u3138\u3139\u3141\u3142\u3143\u3145\u3146\u3147\u3148\u3149\u314A\u314B\u314C\u314D\u314E";
+export declare const medial_letters = "\u314F\u3150\u3151\u3152\u3153\u3154\u3155\u3156\u3157\u3158\u3159\u315A\u315B\u315C\u315D\u315E\u315F\u3160\u3161\u3162\u3163";
+/** @type {Record<string, string | undefined>} */
+export declare const joined_finals: Record<string, string | undefined>;
+/** @type {Record<string, string | undefined>} */
+export declare const joined_vowels: Record<string, string | undefined>;
+/** @type {Record<string, [ first: string, second: string ] | undefined>} */
+export declare const split_vowels: Record<string, [first: string, second: string] | undefined>;
+/**
+ * @param {string} char
+ * @returns {{ final: number, initial: number, medial: number } | null}
+ */
+export declare function parts_of(char: string): {
+    final: number;
+    initial: number;
+    medial: number;
+} | null;
+/**
+ * @param {number} initial
+ * @param {number} medial
+ * @param {string} final
+ * @returns {string}
+ */
+export declare function syllable(initial: number, medial: number, final: string): string;
+//# sourceMappingURL=jamo.d.ts.map

package/types/jamo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jamo.d.ts","sourceRoot":"","sources":["../src/jamo.js"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa,uKAAgC,CAAA;AAC1D,eAAO,MAAM,eAAe,uHAAwB,CAAA;AACpD,eAAO,MAAM,cAAc,mIAA0B,CAAA;AACrD,iDAAiD;AACjD,eAAO,MAAM,aAAa,EADf,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAK3C,CAAA;AACD,iDAAiD;AACjD,eAAO,MAAM,aAAa,EADf,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAS3C,CAAA;AACD,4EAA4E;AAC5E,eAAO,MAAM,YAAY,EADd,MAAM,CAAC,MAAM,EAAE,CAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAE,GAAG,SAAS,CAQtE,CAAA;AACD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAHlB,MAGkB,GAFhB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAarE;AACD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EALrB,MAKqB,EAAE,MAAM,EAJ7B,MAI6B,EAAE,KAAK,EAHpC,MAGoC,GAFlC,MAAM,CAMlB"}

package/types/letters_of.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"letters_of.d.ts","sourceRoot":"","sources":["../src/letters_of.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,CAAC,OAAO,WAAU,IAAI,EAHjB,MAGiB,GAFf,MAAM,EAAE,CAepB"}
+{"version":3,"file":"letters_of.d.ts","sourceRoot":"","sources":["../src/letters_of.js"],"names":[],"mappings":"AACA;;;GAGG;AACH,MAAM,CAAC,OAAO,WAAU,IAAI,EAHjB,MAGiB,GAFf,MAAM,EAAE,CAepB"}

package/types/particle.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The Korean particle that follows a word, chosen by how the word is read aloud: by the final
+ * consonant of its last Hangul syllable, by the Korean reading of a number (`1` is 일, `3` is 삼,
+ * `10` is 십), and by the Korean name of a Latin letter (`HP` is 에이치피, `URL` ends in ㄹ) or,
+ * for a word spelled in lower case, by how its spelling ends (`l` is ㄹ, `m`, `n` and `ng` a consonant).
+ * Marks at the end of the word are passed over. Anything else reads as ending in a vowel.
+ * The notation is one of `"은(는)"`, `"이(가)"`, `"을(를)"`, `"과(와)"`, `"아(야)"`, `"(이)"` and `"(으)"`;
+ * the last two give the syllable that goes between the word and the next one, and nothing after a vowel.
+ * `"(으)"` gives nothing after ㄹ too, as `(으)로` needs. Any other notation throws a `TypeError`.
+ * @param {string} word
+ * @param {string} notation
+ * @returns {string}
+ * @example particle("사과", "이(가)") //=> "가"
+ *
+ * particle("밤", "은(는)") //=> "은"
+ *
+ * "서울" + particle("서울", "(으)") + "로" //=> "서울로"
+ *
+ * "HP" + particle("HP", "을(를)") //=> "HP를"
+ */
+export default function (word: string, notation: string): string;
+//# sourceMappingURL=particle.d.ts.map

package/types/particle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle.d.ts","sourceRoot":"","sources":["../src/particle.js"],"names":[],"mappings":"AAgFA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,OAAO,WAAU,IAAI,EAXjB,MAWiB,EAAE,QAAQ,EAV3B,MAU2B,GATzB,MAAM,CAoBlB"}

package/types/searcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"searcher.d.ts","sourceRoot":"","sources":["../src/searcher.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,OAAO,WAAU,IAAI,EAXjB,MAWiB,GAVf,MAAM,OAAC,CAsBnB"}
+{"version":3,"file":"searcher.d.ts","sourceRoot":"","sources":["../src/searcher.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,OAAO,WAAU,IAAI,EAXjB,MAWiB,GAVf,MAAM,OAAC,CA0BnB"}

package/types/type_letter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Types one key on a two-set (dubeolsik) Korean keyboard: returns the text with the key composed into
+ * its last character, as an input method does. `letter` is a compatibility jamo (`ㄱ`, `ㅏ`, and
+ * the double `ㄲ`, `ㅒ` that the shift key gives); any other string is appended as it is.
+ * A consonant and a vowel make a syllable, two vowels join (`ㅗ` and `ㅏ` into `ㅘ`), a consonant
+ * after a syllable becomes its final and joins the final before it when the two make a compound
+ * final (`ㄹ` and `ㄱ` into `ㄺ`), and a vowel after a final moves it onto a new syllable (a compound
+ * final moves only its second consonant). Two lone consonants join the same way (`ㄱ` and `ㅅ` into
+ * `ㄳ`), and a vowel splits them again. The same key never makes a double consonant: `ㄱ` after
+ * `각` is appended, since `ㄲ` needs the shift key.
+ * @param {string} text
+ * @param {string} letter
+ * @returns {string}
+ * @example typeLetter("ㄱ", "ㅏ") //=> "가"
+ *
+ * typeLetter("가", "ㄱ") //=> "각"
+ *
+ * typeLetter("각", "ㅏ") //=> "가가"
+ *
+ * typeLetter("고", "ㅏ") //=> "과"
+ *
+ * typeLetter("갈", "ㄱ") //=> "갉"
+ */
+export default function (text: string, letter: string): string;
+//# sourceMappingURL=type_letter.d.ts.map

package/types/type_letter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type_letter.d.ts","sourceRoot":"","sources":["../src/type_letter.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,OAAO,WAAU,IAAI,EAbjB,MAaiB,EAAE,MAAM,EAZzB,MAYyB,GAXvB,MAAM,CAiElB"}