Schema

Defined in: src/schema.ts:302

Class for defining a schema for transliteration.

Remarks

Examples are truncated for brevity.

Extended by

• SBL

Implements

• SylOpts
• SchemaVowels

Constructors

Constructor

new Schema(schema): Schema

Defined in: src/schema.ts:1875

Parameters

Parameter	Type
schema	Schema

Returns

Schema

Consonants

ALEF

ALEF: string

Defined in: src/schema.ts:834

HEBREW LETTER ALEF (U+05D0) א

Example

const schema = new Schema({
  // truncated for brevity
  ALEF: "ʾ",
});
transliterate("אָב", schema);
// ʾāb

---

AYIN

AYIN: string

Defined in: src/schema.ts:1258

HEBREW LETTER AYIN (U+05E2) ע

Example

const schema = new Schema({
  // truncated for brevity
  AYIN: "ʿ",
});
transliterate("עָ֑יִן", schema);
// ʿāyin

---

BET

BET: string

Defined in: src/schema.ts:850

HEBREW LETTER BET (U+05D1) ב

Example

const schema = new Schema({
  // truncated for brevity
  BET: "b",
});
transliterate("בְּבֵית", schema);
// bəbêt

---

BET_DAGESH?

optional BET_DAGESH?: string

Defined in: src/schema.ts:884

HEBREW LETTER BET (U+05D1) and DAGESH (U+05BC) ּב

Examples

With only BET set

const schema = new Schema({
  // truncated for brevity
  BET: "b",
});
transliterate("בְּבֵית", schema);
// bəbêt

With BET and BET_DAGESH set

const schema = new Schema({
  // truncated for brevity
  BET: "v",
  BET_DAGESH: "b",
});
transliterate("בְּבֵית", schema);
// bəvêt

Remarks

The letter bet with a dagesh kal. Use when need to distinguish between spirantized forms

---

DALET

DALET: string

Defined in: src/schema.ts:950

HEBREW LETTER DALET (U+05D3) ד

Example

const schema = new Schema({
  // truncated for brevity
  DALET: "d",
});
transliterate("דֹּ֣ד", schema);
// dōd

---

DALET_DAGESH?

optional DALET_DAGESH?: string

Defined in: src/schema.ts:984

HEBREW LETTER DALET (U+05D3) and DAGESH (U+05BC) דּ

Examples

With only DALET set

const schema = new Schema({
  // truncated for brevity
  DALET: "d",
});
transliterate("דֹּ֣ד", schema);
// dōd

With DALET and DALET_DAGESH set

const schema = new Schema({
  // truncated for brevity
  DALET: "dh",
  DALET_DAGESH: "d",
});
transliterate("דֹּ֣ד", schema);
// dōdh

Remarks

The letter dalet with a dagesh kal. Ue when need to distinguish between spirantized forms

---

FINAL_KAF

FINAL_KAF: string

Defined in: src/schema.ts:1096

HEBREW LETTER FINAL KAF (U+05DA) ך

Example

const schema = new Schema({
  // truncated for brevity
  FINAL KAF: "k",
});
transliterate("לֶךְ", schema);
// lek

---

FINAL_MEM

FINAL_MEM: string

Defined in: src/schema.ts:1178

HEBREW LETTER FINAL MEM (U+05DD) ם

Example

const schema = new Schema({
  // truncated for brevity
  FINAL MEM: "m",
});
transliterate("מַ֖יִם", schema);
// mayim

---

FINAL_NUN

FINAL_NUN: string

Defined in: src/schema.ts:1210

HEBREW LETTER FINAL NUN (U+05DF) ן

Example

const schema = new Schema({
  // truncated for brevity
  FINAL NUN: "n",
});
transliterate("נ֔וּן", schema);
// nûn

---

FINAL_PE

FINAL_PE: string

Defined in: src/schema.ts:1274

HEBREW LETTER FINAL PE (U+05E3) ף

Example

const schema = new Schema({
  // truncated for brevity
  FINAL PE: "p",
});
transliterate("כַּ֣ף", schema);
// kap

---

FINAL_TSADI

FINAL_TSADI: string

Defined in: src/schema.ts:1340

HEBREW LETTER FINAL TSADI (U+05E5) ץ

Example

const schema = new Schema({
  // truncated for brevity
  FINAL TSADI: "ṣ",
});
transliterate("צָ֚ץ", schema);
// ṣāṣ

---

GIMEL

GIMEL: string

Defined in: src/schema.ts:900

HEBREW LETTER GIMEL (U+05D2) ג

Example

const schema = new Schema({
  // truncated for brevity
  GIMEL: "g",
});
transliterate("גַּ֣גּ", schema);
// gag

---

GIMEL_DAGESH?

optional GIMEL_DAGESH?: string

Defined in: src/schema.ts:934

HEBREW LETTER GIMEL (U+05D2) and DAGESH (U+05BC) גּ

Examples

With only GIMEL set

const schema = new Schema({
  // truncated for brevity
  GIMEL: "g"
});
transliterate("גַּ֣ג", schema);
// gag

With GIMEL and GIMEL_DAGESH set

const schema = new Schema({
  // truncated for brevity
  GIMEL: "gh",
  GIMEL_DAGESH: "g",
});
transliterate("גַּ֣ג", schema);
// gagh

Remarks

The letter gimel with a dagesh kal. Use when need to distinguish between spirantized forms

---

HE

HE: string

Defined in: src/schema.ts:1000

HEBREW LETTER HE (U+05D4) ה

Example

const schema = new Schema({
  // truncated for brevity
  HE: "h",
});
transliterate("הֵ֗ם", schema);
// hēm

---

HET

HET: string

Defined in: src/schema.ts:1048

HEBREW LETTER HET (U+05D7) ח

Example

const schema = new Schema({
  // truncated for brevity
  HET: "ḥ"
});
transliterate("חַ֣ג", schema);
// ḥag

---

KAF

KAF: string

Defined in: src/schema.ts:1112

HEBREW LETTER KAF (U+05DB) כ

Example

const schema = new Schema({
  // truncated for brevity
  KAF: "k",
});
transliterate("כָּ֚כָה", schema);
// kākâ

---

KAF_DAGESH?

optional KAF_DAGESH?: string

Defined in: src/schema.ts:1146

HEBREW LETTER KAF (U+05DB) and DAGESH (U+05BC) כּ

Examples

With only KAF set

const schema = new Schema({
  // truncated for brevity
  KAF: "k",
});
transliterate("כָּ֚כָה", schema);
// kākâ

With KAF set and KAF_DAGESH set

const schema = new Schema({
  // truncated for brevity
  KAF: "kh",
  KAF_DAGESH: "k",
});
transliterate("כָּ֚כָה", schema);
// kākhâ

Remarks

The letter kaf with a dagesh kal. Use when need to distinguish between spirantized forms

---

LAMED

LAMED: string

Defined in: src/schema.ts:1162

HEBREW LETTER LAMED (U+05DC) ל

Example

const schema = new Schema({
  // truncated for brevity
  LAMED: "l",
});
transliterate("עַל", schema);
// ʿal

---

MEM

MEM: string

Defined in: src/schema.ts:1194

HEBREW LETTER MEM (U+05DE) מ

Example

const schema = new Schema({
  // truncated for brevity
  MEM: "m",
});
transliterate("מַ֖יִם", schema);
// mayim

---

NUN

NUN: string

Defined in: src/schema.ts:1226

HEBREW LETTER NUN (U+05E0) נ

Example

const schema = new Schema({
  // truncated for brevity
  NUN: "n",
});
transliterate("נ֔וּן", schema);
// nûn

---

PE

PE: string

Defined in: src/schema.ts:1290

HEBREW LETTER PE (U+05E4) פ

Example

const schema = new Schema({
  // truncated for brevity
  PE: "p",
});
transliterate("פֶּ֣רֶא חָפְשִׁ֑י", schema);
// pereʾ ḥopšî

---

PE_DAGESH?

optional PE_DAGESH?: string

Defined in: src/schema.ts:1324

HEBREW LETTER PE (U+05E4) and DAGESH (U+05BC) פּ

Examples

With only PE set

const schema = new Schema({
  // truncated for brevity
  PE_DAGESH: "p",
});
transliterate("פֶּ֣רֶא חָפְשִׁ֑י", schema);
// pereʾ ḥopšî

With PE and PE_DAGESH set

const schema = new Schema({
  // truncated for brevity
  PE: "f",
  PE_DAGESH: "p",
});
transliterate("פֶּ֣רֶא חָפְשִׁ֑י", schema);
// pereʾ ḥofšî

Remarks

The letter pe with a dagesh kal Use when need to distinguish between spirantized forms

---

QOF

QOF: string

Defined in: src/schema.ts:1372

HEBREW LETTER QOF (U+05E7) ק

Example

const schema = new Schema({
  // truncated for brevity
  QOF: "q",
});
transliterate("רַ֥ק", schema);
// raq

---

RESH

RESH: string

Defined in: src/schema.ts:1388

HEBREW LETTER RESH (U+05E8) ר

Example

const schema = new Schema({
  // truncated for brevity
  RESH: "r",
});
transliterate("רַ֥ק", schema);
// raq

---

SAMEKH

SAMEKH: string

Defined in: src/schema.ts:1242

HEBREW LETTER SAMEKH (U+05E1) ס

Example

const schema = new Schema({
  // truncated for brevity
  SAMEKH: "s",
});
transliterate("ס֥וּס", schema);
// sûs

---

SHIN

SHIN: string

Defined in: src/schema.ts:1405

HEBREW LETTER SHIN (U+05E9) and SHIN DOT (U+05C1) שׁ

Example

const schema = new Schema({
  // truncated for brevity
  SHIN: "š",
});
transliterate("שֵׁ֖ן", schema);
// šēn

---

SIN

SIN: string

Defined in: src/schema.ts:1422

HEBREW LETTER SHIN (U+05E9) and SIN DOT (U+05C2) שׁ

Example

const schema = new Schema({
  // truncated for brevity
  SIN: "ś",
});
transliterate("כַּשְׂדִּ֔ים", schema);
// kaśdîm

---

TAV

TAV: string

Defined in: src/schema.ts:1438

HEBREW LETTER TAV (U+05EA) ת

Example

const schema = new Schema({
  // truncated for brevity
  TAV: "t",
});
transliterate("תֵּ֛ת", schema);
// tēt

---

TAV_DAGESH?

optional TAV_DAGESH?: string

Defined in: src/schema.ts:1472

HEBREW LETTER TAV (U+05EA) and DAGESH (U+05BC) תּ

Examples

With only TAV set

const schema = new Schema({
  // truncated for brevity
  TAV: "t",
});
transliterate("תֵּ֛ת", schema);
// tēt

With TAV and TAV_DAGESH set

const schema = new Schema({
  // truncated for brevity
  TAV: "th",
  TAV_DAGESH: "t",
});
transliterate("תֵּ֛ת", schema);
// tēth

Remarks

The letter tav with a dagesh kal. Use when need to distinguish between spirantized forms

---

TET

TET: string

Defined in: src/schema.ts:1064

HEBREW LETTER TET (U+05D8) ט

Example

const schema = new Schema({
  // truncated for brevity
  TET: "ṭ",
});
transliterate("טִֽיט", schema);
// ṭîṭ

---

TSADI

TSADI: string

Defined in: src/schema.ts:1356

HEBREW LETTER TSADI (U+05E6) צ

Example

const schema = new Schema({
  // truncated for brevity
  TSADI: "ṣ",
});
transliterate("צָ֚ץ", schema);
// ṣāṣ

---

VAV

VAV: string

Defined in: src/schema.ts:1016

HEBREW LETTER VAV (U+05D5) ו

Example

const schema = new Schema({
  // truncated for brevity
  VAV: "w",
});
transliterate("וָוִ֖ים", schema);
// wāwîm

---

YOD

YOD: string

Defined in: src/schema.ts:1080

HEBREW LETTER YOD (U+05D9) י

Example

const schema = new Schema({
  // truncated for brevity
  YOD: "y",
});
transliterate("יָ֗ד", schema);
// yād

---

ZAYIN

ZAYIN: string

Defined in: src/schema.ts:1032

HEBREW LETTER ZAYIN (U+05D6) ז

Example

const schema = new Schema({
  // truncated for brevity
  ZAYIN: "z",
});
transliterate("זֵ֣ד", schema);
// zēd

Marks

DAGESH

DAGESH: string

Defined in: src/schema.ts:528

HEBREW POINT DAGESH OR MAPIQ (U+05BC) ּ◌

Examples

A blank string

const schema = new Schema({
  // truncated for brevity
  DAGESH: "",
});
transliterate("כֵּ֑ן", schema);
// kēn

A character

const schema = new Schema({
  // truncated for brevity
  DAGESH: ".",
});
transliterate("כֵּ֑ן", schema);
// k.ēn

Remarks

Typically, this should be a blank string.

---

DAGESH_CHAZAQ

DAGESH_CHAZAQ: string | boolean

Defined in: src/schema.ts:559

HEBREW POINT DAGESH OR MAPIQ (U+05BC) ּ◌

A string or boolean, and if set to true, the consonant with the dagesh is repeated.

Examples

As a string

const schema = new Schema({
  // truncated for brevity
  DAGESH_CHAZAQ: "\u0301",
});
transliterate("שַׁבָּת", schema);
// šab́āt

As a boolean

const schema = new Schema({
  // truncated for brevity
  DAGESH_CHAZAQ: true,
});
transliterate("שַׁבָּת", schema);
// šabbāt

---

MAQAF

MAQAF: string

Defined in: src/schema.ts:576

HEBREW PUNCTUATION MAQAF (U+05BE) ־◌

Example

const schema = new Schema({
  // truncated for brevity
  { MAQAF: "-" }
});
transliterate("אַל־", schema);
// ʾal-

---

PASEQ

PASEQ: string

Defined in: src/schema.ts:595

HEBREW PUNCTUATION PASEQ (U+05C0) ׀ ◌

Example

const schema = new Schema({
  // truncated for brevity
  PASEQ: "",
})
transliterate("כְּשֶׁ֣בֶת ׀ הַמֶּ֣לֶךְ", schema);
// kəšebet  hammelek

Remarks

If a blank string, two spaces will occur between words; see example.

---

SOF_PASUQ

SOF_PASUQ: string

Defined in: src/schema.ts:612

HEBREW PUNCTUATION SOF PASUQ (U+05C3) ׃◌

Example

const schema = new Schema({
  // truncated for brevity
  SOF_PASUQ: ".",
});
transliterate("הָאָֽרֶץ׃", schema);
// hāʾāreṣ.

Orthographic Features

ADDITIONAL_FEATURES?

optional ADDITIONAL_FEATURES?: (WordFeature | SyllableFeature | ClusterFeature)[]

Defined in: src/schema.ts:1617

Rules for customized output

This property is an array of objects with the following properties each:

• FEATURE: the type of feature that the rule is checking — “word”, “syllable”, or “cluster”
• HEBREW: the Hebrew text that the rule matches, given as a string or Regex
• PASS_THROUGH?: An optional property; true if the rule should pass the characters of the result of the TRANSLITERATION callback to the be mapped to the schema
• TRANSLITERATION: the output of the rule, either a string or a callback whose properties differ based on the FEATURE

The examples give the best indication of how to use these features, though see the particular types for more details

Examples

FEATURE is "word" and TRANSLITERATION is a string

const schema = new Schema({
  // truncated for brevity
  ADDITIONAL_FEATURES: [{
    FEATURE: "word",
    HEBREW: "הָאָרֶץ",
    TRANSLITERATION: "The Earth"
  }]
})
transliterate("וְאֵ֥ת הָאָֽרֶץ", schema);
// wəʾēt The Earth

FEATURE is "word" and TRANSLITERATION is a callback

const schema = new Schema({
  // truncated for brevity
  ADDITIONAL_FEATURES: [{
    HEBREW: "שְׁתַּיִם",
    FEATURE: "word",
    TRANSLITERATION: function (_word, _hebrew, schema) {
      return (
        schema["SHIN"] +
        (schema["TAV_DAGESH"] ?? schema["TAV"]) +
        schema["PATAH"] +
        schema["YOD"] +
        schema["HIRIQ"] +
        schema["FINAL_MEM"]
      );
    }
  }]
});
transliterate("שְׁתַּיִם", schema);
// štayim

FEATURE is "syllable" and TRANSLITERATION is a string

const schema = new Schema({
  // truncated for brevity
  ADDITIONAL_FEATURES: [{
    FEATURE: "syllable",
    HEBREW: /יּ(?![\u{05B4}-\u{05BB}])/u, // a yod with a dagesh, not followed by a vowel character
    TRANSLITERATION: "Y"
  }]
});
transliterate("מְחִיּיָאֵ֗ל", schema);
// məḥiYyāʾēl

FEATURE is "syllable" and TRANSLITERATION is a callback

const schema = new Schema({
  // truncated for brevity
  ADDITIONAL_FEATURES: [{
    FEATURE: "syllable",
    HEBREW: /\u{05C7}/u,
    TRANSLITERATION: (syllable) => {
      // If the syllable contains a qamets qatan character (U+05C7), check the text of the next syllable
      const next = syllable?.next?.value?.text;

      // If the next syllable includes a hateph qamets, then replace the qamets qatan with a regular qamets
      if (next && next.includes("\u05B3")) {
        return syllable.text.replace("\u{05C7}", "\u{05B8}");
      }
      return syllable.text;
    }
  }]
});
transliterate("נָעֳמִי֙", schema);
// nāʿŏmî

FEATURE is "cluster" and TRANSLITERATION is a string

const schema = new Schema({
  // truncated for brevity
  ADDITIONAL_FEATURES: [{
    FEATURE: "cluster",
    HEBREW: "זּ",
    TRANSLITERATION: "tz"
  }]
});;
transliterate("הַזֹּאת", schema);
// hatzōʾt

FEATURE is “cluster” and TRANSLITERATION is a callback

const schema = new Schema({
  // truncated for brevity
  TAV_DAGESH: "tʰ",,
  ADDITIONAL_FEATURES: [{
    FEATURE: 'cluster',
    HEBREW: /תּ(?!\u{05B0})/u,
    TRANSLITERATION: (cluster, _, schema) => {
      // Because the *_DAGESH value is a digraph, we need to replace the first character
      // or it will be doubled in rules.ts as "tʰtʰ"

      // If there is a dagesh, but it is the beginning of the word
      // we can return the text, as the character w/ the dagesh will not be doubled
      if (!cluster.prev || cluster.prev.value?.isNotHebrew) {
        return cluster.text;
      }

      // If there is a dagesh, it may be that it is a dagesh qal (i.e. lene)
      // If it is a dagesh lene, then like the beginning of the word,
      // the character w/ the dagesh will not be doubled
      const prevCoda = cluster.syllable?.prev?.value?.codaWithGemination;
      if (!prevCoda?.includes("ת",)) {
        return cluster.text;
      }

      // convert "tʰtʰ" to "ttʰ"
      const noAspiration = schema['TAV_DAGESH']?.replace("ʰ",, '') ?? '';
      return cluster.text.replace("תּ",,`${noAspiration + schema['TAV_DAGESH']}`);
    },
  }]
});
transliterate("וַתֵּ֨שֶׁב", schema);
// wattʰēšeb

---

BET_DAGESH?

optional BET_DAGESH?: string

Defined in: src/schema.ts:884

HEBREW LETTER BET (U+05D1) and DAGESH (U+05BC) ּב

Examples

With only BET set

const schema = new Schema({
  // truncated for brevity
  BET: "b",
});
transliterate("בְּבֵית", schema);
// bəbêt

With BET and BET_DAGESH set

const schema = new Schema({
  // truncated for brevity
  BET: "v",
  BET_DAGESH: "b",
});
transliterate("בְּבֵית", schema);
// bəvêt

Remarks

The letter bet with a dagesh kal. Use when need to distinguish between spirantized forms

---

DAGESH_CHAZAQ

DAGESH_CHAZAQ: string | boolean

Defined in: src/schema.ts:559

HEBREW POINT DAGESH OR MAPIQ (U+05BC) ּ◌

A string or boolean, and if set to true, the consonant with the dagesh is repeated.

Examples

As a string

const schema = new Schema({
  // truncated for brevity
  DAGESH_CHAZAQ: "\u0301",
});
transliterate("שַׁבָּת", schema);
// šab́āt

As a boolean

const schema = new Schema({
  // truncated for brevity
  DAGESH_CHAZAQ: true,
});
transliterate("שַׁבָּת", schema);
// šabbāt

---

DALET_DAGESH?

optional DALET_DAGESH?: string

Defined in: src/schema.ts:984

HEBREW LETTER DALET (U+05D3) and DAGESH (U+05BC) דּ

Examples

With only DALET set

const schema = new Schema({
  // truncated for brevity
  DALET: "d",
});
transliterate("דֹּ֣ד", schema);
// dōd

With DALET and DALET_DAGESH set

const schema = new Schema({
  // truncated for brevity
  DALET: "dh",
  DALET_DAGESH: "d",
});
transliterate("דֹּ֣ד", schema);
// dōdh

Remarks

The letter dalet with a dagesh kal. Ue when need to distinguish between spirantized forms

---

DIVINE_NAME

DIVINE_NAME: string

Defined in: src/schema.ts:1633

The full form of the divine name - יהוה

Example

const schema = new Schema({
  // truncated for brevity
  DIVINE_NAME: "yhwh",
});
transliterate("יְהֹוָ֗ה", schema);
// yhwh

---

DIVINE_NAME_ELOHIM?

optional DIVINE_NAME_ELOHIM?: string

Defined in: src/schema.ts:1657

The full form of the divine name pointed as ‘elohim

Example

const schema = new Schema({
  // truncated for brevity
  DIVINE_NAME_ELOHIM: "ʾĕlōhîm",
});
transliterate("יֱהֹוִה", schema);
// ʾĕlōhîm

Remarks

Matches on the forms:

• יֱהֹוִה
• יֱהוִה
• יְהֹוִה
• יְהוִה If undefined, defaults to value of DIVINE_NAME

---

FURTIVE_PATAH

FURTIVE_PATAH: string

Defined in: src/schema.ts:648

HEBREW POINT PATAH (U+05B7) ◌ַ as a furtive patah

Example

const schema = new Schema({
  // truncated for brevity
  FURTIVE_PATAH: "a",
});
transliterate("נֹ֖חַ", schema);
// nōaḥ

---

GIMEL_DAGESH?

optional GIMEL_DAGESH?: string

Defined in: src/schema.ts:934

HEBREW LETTER GIMEL (U+05D2) and DAGESH (U+05BC) גּ

Examples

With only GIMEL set

const schema = new Schema({
  // truncated for brevity
  GIMEL: "g"
});
transliterate("גַּ֣ג", schema);
// gag

With GIMEL and GIMEL_DAGESH set

const schema = new Schema({
  // truncated for brevity
  GIMEL: "gh",
  GIMEL_DAGESH: "g",
});
transliterate("גַּ֣ג", schema);
// gagh

Remarks

The letter gimel with a dagesh kal. Use when need to distinguish between spirantized forms

---

HIRIQ_YOD

HIRIQ_YOD: string

Defined in: src/schema.ts:665

HEBREW POINT HIRIQ (U+05B4) and YOD (U+05D9) י◌ִ

Example

const schema = new Schema({
  // truncated for brevity
  HIRIQ_YOD: "î",
});
transliterate("עִ֔יר", schema);
// ʿîr

---

HOLAM_VAV

HOLAM_VAV: string

Defined in: src/schema.ts:733

HEBREW LETTER HOLAM (U+05B9) and VAV (U+05D5) ֹו◌

Example

const schema = new Schema({
  // truncated for brevity
  HOLAM_VAV: "ô",
});
transliterate("ס֣וֹא", schema);
// sôʾ

---

KAF_DAGESH?

optional KAF_DAGESH?: string

Defined in: src/schema.ts:1146

HEBREW LETTER KAF (U+05DB) and DAGESH (U+05BC) כּ

Examples

With only KAF set

const schema = new Schema({
  // truncated for brevity
  KAF: "k",
});
transliterate("כָּ֚כָה", schema);
// kākâ

With KAF set and KAF_DAGESH set

const schema = new Schema({
  // truncated for brevity
  KAF: "kh",
  KAF_DAGESH: "k",
});
transliterate("כָּ֚כָה", schema);
// kākhâ

Remarks

The letter kaf with a dagesh kal. Use when need to distinguish between spirantized forms

---

MS_SUFX

MS_SUFX: string

Defined in: src/schema.ts:818

HEBREW LETTER QAMATS (U+05B8) and YOD (U+05D9) and VAV (U+05D5) יו◌ָ

Example

const schema = new Schema({
  // truncated for brevity
  MS_SUFX: ”āyw”,
});
transliterate("יָדָ֛יו", schema);
// yādāyw

---

ON_COMPLETE?

optional ON_COMPLETE?: (result, context) => string

Defined in: src/schema.ts:1788

A callback that is invoked when transliteration is complete

Parameters

Parameter	Type
result	string
context	{ original: string; schema: Omit<Schema, "ON_COMPLETE">; text: Text; }
context.original	string
context.schema	Omit<Schema, "ON_COMPLETE">
context.text	Text

Returns

string

Examples

Modifying the result

const schema = new Schema({
  // truncated for brevity
  ON_COMPLETE: (result) => result.replace("th", "t'h"),
});
transliterate("תִתְהַלָּֽל", schema);
// tit'hallāl

Accessing callback arguments

const schema = new Schema({
  // truncated for brevity
  ON_COMPLETE: (result, { original, schema, text }) => {
    console.log("Original Hebrew:", original);
    console.log("Schema value:", schema.PATAH);
    console.log("Word count:", text.words.length);
    return result;
  },
});
transliterate("שָּׁלוֹם", schema);
// "šālôm"
// Original Hebrew: שָּׁלוֹם
// Schema value: a
// Word count: 1

---

PATAH_HE?

optional PATAH_HE?: string

Defined in: src/schema.ts:767

HEBREW POINT PATAH (U+05B7) and HE (U+05D4) ה◌ַ

Example

const schema = new Schema({
  // truncated for brevity
  PATAH_HE: "â",
});
transliterate("מַה־", schema);
// mâ-

---

PE_DAGESH?

optional PE_DAGESH?: string

Defined in: src/schema.ts:1324

HEBREW LETTER PE (U+05E4) and DAGESH (U+05BC) פּ

Examples

With only PE set

const schema = new Schema({
  // truncated for brevity
  PE_DAGESH: "p",
});
transliterate("פֶּ֣רֶא חָפְשִׁ֑י", schema);
// pereʾ ḥopšî

With PE and PE_DAGESH set

const schema = new Schema({
  // truncated for brevity
  PE: "f",
  PE_DAGESH: "p",
});
transliterate("פֶּ֣רֶא חָפְשִׁ֑י", schema);
// pereʾ ḥofšî

Remarks

The letter pe with a dagesh kal Use when need to distinguish between spirantized forms

---

QAMATS_HE

QAMATS_HE: string

Defined in: src/schema.ts:750

HEBREW POINT QAMATS (U+05B8) and HE (U+05D4) ה◌ָ

Example

const schema = new Schema({
  // truncated for brevity
  QAMATS_HE: "â",
});
transliterate("עֵצָ֖ה", schema);
// ʿēṣâ

---

SEGOL_HE?

optional SEGOL_HE?: string

Defined in: src/schema.ts:784

HEBREW POINT SEGOL (U+05B6) and HE (U+05D4) ה◌ֶ

Example

const schema = new Schema({
  // truncated for brevity
  SEGOL_HE: "ê",
});
transliterate("יִקְרֶ֥ה", schema);
// yiqrê

---

SEGOL_YOD

SEGOL_YOD: string

Defined in: src/schema.ts:699

HEBREW POINT SEGOL (U+05B6) and YOD (U+05D9) י◌ֶ

Example

const schema = new Schema({
  // truncated for brevity
  SEGOL_YOD: "ê",
});
transliterate("אֱלֹהֶ֑יךָ", schema);
// ʾĕlōhêkā

---

SHIN

SHIN: string

Defined in: src/schema.ts:1405

HEBREW LETTER SHIN (U+05E9) and SHIN DOT (U+05C1) שׁ

Example

const schema = new Schema({
  // truncated for brevity
  SHIN: "š",
});
transliterate("שֵׁ֖ן", schema);
// šēn

---

SHUREQ

SHUREQ: string

Defined in: src/schema.ts:716

HEBREW LETTER VAV (U+05D5) and DAGESH (U+05BC) וּ

Example

const schema = new Schema({
  // truncated for brevity
  SHUREQ: "û",
});
transliterate("קוּם", schema);
// qûm

---

SIN

SIN: string

Defined in: src/schema.ts:1422

HEBREW LETTER SHIN (U+05E9) and SIN DOT (U+05C2) שׁ

Example

const schema = new Schema({
  // truncated for brevity
  SIN: "ś",
});
transliterate("כַּשְׂדִּ֔ים", schema);
// kaśdîm

---

STRESS_MARKER?

optional STRESS_MARKER?: { exclude?: "never" | "final" | "single"; location: "before-syllable" | "after-syllable" | "before-vowel" | "after-vowel"; mark: string; }

Defined in: src/schema.ts:1695

A mark for indentifying the stressed syllable

exclude?

optional exclude?: "never" | "final" | "single"

Whether to exclude the mark on certain syllables

Default

"never"

Examples

undefined and "never" are the same

const schema = new Schema({
  STRESS_MARKER: {
    location: "after-vowel",
    mark: "\u0301",
   },
});
transliterate("בֹּ֖קֶר י֥וֹם אֶחָֽד׃ ", schema);
// bṓqer yốm ʾeḥā́d

Exclude only single syllable words using "single"

const schema = new Schema({
  STRESS_MARKER: {
    location: "after-vowel",
    mark: "\u0301",
    exclude: "single",
   },
});
transliterate("בֹּ֖קֶר י֥וֹם אֶחָֽד׃ ", schema);
// bṓqer yôm ʾeḥā́d

Exclude when accent is on the final syllable, implicitly excluding single syllable words using "final"

const schema = new Schema({
  STRESS_MARKER: {
    location: "after-vowel",
    mark: "\u0301",
    exclude: "final",
   },
});
transliterate("בֹּ֖קֶר י֥וֹם אֶחָֽד׃ ", schema);
// bṓqer yôm ʾeḥād

location

location: "before-syllable" | "after-syllable" | "before-vowel" | "after-vowel"

The location of the mark

mark

mark: string

A string to use as the marker

Example

const schema = new Schema({
  // truncated for brevity
  STRESS_MARKER: {
    location: "after-vowel",
    mark: "\u0301",
   },
});
transliterate("מֶ֣לֶךְ", schema);
// mélek

Remarks

Taamim are needed in the Hebrew text to correctly identify stress.

---

SYLLABLE_SEPARATOR?

optional SYLLABLE_SEPARATOR?: string

Defined in: src/schema.ts:1673

A syllable separator, usually an empty string

Example

const schema = new Schema({
  // truncated for brevity
  SYLLABLE_SEPARATOR: "-",
});
transliterate('הָאָֽרֶץ', schema);
// hā-ʾā-reṣ

---

TAV_DAGESH?

optional TAV_DAGESH?: string

Defined in: src/schema.ts:1472

HEBREW LETTER TAV (U+05EA) and DAGESH (U+05BC) תּ

Examples

With only TAV set

const schema = new Schema({
  // truncated for brevity
  TAV: "t",
});
transliterate("תֵּ֛ת", schema);
// tēt

With TAV and TAV_DAGESH set

const schema = new Schema({
  // truncated for brevity
  TAV: "th",
  TAV_DAGESH: "t",
});
transliterate("תֵּ֛ת", schema);
// tēth

Remarks

The letter tav with a dagesh kal. Use when need to distinguish between spirantized forms

---

TSERE_HE?

optional TSERE_HE?: string

Defined in: src/schema.ts:801

HEBREW POINT TSERE (U+05B5) and HE (U+05D4) ה◌ֵ

Example

const schema = new Schema({
  // truncated for brevity
  TSERE_HE: "ê",
});
transliterate("הָאַרְיֵ֔ה", schema);
// hāʾaryê

---

TSERE_YOD

TSERE_YOD: string

Defined in: src/schema.ts:682

HEBREW POINT TSERE (U+05B5) and YOD (U+05D9) י◌ֵ

Example

const schema = new Schema({
  // truncated for brevity
  TSERE_YOD: "ê",
});
transliterate("אֵ֤ין", schema);
// ʾên

Syllabification

allowNoNiqqud

allowNoNiqqud: boolean | undefined

Defined in: src/schema.ts:1802

Remarks

See implementation for more details

Implementation of

SylOpts.allowNoNiqqud

---

article

article: boolean | undefined

Defined in: src/schema.ts:1809

Remarks

See implementation for more details

Implementation of

SylOpts.article

---

holemHaser

holemHaser: "update" | "preserve" | "remove" | undefined

Defined in: src/schema.ts:1816

Remarks

See implementation for more details

Implementation of

SylOpts.holemHaser

---

ketivQeres?

optional ketivQeres?: KetivQere[]

Defined in: src/schema.ts:1824

Remarks

See implementation for more details

Implementation of

SylOpts.ketivQeres

---

longVowels

longVowels: boolean | undefined

Defined in: src/schema.ts:1831

Remarks

See implementation for more details

Implementation of

SylOpts.longVowels

---

qametsQatan

qametsQatan: boolean | undefined

Defined in: src/schema.ts:1838

Remarks

See implementation for more details

Implementation of

SylOpts.qametsQatan

---

shevaAfterMeteg

shevaAfterMeteg: boolean | undefined

Defined in: src/schema.ts:1845

Remarks

See implementation for more details

Implementation of

SylOpts.shevaAfterMeteg

---

shevaWithMeteg?

optional shevaWithMeteg?: boolean

Defined in: src/schema.ts:1852

Remarks

See implementation for more details

Implementation of

SylOpts.shevaWithMeteg

---

sqnmlvy

sqnmlvy: boolean | undefined

Defined in: src/schema.ts:1859

Remarks

See implementation for more details

Implementation of

SylOpts.sqnmlvy

---

strict

strict: boolean | undefined

Defined in: src/schema.ts:1866

Remarks

See implementation for more details

Implementation of

SylOpts.strict

---

wawShureq

wawShureq: boolean | undefined

Defined in: src/schema.ts:1873

Remarks

See implementation for more details

Implementation of

SylOpts.wawShureq

Taamim

MAQAF

MAQAF: string

Defined in: src/schema.ts:576

HEBREW PUNCTUATION MAQAF (U+05BE) ־◌

Example

const schema = new Schema({
  // truncated for brevity
  { MAQAF: "-" }
});
transliterate("אַל־", schema);
// ʾal-

---

SOF_PASUQ

SOF_PASUQ: string

Defined in: src/schema.ts:612

HEBREW PUNCTUATION SOF PASUQ (U+05C3) ׃◌

Example

const schema = new Schema({
  // truncated for brevity
  SOF_PASUQ: ".",
});
transliterate("הָאָֽרֶץ׃", schema);
// hāʾāreṣ.

Vowels

FURTIVE_PATAH

FURTIVE_PATAH: string

Defined in: src/schema.ts:648

HEBREW POINT PATAH (U+05B7) ◌ַ as a furtive patah

Example

const schema = new Schema({
  // truncated for brevity
  FURTIVE_PATAH: "a",
});
transliterate("נֹ֖חַ", schema);
// nōaḥ

---

HATAF_PATAH

HATAF_PATAH: string

Defined in: src/schema.ts:350

HEBREW POINT HATAF PATAH (U+05B2) ֲ◌

Example

const schema = new Schema({
  // truncated for brevity
  HATAF_PATAH: "ă",
});
transliterate("נַֽעֲשֶׂ֥ה", schema);
// naʿăśê

Implementation of

SchemaVowels.HATAF_PATAH

---

HATAF_QAMATS

HATAF_QAMATS: string

Defined in: src/schema.ts:366

HEBREW POINT HATAF QAMATS (U+05B3) ֳ◌

Example

const schema = new Schema({
  // truncated for brevity
  HATAF_QAMATS: "ŏ",
});
transliterate("אֳרָנִים", schema);
// ʾŏrānîm

Implementation of

SchemaVowels.HATAF_QAMATS

---

HATAF_SEGOL

HATAF_SEGOL: string

Defined in: src/schema.ts:334

HEBREW POINT HATAF SEGOL (U+05B1) ֱ◌

Example

const schema = new Schema({
  // truncated for brevity
  HATAF_SEGOL: "ĕ",
});
transliterate("אֱלֹהִ֑ים", schema);
// ʾĕlōhîm

Implementation of

SchemaVowels.HATAF_SEGOL

---

HIRIQ

HIRIQ: string

Defined in: src/schema.ts:382

HEBREW POINT HIRIQ (U+05B4) ִ◌

Example

const schema = new Schema({
  // truncated for brevity
  HIRIQ: "i",
});
transliterate("הִנֵּה֩", schema);
// hinnê

Implementation of

SchemaVowels.HIRIQ

---

HIRIQ_YOD

HIRIQ_YOD: string

Defined in: src/schema.ts:665

HEBREW POINT HIRIQ (U+05B4) and YOD (U+05D9) י◌ִ

Example

const schema = new Schema({
  // truncated for brevity
  HIRIQ_YOD: "î",
});
transliterate("עִ֔יר", schema);
// ʿîr

---

HOLAM

HOLAM: string

Defined in: src/schema.ts:462

HEBREW POINT HOLAM (U+05B9) ֹ◌

Example

const schema = new Schema({
  // truncated for brevity
  HOLAM: "ō",
});
transliterate("לֹא", schema);
// lōʾ

Implementation of

SchemaVowels.HOLAM

---

HOLAM_HASER

HOLAM_HASER: string

Defined in: src/schema.ts:481

HEBREW POINT HOLAM HASER FOR VAV (U+05BA) ֹ◌

Example

const schema = new Schema({
  // truncated for brevity
  HOLAM_HASER: "ō",
});
transliterate("עָוֺן֙", schema);
// ʿāwōn

Remarks

See holemHaser for more about this character

Implementation of

SchemaVowels.HOLAM_HASER

---

HOLAM_VAV

HOLAM_VAV: string

Defined in: src/schema.ts:733

HEBREW LETTER HOLAM (U+05B9) and VAV (U+05D5) ֹו◌

Example

const schema = new Schema({
  // truncated for brevity
  HOLAM_VAV: "ô",
});
transliterate("ס֣וֹא", schema);
// sôʾ

---

MS_SUFX

MS_SUFX: string

Defined in: src/schema.ts:818

HEBREW LETTER QAMATS (U+05B8) and YOD (U+05D9) and VAV (U+05D5) יו◌ָ

Example

const schema = new Schema({
  // truncated for brevity
  MS_SUFX: ”āyw”,
});
transliterate("יָדָ֛יו", schema);
// yādāyw

---

PATAH

PATAH: string

Defined in: src/schema.ts:430

HEBREW POINT PATAH (U+05B7) ַ◌

Example

const schema = new Schema({
  // truncated for brevity
  PATAH: "a",
});
transliterate("נַ֗עַר", schema);
// naʿar

Implementation of

SchemaVowels.PATAH

---

PATAH_HE?

optional PATAH_HE?: string

Defined in: src/schema.ts:767

HEBREW POINT PATAH (U+05B7) and HE (U+05D4) ה◌ַ

Example

const schema = new Schema({
  // truncated for brevity
  PATAH_HE: "â",
});
transliterate("מַה־", schema);
// mâ-

---

QAMATS

QAMATS: string

Defined in: src/schema.ts:446

HEBREW POINT QAMATS (U+05B8) ָ◌

Example

const schema = new Schema({
  // truncated for brevity
  QAMATS: "ā",
});
transliterate("דָבָר֙", schema);
// dābār

Implementation of

SchemaVowels.QAMATS

---

QAMATS_HE

QAMATS_HE: string

Defined in: src/schema.ts:750

HEBREW POINT QAMATS (U+05B8) and HE (U+05D4) ה◌ָ

Example

const schema = new Schema({
  // truncated for brevity
  QAMATS_HE: "â",
});
transliterate("עֵצָ֖ה", schema);
// ʿēṣâ

---

QAMATS_QATAN

QAMATS_QATAN: string

Defined in: src/schema.ts:631

HEBREW POINT QAMATS QATAN (U+05C7) ׇ◌

Example

const schema = new Schema({
  // truncated for brevity
  QAMATS QATAN: "o",
});
transliterate("כָּל־הָעָ֖ם", schema);
// kol-hāʿām

Remarks

See qametsQatan for details about this character.

Implementation of

SchemaVowels.QAMATS_QATAN

---

QUBUTS

QUBUTS: string

Defined in: src/schema.ts:497

HEBREW POINT QUBUTS (U+05BB) ֻ◌

Example

const schema = new Schema({
  // truncated for brevity
  QUBUTS: "u",
});
transliterate("קֻ֣ם", schema);
// qūm

Implementation of

SchemaVowels.QUBUTS

---

SEGOL

SEGOL: string

Defined in: src/schema.ts:414

HEBREW POINT SEGOL (U+05B6) ֶ◌

Example

const schema = new Schema({
  // truncated for brevity
  SEGOL: "e",
});
transliterate("אֶל", schema);
// ʾel

Implementation of

SchemaVowels.SEGOL

---

SEGOL_HE?

optional SEGOL_HE?: string

Defined in: src/schema.ts:784

HEBREW POINT SEGOL (U+05B6) and HE (U+05D4) ה◌ֶ

Example

const schema = new Schema({
  // truncated for brevity
  SEGOL_HE: "ê",
});
transliterate("יִקְרֶ֥ה", schema);
// yiqrê

---

SEGOL_YOD

SEGOL_YOD: string

Defined in: src/schema.ts:699

HEBREW POINT SEGOL (U+05B6) and YOD (U+05D9) י◌ֶ

Example

const schema = new Schema({
  // truncated for brevity
  SEGOL_YOD: "ê",
});
transliterate("אֱלֹהֶ֑יךָ", schema);
// ʾĕlōhêkā

---

SHUREQ

SHUREQ: string

Defined in: src/schema.ts:716

HEBREW LETTER VAV (U+05D5) and DAGESH (U+05BC) וּ

Example

const schema = new Schema({
  // truncated for brevity
  SHUREQ: "û",
});
transliterate("קוּם", schema);
// qûm

---

TSERE

TSERE: string

Defined in: src/schema.ts:398

HEBREW POINT TSERE (U+05B5) ֵ◌

Example

const schema = new Schema({
  // truncated for brevity
  TSERE: "ē",
});
transliterate("אֵשׁ", schema);
// ʾēš

Implementation of

SchemaVowels.TSERE

---

TSERE_HE?

optional TSERE_HE?: string

Defined in: src/schema.ts:801

HEBREW POINT TSERE (U+05B5) and HE (U+05D4) ה◌ֵ

Example

const schema = new Schema({
  // truncated for brevity
  TSERE_HE: "ê",
});
transliterate("הָאַרְיֵ֔ה", schema);
// hāʾaryê

---

TSERE_YOD

TSERE_YOD: string

Defined in: src/schema.ts:682

HEBREW POINT TSERE (U+05B5) and YOD (U+05D9) י◌ֵ

Example

const schema = new Schema({
  // truncated for brevity
  TSERE_YOD: "ê",
});
transliterate("אֵ֤ין", schema);
// ʾên

---

VOCAL_SHEVA

VOCAL_SHEVA: string

Defined in: src/schema.ts:318

HEBREW POINT SHEVA (U+05B0) ְ◌

Example

const schema = new Schema({
  // truncated for brevity
  VOCAL_SHEVA: "ə",
});
transliterate("סְלִ֣ק", schema);
// səliq