hebrew-transliteration 2.1.2 → 2.2.1

package/dist/rules.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordRules = exports.sylRules = void 0;
+const cluster_1 = require("havarotjs/dist/cluster");
+const regularExpressions_1 = require("havarotjs/dist/utils/regularExpressions");
+const mapChars_1 = require("./mapChars");
+const taamim = /[\u{0590}-\u{05AF}\u{05BD}\u{05BF}]/u;
+const changeElementSplit = (input, split, join) => input.split(split).join(join);
+const consonantFeatures = (clusterText, syl, cluster, schema) => {
+    var _a;
+    if ((_a = schema.ADDITIONAL_FEATURES) === null || _a === void 0 ? void 0 : _a.length) {
+        const clusterSeqs = schema.ADDITIONAL_FEATURES.filter((s) => s.FEATURE === "cluster");
+        for (const seq of clusterSeqs) {
+            const heb = new RegExp(seq.HEBREW, "u");
+            if (heb.test(clusterText)) {
+                const sylSeq = changeElementSplit(clusterText, heb, seq.TRANSLITERATION);
+                return [...sylSeq].map((char) => (0, mapChars_1.mapChars)(char, schema)).join("");
+            }
+        }
+    }
+    clusterText = cluster.hasShewa && syl.isClosed ? clusterText.replace(/\u{05B0}/u, "") : clusterText;
+    // mappiq he
+    if (/ה\u{05BC}$/mu.test(clusterText)) {
+        return changeElementSplit(clusterText, /ה\u{05BC}/u, schema.HE);
+    }
+    if (syl.isFinal && !syl.isClosed) {
+        const furtiveChet = /\u{05D7}\u{05B7}$/mu;
+        if (furtiveChet.test(clusterText)) {
+            return changeElementSplit(clusterText, furtiveChet, "\u{05B7}\u{05D7}");
+        }
+        const furtiveAyin = /\u{05E2}\u{05B7}$/mu;
+        if (furtiveAyin.test(clusterText)) {
+            return changeElementSplit(clusterText, furtiveAyin, "\u{05B7}\u{05E2}");
+        }
+        const furtiveHe = /\u{05D4}\u{05BC}\u{05B7}$/mu;
+        if (furtiveHe.test(clusterText)) {
+            return changeElementSplit(clusterText, furtiveHe, "\u{05B7}\u{05D4}\u{05BC}");
+        }
+    }
+    // dagesh chazaq
+    const prevHasVowel = cluster.prev instanceof cluster_1.Cluster ? cluster.prev.hasVowel : false;
+    const isDoubled = schema.DAGESH_CHAZAQ && prevHasVowel && /\u{05BC}/u.test(clusterText);
+    if (schema.BET_DAGESH && /ב\u{05BC}/u.test(clusterText)) {
+        return changeElementSplit(clusterText, /ב\u{05BC}/u, schema.BET_DAGESH.repeat(isDoubled ? 2 : 1));
+    }
+    if (schema.GIMEL_DAGESH && /ג\u{05BC}/u.test(clusterText)) {
+        return changeElementSplit(clusterText, /ג\u{05BC}/u, schema.GIMEL_DAGESH.repeat(isDoubled ? 2 : 1));
+    }
+    if (schema.DALET_DAGESH && /ד\u{05BC}/u.test(clusterText)) {
+        return changeElementSplit(clusterText, /ד\u{05BC}/u, schema.DALET_DAGESH.repeat(isDoubled ? 2 : 1));
+    }
+    if (schema.KAF_DAGESH && /כ\u{05BC}/u.test(clusterText)) {
+        return changeElementSplit(clusterText, /כ\u{05BC}/u, schema.KAF_DAGESH.repeat(isDoubled ? 2 : 1));
+    }
+    if (schema.KAF_DAGESH && /ך\u{05BC}/u.test(clusterText)) {
+        return changeElementSplit(clusterText, /ך\u{05BC}/u, schema.KAF_DAGESH.repeat(isDoubled ? 2 : 1));
+    }
+    if (schema.PE_DAGESH && /פ\u{05BC}/u.test(clusterText)) {
+        return changeElementSplit(clusterText, /פ\u{05BC}/u, schema.PE_DAGESH.repeat(isDoubled ? 2 : 1));
+    }
+    if (schema.TAV_DAGESH && /ת\u{05BC}/u.test(clusterText)) {
+        return changeElementSplit(clusterText, /ת\u{05BC}/u, schema.TAV_DAGESH.repeat(isDoubled ? 2 : 1));
+    }
+    if (/ש\u{05C1}/u.test(clusterText)) {
+        return changeElementSplit(clusterText, /ש\u{05C1}/u, schema.SHIN.repeat(isDoubled ? 2 : 1));
+    }
+    if (/ש\u{05C2}/u.test(clusterText)) {
+        return changeElementSplit(clusterText, /ש\u{05C2}/u, schema.SIN.repeat(isDoubled ? 2 : 1));
+    }
+    if (isDoubled) {
+        const consonant = cluster.chars[0].text;
+        const consonantDagesh = new RegExp(consonant + "\u{05BC}", "u");
+        return changeElementSplit(clusterText, consonantDagesh, `${consonant + consonant}`);
+    }
+    if (cluster.isShureq) {
+        return schema.SHUREQ;
+    }
+    return clusterText;
+};
+const materFeatures = (syl, schema) => {
+    const mater = syl.clusters.filter((c) => c.isMater)[0];
+    const prev = mater.prev instanceof cluster_1.Cluster ? mater.prev : null;
+    const materText = mater.text;
+    const prevText = ((prev === null || prev === void 0 ? void 0 : prev.text) || "").replace(taamim, "");
+    // string comprised of all non-mater clusters in a syl with a mater
+    let noMaterText = syl.clusters
+        .filter((c) => !c.isMater)
+        .map((c) => consonantFeatures(c.text.replace(taamim, ""), syl, c, schema))
+        .join("");
+    // workaround for maqaf
+    const hasMaqaf = mater.text.includes("־");
+    noMaterText = hasMaqaf ? noMaterText.concat("־") : noMaterText;
+    if (/י/.test(materText)) {
+        // hiriq
+        if (/\u{05B4}/u.test(prevText)) {
+            return changeElementSplit(noMaterText, /\u{05B4}/u, schema.HIRIQ_YOD);
+        }
+        // tsere
+        if (/\u{05B5}/u.test(prevText)) {
+            return changeElementSplit(noMaterText, /\u{05B5}/u, schema.TSERE_YOD);
+        }
+        // segol
+        if (/\u{05B6}/u.test(prevText)) {
+            return changeElementSplit(noMaterText, /\u{05B6}/u, schema.SEGOL_YOD);
+        }
+    }
+    if (/ו/u.test(materText)) {
+        // holam
+        if (/\u{05B9}/u.test(prevText)) {
+            return changeElementSplit(noMaterText, /\u{05B9}/u, schema.HOLAM_VAV);
+        }
+    }
+    if (/ה/.test(materText)) {
+        // qamets
+        if (/\u{05B8}/u.test(prevText)) {
+            return changeElementSplit(noMaterText, /\u{05B8}/u, schema.QAMATS_HE);
+        }
+        // seghol
+        if (/\u{05B6}/u.test(prevText)) {
+            return changeElementSplit(noMaterText, /\u{05B6}/u, schema.SEGOL_HE);
+        }
+        // tsere
+        if (/\u{05B5}/u.test(prevText)) {
+            return changeElementSplit(noMaterText, /\u{05B5}/u, schema.SEGOL_HE);
+        }
+    }
+    return materText;
+};
+const joinChars = (isAccented, sylChars, schema) => {
+    if (!isAccented) {
+        return sylChars.map((char) => (0, mapChars_1.mapChars)(char, schema)).join("");
+    }
+    if (schema.STRESS_MARKER) {
+        const location = schema.STRESS_MARKER.location;
+        const mark = schema.STRESS_MARKER.mark;
+        if (location === "before-syllable") {
+            return `${mark}${sylChars.map((char) => (0, mapChars_1.mapChars)(char, schema)).join("")}`;
+        }
+        if (location === "after-syllable") {
+            return `${sylChars.map((char) => (0, mapChars_1.mapChars)(char, schema)).join("")}${mark}`;
+        }
+        const vowels = [
+            schema.PATAH,
+            schema.HATAF_PATAH,
+            schema.QAMATS,
+            schema.HATAF_QAMATS,
+            schema.SEGOL,
+            schema.HATAF_SEGOL,
+            schema.TSERE,
+            schema.HIRIQ,
+            schema.HOLAM,
+            schema.QAMATS_QATAN,
+            schema.QUBUTS,
+            schema.QAMATS_HE,
+            schema.SEGOL_HE,
+            schema.TSERE_HE,
+            schema.HIRIQ_YOD,
+            schema.TSERE_YOD,
+            schema.SEGOL_YOD,
+            schema.HOLAM_VAV,
+            schema.SHUREQ
+        ].sort((a, b) => b.length - a.length);
+        const vowelRgx = new RegExp(`${vowels.join("|")}`);
+        const str = sylChars.map((char) => (0, mapChars_1.mapChars)(char, schema)).join("");
+        const match = str.match(vowelRgx);
+        if (location === "before-vowel") {
+            return (match === null || match === void 0 ? void 0 : match.length) ? str.replace(match[0], `${mark}${match[0]}`) : str;
+        }
+        // after-vowel
+        return (match === null || match === void 0 ? void 0 : match.length) ? str.replace(match[0], `${match[0]}${mark}`) : str;
+    }
+    return sylChars.map((char) => (0, mapChars_1.mapChars)(char, schema)).join("");
+};
+const sylRules = (syl, schema) => {
+    var _a;
+    const sylTxt = syl.text.replace(taamim, "");
+    if ((_a = schema.ADDITIONAL_FEATURES) === null || _a === void 0 ? void 0 : _a.length) {
+        const sylSeqs = schema.ADDITIONAL_FEATURES.filter((s) => s.FEATURE === "syllable");
+        for (const seq of sylSeqs) {
+            const heb = new RegExp(seq.HEBREW, "u");
+            if (heb.test(sylTxt)) {
+                const wordSeq = changeElementSplit(sylTxt, heb, seq.TRANSLITERATION);
+                return joinChars(syl.isAccented, [...wordSeq], schema);
+            }
+        }
+    }
+    // syllable is 3ms sufx
+    const mSSuffix = /\u{05B8}\u{05D9}\u{05D5}/u;
+    if (syl.isFinal && mSSuffix.test(sylTxt)) {
+        const sufxSyl = changeElementSplit(sylTxt, mSSuffix, schema.MS_SUFX);
+        return joinChars(syl.isAccented, [...sufxSyl], schema);
+    }
+    // syllable has a mater
+    // unsure why eslint throwing error here, but not other places...
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-assignment
+    const hasMater = syl.clusters.map((c) => c.isMater).includes(true);
+    if (hasMater) {
+        const materSyl = materFeatures(syl, schema);
+        return joinChars(syl.isAccented, [...materSyl], schema);
+    }
+    // regular syllables
+    const returnTxt = syl.clusters.map((cluster) => {
+        const clusterText = cluster.text.replace(taamim, "");
+        return consonantFeatures(clusterText, syl, cluster, schema);
+    });
+    return joinChars(syl.isAccented, returnTxt, schema);
+};
+exports.sylRules = sylRules;
+/**
+ * formats the Divine Name with any Latin chars
+ *
+ * @param str word text
+ * @param schema
+ * @returns the Divine Name with any pre or proceding Latin chars
+ */
+const getDivineName = (str, schema) => {
+    const begn = str[0];
+    const end = str[str.length - 1];
+    return `${regularExpressions_1.hebChars.test(begn) ? "" : begn}${schema.DIVINE_NAME}${regularExpressions_1.hebChars.test(end) ? "" : end}`;
+};
+const wordRules = (word, schema) => {
+    var _a;
+    if (word.isDivineName)
+        return getDivineName(word.text, schema);
+    if (word.hasDivineName)
+        return `${(0, exports.sylRules)(word.syllables[0], schema)}-${getDivineName(word.text, schema)}`;
+    if (word.isNotHebrew)
+        return word.text;
+    if ((_a = schema.ADDITIONAL_FEATURES) === null || _a === void 0 ? void 0 : _a.length) {
+        const wordSeqs = schema.ADDITIONAL_FEATURES.filter((s) => s.FEATURE === "word");
+        for (const seq of wordSeqs) {
+            const heb = new RegExp(seq.HEBREW, "u");
+            const wordText = word.text.replace(taamim, "");
+            if (heb.test(wordText)) {
+                const wordSeq = changeElementSplit(wordText, heb, seq.TRANSLITERATION);
+                return [...wordSeq].map((char) => (0, mapChars_1.mapChars)(char, schema)).join("");
+            }
+        }
+    }
+    return word;
+};
+exports.wordRules = wordRules;

package/dist/schema.d.ts

@@ -0,0 +1,476 @@
+import { SylOpts } from "havarotjs/dist/text";
+/**
+ * class for defining a schema for transliteration
+ */
+export declare class Schema implements SylOpts {
+    /**
+     * HEBREW POINT SHEVA (U+05B0) ְ◌
+     * @example
+     * 'ǝ'
+     */
+    VOCAL_SHEVA: string;
+    /**
+     * HEBREW POINT HATAF SEGOL (U+05B1) ֱ◌
+     * @example
+     * 'ĕ'
+     */
+    HATAF_SEGOL: string;
+    /**
+     * HEBREW POINT HATAF PATAH (U+05B2) ֲ◌
+     * @example
+     * 'ă'
+     */
+    HATAF_PATAH: string;
+    /**
+     * HEBREW POINT HATAF QAMATS (U+05B3) ֳ◌
+     * @example
+     * 'ŏ'
+     */
+    HATAF_QAMATS: string;
+    /**
+     * HEBREW POINT HIRIQ (U+05B4) ִ◌
+     * @example
+     * 'i'
+     */
+    HIRIQ: string;
+    /**
+     * HEBREW POINT TSERE (U+05B5) ֵ◌
+     * @example
+     * 'ē'
+     */
+    TSERE: string;
+    /**
+     * HEBREW POINT SEGOL (U+05B6) ֶ◌
+     * @example
+     * 'e'
+     */
+    SEGOL: string;
+    /**
+     * HEBREW POINT PATAH (U+05B7) ַ◌
+     * @example
+     * 'a'
+     */
+    PATAH: string;
+    /**
+     * HEBREW POINT QAMATS (U+05B8) ָ◌
+     * @example
+     * 'ā'
+     */
+    QAMATS: string;
+    /**
+     * HEBREW POINT HOLAM (U+05B9) ֹ◌
+     * @example
+     * 'ō'
+     */
+    HOLAM: string;
+    /**
+     * HEBREW POINT QUBUTS (U+05BB) ֻ◌
+     * @example
+     * 'u'
+     */
+    QUBUTS: string;
+    /**
+     * HEBREW POINT DAGESH OR MAPIQ (U+05BC) ּ◌
+     * @description typically, this will be a blank string
+     * @example
+     * ''
+     */
+    DAGESH: string;
+    /**
+     * HEBREW POINT DAGESH OR MAPIQ (U+05BC) ּ◌
+     * @description if true, repeats the consonant with the dagesh
+     * @example
+     * ```js
+     * transliterate('שַׁבָּת', { DAGESH_CHAZAQ: true });
+     * // 'shabbat'
+     * ```
+     */
+    DAGESH_CHAZAQ: boolean;
+    /**
+     * HEBREW PUNCTUATION MAQAF (U+05BE) ־◌
+     * @example
+     * '-'
+     */
+    MAQAF: string;
+    /**
+     * HEBREW PUNCTUATION PASEQ (U+05C0) ׀ ◌
+     * @description if a blank string, two spaces will occur between words
+     * @example
+     * '|' or ''
+     * @example
+     * ```js
+     * transliterate('כְּשֶׁ֣בֶת ׀ הַמֶּ֣לֶךְ', { PASEQ: '' });
+     * // 'kǝšebet  hammelek'
+     * ```
+     */
+    PASEQ: string;
+    /**
+     * HEBREW PUNCTUATION SOF PASUQ (U+05C3) ׃◌
+     * @example
+     * '' or '.'
+     */
+    SOF_PASUQ: string;
+    /**
+     * HEBREW POINT QAMATS QATAN (U+05C7) ׇ◌
+     * @example
+     * 'o'
+     */
+    QAMATS_QATAN: string;
+    /**
+     * HEBREW POINT PATAH (U+05B7) ◌ַ
+     * @example
+     * 'a'
+     */
+    FURTIVE_PATAH: string;
+    /**
+     * HEBREW POINT HIRIQ (U+05B4) and YOD (U+05D9) י◌ִ
+     * @example
+     * 'î'
+     */
+    HIRIQ_YOD: string;
+    /**
+     * HEBREW POINT TSERE (U+05B5) and YOD (U+05D9) י◌ֵ
+     * @example
+     * 'ê'
+     */
+    TSERE_YOD: string;
+    /**
+     * HEBREW POINT SEGOL (U+05B6) and YOD (U+05D9) י◌ֶ
+     * @example
+     * 'ê'
+     */
+    SEGOL_YOD: string;
+    /**
+     * HEBREW LETTER VAV (U+05D5) and DAGESH (U+05BC) וּ
+     * @example
+     * 'û'
+     */
+    SHUREQ: string;
+    /**
+     * HEBREW LETTER HOLAM (U+05B9) and VAV (U+05D5) ֹו◌
+     * @example
+     * 'ô'
+     */
+    HOLAM_VAV: string;
+    /**
+     * HEBREW POINT QAMATS (U+05B8) and HE (U+05D4) ה◌ָ
+     * @example
+     * 'â'
+     */
+    QAMATS_HE: string;
+    /**
+     * HEBREW POINT SEGOL (U+05B6) and HE (U+05D4) ה◌ֶ
+     * @example
+     * 'ê'
+     */
+    SEGOL_HE: string;
+    /**
+     * HEBREW POINT TSERE (U+05B5) and HE (U+05D4) ה◌ֵ
+     * @example
+     * 'ê'
+     */
+    TSERE_HE: string;
+    /**
+     * HEBREW LETTER QAMATS (U+05B8) and YOD (U+05D9) and VAV (U+05D5) יו◌ָ
+     * @example
+     * 'āyw'
+     */
+    MS_SUFX: string;
+    /**
+     * HEBREW LETTER ALEF (U+05D0) א
+     * @example
+     * 'ʾ'
+     */
+    ALEF: string;
+    /**
+     * HEBREW LETTER BET (U+05D1) ב
+     * @example
+     * 'b' or 'v'
+     */
+    BET: string;
+    /**
+     * HEBREW LETTER BET (U+05D1) and DAGESH (U+05BC) ּב
+     * @description
+     * the letter bet with a dagesh kal
+     * @description
+     * use when need to distinguish between spirantized forms
+     * @example
+     * 'b'
+     */
+    BET_DAGESH?: string;
+    /**
+     * HEBREW LETTER GIMEL (U+05D2) ג
+     * @example
+     * 'g'
+     */
+    GIMEL: string;
+    /**
+     * HEBREW LETTER GIMEL (U+05D2) and DAGESH (U+05BC) גּ
+     * @description
+     * the letter gimel with a dagesh kal
+     * @description
+     * use when need to distinguish between spirantized forms
+     * @example
+     * 'g'
+     */
+    GIMEL_DAGESH?: string;
+    /**
+     * HEBREW LETTER DALET (U+05D3) ד
+     * @example
+     * 'd'
+     */
+    DALET: string;
+    /**
+     * HEBREW LETTER DALET (U+05D3) and DAGESH (U+05BC) דּ
+     * @description
+     * the letter dalet with a dagesh kal
+     * @description
+     * use when need to distinguish between spirantized forms
+     * @example
+     * 'd'
+     */
+    DALET_DAGESH?: string;
+    /**
+     * HEBREW LETTER HE (U+05D4) ה
+     * @example
+     * 'h'
+     */
+    HE: string;
+    /**
+     * HEBREW LETTER VAV (U+05D5) ו
+     * @example
+     * 'w'
+     */
+    VAV: string;
+    /**
+     * HEBREW LETTER ZAYIN (U+05D6) ז
+     * @example
+     * 'z'
+     */
+    ZAYIN: string;
+    /**
+     * HEBREW LETTER HET (U+05D7) ח
+     * @example
+     * 'ḥ'
+     */
+    HET: string;
+    /**
+     * HEBREW LETTER TET (U+05D8) ט
+     * @example
+     * 'ṭ'
+     */
+    TET: string;
+    /**
+     * HEBREW LETTER YOD (U+05D9) י
+     * @example
+     * 'y'
+     */
+    YOD: string;
+    /**
+     * HEBREW LETTER FINAL KAF (U+05DA) ך
+     * @example
+     * 'k' or 'kh'
+     */
+    FINAL_KAF: string;
+    /**
+     * HEBREW LETTER KAF (U+05DB) כ
+     * @example
+     * 'k' or 'kh'
+     */
+    KAF: string;
+    /**
+     * HEBREW LETTER KAF (U+05DB) and DAGESH (U+05BC) כּ
+     * @description
+     * the letter kaf with a dagesh kal
+     * @description
+     * use when need to distinguish between spirantized forms
+     * @example
+     * 'k'
+     */
+    KAF_DAGESH?: string;
+    /**
+     * HEBREW LETTER LAMED (U+05DC) ל
+     * @example
+     * 'l'
+     */
+    LAMED: string;
+    /**
+     * HEBREW LETTER FINAL MEM (U+05DD) ם
+     * @example
+     * 'm'
+     */
+    FINAL_MEM: string;
+    /**
+     * HEBREW LETTER MEM (U+05DE) מ
+     * @example
+     * 'm'
+     */
+    MEM: string;
+    /**
+     * HEBREW LETTER FINAL NUN (U+05DF) ן
+     * @example
+     * 'n'
+     */
+    FINAL_NUN: string;
+    /**
+     * HEBREW LETTER NUN (U+05E0) נ
+     * @example
+     * 'n'
+     */
+    NUN: string;
+    /**
+     * HEBREW LETTER SAMEKH (U+05E1) ס
+     * @example
+     * 's'
+     */
+    SAMEKH: string;
+    /**
+     * HEBREW LETTER AYIN (U+05E2) ע
+     * @example
+     * 'ʿ'
+     */
+    AYIN: string;
+    /**
+     * HEBREW LETTER FINAL PE (U+05E3) ף
+     * @example
+     * 'p' or 'f'
+     */
+    FINAL_PE: string;
+    /**
+     * HEBREW LETTER PE (U+05E4) פ
+     * @example
+     * 'p' or 'f'
+     */
+    PE: string;
+    /**
+     * HEBREW LETTER  PE (U+05E4) and DAGESH (U+05BC) פּ
+     * @description
+     * the letter pe with a dagesh kal
+     * @description
+     * use when need to distinguish between spirantized forms
+     * @example
+     * 'p'
+     */
+    PE_DAGESH?: string;
+    /**
+     * HEBREW LETTER FINAL TSADI (U+05E5) ץ
+     * @example
+     * 'ṣ'
+     */
+    FINAL_TSADI: string;
+    /**
+     * HEBREW LETTER TSADI (U+05E6) צ
+     * @example
+     * 'ṣ'
+     */
+    TSADI: string;
+    /**
+     * HEBREW LETTER QOF (U+05E7) ק
+     * @example
+     * 'q'
+     */
+    QOF: string;
+    /**
+     * HEBREW LETTER RESH (U+05E8) ר
+     * @example
+     * 'r'
+     */
+    RESH: string;
+    /**
+     * HEBREW LETTER SHIN (U+05E9) and SHIN DOT (U+05C1) שׁ
+     * @example
+     * 'š'
+     */
+    SHIN: string;
+    /**
+     * HEBREW LETTER SHIN (U+05E9) and SIN DOT (U+05C2) שׁ
+     * @example
+     * 'ś'
+     */
+    SIN: string;
+    /**
+     * HEBREW LETTER TAV (U+05EA) ת
+     * @example
+     * 't' or 'th'
+     */
+    TAV: string;
+    /**
+     * HEBREW LETTER TAV (U+05EA) and DAGESH (U+05BC) תּ
+     * @description
+     * the letter tav with a dagesh kal
+     * @description
+     * use when need to distinguish between spirantized forms
+     * @example
+     * 't'
+     */
+    TAV_DAGESH?: string;
+    /**
+     * define additional sequences of characters
+     *
+     * ⚠️ there may be unpredictable results
+     *
+     * @example
+     * [{
+     *   FEATURE: 'cluster',
+     *   HEBREW: 'זּ',
+     *   TRANSLITERATION: 'tz'
+     * }]
+     */
+    ADDITIONAL_FEATURES?: {
+        /**
+         * additional orthographic feature
+         *
+         * - `"cluster"` is any combination of a single character and optionally a _dagesh_ and vowel.
+         * - `"syllable"` is any combination of a multiple characters and a single vowel and optionally a _dagesh_
+         * - `"word"` covers everything else
+         */
+        FEATURE: "word" | "syllable" | "cluster";
+        /** use consonants and vowels; do not use taamim */
+        HEBREW: string;
+        TRANSLITERATION: string;
+    }[];
+    /**
+     * the full form of the divine name - יהוה
+     * @example
+     * 'yhwh'
+     */
+    DIVINE_NAME: string;
+    /**
+     * a syllable separator, usually an empty string
+     *  @example
+     * '' or '-'
+     * @example
+     * ```js
+     * transliterate('הָאָֽרֶץ', { SYLLABLE_SEPARATOR: '-' });
+     * // 'hā-ʾā-reṣ'
+     * ```
+     */
+    SYLLABLE_SEPARATOR?: string;
+    /**
+     * a mark for indentifying the stressed syllable
+     *
+     * @description
+     * taamim are needed in the Hebrew text to correctly identify stress
+     *  @example
+     * 'ˈ' or '\u0341'
+     * @example
+     * ```js
+     * transliterate('מֶ֣לֶךְ', { STRESS_MARKER: { location: 'after-vowel', mark: '\u0301' } });
+     * // 'mélek'
+     * ```
+     */
+    STRESS_MARKER?: {
+        location: "before-syllable" | "after-syllable" | "before-vowel" | "after-vowel";
+        mark: string;
+    };
+    longVowels: SylOpts["longVowels"];
+    qametsQatan: SylOpts["qametsQatan"];
+    sqnmlvy: SylOpts["sqnmlvy"];
+    wawShureq: SylOpts["wawShureq"];
+    article: SylOpts["article"];
+    allowNoNiqqud: SylOpts["allowNoNiqqud"];
+    constructor(schema: Schema);
+}
+export declare class SBL extends Schema {
+    constructor(schema: Partial<Schema>);
+}