speechready 0.0.1 → 0.1.0

package/dist/verbalize/numbers_en.js

@@ -0,0 +1,83 @@
+/** English number words: cardinals, ordinals, years, digit strings. */
+import { divmod, rpartition } from "../util.js";
+const ONES = [
+    "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
+    "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen",
+];
+const TENS = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"];
+const SCALES = [[1e9, "billion"], [1e6, "million"], [1e3, "thousand"], [100, "hundred"]];
+const ORDINAL_IRREGULAR = {
+    one: "first", two: "second", three: "third", five: "fifth", eight: "eighth", nine: "ninth", twelve: "twelfth",
+};
+export function cardinal(n) {
+    if (n < 0)
+        return "minus " + cardinal(-n);
+    if (n < 20)
+        return ONES[n];
+    if (n < 100) {
+        const [tens, ones] = divmod(n, 10);
+        return TENS[tens] + (ones ? "-" + ONES[ones] : "");
+    }
+    for (const [value, name] of SCALES) {
+        if (n >= value) {
+            const [head, rest] = divmod(n, value);
+            let words = cardinal(head) + " " + name;
+            if (rest)
+                words += " " + cardinal(rest);
+            return words;
+        }
+    }
+    return String(n);
+}
+export function ordinal(n) {
+    const words = cardinal(n);
+    let [head, sep, last] = words.includes(" ") ? rpartition(words, " ") : ["", "", words];
+    if (last.includes("-")) {
+        const [tens, , ones] = rpartition(last, "-");
+        last = tens + "-" + ordinalWord(ones);
+    }
+    else {
+        last = ordinalWord(last);
+    }
+    return head + sep + last;
+}
+function ordinalWord(word) {
+    if (word in ORDINAL_IRREGULAR)
+        return ORDINAL_IRREGULAR[word];
+    if (word.endsWith("y"))
+        return word.slice(0, -1) + "ieth";
+    return word + "th";
+}
+/** Spoken year: 1999 -> nineteen ninety-nine, 2005 -> two thousand five, 2026 -> twenty twenty-six. */
+export function year(n) {
+    if (n < 1000 || n > 9999)
+        return cardinal(n);
+    const [high, low] = divmod(n, 100);
+    if (low === 0) {
+        if (high % 10 === 0)
+            return cardinal(n); // 2000, 3000
+        return cardinal(high) + " hundred"; // 1900, 2100
+    }
+    if (n >= 2000 && n <= 2009)
+        return "two thousand " + cardinal(low);
+    if (low < 10)
+        return cardinal(high) + " oh " + cardinal(low); // 1905 -> nineteen oh five
+    return cardinal(high) + " " + cardinal(low);
+}
+/** Each digit as a word; non-digits pass through as their spoken form where known. */
+export function digits(s) {
+    const out = [];
+    for (const ch of s) {
+        if (/\d/.test(ch))
+            out.push(ONES[parseInt(ch, 10)]);
+        else if (ch === "+")
+            out.push("plus");
+    }
+    return out.join(" ");
+}
+export function decimal(whole, frac) {
+    let text = cardinal(parseInt(whole.replace(/,/g, ""), 10));
+    if (frac)
+        text += " point " + Array.from(frac).map((c) => ONES[parseInt(c, 10)]).join(" ");
+    return text;
+}

package/dist/verbalize/numbers_tr.d.ts

@@ -0,0 +1,24 @@
+/** Turkish number words and suffix helpers (vowel harmony, consonant softening). */
+export declare function cardinal(n: number): string;
+export declare function lastVowel(word: string): string;
+/** Four-way harmony vowel (ı i u ü) for the last vowel of `word`. */
+export declare function harmonyI(word: string): string;
+/** Two-way harmony vowel (a e). */
+export declare function harmonyA(word: string): string;
+/** Final consonant softening before a vowel-initial suffix: dört -> dörd, çeyrek -> çeyreğ. */
+export declare function soften(word: string): string;
+/** Join a spoken word and the suffix the writer attached to the numeral or abbreviation.
+ *
+ * The writer harmonised the suffix against what they wrote (3'te -> üçte works
+ * as is), but a buffer consonant may be wrong for the spoken word: yarım + sı
+ * -> yarımı, kilometre + i -> kilometreyi.
+ */
+export declare function attach(word: string, suffix: string): string;
+/** Re-harmonise a suffix written against an abbreviation (TL'ye, 1/4'ü) for the spoken word (liraya, çeyreği). */
+export declare function reharmonize(word: string, suffix: string): string;
+/** üçüncü, dördüncü, yirmi birinci. */
+export declare function ordinal(n: number): string;
+/** üç -> üçte, dört -> dörtte, on -> onda, beş -> beşte. */
+export declare function locative(word: string): string;
+export declare function digits(s: string): string;
+export declare function decimal(whole: string, frac: string | null | undefined): string;

package/dist/verbalize/numbers_tr.js

@@ -0,0 +1,134 @@
+/** Turkish number words and suffix helpers (vowel harmony, consonant softening). */
+import { divmod, rpartition } from "../util.js";
+const ONES = ["sıfır", "bir", "iki", "üç", "dört", "beş", "altı", "yedi", "sekiz", "dokuz"];
+const TENS = ["", "on", "yirmi", "otuz", "kırk", "elli", "altmış", "yetmiş", "seksen", "doksan"];
+const SCALES = [[1e9, "milyar"], [1e6, "milyon"], [1e3, "bin"]];
+const VOWELS = "aeıioöuü";
+const BACK = new Set("aıou");
+const ROUND = new Set("oöuü");
+const VOICELESS = new Set("çfhkpsşt");
+export function cardinal(n) {
+    if (n < 0)
+        return "eksi " + cardinal(-n);
+    if (n === 0)
+        return "sıfır";
+    const parts = [];
+    let rest = n;
+    for (const [value, name] of SCALES) {
+        if (rest >= value) {
+            const [head, r] = divmod(rest, value);
+            rest = r;
+            parts.push(head === 1 && value === 1000 ? name : `${cardinal(head)} ${name}`);
+        }
+    }
+    if (rest >= 100) {
+        const [head, r] = divmod(rest, 100);
+        rest = r;
+        parts.push(head === 1 ? "yüz" : `${ONES[head]} yüz`);
+    }
+    if (rest >= 10) {
+        const [head, r] = divmod(rest, 10);
+        rest = r;
+        parts.push(TENS[head]);
+    }
+    if (rest > 0)
+        parts.push(ONES[rest]);
+    return parts.join(" ");
+}
+export function lastVowel(word) {
+    const lower = Array.from(word.toLowerCase());
+    for (let i = lower.length - 1; i >= 0; i--) {
+        if (VOWELS.includes(lower[i]))
+            return lower[i];
+    }
+    return "e";
+}
+/** Four-way harmony vowel (ı i u ü) for the last vowel of `word`. */
+export function harmonyI(word) {
+    const v = lastVowel(word);
+    if (BACK.has(v))
+        return ROUND.has(v) ? "u" : "ı";
+    return ROUND.has(v) ? "ü" : "i";
+}
+/** Two-way harmony vowel (a e). */
+export function harmonyA(word) {
+    return BACK.has(lastVowel(word)) ? "a" : "e";
+}
+function vowelCount(word) {
+    let n = 0;
+    for (const ch of word)
+        if (VOWELS.includes(ch))
+            n++;
+    return n;
+}
+/** Final consonant softening before a vowel-initial suffix: dört -> dörd, çeyrek -> çeyreğ. */
+export function soften(word) {
+    if (word.endsWith("dört"))
+        return word.slice(0, -1) + "d";
+    if (word.endsWith("k") && vowelCount(word) >= 2)
+        return word.slice(0, -1) + "ğ";
+    return word;
+}
+/** Join a spoken word and the suffix the writer attached to the numeral or abbreviation.
+ *
+ * The writer harmonised the suffix against what they wrote (3'te -> üçte works
+ * as is), but a buffer consonant may be wrong for the spoken word: yarım + sı
+ * -> yarımı, kilometre + i -> kilometreyi.
+ */
+export function attach(word, suffix) {
+    if (!suffix)
+        return word;
+    let w = word;
+    let s = suffix;
+    const endsInVowel = VOWELS.includes(w[w.length - 1]);
+    if ("sy".includes(s[0]) && s.length > 1 && VOWELS.includes(s[1]) && !endsInVowel) {
+        s = s.slice(1); // drop the buffer consonant after a consonant
+    }
+    else if (VOWELS.includes(s[0]) && endsInVowel) {
+        s = "y" + s; // insert a buffer consonant between two vowels
+    }
+    if (VOWELS.includes(s[0]))
+        w = soften(w);
+    return w + s;
+}
+/** Re-harmonise a suffix written against an abbreviation (TL'ye, 1/4'ü) for the spoken word (liraya, çeyreği). */
+export function reharmonize(word, suffix) {
+    if (!suffix)
+        return suffix;
+    const two = harmonyA(word);
+    const four = harmonyI(word);
+    return Array.from(suffix).map((ch) => ("ae".includes(ch) ? two : "ıiuü".includes(ch) ? four : ch)).join("");
+}
+/** üçüncü, dördüncü, yirmi birinci. */
+export function ordinal(n) {
+    const words = cardinal(n);
+    let [head, , last] = rpartition(words, " ");
+    const v = harmonyI(last);
+    if (VOWELS.includes(last[last.length - 1]))
+        last = last + "nc" + v;
+    else
+        last = soften(last) + v + "nc" + v;
+    return (head ? head + " " : "") + last;
+}
+/** üç -> üçte, dört -> dörtte, on -> onda, beş -> beşte. */
+export function locative(word) {
+    const a = harmonyA(word);
+    const consonant = VOICELESS.has(word[word.length - 1]) ? "t" : "d";
+    return word + consonant + a;
+}
+export function digits(s) {
+    const out = [];
+    for (const ch of s) {
+        if (/\d/.test(ch))
+            out.push(ONES[parseInt(ch, 10)]);
+        else if (ch === "+")
+            out.push("artı");
+    }
+    return out.join(" ");
+}
+export function decimal(whole, frac) {
+    let text = cardinal(parseInt(whole.replace(/\./g, ""), 10));
+    if (frac)
+        text += " virgül " + (frac.startsWith("0") ? digits(frac) : cardinal(parseInt(frac, 10)));
+    return text;
+}

package/dist/verbalize/tr.d.ts

@@ -0,0 +1,9 @@
+/** Turkish verbalization rules, in the order they run.
+ *
+ * Turkish text carries case and possessive suffixes on numerals with an
+ * apostrophe (3'te, 1990'da, %50'si) and uses a dot for thousands and a comma
+ * for decimals. Foreign TTS models get all of these wrong, so they are the
+ * first things this module rewrites.
+ */
+import { Rule } from "./index.js";
+export declare const RULES: Rule[];

package/dist/verbalize/tr.js

@@ -0,0 +1,204 @@
+/** Turkish verbalization rules, in the order they run.
+ *
+ * Turkish text carries case and possessive suffixes on numerals with an
+ * apostrophe (3'te, 1990'da, %50'si) and uses a dot for thousands and a comma
+ * for decimals. Foreign TTS models get all of these wrong, so they are the
+ * first things this module rewrites.
+ */
+import { B, W, escapeRe, findall, fullmatch, group, isDigit, partition, re } from "../util.js";
+import { option, registerRules, rule } from "./index.js";
+import { attach, cardinal, decimal, digits, locative, ordinal, reharmonize } from "./numbers_tr.js";
+const MONTHS = ["Ocak", "Şubat", "Mart", "Nisan", "Mayıs", "Haziran", "Temmuz", "Ağustos", "Eylül", "Ekim", "Kasım", "Aralık"];
+const APOS = "['’]";
+const LOWER = "a-zçğıöşü";
+const UPPER = "A-ZÇĞİÖŞÜ";
+// English letter names as Turkish speakers say them, for foreign tech acronyms (npm, css, sql).
+const EN_LETTERS = Object.fromEntries(Array.from("abcdefghijklmnopqrstuvwxyz").map((ch, i) => [ch, ["ey", "bi", "si", "di", "i", "ef", "ci", "eyç", "ay", "cey", "key", "el", "em", "en", "o", "pi", "kyu", "ar", "es", "ti", "yu", "vi", "dabılyu", "eks", "vay", "zi"][i]]));
+const UNIT_ABBREVIATIONS = new Set(["km", "kg", "cm", "mm", "mg", "ml", "lt", "sn", "dk", "hz", "gr", "kw", "mb", "gb", "kb", "tb", "ms", "vb", "vs", "bkz", "yy", "tl", "krş", "tr", "st", "nr", "sk", "mh", "cd", "pk"]);
+function foreignAcronym(m) {
+    const word = m[0];
+    if (!option("foreign_acronyms", true) || UNIT_ABBREVIATIONS.has(word))
+        return null;
+    return Array.from(word).map((ch) => EN_LETTERS[ch]).join(" ");
+}
+const int = (s) => parseInt(s ?? "", 10);
+function dateWords(y, m, d, suffix = "") {
+    if (!(m >= 1 && m <= 12 && d >= 1 && d <= 31))
+        return null;
+    let yy = y;
+    if (yy < 100)
+        yy += yy < 70 ? 2000 : 1900;
+    return `${cardinal(d)} ${MONTHS[m - 1]} ${attach(cardinal(yy), suffix)}`;
+}
+const dateDmy = (m) => dateWords(int(m[3]), int(m[2]), int(m[1]), group(m, 4) ?? "");
+const dateIso = (m) => dateWords(int(m[1]), int(m[2]), int(m[3]), group(m, 4) ?? "");
+/** How Turkish speakers say one group of a phone number: 0532 -> sıfır beş yüz otuz iki, 00 -> sıfır sıfır, 45 -> kırk beş. */
+function groupWords(groupText) {
+    const words = [];
+    let g = groupText;
+    if (g.startsWith("+")) {
+        words.push("artı");
+        g = g.slice(1);
+    }
+    const stripped = g.replace(/^0+/, "");
+    for (let i = 0; i < g.length - stripped.length; i++)
+        words.push("sıfır");
+    if (stripped)
+        words.push(cardinal(parseInt(stripped, 10)));
+    return words.join(" ");
+}
+function digitGroups(m) {
+    const raw = m[1];
+    const suffix = group(m, 2) ?? "";
+    const count = (raw.match(/\d/g) ?? []).length;
+    if (count < 7 || count > 16)
+        return null;
+    const groups = raw.split(/[\s.\-()]+/u).filter((g) => g);
+    const spoken = groups.map(groupWords);
+    spoken[spoken.length - 1] = attach(spoken[spoken.length - 1], suffix);
+    return spoken.join(", ");
+}
+function timeWords(hh, mm) {
+    const h = parseInt(hh, 10);
+    const minute = parseInt(mm, 10);
+    const hour = cardinal(h);
+    if (minute === 0)
+        return `${hour} sıfır sıfır`;
+    return `${hour} ${mm[0] !== "0" ? cardinal(minute) : "sıfır " + cardinal(minute)}`;
+}
+const time = (m) => attach(timeWords(m[1], m[2]), group(m, 3) ?? "");
+const timeRange = (m) => `${timeWords(m[1], m[2])} ile ${timeWords(m[3], m[4])}`;
+const CURRENCY = {
+    "₺": ["lira", "kuruş"], TL: ["lira", "kuruş"], TRY: ["lira", "kuruş"],
+    $: ["dolar", "sent"], USD: ["dolar", "sent"],
+    "€": ["avro", "sent"], EUR: ["avro", "sent"],
+    "£": ["sterlin", "peni"], GBP: ["sterlin", "peni"],
+};
+function currencyPostfix(m) {
+    const [whole, , frac] = partition(m[1], ",");
+    const scale = group(m, 2) ? ` ${m[2]}` : "";
+    const [unitWord] = CURRENCY[m[3]];
+    return `${decimal(whole, frac || null)}${scale} ${attach(unitWord, reharmonize(unitWord, group(m, 4) ?? ""))}`;
+}
+function money(symbol, whole, frac, suffix = "") {
+    const [unitWord, subWord] = CURRENCY[symbol];
+    const amount = cardinal(parseInt(whole.replace(/\./g, ""), 10));
+    if (frac) {
+        const cents = parseInt(frac.padEnd(2, "0").slice(0, 2), 10);
+        if (cents)
+            return `${amount} ${unitWord} ${cardinal(cents)} ${attach(subWord, reharmonize(subWord, suffix))}`;
+    }
+    return `${amount} ${attach(unitWord, reharmonize(unitWord, suffix))}`;
+}
+const currencyPrefix = (m) => money(m[1], m[2], group(m, 3), group(m, 4) ?? "");
+const currencySuffix = (m) => money(m[3].toUpperCase(), m[1], group(m, 2), group(m, 4) ?? "");
+function percent(m) {
+    const number = group(m, 1) ?? group(m, 3) ?? "";
+    const suffix = group(m, 2) ?? group(m, 4) ?? "";
+    const [whole, , frac] = partition(number, ",");
+    const words = decimal(whole, frac || null);
+    return "yüzde " + attach(words, suffix);
+}
+const UNITS = {
+    "km/sa": "kilometre", "km/s": "kilometre", km: "kilometre", cm: "santimetre", mm: "milimetre",
+    kg: "kilogram", mg: "miligram", GB: "gigabayt", MB: "megabayt", KB: "kilobayt", TB: "terabayt",
+    ms: "milisaniye", sn: "saniye", dk: "dakika", sa: "saat", "°C": "derece", "°": "derece",
+};
+const UNIT_ALTERNATION = Object.keys(UNITS).sort((a, b) => b.length - a.length).map(escapeRe).join("|");
+function unit(m) {
+    const number = m[1];
+    const u = m[2];
+    const suffix = group(m, 3) ?? "";
+    const word = UNITS[u];
+    if (u === "km/sa" || u === "km/s")
+        return `saatte ${number} ${attach(word, reharmonize(word, suffix))}`;
+    return `${number} ${attach(word, reharmonize(word, suffix))}`;
+}
+const FRACTION_NAMES = { "1/2": "yarım", "1/4": "çeyrek" };
+function fraction(m) {
+    const num = parseInt(m[1], 10);
+    const den = parseInt(m[2], 10);
+    const suffix = group(m, 3) ?? "";
+    if (num >= den)
+        return null;
+    if (option("fractions", "spoken") === "division")
+        return `${cardinal(num)} bölü ${attach(cardinal(den), suffix)}`;
+    const named = FRACTION_NAMES[`${num}/${den}`];
+    if (named)
+        return attach(named, reharmonize(named, suffix));
+    return `${locative(cardinal(den))} ${attach(cardinal(num), suffix)}`;
+}
+function range(m) {
+    const a = m[1];
+    const b = m[2];
+    if (a.length > 4 || b.length > 4)
+        return null;
+    return `${a} ila ${b}`;
+}
+const thousands = (m) => attach(decimal(m[1], group(m, 2)), group(m, 3) ?? "");
+const decimalComma = (m) => attach(decimal(m[1], m[2]), group(m, 3) ?? "");
+const ORDINAL_SUFFIX = re("(?:[ıiuü]nc[ıiuü]|nc[ıiuü])");
+function suffixedNumber(m) {
+    const n = parseInt(m[1], 10);
+    const suffix = m[2];
+    if (fullmatch(ORDINAL_SUFFIX, suffix))
+        return ordinal(n);
+    return attach(cardinal(n), suffix);
+}
+const ordinalDot = (m) => ordinal(parseInt(m[1], 10));
+const ABBREVIATIONS = {
+    vb: "ve benzeri", vs: "vesaire", vd: "ve diğerleri", örn: "örneğin", bkz: "bakınız",
+    Dr: "Doktor", Prof: "Profesör", Doç: "Doçent", Av: "Avukat", Sn: "Sayın",
+    No: "numara", no: "numara", Tel: "telefon", tel: "telefon", yy: "yüzyıl",
+    Cad: "Caddesi", Sok: "Sokak", Mah: "Mahallesi", Apt: "Apartmanı", Bul: "Bulvarı",
+    "T.C": "Türkiye Cumhuriyeti", Ltd: "Limited", Şti: "Şirketi", "A.Ş": "Anonim Şirketi",
+    Üniv: "Üniversitesi", Fak: "Fakültesi", Böl: "Bölümü", Hst: "Hastanesi", Müh: "Mühendisi",
+    Alb: "Albay", Yzb: "Yüzbaşı", Bşk: "Başkanı", Yrd: "Yardımcı", Uzm: "Uzman", Öğr: "Öğretim",
+};
+const ABBR_ALTERNATION = Object.keys(ABBREVIATIONS).sort((a, b) => b.length - a.length).map(escapeRe).join("|");
+const abbreviation = (m) => ABBREVIATIONS[m[1]];
+const VOWELS_UP = new Set("AEIİOÖUÜ");
+const RUNS = re(`[${UPPER}]+|\\d+`);
+function alnum(m) {
+    const token = m[0];
+    if (token.replace(/-/g, "").length < 4)
+        return null;
+    const runs = findall(RUNS, token);
+    const out = [];
+    for (const run of runs) {
+        if (isDigit(run))
+            out.push(runs.length === 2 && run.length <= 2 ? cardinal(parseInt(run, 10)) : digits(run));
+        else if (run.length >= 3 && Array.from(run).some((c) => VOWELS_UP.has(c)))
+            out.push(run);
+        else
+            out.push(Array.from(run).join(" "));
+    }
+    return out.join(" ");
+}
+const SEP = String.raw `(?:[ \-]|\.(?!\s))`;
+const SUFFIX = `(?:${APOS}([${LOWER}]+))?`;
+export const RULES = [
+    rule("verbalize.abbreviation", re(String.raw `(?<![${W}.])(${ABBR_ALTERNATION})\.(?![${LOWER}${UPPER}])`), abbreviation, "abbreviation read in full"),
+    rule("verbalize.date.dmy", re(String.raw `${B}(\d{1,2})[./](\d{1,2})[./](\d{4}|\d{2})${B}${SUFFIX}`), dateDmy, "date read as day, month name, year"),
+    rule("verbalize.date.iso", re(String.raw `${B}(\d{4})-(\d{2})-(\d{2})${B}${SUFFIX}`), dateIso, "ISO date read as day, month name, year"),
+    rule("verbalize.phone", re(String.raw `(?<![${W}.])((?:\+?\d{1,3}${SEP})?(?:\(\d{2,4}\)[ \-]?|\d{2,4}${SEP})(?:\d{2,4}${SEP}){1,4}\d{2,4})${SUFFIX}(?![${W}\-]|[.,]\d)`), digitGroups, "digit groups read digit by digit with a pause between groups"),
+    rule("verbalize.number_sign", re(String.raw `#(?=\d)`), () => "numara ", "number sign read as a word"),
+    rule("verbalize.acronym.foreign", re(String.raw `(?<![${W}'’.])[bcdfghjklmnpqrstvwxyz]{2,5}(?![${W}'’])`), foreignAcronym, "lowercase foreign acronym read with English letter names"),
+    rule("verbalize.digits.long", re(String.raw `(?<![${W}.,])\d{7,}(?![${W}]|[.,]\d)`), (m) => digits(m[0]), "long digit string read digit by digit"),
+    rule("verbalize.time.range", re(String.raw `${B}([01]?\d|2[0-3]):([0-5]\d)\s?[-–]\s?([01]?\d|2[0-3]):([0-5]\d)${B}`), timeRange, "time range read with 'ile'"),
+    rule("verbalize.time", re(String.raw `${B}([01]?\d|2[0-3]):([0-5]\d)${B}(?!:)${SUFFIX}`), time, "clock time read as hours and minutes"),
+    rule("verbalize.currency.postfix", re(String.raw `(?<![${W}.,])(\d+(?:,\d+)?)\s?(bin|milyon|milyar)?\s?([₺$€£])${SUFFIX}(?![${W}])`), currencyPostfix, "currency symbol after the amount read as words"),
+    rule("verbalize.currency", re(String.raw `([₺$€£])\s?(\d{1,3}(?:\.\d{3})*|\d+)(?:,(\d{1,2}))?${SUFFIX}(?![${W}]|[.,]\d)`), currencyPrefix, "currency amount read as words"),
+    rule("verbalize.currency.code", re(String.raw `(?<![${W}.,])(\d{1,3}(?:\.\d{3})*|\d+)(?:,(\d{1,2}))?\s?(TL|TRY|USD|EUR|GBP)${B}${SUFFIX}`), currencySuffix, "currency code read as words"),
+    rule("verbalize.percent", re(String.raw `%\s?(\d+(?:,\d+)?)${SUFFIX}|(?<![${W}.])(\d+(?:,\d+)?)\s?%${SUFFIX}`), percent, "percent read as 'yüzde'"),
+    rule("verbalize.unit", re(String.raw `(?<![${W}.,])(\d+(?:,\d+)?)\s?(${UNIT_ALTERNATION})${SUFFIX}(?![${W}/])`), unit, "unit abbreviation read as a word"),
+    rule("verbalize.fraction", re(String.raw `(?<![\d/])([1-9])/([2-9]|10)${SUFFIX}(?![\d/])`), fraction, "fraction read as words"),
+    rule("verbalize.range", re(String.raw `(?<![${W}.,\-/:])(\d+)\s?[-–]\s?(\d+)(?![${W}\-/:]|[.,]\d)`), range, "number range read with 'ila'"),
+    rule("verbalize.thousands", re(String.raw `(?<![${W}.,])(\d{1,3}(?:\.\d{3})+)(?:,(\d+))?${SUFFIX}(?![${W}]|[.,]\d)`), thousands, "dotted thousands read as a number, not a decimal"),
+    rule("verbalize.decimal", re(String.raw `(?<![${W}.,])(\d+),(\d+)${SUFFIX}(?![${W}]|[.,]\d)`), decimalComma, "decimal comma read as 'virgül'"),
+    rule("verbalize.suffix", re(String.raw `${B}(\d+)${APOS}([${LOWER}]+)${B}`), suffixedNumber, "numeral with a suffix read as one word"),
+    rule("verbalize.ordinal", re(String.raw `${B}(\d{1,3})\.(?=\s+[${LOWER}])`), ordinalDot, "numeral with a dot before a lowercase word read as an ordinal"),
+    rule("verbalize.minus", re(String.raw `(?<![${W}.)\-–])[-–](?=\d)`), () => "eksi ", "leading minus read as a word"),
+    rule("verbalize.alnum", re(String.raw `${B}(?=[${UPPER}0-9-]*\d)(?=[${UPPER}0-9-]*[${UPPER}])[${UPPER}0-9]+(?:-[${UPPER}0-9]+)*${B}`), alnum, "identifier spelled out"),
+];
+registerRules("tr", RULES);

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "0.1.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+// Generated by scripts/build-profiles.mjs from package.json. Do not edit.
+export const version = "0.1.0";

package/package.json

@@ -1,11 +1,31 @@
 {
   "name": "speechready",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Prepare text for text-to-speech: clean LLM output, verbalize ambiguous tokens, compile pauses to each provider's syntax, chunk under model limits.",
-  "main": "index.js",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
   "license": "MIT",
   "author": "Berker Batur",
-  "repository": { "type": "git", "url": "https://github.com/berkerbatur/speechready" },
+  "repository": { "type": "git", "url": "https://github.com/berkerbatur/speechready", "directory": "js" },
+  "homepage": "https://github.com/berkerbatur/speechready",
   "keywords": ["tts", "text-to-speech", "text-normalization", "ssml", "voice-agents"],
-  "files": ["index.js", "README.md", "LICENSE"]
+  "files": ["dist", "README.md", "LICENSE"],
+  "engines": { "node": ">=20" },
+  "scripts": {
+    "build": "node scripts/build-profiles.mjs && tsc -p tsconfig.json",
+    "test": "npm run build && node --test test/spec.test.mjs test/package.test.mjs",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "typescript": "^5.6.3",
+    "yaml": "^2.6.1"
+  }
 }

package/index.js

@@ -1,2 +0,0 @@
-// speechready: prepare text for text-to-speech. Placeholder release; the first working version follows.
-module.exports = { version: "0.0.1" };