อ้างอิง API

use kham_core::{Tokenizer, TokenStream};

let tok = Tokenizer::new();

// Streaming — consume one token at a time
let mut stream = tok.segment_stream("ธนาคาร100แห่ง");

// next_word() — skip whitespace
while let Some(t) = stream.next_word() {
    println!("{} ({:?})", t.text, t.kind);
}

// next_above_confidence(0.8) — skip low-confidence tokens
let mut stream = tok.segment_stream("ธนาคาร100แห่ง");
while let Some(t) = stream.next_above_confidence(0.8) {
    println!("{} conf={:.2}", t.text, t.confidence);
}

import kham

# ง่าย — list ของ string
words = kham.segment("กินข้าวกับปลา")
# ['กิน', 'ข้าว', 'กับ', 'ปลา']

# รายละเอียด — Token object (text, byte_start/end, char_start/end, kind)
for t in kham.segment_tokens("ธนาคาร100แห่ง"):
    print(t.text, t.char_start, t.char_end, t.kind)
# ธนาคาร  0  6  Thai
# 100      6  9  Number
# แห่ง     9 13  Thai

# normalize ก่อน segment
text = kham.normalize("ข้้าว")   # "ข้าว"
words = kham.segment(text)

# segment_above_confidence — เฉพาะ token ที่มี confidence ≥ threshold
for t in kham.segment_above_confidence("ธนาคาร100แห่ง", 0.8):
    print(t.text, t.confidence)

import init, { segment, segment_tokens, normalize, segment_above_confidence } from '/wasm/kham_wasm.js';
await init(); // เรียกครั้งเดียวตอน load

// ง่าย — JS Array ของ string
const words = segment("กินข้าวกับปลา");
// ["กิน", "ข้าว", "กับ", "ปลา"]

// รายละเอียด — Token (text, charStart, charEnd, byteStart, byteEnd, kind)
const tokens = segment_tokens("ธนาคาร100แห่ง");
for (const t of tokens) {
  console.log(t.text, t.char_start, t.char_end, t.kind);
}

// normalize ก่อน segment
const clean = normalize("ข้้าว");   // "ข้าว"
const toks  = segment(clean);

// segment_above_confidence — เฉพาะ token ที่มี confidence ≥ threshold
const high = segment_above_confidence("ธนาคาร100แห่ง", 0.8);
for (const t of high) console.log(t.text, t.confidence);

#include "kham.h"

// ง่าย — array ของ token string (legacy API)
KhamTokens *toks = kham_segment("กินข้าวกับปลา");
for (size_t i = 0; i < toks->len; i++)
    printf("%s\n", toks->words[i]);
kham_tokens_free(toks);

// รายละเอียด — KhamToken พร้อม byte/char span
KhamTokenList *list = kham_segment_tokens("ธนาคาร100แห่ง");
for (size_t i = 0; i < list->len; i++) {
    KhamToken t = list->tokens[i];
    printf("%s  chars=%zu..%zu  %s\n",
           t.text, t.char_start, t.char_end, t.kind);
}
kham_token_list_free(list);

import kham

tokens = kham.segment_tokens("ธนาคาร100แห่ง")

for t in tokens:
    # t.text       — str
    # t.byte_start / t.byte_end  — UTF-8 byte offsets
    # t.char_start / t.char_end  — Unicode scalar-value offsets
    # t.kind        — str: "Thai" | "Latin" | "Number" | "Punctuation"
    #                       "Emoji" | "Whitespace" | "Unknown"
    #                       "Person" | "Place" | "Org"  (Named entities)
    # t.confidence  — float: 0.0 (Unknown) … 1.0 (dict match ที่มีความมั่นใจสูง)
    print(f"{t.text!r:12} kind={t.kind}  chars={t.char_start}..{t.char_end}  conf={t.confidence:.2f}")

import init, { segment_tokens } from '/wasm/kham_wasm.js';
await init();

const tokens = segment_tokens("ธนาคาร100แห่ง");

for (const t of tokens) {
  // t.text       — string
  // t.byte_start / t.byte_end  — UTF-8 byte offsets
  // t.char_start / t.char_end  — Unicode scalar-value offsets
  // t.kind        — "Thai" | "Latin" | "Number" | "Punctuation"
  //                 "Emoji" | "Whitespace" | "Unknown"
  //                 "Person" | "Place" | "Org"  (Named entities)
  // t.confidence  — number: 0.0 (Unknown) … 1.0
  console.log(t.text, t.kind, t.char_start, t.char_end, t.confidence);
}

#include "kham.h"

// KhamToken fields:
//   text       — char* (null-terminated UTF-8)
//   byte_start / byte_end  — size_t byte offsets
//   char_start / char_end  — size_t Unicode scalar-value offsets
//   kind       — char*: "Thai" | "Latin" | "Number" | "Punctuation"
//                       "Emoji" | "Whitespace" | "Unknown"
//                       "Person" | "Place" | "Org"  (FTS pipeline เท่านั้น)
//   confidence — float: 0.0 (Unknown) … 1.0

KhamTokenList *list = kham_segment_tokens("ธนาคาร100แห่ง");
for (size_t i = 0; i < list->len; i++) {
    KhamToken *t = &list->tokens[i];
    printf("%-10s  bytes=%zu..%zu  chars=%zu..%zu  kind=%s\n",
           t->text, t->byte_start, t->byte_end,
           t->char_start, t->char_end, t->kind);
}
kham_token_list_free(list);

import kham

# กฎ 1 — ลบวรรณยุกต์ซ้ำ
kham.normalize("ข้้าว")   # → "ข้าว"

# กฎ 2 — รวม sara am
# nikhahit (U+0E4D) + sara aa (U+0E32) → sara am (U+0E33)
kham.normalize("\u0e01\u0e4d\u0e32")  # กํา → กำ

# canonical อยู่แล้ว — คืนค่าเดิม
kham.normalize("กินข้าว")  # → "กินข้าว"

# วิธีใช้ทั่วไป: normalize ก่อน segment
words = kham.segment(kham.normalize(raw_input))

import init, { normalize, segment } from '/wasm/kham_wasm.js';
await init();

// กฎ 1 — ลบวรรณยุกต์ซ้ำ
normalize("ข้้าว");   // → "ข้าว"

// กฎ 2 — รวม sara am
// nikhahit (U+0E4D) + sara aa (U+0E32) → sara am (U+0E33)
normalize("\u0E01\u0E4D\u0E32");  // กํา → กำ

// canonical อยู่แล้ว — คืนค่าเดิม
normalize("กินข้าว");  // → "กินข้าว"

// วิธีใช้ทั่วไป: normalize ก่อน segment
const words = segment(normalize(rawInput));

#include "kham.h"

// kham_normalize คืน heap-allocated string — free ด้วย kham_string_free

char *out = kham_normalize("ข้้าว");   // "ข้าว"
printf("%s\n", out);
kham_string_free(out);

// รวม sara am: nikhahit + sara aa → sara am
char *out2 = kham_normalize("\xe0\xb8\x81\xe0\xb9\x8d\xe0\xb8\xb2"); // กํา
printf("%s\n", out2);   // กำ
kham_string_free(out2);

// วิธีใช้ทั่วไป: normalize แล้ว segment
char *norm = kham_normalize(raw_input);
KhamTokens *toks = kham_segment(norm);
kham_string_free(norm);
// ... ใช้ toks ...
kham_tokens_free(toks);

import kham

# FtsToken fields: text, position, kind, is_stop, roman,
#                  pos, ne, synonyms (list), trigrams (list), confidence (float)
for t in kham.segment_fts("นายกรัฐมนตรีกินข้าว"):
    print(f"{t.text:10} pos={t.pos!r:15} ne={t.ne!r} stop={t.is_stop}")

# POS tags: "Noun" | "Verb" | "Adj" | "Adv" | "Particle" | "ProperNoun"
#           "Pronoun" | "Numeral" | "Classifier" | "Conjunction"
#           "Auxiliary" | "Determiner" | "Preposition"  (None ถ้า OOV)
# NE tags:  "Person" | "Place" | "Org"  (None ถ้าไม่อยู่ใน gazetteer)

# Romanization มีใน FtsToken ทุกตัว
for t in kham.segment_fts("กินข้าว"):
    print(t.text, "→", t.roman)   # กิน → kin

import init, { segment_fts } from '/wasm/kham_wasm.js';
await init();

// FtsToken properties: text, position, kind, is_stop, roman,
//                      pos (string|null), ne (string|null),
//                      synonyms (string[]), trigrams (string[]),
//                      confidence (number: 0.0…1.0)
const tokens = segment_fts("นายกรัฐมนตรีกินข้าว");
for (const t of tokens) {
  console.log(t.text, '| pos:', t.pos, '| ne:', t.ne,
              '| stop:', t.is_stop, '| roman:', t.roman);
}

// POS tags: "Noun" | "Verb" | "Adj" | "Adv" | "Particle" | "ProperNoun"
//           "Pronoun" | "Numeral" | "Classifier" | "Conjunction"
//           "Auxiliary" | "Determiner" | "Preposition"  (null ถ้า OOV)
// NE tags:  "Person" | "Place" | "Org"  (null ถ้าไม่อยู่ใน gazetteer)

#include "kham.h"

// KhamFtsToken fields:
//   text, position, kind, is_stop, roman (char*, ไม่เป็น NULL)
//   pos (char* หรือ NULL ถ้า OOV), ne (char* หรือ NULL)
//   synonyms / synonyms_len, trigrams / trigrams_len

KhamFtsTokenList *list = kham_fts_segment("นายกรัฐมนตรีกินข้าว");
for (size_t i = 0; i < list->len; i++) {
    KhamFtsToken *t = &list->tokens[i];
    printf("%-10s  pos=%-14s  ne=%-8s  stop=%d  roman=%s\n",
           t->text,
           t->pos  ? t->pos  : "(none)",
           t->ne   ? t->ne   : "(none)",
           t->is_stop, t->roman);
}
kham_fts_token_list_free(list);

// Flat lexeme array (สำหรับ PostgreSQL tsvector / SQLite FTS5)
size_t len;
char **lex = kham_fts_lexemes("กินข้าวกับปลา", &len);
for (size_t i = 0; i < len; i++) printf("%s\n", lex[i]);
kham_fts_lexemes_free(lex, len);

import kham

# POS tagging เข้าถึงผ่าน segment_fts()
# t.pos คืน string tag หรือ None สำหรับ OOV / token ที่ไม่ใช่ภาษาไทย

for t in kham.segment_fts("นักเรียนกินข้าวกับปลา"):
    if t.pos:
        print(f"{t.text:8} → {t.pos}")
# นักเรียน → Noun
# กิน      → Verb
# ข้าว     → Noun
# กับ      → Preposition
# ปลา      → Noun

import init, { segment_fts } from '/wasm/kham_wasm.js';
await init();

// POS tagging เข้าถึงผ่าน segment_fts()
// t.pos คืน string tag หรือ null สำหรับ OOV / token ที่ไม่ใช่ภาษาไทย

const tokens = segment_fts("นักเรียนกินข้าวกับปลา");
for (const t of tokens) {
  if (t.pos) console.log(t.text, '→', t.pos);
}
// นักเรียน → Noun
// กิน      → Verb
// ข้าว     → Noun
// กับ      → Preposition
// ปลา      → Noun

#include "kham.h"

// POS tagging เข้าถึงผ่าน kham_fts_segment()
// t->pos เป็น NULL สำหรับ OOV / token ที่ไม่ใช่ภาษาไทย

KhamFtsTokenList *list = kham_fts_segment("นักเรียนกินข้าวกับปลา");
for (size_t i = 0; i < list->len; i++) {
    KhamFtsToken *t = &list->tokens[i];
    if (t->pos)
        printf("%-10s → %s\n", t->text, t->pos);
}
// นักเรียน → Noun
// กิน      → Verb
// ข้าว     → Noun
// กับ      → Preposition
// ปลา      → Noun
kham_fts_token_list_free(list);

import kham

# NE tagging เข้าถึงผ่าน segment_fts()
# t.ne คืน "Person" | "Place" | "Org" หรือ None

for t in kham.segment_fts("บริษัทไทยออยล์ก่อตั้งในกรุงเทพ"):
    if t.ne:
        print(f"{t.text:12} → {t.ne}")
# ไทยออยล์  → Org
# กรุงเทพ   → Place

import init, { segment_fts } from '/wasm/kham_wasm.js';
await init();

// NE tagging เข้าถึงผ่าน segment_fts()
// t.ne คืน "Person" | "Place" | "Org" หรือ null

const tokens = segment_fts("บริษัทไทยออยล์ก่อตั้งในกรุงเทพ");
for (const t of tokens) {
  if (t.ne) console.log(t.text, '→', t.ne);
}
// ไทยออยล์  → Org
// กรุงเทพ   → Place

#include "kham.h"

// NE tagging เข้าถึงผ่าน kham_fts_segment()
// t->ne เป็น NULL ถ้าไม่อยู่ใน NE gazetteer

KhamFtsTokenList *list = kham_fts_segment("บริษัทไทยออยล์ก่อตั้งในกรุงเทพ");
for (size_t i = 0; i < list->len; i++) {
    KhamFtsToken *t = &list->tokens[i];
    if (t->ne)
        printf("%-12s → %s\n", t->text, t->ne);
}
// ไทยออยล์  → Org
// กรุงเทพ   → Place
kham_fts_token_list_free(list);

import kham

# romanize() คืน list ของ RomanToken(text, roman)
for t in kham.romanize("กินข้าวกับปลา"):
    print(f"{t.text:6} → {t.roman}")
# กิน   → kin
# ข้าว  → khao
# กับ   → kap
# ปลา   → pla

# roman มีใน FtsToken ทุกตัวด้วย
for t in kham.segment_fts("กรุงเทพ"):
    print(t.text, t.roman)   # กรุงเทพ  Krung Thep

import init, { romanize } from '/wasm/kham_wasm.js';
await init();

// romanize() คืน array ของ RomanToken (text, roman)
const pairs = romanize("กินข้าวกับปลา");
for (const t of pairs) {
  console.log(t.text, '→', t.roman);
}
// กิน   → kin
// ข้าว  → khao
// กับ   → kap
// ปลา   → pla

// roman มีใน FtsToken ทุกตัวจาก segment_fts() ด้วย

#include "kham.h"

// kham_romanize คืน KhamRomanTokenList
// แต่ละ KhamRomanToken มี: text (char*), roman (char*)

KhamRomanTokenList *list = kham_romanize("กินข้าวกับปลา");
for (size_t i = 0; i < list->len; i++) {
    KhamRomanToken *t = &list->tokens[i];
    printf("%-6s → %s\n", t->text, t->roman);
}
// กิน   → kin
// ข้าว  → khao
// กับ   → kap
// ปลา   → pla
kham_roman_token_list_free(list);

// roman มีใน KhamFtsToken ทุกตัวจาก kham_fts_segment() ด้วย

import kham

# เลขไทย → ASCII
kham.thai_digits_to_ascii("ราคา ๑๒๓ บาท")   # "ราคา 123 บาท"

# คำไทย → ตัวเลข (คืน int หรือ None)
kham.thai_word_to_number("หนึ่งร้อยยี่สิบสาม")  # 123
kham.thai_word_to_number("สองล้าน")              # 2000000
kham.thai_word_to_number("กินข้าว")              # None

# ตัวเลข → คำไทย
kham.number_to_thai_word(42)          # "สี่สิบสอง"
kham.number_to_thai_word(1_000_000)   # "หนึ่งล้าน"

# ข้อความบาท
kham.number_to_baht_text(1234, 50)
# "หนึ่งพันสองร้อยสามสิบสี่บาทห้าสิบสตางค์"

amt = kham.parse_baht_text("หนึ่งร้อยบาทถ้วน")  # BahtAmount หรือ None
if amt:
    print(amt.baht, amt.satang)   # 100  0

import init, {
  thai_digits_to_ascii, thai_word_to_number, number_to_thai_word,
  number_to_baht_text, parse_baht_text,
} from '/wasm/kham_wasm.js';
await init();

// เลขไทย → ASCII
thai_digits_to_ascii("ราคา ๑๒๓ บาท");   // "ราคา 123 บาท"

// คำไทย → ตัวเลข (คืน decimal string; "" ถ้าไม่ใช่ตัวเลข)
thai_word_to_number("หนึ่งร้อยยี่สิบสาม");  // "123"
thai_word_to_number("กินข้าว");              // ""

// ตัวเลข → คำไทย (u64 เป็น BigInt — รองรับถึง 9,007,199,254,740,991)
number_to_thai_word(42n);              // "สี่สิบสอง"
number_to_thai_word(10_000_000_000n);  // "หนึ่งหมื่นล้าน"

// ข้อความบาท (baht เป็น BigInt)
number_to_baht_text(1234n, 50);
// "หนึ่งพันสองร้อยสามสิบสี่บาทห้าสิบสตางค์"

const r = parse_baht_text("หนึ่งร้อยบาทถ้วน");
if (r.valid) console.log(r.baht, r.satang);  // 100n  0

#include "kham.h"

// เลขไทย → ASCII (free ด้วย kham_string_free)
char *s = kham_thai_digits_to_ascii("ราคา ๑๒๓ บาท");
printf("%s\n", s);   // "ราคา 123 บาท"
kham_string_free(s);

// คำไทย → ตัวเลข
uint64_t n;
if (kham_thai_word_to_number("หนึ่งร้อยยี่สิบสาม", &n))
    printf("%llu\n", (unsigned long long)n);  // 123

// ตัวเลข → คำไทย (free ด้วย kham_string_free)
char *word = kham_number_to_thai_word(1000000);
printf("%s\n", word);   // "หนึ่งล้าน"
kham_string_free(word);

// ข้อความบาท (free ด้วย kham_string_free)
char *baht = kham_number_to_baht_text(1234, 50);
printf("%s\n", baht);
kham_string_free(baht);

// Parse บาท (free ด้วย kham_baht_amount_free)
KhamBahtAmount *amt = kham_parse_baht_text("หนึ่งร้อยบาทถ้วน");
if (amt) {
    printf("%llu baht %u satang\n",
           (unsigned long long)amt->baht, amt->satang);
    kham_baht_amount_free(amt);
}

import kham

# split_sentences() คืน list ของ Sentence(text, char_start, char_end)
text = "คุณชอบอาหารไทยไหม? ผมชอบต้มยำกุ้ง!\nอาหารไทยรสเผ็ด"
for i, s in enumerate(kham.split_sentences(text)):
    print(f"S{i}: {s.text!r}  chars={s.char_start}..{s.char_end}")

# ประกอบข้อความคืนจาก span:
reconstructed = "".join(s.text for s in kham.split_sentences(text))
assert reconstructed == text

import init, { split_sentences } from '/wasm/kham_wasm.js';
await init();

// split_sentences() คืน array ของ Sentence (text, char_start, char_end)
const text = "คุณชอบอาหารไทยไหม? ผมชอบต้มยำกุ้ง!\nอาหารไทยรสเผ็ด";
const sents = split_sentences(text);

for (const s of sents) {
  console.log(s.text, s.char_start, s.char_end);
}

// Slice string ด้วย char offset
// (ใช้ [...text] spread เพื่อให้ได้ Unicode scalar values)
const chars = [...text];
for (const s of sents) {
  console.log(chars.slice(s.char_start, s.char_end).join(''));
}

#include "kham.h"

// KhamSentence fields: text (char*), char_start, char_end (size_t)

const char *text = "คุณชอบอาหารไทยไหม? ผมชอบต้มยำกุ้ง!\nอาหารไทยรสเผ็ด";
KhamSentenceList *list = kham_split_sentences(text);

for (size_t i = 0; i < list->len; i++) {
    KhamSentence *s = &list->sentences[i];
    printf("S%zu: %s  (chars %zu..%zu)\n",
           i, s->text, s->char_start, s->char_end);
}
// S0: คุณชอบอาหารไทยไหม?  (chars 0..19)
// S1:  ผมชอบต้มยำกุ้ง!   (chars 19..36)
// S2: <newline>อาหารไทยรสเผ็ด  (chars 36..50)
kham_sentence_list_free(list);

import kham

# Thai soundex  (algo เริ่มต้น "lk82")
kham.soundex_word("กาน")              # "1600"  (lk82)
kham.soundex_word("กาน", "udom83")    # "1900"
kham.soundex_word("กาน", "metasound") # "112"

# เปรียบเทียบเสียง
kham.sounds_like("กาน", "ขาน")            # True  (กลุ่ม lk82 เดียวกัน)
kham.sounds_like("ลาน", "ราน", "udom83")  # False (ล/ร แยกกันใน udom83)

# Cross-language ไทย–อังกฤษ
kham.thai_english_soundex("Somchai")       # code เดียวกับ "สมชาย"
kham.sounds_like_cross_lang("สมชาย", "Somchai")   # True
kham.sounds_like_cross_lang("Robert",  "Rupert")   # True

import init, {
  soundex_word, sounds_like, thai_english_soundex, sounds_like_cross_lang,
} from '/wasm/kham_wasm.js';
await init();

// Thai soundex  (algo เริ่มต้น "lk82")
soundex_word("กาน");               // "1600"  (lk82)
soundex_word("กาน", "udom83");     // "1900"
soundex_word("กาน", "metasound");  // "112"

// เปรียบเทียบเสียง
sounds_like("กาน", "ขาน");             // true  (กลุ่ม lk82 เดียวกัน)
sounds_like("ลาน", "ราน", "udom83");   // false (ล/ร แยกกัน)

// Cross-language ไทย–อังกฤษ
thai_english_soundex("Somchai");        // code เดียวกับ "สมชาย"
sounds_like_cross_lang("สมชาย", "Somchai");   // true
sounds_like_cross_lang("Robert",  "Rupert");   // true

#include "kham.h"

// kham_soundex — algo: "lk82" (default/NULL), "udom83", "metasound"
// ผลลัพธ์ string ทั้งหมด free ด้วย kham_string_free

char *code = kham_soundex("กาน", NULL);       // "1600"  (lk82)
kham_string_free(code);
code = kham_soundex("กาน", "udom83");          // "1900"
kham_string_free(code);
code = kham_soundex("กาน", "metasound");       // "112"
kham_string_free(code);

// เปรียบเทียบเสียง (ไม่ allocate)
bool alike = kham_sounds_like("กาน", "ขาน", NULL);     // true  (lk82)
bool split = kham_sounds_like("ลาน", "ราน", "udom83"); // false

// Cross-language ไทย–อังกฤษ
char *eng = kham_thai_english_soundex("Somchai");
char *tha = kham_thai_english_soundex("สมชาย");
printf("match=%d\n", strcmp(eng, tha) == 0);  // 1
kham_string_free(eng);
kham_string_free(tha);

bool cross = kham_sounds_like_cross_lang("สมชาย", "Somchai");  // true

import kham

# spell_suggestions(word, max_n) → list[SpellSuggestion]
suggs = kham.spell_suggestions("กีนข้าว", 5)
for s in suggs:
    print(f"{s.word:12} edit={s.edit_distance} soundex={s.soundex_match} freq={s.freq_score}")
# กินข้าว  edit=1  soundex=True  freq=…

# field ของ SpellSuggestion:
# s.word          — str    คำ candidate
# s.edit_distance — int    Levenshtein distance (0–2)
# s.soundex_match — bool   lk82 code ตรงกัน
# s.freq_score    — int    TNC corpus frequency (0 ถ้าไม่มี)

# คำที่สะกดถูก → edit_distance 0
top = kham.spell_suggestions("กิน", 1)
assert top[0].word == "กิน" and top[0].edit_distance == 0

import init, { spell_suggestions } from '/wasm/kham_wasm.js';
await init();

// spell_suggestions(word, maxN) → SpellSuggestion[]
const suggs = spell_suggestions("กีนข้าว", 5);
for (const s of suggs) {
  console.log(s.word, 'edit:', s.edit_distance,
              'soundex:', s.soundex_match, 'freq:', s.freq_score);
}
// กินข้าว  edit: 1  soundex: true  freq: …

// property ของ SpellSuggestion:
// s.word          — string   คำ candidate
// s.edit_distance — number   Levenshtein distance (0–2)
// s.soundex_match — boolean  lk82 code ตรงกัน
// s.freq_score    — number   TNC corpus frequency

#include "kham.h"

// kham_spell_suggestions(word, max_n) → KhamSpellList*
// free ด้วย kham_spell_list_free()

KhamSpellList *list = kham_spell_suggestions("กีนข้าว", 5);
for (size_t i = 0; i < list->len; i++) {
    KhamSpellSuggestion *s = &list->suggestions[i];
    printf("%-12s  edit=%u  soundex=%d  freq=%u\n",
           s->word, s->edit_distance, s->soundex_match, s->freq_score);
}
kham_spell_list_free(list);

// field ของ KhamSpellSuggestion:
//   word          — char*    คำ candidate (heap-allocated)
//   edit_distance — uint8_t  Levenshtein distance (0–2)
//   soundex_match — bool     lk82 code ตรงกัน
//   freq_score    — uint32_t TNC corpus frequency

let extractor = KeyExtractor::builtin();
let text = "นักพัฒนาซอฟต์แวร์เขียนโค้ดทุกวัน นักพัฒนาซอฟต์แวร์ใช้ภาษาต่าง ๆ";
let phrases = extractor.extract_phrases(text, 5);
for p in &phrases {
    println!("{:20} score={:.4} count={}", p.word, p.score, p.count);
}

import kham

# extract_keywords(text, max_n) → list[Keyword]
text = ("นักวิทยาศาสตร์ค้นพบดาวเคราะห์ใหม่ในระบบสุริยะ "
        "ดาวดวงนี้โคจรอยู่ใกล้ดาวเคราะห์น้อย")

keywords = kham.extract_keywords(text, 5)
for kw in keywords:
    print(f"{kw.word:12} score={kw.score:.4f} count={kw.count}")

# field ของ Keyword:
# kw.word  — str    คำสำคัญ
# kw.score — float  relevance score (TF × IDF_proxy)
# kw.count — int    จำนวนครั้งที่ปรากฏ

import init, { extract_keywords } from '/wasm/kham_wasm.js';
await init();

// extract_keywords(text, maxN) → Keyword[]
const text = "นักวิทยาศาสตร์ค้นพบดาวเคราะห์ใหม่ในระบบสุริยะ " +
             "ดาวดวงนี้โคจรอยู่ใกล้ดาวเคราะห์น้อย";

const keywords = extract_keywords(text, 5);
for (const kw of keywords) {
  console.log(kw.word, 'score:', kw.score.toFixed(4), 'count:', kw.count);
}

// property ของ Keyword:
// kw.word  — string  คำสำคัญ
// kw.score — number  relevance score (TF × IDF_proxy)
// kw.count — number  จำนวนครั้งที่ปรากฏ

#include "kham.h"

// kham_keywords(text, max_n) → KhamKeywordList*
// free ด้วย kham_keyword_list_free()

const char *text =
    "นักวิทยาศาสตร์ค้นพบดาวเคราะห์ใหม่ในระบบสุริยะ "
    "ดาวดวงนี้โคจรอยู่ใกล้ดาวเคราะห์น้อย";

KhamKeywordList *list = kham_keywords(text, 5);
for (size_t i = 0; i < list->len; i++) {
    KhamKeyword *kw = &list->keywords[i];
    printf("%-12s  score=%.4f  count=%zu\n",
           kw->word, kw->score, kw->count);
}
kham_keyword_list_free(list);

// field ของ KhamKeyword:
//   word  — char*   คำสำคัญ (heap-allocated)
//   score — float   TF × IDF_proxy relevance score
//   count — size_t  จำนวนครั้งที่ปรากฏ