src/vs/base/common/naturalLanguage/korean.ts

423 LOC · 413 covered · 10 uncovered · 31 ranges · 4172 concepts · 13 introducers · 2069 tests
File neighbourhood

The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
  1
  >
  /*---------------------------------------------------------------------------------------------
  
korean.ts ×5

  2
  >
   *  Copyright (c) Microsoft Corporation. All rights reserved.
  
  3
  >
   *  Licensed under the MIT License. See License.txt in the project root for license information.
  
  4
  >
   *--------------------------------------------------------------------------------------------*/
  
  5
  >
  
  6
  >
  // allow-any-unicode-comment-file
  
  7
  >
  
  8
  >
  /**
  
  9
  >
   * Gets alternative Korean characters for the character code. This will return the ascii
  
  10
  >
   * character code(s) that a Hangul character may have been input with using a qwerty layout.
  
  11
  >
   *
  
  12
  >
   * This only aims to cover modern (not archaic) Hangul syllables.
  
  13
  >
   *
  
  14
  >
   * @param code The character code to get alternate characters for
  
  15
  >
   */
  
  16
  >
  export function getKoreanAltChars(code: number): ArrayLike<number> | undefined {
  
  17
  >
  	const result = disassembleKorean(code);
  
korean.ts ×5

  18
  >
  	if (result && result.length > 0) {
  
  19
  >
  		return new Uint32Array(result);
  
korean.ts ×6

  20
  >
  	}
  
  21
  >
  	return undefined;
  
korean.ts ×3

  22
  >
  }
  
  23
  >
  
korean.ts ×5

  24
  >
  let codeBufferLength = 0;
  
  25
  >
  const codeBuffer = new Uint32Array(10);
  
  26
  >
  function disassembleKorean(code: number): Uint32Array | undefined {
  
korean.ts ×5

  27
  >
  	codeBufferLength = 0;
  
  28
  >
  
  29
  >
  	// Initial consonants (초성)
  
  30
  >
  	getCodesFromArray(code, modernConsonants, HangulRangeStartCode.InitialConsonant);
  
  31
  >
  	if (codeBufferLength > 0) {
  
  32
  >
  		return codeBuffer.subarray(0, codeBufferLength);
  
korean.ts ×1

  33
  >
  	}
  
  34
  >
  
korean.ts ×1

  35
  >
  	// Vowels (중성)
  
  36
  >
  	getCodesFromArray(code, modernVowels, HangulRangeStartCode.Vowel);
  
  37
  >
  	if (codeBufferLength > 0) {
  
  38
  >
  		return codeBuffer.subarray(0, codeBufferLength);
  
korean.ts ×1

  39
  >
  	}
  
  40
  >
  
korean.ts ×1

  41
  >
  	// Final consonants (종성)
  
  42
  >
  	getCodesFromArray(code, modernFinalConsonants, HangulRangeStartCode.FinalConsonant);
  
  43
  >
  	if (codeBufferLength > 0) {
  
  44
  >
  		return codeBuffer.subarray(0, codeBufferLength);
  
korean.ts ×1

  45
  >
  	}
  
  46
  >
  
korean.ts ×1

  47
  >
  	// Hangul Compatibility Jamo
  
  48
  >
  	getCodesFromArray(code, compatibilityJamo, HangulRangeStartCode.CompatibilityJamo);
  
  49
  >
  	if (codeBufferLength) {
  
  50
  >
  		return codeBuffer.subarray(0, codeBufferLength);
  
korean.ts ×1

  51
  >
  	}
  
  52
  >
  
korean.ts ×3

  53
  >
  	// Hangul Syllables
  
  54
  >
  	if (code >= 0xAC00 && code <= 0xD7A3) {
  
korean.ts ×5

  55
  >
  		const hangulIndex = code - 0xAC00;
  
korean.ts ×4

  56
  >
  		const vowelAndFinalConsonantProduct = hangulIndex % 588;
  
  57
  >
  
  58
  >
  		// 0-based starting at 0x1100
  
  59
  >
  		const initialConsonantIndex = Math.floor(hangulIndex / 588);
  
  60
  >
  		// 0-based starting at 0x1161
  
  61
  >
  		const vowelIndex = Math.floor(vowelAndFinalConsonantProduct / 28);
  
  62
  >
  		// 0-based starting at 0x11A8
  
  63
  >
  		// Subtract 1 as the standard algorithm uses the 0 index to represent no
  
  64
  >
  		// final consonant
  
  65
  >
  		const finalConsonantIndex = vowelAndFinalConsonantProduct % 28 - 1;
  
  66
  >
  
  67
  >
  		if (initialConsonantIndex < modernConsonants.length) {
  
  68
  >
  			getCodesFromArray(initialConsonantIndex, modernConsonants, 0);
  
  69
  >
  		} else if (HangulRangeStartCode.InitialConsonant + initialConsonantIndex - HangulRangeStartCode.CompatibilityJamo < compatibilityJamo.length) {
  
  70
  
  			getCodesFromArray(HangulRangeStartCode.InitialConsonant + initialConsonantIndex, compatibilityJamo, HangulRangeStartCode.CompatibilityJamo);
  
  71
  
  		}
  
  72
  >
  
korean.ts ×4

  73
  >
  		if (vowelIndex < modernVowels.length) {
  
  74
  >
  			getCodesFromArray(vowelIndex, modernVowels, 0);
  
  75
  >
  		} else if (HangulRangeStartCode.Vowel + vowelIndex - HangulRangeStartCode.CompatibilityJamo < compatibilityJamo.length) {
  
  76
  
  			getCodesFromArray(HangulRangeStartCode.Vowel + vowelIndex - HangulRangeStartCode.CompatibilityJamo, compatibilityJamo, HangulRangeStartCode.CompatibilityJamo);
  
  77
  
  		}
  
  78
  >
  
korean.ts ×4

  79
  >
  		if (finalConsonantIndex >= 0) {
  
  80
  >
  			if (finalConsonantIndex < modernFinalConsonants.length) {
  
  81
  >
  				getCodesFromArray(finalConsonantIndex, modernFinalConsonants, 0);
  
  82
  >
  			} else if (HangulRangeStartCode.FinalConsonant + finalConsonantIndex - HangulRangeStartCode.CompatibilityJamo < compatibilityJamo.length) {
  
  83
  
  				getCodesFromArray(HangulRangeStartCode.FinalConsonant + finalConsonantIndex - HangulRangeStartCode.CompatibilityJamo, compatibilityJamo, HangulRangeStartCode.CompatibilityJamo);
  
  84
  
  			}
  
  85
  >
  		}
  
korean.ts ×4

  86
  >
  
  87
  >
  		if (codeBufferLength > 0) {
  
  88
  >
  			return codeBuffer.subarray(0, codeBufferLength);
  
  89
  >
  		}
  
  90
  >
  	}
  
  91
  >
  	return undefined;
  
korean.ts ×3

  92
  >
  }
  
  93
  >
  
korean.ts ×5

  94
  >
  function getCodesFromArray(code: number, array: ArrayLike<number>, arrayStartIndex: number): void {
  
korean.ts ×5

  95
  >
  	// Verify the code is within the array's range
  
  96
  >
  	if (code >= arrayStartIndex && code < arrayStartIndex + array.length) {
  
  97
  >
  		addCodesToBuffer(array[code - arrayStartIndex]);
  
korean.ts ×6

  98
  >
  	}
  
  99
  >
  }
  
korean.ts ×5

  100
  >
  
korean.ts ×5

  101
  >
  function addCodesToBuffer(codes: number): void {
  
korean.ts ×6

  102
  >
  	// NUL is ignored, this is used for archaic characters to avoid using a Map
  
  103
  >
  	// for the data
  
  104
  >
  	if (codes === AsciiCode.NUL) {
  
  105
  
  		return;
  
  106
  
  	}
  
  107
  >
  	// Number stored in format: OptionalThirdCode << 16 | OptionalSecondCode << 8 | Code
  
korean.ts ×6

  108
  >
  	codeBuffer[codeBufferLength++] = codes & 0xFF;
  
  109
  >
  	if (codes >> 8) {
  
  110
  >
  		codeBuffer[codeBufferLength++] = (codes >> 8) & 0xFF;
  
korean.ts ×1

  111
  >
  	}
  
  112
  >
  	if (codes >> 16) {
  
korean.ts ×6

  113
  
  		codeBuffer[codeBufferLength++] = (codes >> 16) & 0xFF;
  
  114
  
  	}
  
  115
  >
  }
  
korean.ts ×6

  116
  >
  
korean.ts ×5

  117
  >
  const enum HangulRangeStartCode {
  
  118
  >
  	InitialConsonant = 0x1100,
  
  119
  >
  	Vowel = 0x1161,
  
  120
  >
  	FinalConsonant = 0x11A8,
  
  121
  >
  	CompatibilityJamo = 0x3131,
  
  122
  >
  }
  
  123
  >
  
  124
  >
  const enum AsciiCode {
  
  125
  >
  	NUL = 0,
  
  126
  >
  	A = 65,
  
  127
  >
  	B = 66,
  
  128
  >
  	C = 67,
  
  129
  >
  	D = 68,
  
  130
  >
  	E = 69,
  
  131
  >
  	F = 70,
  
  132
  >
  	G = 71,
  
  133
  >
  	H = 72,
  
  134
  >
  	I = 73,
  
  135
  >
  	J = 74,
  
  136
  >
  	K = 75,
  
  137
  >
  	L = 76,
  
  138
  >
  	M = 77,
  
  139
  >
  	N = 78,
  
  140
  >
  	O = 79,
  
  141
  >
  	P = 80,
  
  142
  >
  	Q = 81,
  
  143
  >
  	R = 82,
  
  144
  >
  	S = 83,
  
  145
  >
  	T = 84,
  
  146
  >
  	U = 85,
  
  147
  >
  	V = 86,
  
  148
  >
  	W = 87,
  
  149
  >
  	X = 88,
  
  150
  >
  	Y = 89,
  
  151
  >
  	Z = 90,
  
  152
  >
  	a = 97,
  
  153
  >
  	b = 98,
  
  154
  >
  	c = 99,
  
  155
  >
  	d = 100,
  
  156
  >
  	e = 101,
  
  157
  >
  	f = 102,
  
  158
  >
  	g = 103,
  
  159
  >
  	h = 104,
  
  160
  >
  	i = 105,
  
  161
  >
  	j = 106,
  
  162
  >
  	k = 107,
  
  163
  >
  	l = 108,
  
  164
  >
  	m = 109,
  
  165
  >
  	n = 110,
  
  166
  >
  	o = 111,
  
  167
  >
  	p = 112,
  
  168
  >
  	q = 113,
  
  169
  >
  	r = 114,
  
  170
  >
  	s = 115,
  
  171
  >
  	t = 116,
  
  172
  >
  	u = 117,
  
  173
  >
  	v = 118,
  
  174
  >
  	w = 119,
  
  175
  >
  	x = 120,
  
  176
  >
  	y = 121,
  
  177
  >
  	z = 122,
  
  178
  >
  }
  
  179
  >
  
  180
  >
  /**
  
  181
  >
   * Numbers that represent multiple ascii codes. These are precomputed at compile time to reduce
  
  182
  >
   * bundle and runtime overhead.
  
  183
  >
   */
  
  184
  >
  const enum AsciiCodeCombo {
  
  185
  >
  	fa = AsciiCode.a << 8 | AsciiCode.f,
  
  186
  >
  	fg = AsciiCode.g << 8 | AsciiCode.f,
  
  187
  >
  	fq = AsciiCode.q << 8 | AsciiCode.f,
  
  188
  >
  	fr = AsciiCode.r << 8 | AsciiCode.f,
  
  189
  >
  	ft = AsciiCode.t << 8 | AsciiCode.f,
  
  190
  >
  	fv = AsciiCode.v << 8 | AsciiCode.f,
  
  191
  >
  	fx = AsciiCode.x << 8 | AsciiCode.f,
  
  192
  >
  	hk = AsciiCode.k << 8 | AsciiCode.h,
  
  193
  >
  	hl = AsciiCode.l << 8 | AsciiCode.h,
  
  194
  >
  	ho = AsciiCode.o << 8 | AsciiCode.h,
  
  195
  >
  	ml = AsciiCode.l << 8 | AsciiCode.m,
  
  196
  >
  	nj = AsciiCode.j << 8 | AsciiCode.n,
  
  197
  >
  	nl = AsciiCode.l << 8 | AsciiCode.n,
  
  198
  >
  	np = AsciiCode.p << 8 | AsciiCode.n,
  
  199
  >
  	qt = AsciiCode.t << 8 | AsciiCode.q,
  
  200
  >
  	rt = AsciiCode.t << 8 | AsciiCode.r,
  
  201
  >
  	sg = AsciiCode.g << 8 | AsciiCode.s,
  
  202
  >
  	sw = AsciiCode.w << 8 | AsciiCode.s,
  
  203
  >
  }
  
  204
  >
  
  205
  >
  /**
  
  206
  >
   * Hangul Jamo - Modern consonants #1
  
  207
  >
   *
  
  208
  >
   * Range U+1100..U+1112
  
  209
  >
   *
  
  210
  >
   * |        | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
  
  211
  >
   * |--------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
  
  212
  >
   * | U+110x | ᄀ | ᄁ | ᄂ | ᄃ | ᄄ | ᄅ | ᄆ | ᄇ | ᄈ | ᄉ | ᄊ | ᄋ | ᄌ | ᄍ | ᄎ | ᄏ |
  
  213
  >
   * | U+111x | ᄐ | ᄑ | ᄒ |
  
  214
  >
   */
  
  215
  >
  const modernConsonants = new Uint8Array([
  
  216
  >
  	AsciiCode.r, // ㄱ
  
  217
  >
  	AsciiCode.R, // ㄲ
  
  218
  >
  	AsciiCode.s, // ㄴ
  
  219
  >
  	AsciiCode.e, // ㄷ
  
  220
  >
  	AsciiCode.E, // ㄸ
  
  221
  >
  	AsciiCode.f, // ㄹ
  
  222
  >
  	AsciiCode.a, // ㅁ
  
  223
  >
  	AsciiCode.q, // ㅂ
  
  224
  >
  	AsciiCode.Q, // ㅃ
  
  225
  >
  	AsciiCode.t, // ㅅ
  
  226
  >
  	AsciiCode.T, // ㅆ
  
  227
  >
  	AsciiCode.d, // ㅇ
  
  228
  >
  	AsciiCode.w, // ㅈ
  
  229
  >
  	AsciiCode.W, // ㅉ
  
  230
  >
  	AsciiCode.c, // ㅊ
  
  231
  >
  	AsciiCode.z, // ㅋ
  
  232
  >
  	AsciiCode.x, // ㅌ
  
  233
  >
  	AsciiCode.v, // ㅍ
  
  234
  >
  	AsciiCode.g, // ㅎ
  
  235
  >
  ]);
  
  236
  >
  
  237
  >
  /**
  
  238
  >
   * Hangul Jamo - Modern Vowels
  
  239
  >
   *
  
  240
  >
   * Range U+1161..U+1175
  
  241
  >
   *
  
  242
  >
   * |        | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
  
  243
  >
   * |--------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
  
  244
  >
   * | U+116x |   | ᅡ | ᅢ | ᅣ | ᅤ | ᅥ | ᅦ | ᅧ | ᅨ | ᅩ | ᅪ | ᅫ | ᅬ | ᅭ | ᅮ | ᅯ |
  
  245
  >
   * | U+117x | ᅰ | ᅱ | ᅲ | ᅳ | ᅴ | ᅵ |
  
  246
  >
   */
  
  247
  >
  const modernVowels = new Uint16Array([
  
  248
  >
  	AsciiCode.k,       //  -> ㅏ
  
  249
  >
  	AsciiCode.o,       //  -> ㅐ
  
  250
  >
  	AsciiCode.i,       //  -> ㅑ
  
  251
  >
  	AsciiCode.O,       //  -> ㅒ
  
  252
  >
  	AsciiCode.j,       //  -> ㅓ
  
  253
  >
  	AsciiCode.p,       //  -> ㅔ
  
  254
  >
  	AsciiCode.u,       //  -> ㅕ
  
  255
  >
  	AsciiCode.P,       //  -> ㅖ
  
  256
  >
  	AsciiCode.h,       //  -> ㅗ
  
  257
  >
  	AsciiCodeCombo.hk, //  -> ㅘ
  
  258
  >
  	AsciiCodeCombo.ho, //  -> ㅙ
  
  259
  >
  	AsciiCodeCombo.hl, //  -> ㅚ
  
  260
  >
  	AsciiCode.y,       //  -> ㅛ
  
  261
  >
  	AsciiCode.n,       //  -> ㅜ
  
  262
  >
  	AsciiCodeCombo.nj, //  -> ㅝ
  
  263
  >
  	AsciiCodeCombo.np, //  -> ㅞ
  
  264
  >
  	AsciiCodeCombo.nl, //  -> ㅟ
  
  265
  >
  	AsciiCode.b,       //  -> ㅠ
  
  266
  >
  	AsciiCode.m,       //  -> ㅡ
  
  267
  >
  	AsciiCodeCombo.ml, //  -> ㅢ
  
  268
  >
  	AsciiCode.l,       //  -> ㅣ
  
  269
  >
  ]);
  
  270
  >
  
  271
  >
  /**
  
  272
  >
   * Hangul Jamo - Modern Consonants #2
  
  273
  >
   *
  
  274
  >
   * Range U+11A8..U+11C2
  
  275
  >
   *
  
  276
  >
   * |        | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
  
  277
  >
   * |--------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
  
  278
  >
   * | U+11Ax |   |   |   |   |   |   |   |   | ᆨ | ᆩ | ᆪ | ᆫ | ᆬ | ᆭ | ᆮ | ᆯ |
  
  279
  >
   * | U+11Bx | ᆰ | ᆱ | ᆲ | ᆳ | ᆴ | ᆵ | ᆶ | ᆷ | ᆸ | ᆹ | ᆺ | ᆻ | ᆼ | ᆽ | ᆾ | ᆿ |
  
  280
  >
   * | U+11Cx | ᇀ | ᇁ | ᇂ |
  
  281
  >
   */
  
  282
  >
  const modernFinalConsonants = new Uint16Array([
  
  283
  >
  	AsciiCode.r,       // ㄱ
  
  284
  >
  	AsciiCode.R,       // ㄲ
  
  285
  >
  	AsciiCodeCombo.rt, // ㄳ
  
  286
  >
  	AsciiCode.s,       // ㄴ
  
  287
  >
  	AsciiCodeCombo.sw, // ㄵ
  
  288
  >
  	AsciiCodeCombo.sg, // ㄶ
  
  289
  >
  	AsciiCode.e,       // ㄷ
  
  290
  >
  	AsciiCode.f,       // ㄹ
  
  291
  >
  	AsciiCodeCombo.fr, // ㄺ
  
  292
  >
  	AsciiCodeCombo.fa, // ㄻ
  
  293
  >
  	AsciiCodeCombo.fq, // ㄼ
  
  294
  >
  	AsciiCodeCombo.ft, // ㄽ
  
  295
  >
  	AsciiCodeCombo.fx, // ㄾ
  
  296
  >
  	AsciiCodeCombo.fv, // ㄿ
  
  297
  >
  	AsciiCodeCombo.fg, // ㅀ
  
  298
  >
  	AsciiCode.a,       // ㅁ
  
  299
  >
  	AsciiCode.q,       // ㅂ
  
  300
  >
  	AsciiCodeCombo.qt, // ㅄ
  
  301
  >
  	AsciiCode.t,       // ㅅ
  
  302
  >
  	AsciiCode.T,       // ㅆ
  
  303
  >
  	AsciiCode.d,       // ㅇ
  
  304
  >
  	AsciiCode.w,       // ㅈ
  
  305
  >
  	AsciiCode.c,       // ㅊ
  
  306
  >
  	AsciiCode.z,       // ㅋ
  
  307
  >
  	AsciiCode.x,       // ㅌ
  
  308
  >
  	AsciiCode.v,       // ㅍ
  
  309
  >
  	AsciiCode.g,       // ㅎ
  
  310
  >
  ]);
  
  311
  >
  
  312
  >
  /**
  
  313
  >
   * Hangul Compatibility Jamo
  
  314
  >
   *
  
  315
  >
   * Range U+3131..U+318F
  
  316
  >
   *
  
  317
  >
   * This includes range includes archaic jamo which we don't consider, these are
  
  318
  >
   * given the NUL character code in order to be ignored.
  
  319
  >
   *
  
  320
  >
   * |        | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
  
  321
  >
   * |--------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
  
  322
  >
   * | U+313x |   | ㄱ | ㄲ | ㄳ | ㄴ | ㄵ | ㄶ | ㄷ | ㄸ | ㄹ | ㄺ | ㄻ | ㄼ | ㄽ | ㄾ | ㄿ |
  
  323
  >
   * | U+314x | ㅀ | ㅁ | ㅂ | ㅃ | ㅄ | ㅅ | ㅆ | ㅇ | ㅈ | ㅉ | ㅊ | ㅋ | ㅌ | ㅍ | ㅎ | ㅏ |
  
  324
  >
   * | U+315x | ㅐ | ㅑ | ㅒ | ㅓ | ㅔ | ㅕ | ㅖ | ㅗ | ㅘ | ㅙ | ㅚ | ㅛ | ㅜ | ㅝ | ㅞ | ㅟ |
  
  325
  >
   * | U+316x | ㅠ | ㅡ | ㅢ | ㅣ | HF | ㅥ | ㅦ | ㅧ | ㅨ | ㅩ | ㅪ | ㅫ | ㅬ | ㅭ | ㅮ | ㅯ |
  
  326
  >
   * | U+317x | ㅰ | ㅱ | ㅲ | ㅳ | ㅴ | ㅵ | ㅶ | ㅷ | ㅸ | ㅹ | ㅺ | ㅻ | ㅼ | ㅽ | ㅾ | ㅿ |
  
  327
  >
   * | U+318x | ㆀ | ㆁ | ㆂ | ㆃ | ㆄ | ㆅ | ㆆ | ㆇ | ㆈ | ㆉ | ㆊ | ㆋ | ㆌ | ㆍ | ㆎ |
  
  328
  >
   */
  
  329
  >
  const compatibilityJamo = new Uint16Array([
  
  330
  >
  	AsciiCode.r,        // ㄱ
  
  331
  >
  	AsciiCode.R,        // ㄲ
  
  332
  >
  	AsciiCodeCombo.rt,  // ㄳ
  
  333
  >
  	AsciiCode.s,        // ㄴ
  
  334
  >
  	AsciiCodeCombo.sw,  // ㄵ
  
  335
  >
  	AsciiCodeCombo.sg,  // ㄶ
  
  336
  >
  	AsciiCode.e,        // ㄷ
  
  337
  >
  	AsciiCode.E,        // ㄸ
  
  338
  >
  	AsciiCode.f,        // ㄹ
  
  339
  >
  	AsciiCodeCombo.fr,  // ㄺ
  
  340
  >
  	AsciiCodeCombo.fa,  // ㄻ
  
  341
  >
  	AsciiCodeCombo.fq,  // ㄼ
  
  342
  >
  	AsciiCodeCombo.ft,  // ㄽ
  
  343
  >
  	AsciiCodeCombo.fx,  // ㄾ
  
  344
  >
  	AsciiCodeCombo.fv,  // ㄿ
  
  345
  >
  	AsciiCodeCombo.fg,  // ㅀ
  
  346
  >
  	AsciiCode.a,        // ㅁ
  
  347
  >
  	AsciiCode.q,        // ㅂ
  
  348
  >
  	AsciiCode.Q,        // ㅃ
  
  349
  >
  	AsciiCodeCombo.qt,  // ㅄ
  
  350
  >
  	AsciiCode.t,        // ㅅ
  
  351
  >
  	AsciiCode.T,        // ㅆ
  
  352
  >
  	AsciiCode.d,        // ㅇ
  
  353
  >
  	AsciiCode.w,        // ㅈ
  
  354
  >
  	AsciiCode.W,        // ㅉ
  
  355
  >
  	AsciiCode.c,        // ㅊ
  
  356
  >
  	AsciiCode.z,        // ㅋ
  
  357
  >
  	AsciiCode.x,        // ㅌ
  
  358
  >
  	AsciiCode.v,        // ㅍ
  
  359
  >
  	AsciiCode.g,        // ㅎ
  
  360
  >
  	AsciiCode.k,        // ㅏ
  
  361
  >
  	AsciiCode.o,        // ㅐ
  
  362
  >
  	AsciiCode.i,        // ㅑ
  
  363
  >
  	AsciiCode.O,        // ㅒ
  
  364
  >
  	AsciiCode.j,        // ㅓ
  
  365
  >
  	AsciiCode.p,        // ㅔ
  
  366
  >
  	AsciiCode.u,        // ㅕ
  
  367
  >
  	AsciiCode.P,        // ㅖ
  
  368
  >
  	AsciiCode.h,        // ㅗ
  
  369
  >
  	AsciiCodeCombo.hk,  // ㅘ
  
  370
  >
  	AsciiCodeCombo.ho,  // ㅙ
  
  371
  >
  	AsciiCodeCombo.hl,  // ㅚ
  
  372
  >
  	AsciiCode.y,        // ㅛ
  
  373
  >
  	AsciiCode.n,        // ㅜ
  
  374
  >
  	AsciiCodeCombo.nj,  // ㅝ
  
  375
  >
  	AsciiCodeCombo.np,  // ㅞ
  
  376
  >
  	AsciiCodeCombo.nl,  // ㅟ
  
  377
  >
  	AsciiCode.b,        // ㅠ
  
  378
  >
  	AsciiCode.m,        // ㅡ
  
  379
  >
  	AsciiCodeCombo.ml,  // ㅢ
  
  380
  >
  	AsciiCode.l,        // ㅣ
  
  381
  >
  	// HF: Hangul Filler (everything after this is archaic)
  
  382
  >
  	// ㅥ
  
  383
  >
  	// ㅦ
  
  384
  >
  	// ㅧ
  
  385
  >
  	// ㅨ
  
  386
  >
  	// ㅩ
  
  387
  >
  	// ㅪ
  
  388
  >
  	// ㅫ
  
  389
  >
  	// ㅬ
  
  390
  >
  	// ㅮ
  
  391
  >
  	// ㅯ
  
  392
  >
  	// ㅰ
  
  393
  >
  	// ㅱ
  
  394
  >
  	// ㅲ
  
  395
  >
  	// ㅳ
  
  396
  >
  	// ㅴ
  
  397
  >
  	// ㅵ
  
  398
  >
  	// ㅶ
  
  399
  >
  	// ㅷ
  
  400
  >
  	// ㅸ
  
  401
  >
  	// ㅹ
  
  402
  >
  	// ㅺ
  
  403
  >
  	// ㅻ
  
  404
  >
  	// ㅼ
  
  405
  >
  	// ㅽ
  
  406
  >
  	// ㅾ
  
  407
  >
  	// ㅿ
  
  408
  >
  	// ㆀ
  
  409
  >
  	// ㆁ
  
  410
  >
  	// ㆂ
  
  411
  >
  	// ㆃ
  
  412
  >
  	// ㆄ
  
  413
  >
  	// ㆅ
  
  414
  >
  	// ㆆ
  
  415
  >
  	// ㆇ
  
  416
  >
  	// ㆈ
  
  417
  >
  	// ㆉ
  
  418
  >
  	// ㆊ
  
  419
  >
  	// ㆋ
  
  420
  >
  	// ㆌ
  
  421
  >
  	// ㆍ
  
  422
  >
  	// ㆎ
  
  423
  >
  ]);