Giter VIP home page Giter VIP logo

Comments (23)

johnlockejrr avatar johnlockejrr commented on June 21, 2024 1

from hebrew-transliteration.

charlesLoder avatar charlesLoder commented on June 21, 2024 1

@JacobWeinbren

I'm glad you're finding the library useful!

As @johnlockejrr noted in Biblical Hebrew the sheva in בְּרוּכָה is most certainly vocal.

In Modern Hebrew, however, the sheva would be silent, so the bet and resh would be blended together like in English.

For your case, you could set the VOCAL_SHEVA to an empty string:

transliterate("בְּרוּכָה", { VOCAL_SHEVA: "" })
// brûkâ

This can be done on the website's interface as well.

This is probably you're best bet.

Though that solves your immediate use case, it will still give some incorrect results with a few words. For a word like לְבָנִים, even though it has an initial sheva like בְּרוּכָה, in Modern Hebrew, unlike בְּרוּכָה, the sheva is pronounced — lǝvanim.

If you're curious, there's more here.

Hope that helps

from hebrew-transliteration.

charlesLoder avatar charlesLoder commented on June 21, 2024 1

The rules in that stackexchange are for Biblical Hebrew. The first rule would apply to בְּרוּכָה making it a vocal sheva. The package already follows those rules by default, but the can be adjusted as well.

Using the JS package (it won't work well on the website), you can write an ADDITIONAL_FEATURE using a callback.

Coffin and Bolozky give a pretty detailed analysis of Modern Hebrew syllable structure in their work A Reference Grammar of Modern Hebrew

from hebrew-transliteration.

charlesLoder avatar charlesLoder commented on June 21, 2024 1

@JacobWeinbren

Here is a solution:

const str = "גְּדֹולִים לְבָנִים תְּשׁוּקָה תְּאוּנָה";
console.log(
  heb.transliterate(str, {
    longVowels: false,
    ADDITIONAL_FEATURES: [
      {
        FEATURE: "syllable",
        HEBREW: "\u{05B0}",
        TRANSLITERATION: (syllable, _hebrew, schema) => {
          // if vowel is not a shewa then shewa is silent, so skip
          if (syllable.vowel !== "\u{05B0}") return syllable.text;

          // if syllable vowel is a shewa and contains one of the following, then the shewa is vocal
          if (["י", "ל", "מ", "נ", "ר"].includes(syllable.onset)) {
            return syllable.text;
          }

          // if the syllable vowel is a shewa and the next syllable contains a guttural, then the shewa is vocal
          const next = syllable?.next?.value.onset;
          if (next && ["א", "ה", "ע"].includes(next)) {
            return syllable.text;
          }

          // else the shewa is silent
          return syllable.text.replace("\u{05B0}", "");
        }
      }
    ]
  })
);
// gdôlîm lǝbānîm tšûqâ tǝʾûnâ

As for an initial vav, thought the rules above would indicate that it is silent, I'm pretty sure it should be vocal.

Somewhere else you asked about — הוֹלְכִים. In Modern Israeli, a shewa after a long vowel is usually silent (like in the phrase "eykh omrim"). Theoretically, the longVowels option set to false should work, but there is a bug I need to fix

from hebrew-transliteration.

charlesLoder avatar charlesLoder commented on June 21, 2024 1

The longVowel option is part of the havarotjs package. I still need to make the issue for it.

(if the syllable is the last one it checks first).

Not sure I follow.

Here's an updated solution:

const str = "וְמֶלֶךְ יַלְדָּה גְּדֹולִים לְבָנִים תְּשׁוּקָה תְּאוּנָה";
console.log(
  heb.transliterate(str, {
    longVowels: false,
    ADDITIONAL_FEATURES: [
      {
        FEATURE: "syllable",
        HEBREW: /^\D{1,2}\u{05B0}/,
        TRANSLITERATION: (syllable, _hebrew, schema) => {
          // if vowel is not a shewa then shewa is silent, so skip
          if (syllable.vowel !== "\u{05B0}") {
            return syllable.text;
          }

          // if it is the first syallble and is conjunctive vav, then the shewa is vocal
          const isFirstSyllable = syllable.prev ? false : true;
          if (isFirstSyllable && syllable.text.includes("וְ")) {
            return syllable.text;
          }

          // if syllable vowel is a shewa and contains one of the following, then the shewa is vocal
          if (["י", "ל", "מ", "נ", "ר"].includes()) {
            return syllable.text;
          }

          // if the syllable vowel is a shewa and the next syllable contains a guttural, then the shewa is vocal
          const next = syllable?.next?.value.onset;
          if (next && ["א", "ה", "ע"].includes(next)) {
            return syllable.text;
          }

          // else the shewa is silent
          return syllable.text.replace("\u{05B0}", "");
        }
      }
    ]
  })
);
// wǝmelek yaldâ gdôlîm lbānîm tšûqâ tǝʾûnâ

Note the updated regex — /^\D{1,2}\u{05B0}/

You can fiddle around with it.

You can also extend a premade schema with destructuring

heb.transliterate(str, {
    ...brillSimple,
    ADDITIONAL_FEATURES: [
    // all the stuff
  ]
});

from hebrew-transliteration.

charlesLoder avatar charlesLoder commented on June 21, 2024 1

I don't understand why this causes the letters to switch in yalda

Normally, that issue arises from this block

hebrew-transliteration/src/rules.ts

Lines 350 to 355 in 6f97bf7

// this is the only way to make the "// regular syllables" block work
syl = new Syllable([new Cluster(transliteration(syl, seq.HEBREW, schema))], {
isClosed: syl.isClosed,
isAccented: syl.isAccented,
isFinal: syl.isFinal
});

It's just a poor design choice I made that needs to be refactored.

This is the error I get without adding the question mark. I think it is an error with the last syllable (which does not have a next).

You'll want to have the question marks for optional chaining; they're useful to see if the value exists or not.

from hebrew-transliteration.

charlesLoder avatar charlesLoder commented on June 21, 2024 1

Using the schema here, you can adjust the regex a little more:

- HEBREW: /\D{1,2}\u{05B0}/,
+ HEBREW: /^\D{1}[\u{05C1}|\u{05C2}]?\D{1}\u{05B0}/,

These regexes can get a little complicated.

In havarotjs, syllable.vowel says the vowel is null, and the letter is a vav. Which is why it isn't being picked up.

OK, I'll look into that a little more.

At some point, I need to sit down with both of these projects and really consider some good changes.

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder

Is there any way to address the other cases for modern Ivrit? How would I use Syllable.medial to achieve this?

https://judaism.stackexchange.com/questions/92599/what-are-the-rules-for-shva-na

  1. first letter of a word.
  2. second of two shvas under consecutive letters.
  3. after a tenua gedolah(long vowel), where the long vowel has no primary stress.(also some other cases, and can even be after a short vowel where the short vowel is "lengthened"/treated as a long vowel!)
  4. under a dagesh
  5. if a shva appears under the first of two consecutive identical letters (e.g., the first lamed of halleluyah)

This is the closest I could find to a comprehensive ruleset for all the cases where sheva is pronounced.

Thank you!

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder I am not confident enough in Hebrew to write a callback that would apply to most of the rules and exceptions of modern Ivrit to the vocal Shewa. Say we made the rules for long vowels, short vowels, first letters, identical letters, dagesh...there are so many potential exceptions. If I understand you correctly, this seems a significant roadblock to transcribing modern Ivrit.

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder Using the Additional Features, would something like this be what you are looking for?

It addresses the three rules outlined in A Reference Grammer of Modern Hebrew. But what about ve - e.g. וְחָלָב? Under these rules, it would be silent?

const heb = require("hebrew-transliteration");
const brillSimple = require("hebrew-transliteration/schemas").brillSimple;

let text = "גְּדֹולִים";
let transliterated = heb.transliterate(text, brillSimple, {
	ADDITIONAL_FEATURES: [
		{
			FEATURE: "syllable",
			HEBREW: ".*\u{05B0}.*", // matches any shewa in a syllable
			TRANSLITERATION: function (syllable, _hebrew, schema) {
				console.log("test");
				// If the shva should be vocal
				if (
					["י", "ל", "מ", "נ", "ר"].includes(syllable.text[0]) ||
					["א", "ה", "ע"].includes(syllable.text[1])
				) {
					return syllable.text.replace(
						new RegExp("\u{05B0}", "u"),
						schema["VOCAL_SHEVA"]
					);
				}
				// If none of the conditions are met, the shva is silent
				return syllable.text.replace(new RegExp("\u{05B0}", "u"), "");
			},
		},
		{
			FEATURE: "word",
			HEBREW: "\u{05B0}.*\u{05B0}", // matches any shewa that is preceded by another shewa in a word
			TRANSLITERATION: function (word, _hebrew, schema) {
				// Replace each shewa that is preceded by another shewa with a vocal shewa
				return word.text.replace(
					new RegExp("\u{05B0}.*\u{05B0}", "u"),
					schema["VOCAL_SHEVA"]
				);
			},
		},
	],
});

console.log(transliterated);

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder

Thanks a lot!

One fix to your code

const next = syllable?.next?.value?.onset;

(if the syllable is the last one it checks first).

Could we write in an edge case if the word begins with ve (וְ) 'and'? It is one of the most common lexemes (I'm sure you knew this already, apologies). Something like:

{
	FEATURE: "word",
	HEBREW: "^וְ",
	TRANSLITERATION: function (word, _hebrew, schema) {
		return word.text.replace("\u{05B0}", schema["VOCAL_SHEVA"]);
	},
},

Also, Is there any way I can help you with fixing the longVowels option?

EDIT: I see what you mean - יַלְדָּה produces ylada
EDIT 2: The third rule of shva, 'A shewa preceded by a shewa is typically vocal as well' doesn't work for מֵאַרְצְךָ

Thanks again!

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

Thank you for this. Regarding the longvowel if you make it an issue, I will try my best to help. How much does it come up in Hebrew do you think?

const next = syllable?.next?.value.onset;
                                                                          ^
TypeError: Cannot read properties of undefined (reading 'onset')
    at TRANSLITERATION (/Users/jacobweinbren/Desktop/test/test.js:32:40)
    at sylRules (/Users/jacobweinbren/Desktop/test/node_modules/hebrew-transliteration/dist/rules.js:274:70)
    at /Users/jacobweinbren/Desktop/test/node_modules/hebrew-transliteration/dist/transliterate.js:83:50
    at Array.map (<anonymous>)
    at /Users/jacobweinbren/Desktop/test/node_modules/hebrew-transliteration/dist/transliterate.js:83:18
    at Array.map (<anonymous>)
    at Object.transliterate (/Users/jacobweinbren/Desktop/test/node_modules/hebrew-transliteration/dist/transliterate.js:78:10)
    at Object.<anonymous> (/Users/jacobweinbren/Desktop/test/test.js:7:6)
    at Module._compile (node:internal/modules/cjs/loader:1159:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1213:10)

This is the error I get without adding the question mark. I think it is an error with the last syllable (which does not have a next).

Without going on too much of a tangent from the original issue (which you have very kindly solved), some exceptions still do not work due to the third rule, such as:

מִשְׁפְּחֹת = mishpechot

To solve this, I implemented this...hopefully this is ok?

{
  FEATURE: "word", // Apply rule at the word level
  HEBREW: /\u{05B0}/,  // Match Shva sign anywhere in word
  
  TRANSLITERATION: function (word, _hebrew, schema) {
    // Regular expression to match two consecutive Shvas with possible intervening diacritics
    const regex = /([\u{05D0}-\u{05EA}][\u{0591}-\u{05C7}]*)(\u{05B0})([\u{05D0}-\u{05EA}][\u{0591}-\u{05C7}]*)(\u{05B0})/gu;

    // Replace each match with first and third group followed by a vocal Shva
    const replaced = word.text.replace(regex, `$1$3${schema["VOCAL_SHEVA"]}`);
    
    return replaced; // Return transliterated word
  },
},

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder We can use syllable.prev to make the shva after the long vowel (hireq, qamets, tsere, segol, qibbuts, and shuruq) silent.

{
  FEATURE: "syllable", // Work on the syllable level
  HEBREW: /\u{05B0}/, // Match Shva in a syllable
  TRANSLITERATION: function (syllable, _hebrew, schema) {
    // If Shva follows a long vowel, make it silent
    if (syllable.prev && ["\u{05B4}", "\u{05B8}", "\u{05B5}", "\u{05B9}", "\u{05BB}"].includes(syllable.prev.vowel) && syllable.vowel === "\u{05B0}") {
      return syllable.text.replace(/\u{05B0}/u, '');
    }
    // Make second of consecutive Shvas vocal
    const replaced = syllable.text.replace(/([\u{05D0}-\u{05EA}][\u{0591}-\u{05C7}]*)(\u{05B0})([\u{05D0}-\u{05EA}][\u{0591}-\u{05C7}]*)(\u{05B0})/gu, `$1$3${schema["VOCAL_SHEVA"]}`);
    return replaced;
  },
},

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder Here is the full code to handle modern Ivrit. Thanks so much for helping!!

EDIT: This still doesn't work for מַה שְּׁלוֹמֵךְ, not sure why.

const heb = require("hebrew-transliteration");
const brillSimple = require("hebrew-transliteration/schemas").brillSimple;

// Arrays of characters for different conditions
const longVowels = ["\u{05B4}", "\u{05B8}", "\u{05B5}", "\u{05B9}", "\u{05BB}"];
const gutturals = ["א", "ה", "ע"];
const vocalChars = ["י", "ל", "מ", "נ", "ר"];

const schema = {
	...brillSimple,
	longVowels: false,
	ADDITIONAL_FEATURES: [
		{
			FEATURE: "word",
			// Regular expression to match Shva in a word
			HEBREW: /\D{1,2}\u{05B0}/,
			// Replace consecutive Shvas with a vocal Shva
			TRANSLITERATION: (word, _, schema) =>
				word.text.replace(
					/([\u{05D0}-\u{05EA}][\u{0591}-\u{05C7}]*)(\u{05B0})([\u{05D0}-\u{05EA}][\u{0591}-\u{05C7}]*)(\u{05B0})/gu,
					`$1$3${schema["VOCAL_SHEVA"]}`
				),
		},
		{
			FEATURE: "syllable",
			// Regular expression to match Shva at the start of a syllable
			HEBREW: /^\D{1,2}\u{05B0}/,
			// Handle rules of Shva in a syllable
			TRANSLITERATION: (syllable, _, schema) => {
				const isFirstSyllable = !syllable.prev;
				const nextOnset = syllable?.next?.value?.onset;

				// If Shva follows a long vowel, make it silent
				if (
					syllable.vowel === "\u{05B0}" &&
					syllable.prev &&
					longVowels.includes(syllable.prev.vowel)
				) {
					return syllable.text.replace(/\u{05B0}/u, "");
				}

				// If Shva is in the first syllable and is a conjunctive vav, make it vocal
				if (isFirstSyllable && syllable.text.includes("וְ")) {
					return syllable.text;
				}

				// If Shva follows one of the characters in vocalChars, make it vocal
				if (vocalChars.includes(syllable.text.charAt(0))) {
					return syllable.text;
				}

				// If the next syllable contains a guttural, make Shva vocal
				if (nextOnset && gutturals.includes(nextOnset)) {
					return syllable.text;
				}

				// If none of the above conditions are met, return the original syllable text
				return syllable.text;
			},
		},
	],
};

console.log(heb.transliterate("בְּרוּכָה הַבָּאָה", schema));
console.log(heb.transliterate("הוֹלְכִים", schema));
console.log(heb.transliterate("יַלְדָּה", schema));
console.log(heb.transliterate("מִשְׁפְּחֹת", schema));
console.log(heb.transliterate("וְאָנִי", schema));

Produces

brukha habba’a
holkhim
yalda
mishpᵉḥot
vᵉ’ani

I will try and work on this more tomorrow.

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder I don't understand why this causes the letters to switch in yalda

{
			FEATURE: "syllable",
			// Regular expression to match Shva in a word
			HEBREW: /\D{1,2}\u{05B0}/,
			// Replace consecutive Shvas with a vocal Shva
			TRANSLITERATION: (syllable, _, schema) => {
				return syllable.text;
			},
		},

It makes it hard to fix the מַה שְּׁלוֹמֵךְ problem

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder I can't find any obvious solution other than reversing clusters, but this causes even more problems.

With the final return changed to return syllable.text.replace(/\u{05B0}/u, ""); I am getting this

brukha habba’a // correct
holkhim // correct
ylada // should be: yalda
mishpᵉḥot // correct
vᵉ’ani // correct
mah shlomkhe // should be: mah shlomekh

Thanks for posting the longVowels issue, I will take a look.

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder Managed to fix the word ordering bug and potentially the long vowel issue you raised - but אַנְגְּלִית produces issues. Not sure what I can do about these exceptions, or is there a rule I am missing?

from hebrew-transliteration.

charlesLoder avatar charlesLoder commented on June 21, 2024

@JacobWeinbren

What's your schema look like now?

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder It looks like this - thanks a lot!

const heb = require("hebrew-transliteration");
const brillSimple = require("hebrew-transliteration/schemas").brillSimple;

// Arrays of characters for different conditions
const longVowels = ["\u{05B4}", "\u{05B8}", "\u{05B5}", "\u{05B9}", "\u{05BB}"];
const gutturals = ["א", "ה", "ע"];
const vocalChars = ["י", "ל", "מ", "נ", "ר"];

const schema = {
	...brillSimple,
	longVowels: false,
	ADDITIONAL_FEATURES: [
		{
			FEATURE: "word",
			// Regular expression to match Shva in a word
			HEBREW: /\D{1,2}\u{05B0}/,
			// Replace consecutive Shvas with a vocal Shva
			TRANSLITERATION: (word, _, schema) =>
				word.text.replace(
					/([\u{05D0}-\u{05EA}][\u{0591}-\u{05C7}]*)(\u{05B0})([\u{05D0}-\u{05EA}][\u{0591}-\u{05C7}]*)(\u{05B0})/gu,
					`$1$3${schema["VOCAL_SHEVA"]}`
				),
		},
		{
			FEATURE: "syllable",
			// Regular expression to match Shva at the start of a syllable
			HEBREW: /\D{1,2}\u{05B0}/,
			// Handle rules of Shva in a syllable
			TRANSLITERATION: (syllable, _, schema) => {
				const isFirstSyllable = !syllable.prev;
				const nextOnset = syllable?.next?.value?.onset;

				if (
					// If Shva follows a long vowel, make it silent
					syllable.prev &&
					longVowels.includes(syllable.prev.vowel)
				) {
					return syllable.text.replace(/\u{05B0}/u, "");
				}

				if (
					// If Shva is in the first syllable and is a conjunctive vav, make it vocal
					(isFirstSyllable && syllable.text.includes("וְ")) ||
					// If Shva follows one of the characters in vocalChars, make it vocal
					vocalChars.includes(syllable.text.charAt(0)) ||
					// If the next syllable contains a guttural, make Shva vocal
					(nextOnset && gutturals.includes(nextOnset))
				) {
					return syllable.text;
				}

				return syllable.text.replace(/\u{05B0}/u, "");
			},
		},
	],
};

console.log(heb.transliterate("בְּרוּכָה הַבָּאָה", schema));
console.log(heb.transliterate("הוֹלְכִים", schema));
console.log(heb.transliterate("יַלְדָּה", schema));
console.log(heb.transliterate("מִשְׁפְּחֹת", schema));
console.log(heb.transliterate("וְאָנִי", schema));
console.log(heb.transliterate("מַה שְּׁלוֹמֵךְ", schema));

Produces

brukha habba’a
holᵉkhim //wrong
yalda
mishpᵉḥot
vᵉ’ani
mah shlomekh

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder One of the issues with long vowels is the other kinds of long vowels that aren't just below letters. הוֹלְכִים has a vav with a dot on top. In havarotjs, syllable.vowel says the vowel is null, and the letter is a vav. Which is why it isn't being picked up.

In Hebrew, certain consonants ("א", "ה", "ו", "י") can serve as matres lectionis, that is, they can represent vowel sounds. The "ו" with a dot above it (Holam Male) represents a long "o" sound.

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder Also, thanks a lot for continuing to help!!

EDIT: /^\D{1}[\u{05C1}|\u{05C2}]?\D{1}\u{05B0}/ seems to break the schema?

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder Not to go full circle. I removed the letter-switching change I made, and added detection for holam male. It works for holkhim. But yalda is still acting up.

EDIT: And when I add the fix, holkhim goes back to being a vocal shva (because clusters break), but yalda works.

from hebrew-transliteration.

JacobWeinbren avatar JacobWeinbren commented on June 21, 2024

@charlesLoder Finally can get some sleep.

Ok so the pull request I have tested and it works. The issue with the long vowels? You can see it being tested here. /^\D{1}[\u{05C1}|\u{05C2}]?\D{1}\u{05B0}/ seems to breaks things but if you can show me how to make it work properly - I'm open ears. Not 100% sure why we are testing for shin or sin? אַנְגְּלִית also doesn't work - but you'd expect that because it breaks the two shva's in a row rule.

Anyway, as a novice, I am super pleased with this. Thanks a lot!

const heb = require("hebrew-transliteration");
const brillSimple = require("hebrew-transliteration/schemas").brillSimple;

// Arrays of characters for different conditions
const gutturals = ["א", "ה", "ע"];
const vocalChars = ["י", "ל", "מ", "נ", "ר"];

const schema = {
	...brillSimple,
	longVowels: false,
	ADDITIONAL_FEATURES: [
		{
			FEATURE: "word",
			// Regular expression to match Shva in a word
			HEBREW: /\D{1,2}\u{05B0}/,
			// Replace consecutive Shvas with a vocal Shva
			TRANSLITERATION: (word, _, schema) =>
				word.text.replace(
					/([\u{05D0}-\u{05EA}][\u{0591}-\u{05C7}]*)(\u{05B0})([\u{05D0}-\u{05EA}][\u{0591}-\u{05C7}]*)(\u{05B0})/gu,
					`$1$3${schema["VOCAL_SHEVA"]}`
				),
		},
		{
			FEATURE: "syllable",
			// Regular expression to match Shva at the start of a syllable
			HEBREW: /\D{1,2}\u{05B0}/,
			// Handle rules of Shva in a syllable
			TRANSLITERATION: (syllable, _, schema) => {
				const isFirstSyllable = !syllable.prev;
				const nextOnset = syllable?.next?.value?.onset;

				if (
					// If Shva follows a long vowel, make it silent
					syllable.prev &&
					/[\u{05B5}\u{05B8}\u{05B9}\u{05BA}\u05B9]/u.test(
						syllable.prev.text
					)
				) {
					return syllable.text.replace(/\u{05B0}/u, "");
				}

				if (
					// If Shva is in the first syllable and is a conjunctive vav, make it vocal
					(isFirstSyllable && syllable.text.includes("וְ")) ||
					// If Shva follows one of the characters in vocalChars, make it vocal
					vocalChars.includes(syllable.text.charAt(0)) ||
					// If the next syllable contains a guttural, make Shva vocal
					(nextOnset && gutturals.includes(nextOnset))
				) {
					return syllable.text;
				}

				return syllable.text.replace(/\u{05B0}/u, "");
			},
		},
	],
};

console.log(heb.transliterate("בְּרוּכָה הַבָּאָה", schema));
console.log(heb.transliterate("הוֹלְכִים", schema));
console.log(heb.transliterate("יַלְדָּה", schema));
console.log(heb.transliterate("מִשְׁפְּחֹת", schema));
console.log(heb.transliterate("וְאָנִי", schema));
console.log(heb.transliterate("מַה שְּׁלוֹמֵךְ", schema));

Returns

brukha habba’a
holkhim
yalda
mishpᵉḥot
vᵉ’ani
mah shlomekh

from hebrew-transliteration.

Related Issues (20)

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.