hebrew-transliteration 1.2.6 → 2.0.0

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2022 Charles Loder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,16 +1,20 @@
 # hebrew-transliteration
 
-Transliterate Unicode Hebrew text according to SBL's guidelines
+A JavaScript package for transliterating Hebrew
 
 ## install
 
 ### npm
 
-`npm install --save hebrew-transliteration`
+```bash
+npm install hebrew-transliteration
+```
 
 ### local
 
-Download or clone this repository.
+You will need to have [node installed](https://nodejs.org/en/download/).
+
+Download or clone this repository
 
 ```bash
 cd hebrew-transliteration
@@ -23,74 +27,291 @@ npm run build
 ```javascript
 const heb = require("hebrew-transliteration");
 const transliterate = heb.transliterate;
-
-transliterate("אֱלֹהִים") >>> "ʾĕlōhîm";
+transliterate("אֱלֹהִים");
+// ʾĕlōhîm
 ```
 
 ## DOCS
 
-### transliterate
+### About
+
+This is a JavaScript package for transliterating Hebrew.
+
+It exports 3 [functions](#functions):
+
+1. [`transliterate()`](#transliterate) — the main function which transliterates Hebrew
+2. [`remove()`](#remove) — removes taamim and optionally removes certain niqqudim
+3. [`sequence()`](#sequence) — sequences Hebrew characters according to the [SBL Hebrew Font Manual](https://www.sbl-site.org/Fonts/SBLHebrewUserManual1.5x.pdf)
+
+And it exports 2 [classes](#classes):
+
+1. [`Text`](#text) — the [`Text`](https://charlesloder.github.io/havarot/classes/text.Text.html) class from the `havarotjs` package
+2. [`Schema`](#schema) — a schema for transliterating Hebrew
+
+### Functions
+
+#### `transliterate()`
+
+Takes a `string` or [`Text`](#text), and optionally a [`Schema`](#schema) or `Partial<Schema>`
 
 ```javascript
-heb.transliterate(text, { isSequenced: true, qametsQatan: false, isSimple: false });
+heb.transliterate("אֱלֹהִים");
+// "ʾĕlōhîm";
 ```
 
-Takes `text` \<\<String\>\> and `[options]` \<\<Object\>\>.
+If no [`Schema`](#schema) is passed, then the package defaults to SBL's academic style.
+
+You can pass in a `Partial<Schema>` that will modify SBL's academic style:
+
+```javascript
+heb.transliterate("שָׁלוֹם", { SHIN: "sh" });
+// shālôm
+```
+
+If you need a fully customized transliteration, it is best to use the [`Schema`](#schema) constructor:
 
 ```javascript
-heb.transliterate("כָּל־הָעָם") >>> "kāl-hāʿām";
+const schema = new heb.Schema({
+  ALEF: "'",
+  BET: "B",
+  ...
+  QAMETS: "A",
+  ...
+}) // truncated for brevity
+
+heb.transliterate("אָ֣ב", schema)
+// 'AB
+```
 
-heb.transliterate("כָּל־הָעָם", { qametsQatan: true }) >>> "kol-hāʿām";
+---
+
+#### `remove()`
+
+Takes `string` and options. The default only removes taamim (i.e., accent or cantillation) marks.
+
+```javascript
+heb.remove("שָׂרַ֣י אִשְׁתְּךָ֔");
+// "שָׂרַי אִשְׁתְּךָ";
 
-heb.transliterate("שָׁלֹום") >>> "šālôm";
+heb.remove("שָׂרַ֣י אִשְׁתְּךָ֔", { removeVowels: true });
+// "שׂרי אשׁתך";
 
-heb.transliterate("שָׁלֹום", { isSimple: true }) >>> "shalom";
+heb.remove("שָׂרַ֣י אִשְׁתְּךָ֔", { removeVowels: true, removeShinDot: true, removeSinDot: true });
+// "שרי אשתך";
 ```
 
 ---
 
-### remove
+#### `sequence()`
+
+Takes a `string`. Returns a string of properly sequenced characters according to the [SBL Hebrew Font manual](https://www.sbl-site.org/Fonts/SBLHebrewUserManual1.5x.pdf) following the pattern of: consonant - dagesh - vowel - ta'am
 
 ```javascript
-heb.remove(text, { removeVowels: false });
+heb.sequence("\u{5D1}\u{5B0}\u{5BC}\u{5E8}\u{5B5}\u{5D0}\u{5E9}\u{5B4}\u{5C1}\u{596}\u{5D9}\u{5EA}");
+//           "\u{5D1}\u{5BC}\u{5B0}\u{5E8}\u{5B5}\u{5D0}\u{5E9}\u{5C1}\u{5B4}\u{596}\u{5D9}\u{5EA}"
 ```
 
-Takes `text` \<\<String\>\> and `[options]` \<\<Object\>\>. With `{removeVowels: false}`, will only remove cantillation (i.e., accent) marks.
+### Classes
+
+#### Text
+
+The [`Text`](https://charlesloder.github.io/havarot/classes/text.Text.html) class from the [`havarotjs`](https://www.npmjs.com/package/havarotjs) package.
+
+This class is used by [`transliterate()`](#transliterate) internally to syllabify Hebrew text, but it is exposed as well.
 
 ```javascript
-heb.remove("כָּל־הָעָם", { removeVowels: true }) >>> "כל־העם";
+const text = new heb.Text("הֲבָרֹות");
+text.syllables;
+// [
+//    Syllable { original: "הֲ" },
+//    Syllable { original: "בָ" },
+//    Syllable { original: "רֹות" }
+//  ]
 ```
 
----
+If a `Text` is passed into [`transliterate()`](#transliterate) instead of a `string`, then the syllabification from the `Text` class is used.
+If a `string` is passed in, then syllabification come from the options passed into the [`Schema`](#schema).
+See more under [syllabification](#syllabification).
+
+#### Schema
 
-### sequence
+A `Schema` is used to define a schema for transliteration. See the [`Schema` source](src/schema.ts) for all available properties.
+
+The `Schema` can be divided into a few categories.
+
+##### 1) Syllabification
+
+The options used for syllabifying Hebrew text can be found [here](https://charlesloder.github.io/havarot/interfaces/text.SylOpts.html)
+
+###### Differences between `Text` and `Schema`
+
+There are 5 options for syllabification that are the [same as the ones used by the `Text`](https://charlesloder.github.io/havarot/interfaces/text.SylOpts.html) class. The only `Text` syllabification option that `Schema` does not use is `schema` (yes, that's confusing):
 
 ```javascript
-heb.sequence(text);
+const text = new heb.Text("חׇכְמָ֣ה", { schema: "traditional" }); // this is okay
+const schema = new heb.Schema({ schema: "traditional" }); // this does nothing
 ```
 
-Takes `text` \<\<String\>\>. Returns a string of properly sequenced characters according to the [SBL Hebrew Font manual](https://www.sbl-site.org/Fonts/SBLHebrewUserManual1.5x.pdf).
+Read more about the syllabification options for the [`Text`](https://charlesloder.github.io/havarot/interfaces/text.SylOpts.html) and a [higher level overview](https://charlesloder.github.io/havarot/pages/Linguistic/syllabification.html)
+
+###### Precedence of `Text` over `Schema`
+
+The syllabification options set by `Schema` are used if a `string` is passed into [`transliterate()`](#transliterate). If a `Text` is passed into [`transliterate()`](#transliterate) instead of a `string`, then the syllabification from the `Text` class is used:
 
 ```javascript
-heb.sequence("\u{5D1}\u{5B0}\u{5BC}\u{5E8}\u{5B5}\u{5D0}\u{5E9}\u{5B4}\u{5C1}\u{596}\u{5D9}\u{5EA}") >>>
-  "\u{5D1}\u{5BC}\u{5B0}\u{5E8}\u{5B5}\u{5D0}\u{5E9}\u{5C1}\u{5B4}\u{596}\u{5D9}\u{5EA}";
+// using default
+heb.transliterate("חָכְמָ֣ה"); // ḥokmâ
+
+// using Schema for syllabification
+heb.transliterate("חָכְמָ֣ה", { qametsQatan: false }); // ḥākǝmâ
+
+// using Text for syllabification
+heb.transliterate(new heb.Text("חָכְמָ֣ה", { qametsQatan: false })); // ḥākǝmâ
+
+// using Schema and Text — Text takes precedence
+heb.transliterate(new heb.Text("חָכְמָ֣ה", { qametsQatan: true }), { qametsQatan: false }); // ḥokmâ
 ```
 
-## License
+**Note**: `qametsQatan` only converts a regular _qamets_ character; if a [_qamets qatan_ character](https://www.compart.com/en/unicode/U+05C7) is used, it will always be a _qamets qatan_.
 
-MIT
+##### 2) Characters
 
-## Live
+Most `Schema` properties are for defining single Hebrew characters:
 
-Use it live at [charlesLoder.github.io/hebrewTransliteration](https://charlesloder.github.io/hebrewTransliteration/index.html)
+```javascript
+heb.transliterate("אָ", { ALEF: "@", QAMETS: "A" });
+// @A
+```
+
+##### 3) Orthographic Features
+
+Some properties are for defining common Hebrew orthographies for:
+
+###### _BeGaDKePhaT_
 
-## Changelog
+There are properties for the digraphs of _BeGaDKePhaT_ letters:
 
-- v1.1.0: in `transliterate()` the `options` was changed from the misspelled `isSeqeunced` to `isSequenced`.
-- v1.2.0:
-  - rewrote in in TypeScript
-  - added `isSimple` option to `transliterate()` for SBL's General Purpose Style
+- `BET_DAGESH`
+- `GIMEL_DAGESH`
+- `DALET_DAGESH`
+- `KAF_DAGESH`
+- `PE_DAGESH`
+- `TAV_DAGESH`
+
+Each one is the consonant character followed by the _dagesh_ character (U+05BC).
+
+These are helpful for distinguishing between spirantized forms.
+
+```javascript
+heb.transliterate("בְּבֵית", { BET: "b" });
+// bǝbêt
+
+heb.transliterate("בְּבֵית", { BET: "v", BET_DAGESH: "b" });
+// bǝvêt
+```
+
+###### Matres Lectionis
+
+The following properties are for _matres lectionis_:
+
+- `HIRIQ_YOD`
+- `TSERE_YOD`
+- `SEGOL_YOD`
+- `SHUREQ`
+- `HOLAM_VAV`
+- `QAMATS_HE`
+- `SEGOL_HE`
+- `TSERE_HE`
+
+```javascript
+heb.transliterate("פֶּה", { SEGOL_HE: "é" });
+// pé
+```
+
+###### Others
+
+There are other orthographic features:
+
+- `MS_SUFX` — HEBREW LETTER QAMATS (U+05B8) and YOD (U+05D9) and VAV (U+05D5) יו◌ָ
+- `DIVINE_NAME` — the full form of the divine name - יהוה
+- `SYLLABLE_SEPARATOR` — a syllable separator, usually an empty string
+- `DAGESH_CHAZAQ` — if true, repeats the consonant with the _dagesh_
+
+```javascript
+heb.transliterate("שַׁבָּת", { DAGESH_CHAZAQ: true });
+// šabbāt
+
+heb.transliterate("שַׁבָּת", { DAGESH_CHAZAQ: false });
+// šabāt
+
+heb.transliterate("הָאָֽרֶץ", { SYLLABLE_SEPARATOR: "-" });
+// hā-ʾā-reṣ
+```
+
+##### 4) Others
+
+###### Additional Features
+
+The `ADDITIONAL_FEATURES` property is for defining non-typical Hebrew orthography, example:
+
+```javascript
+heb.transliterate("הַזֹּאת", {
+  ADDITIONAL_FEATURES: [
+    {
+      FEATURE: "cluster",
+      HEBREW: "זּ",
+      TRANSLITERATION: "tz"
+    }
+  ]
+});
+// hatzōʾt
+```
+
+- The orthography `זּ` is most often a doubling of the `ZAYIN` (i.e. `'z'` with no _dagesh_, and `'zz'` with a _dagesh chazaq_)
+- In the Romaniote reading tradition, however, the `ZAYIN` is usually transliterated with `'z'` (really `'ζ'`),
+- but a `ZAYIN` followed by a _dagesh_ is transliterated as `'tz'` (really `'τζ'`)
+
+Each additional feature consists of 3 parts:
+
+1. `FEATURE` — has three options:
+  - `"cluster"` — a `cluster` is any combination of a single character and optionally a *dagesh* and vowel.
+  - `"syllable"` — a `syllable` is any combination of a multiple characters and a single vowel and optionally a *dagesh*
+  - `"word"` — covers everything else
+2. `HEBREW` — the Hebrew text to be transliterated
+3. `TRANSLITERATION` — the text used to transliterate the Hebrew text
+
+:warning: this is an experimental property; results may not always meet expectations
+
+###### Stress Marker
+
+The `STRESS_MARKER` property is an optional mark to indicate stress in transliteration.
+
+```javascript
+heb.transliterate("מֶ֣לֶךְ", { STRESS_MARKER: { location: "after-vowel", mark: "\u0301" } });
+// mélek
+```
+
+The `location` has four options:
+
+- `"before-syllable"`
+- `"after-syllable"`
+- `"before-vowel"`
+- `"after-vowel"`
+
+A combining mark (e.g. `"\u0301"`) placed `"after-vowel"` will print on top of the vowel, and placed after a digraph will print on the second vowel.
+
+```javascript
+heb.transliterate("בֵּ֣ית", {
+  TSERE_YOD: "ei",
+  STRESS_MARKER: { location: "after-vowel", mark: "\u0301" }
+});
+// beít
+```
+
+## Live
+
+Use it live at [charlesLoder.github.io/hebrewTransliteration](https://charlesloder.github.io/hebrewTransliteration/index.html)
 
 ## Contributing
 
-Please feel free to Fork, create Pull Requests, or submit issues. This is my first npm package, so any feedback is appreciated!
+See [contributing](./CONTRIBUTING.md)

package/dist/hebCharsTrans.d.ts

@@ -1,2 +1,6 @@
-import { Dict } from "./interfaces";
-export declare const transliterateMap: Dict;
+import { Schema } from "./schema";
+interface map {
+    [k: string]: keyof Schema;
+}
+export declare const transliterateMap: map;
+export {};

package/dist/hebCharsTrans.js

@@ -3,52 +3,55 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transliterateMap = void 0;
 exports.transliterateMap = {
     //   niqqud
-    "\u05B0": "ǝ",
-    "\u05B1": "ĕ",
-    "\u05B2": "ă",
-    "\u05B3": "ŏ",
-    "\u05B4": "i",
-    "\u05B5": "ē",
-    "\u05B6": "e",
-    "\u05B7": "a",
-    "\u05B8": "ā",
-    "\u05B9": "ō",
-    "\u05BA": "ō",
-    "\u05BB": "u",
-    //  "\u{05BC}": "", // HEBREW POINT DAGESH OR MAPIQ (U+05BC)
+    "\u{05B0}": "VOCAL_SHEVA",
+    "\u{05B1}": "HATAF_SEGOL",
+    "\u{05B2}": "HATAF_PATAH",
+    "\u{05B3}": "HATAF_QAMATS",
+    "\u{05B4}": "HIRIQ",
+    "\u{05B5}": "TSERE",
+    "\u{05B6}": "SEGOL",
+    "\u{05B7}": "PATAH",
+    "\u{05B8}": "QAMATS",
+    "\u{05B9}": "HOLAM",
+    "\u{05BA}": "HOLAM",
+    "\u{05BB}": "QUBUTS",
+    "\u{05BC}": "DAGESH",
     //  "\u{05BD}": "", // HEBREW POINT METEG (U+05BD)
-    "\u05BE": "-",
-    "\u05C7": "ο",
+    "\u{05BE}": "MAQAF",
+    "\u{05C0}": "PASEQ",
+    "\u{05C3}": "SOF_PASUQ",
+    "\u{05C7}": "QAMATS_QATAN",
     //   consonants
-    א: "ʾ",
-    ב: "b",
-    ג: "g",
-    ד: "d",
-    ה: "h",
-    ו: "w",
-    ז: "z",
-    ח: "ḥ",
-    ט: "ṭ",
-    י: "y",
-    ך: "k",
-    כ: "k",
-    ל: "l",
-    ם: "m",
-    מ: "m",
-    ן: "n",
-    נ: "n",
-    ס: "s",
-    ע: "ʿ",
-    ף: "p",
-    פ: "p",
-    ץ: "ṣ",
-    צ: "ṣ",
-    ק: "q",
-    ר: "r",
-    ש: "š",
-    ת: "t",
-    "\u05EF": "",
-    װ: "",
-    ױ: "",
-    ײ: "" // HEBREW LIGATURE YIDDISH DOUBLE YOD (U+05F2)
+    א: "ALEF",
+    ב: "BET",
+    ג: "GIMEL",
+    ד: "DALET",
+    ה: "HE",
+    ו: "VAV",
+    ז: "ZAYIN",
+    ח: "HET",
+    ט: "TET",
+    י: "YOD",
+    ך: "FINAL_KAF",
+    כ: "KAF",
+    ל: "LAMED",
+    ם: "FINAL_MEM",
+    מ: "MEM",
+    ן: "FINAL_NUN",
+    נ: "NUN",
+    ס: "SAMEKH",
+    ע: "AYIN",
+    ף: "FINAL_PE",
+    פ: "PE",
+    ץ: "FINAL_TSADI",
+    צ: "TSADI",
+    ק: "QOF",
+    ר: "RESH",
+    ש: "SHIN",
+    ת: "TAV" // HEBREW LETTER TAV (U+05EA)
+    // "\u{05EF}": "", // HEBREW YOD TRIANGLE (U+05EF)
+    // װ: "", // HEBREW LIGATURE YIDDISH DOUBLE VAV (U+05F0)
+    // ױ: "", // HEBREW LIGATURE YIDDISH VAV YOD (U+05F1)
+    // ײ: "" // HEBREW LIGATURE YIDDISH DOUBLE YOD (U+05F2)
 };
+//# sourceMappingURL=hebCharsTrans.js.map

package/dist/hebCharsTrans.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hebCharsTrans.js","sourceRoot":"","sources":["../src/hebCharsTrans.ts"],"names":[],"mappings":";;;AAMa,QAAA,gBAAgB,GAAQ;IACnC,WAAW;IACX,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE,cAAc;IAC1B,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE,QAAQ;IACpB,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE,QAAQ;IACpB,UAAU,EAAE,QAAQ;IACpB,kDAAkD;IAClD,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE,WAAW;IACvB,UAAU,EAAE,cAAc;IAC1B,eAAe;IACf,CAAC,EAAE,MAAM;IACT,CAAC,EAAE,KAAK;IACR,CAAC,EAAE,OAAO;IACV,CAAC,EAAE,OAAO;IACV,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,KAAK;IACR,CAAC,EAAE,OAAO;IACV,CAAC,EAAE,KAAK;IACR,CAAC,EAAE,KAAK;IACR,CAAC,EAAE,KAAK;IACR,CAAC,EAAE,WAAW;IACd,CAAC,EAAE,KAAK;IACR,CAAC,EAAE,OAAO;IACV,CAAC,EAAE,WAAW;IACd,CAAC,EAAE,KAAK;IACR,CAAC,EAAE,WAAW;IACd,CAAC,EAAE,KAAK;IACR,CAAC,EAAE,QAAQ;IACX,CAAC,EAAE,MAAM;IACT,CAAC,EAAE,UAAU;IACb,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,aAAa;IAChB,CAAC,EAAE,OAAO;IACV,CAAC,EAAE,KAAK;IACR,CAAC,EAAE,MAAM;IACT,CAAC,EAAE,MAAM;IACT,CAAC,EAAE,KAAK,CAAC,6BAA6B;IACtC,kDAAkD;IAClD,wDAAwD;IACxD,qDAAqD;IACrD,uDAAuD;CACxD,CAAC"}

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-import { TransOptions, RemoveOptions } from "./interfaces";
-export declare const transliterate: (text: string, { isSequenced, qametsQatan, isSimple }?: TransOptions) => string;
-export declare const remove: (text: string, { removeVowels }?: RemoveOptions) => string;
-export declare const sequence: (text: string) => string;
+import { Text } from "havarotjs";
+import { transliterate } from "./transliterate";
+import { sequence } from "./sequence";
+import { remove } from "./remove";
+import { Schema } from "./schema";
+export { remove, Schema, sequence, Text, transliterate };

package/dist/index.js

@@ -1,22 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sequence = exports.remove = exports.transliterate = void 0;
-var transliterate_1 = require("./transliterate");
-var sequence_1 = require("./sequence");
-var remove_1 = require("./remove");
-exports.transliterate = function (text, _a) {
-    var _b = _a === void 0 ? {} : _a, _c = _b.isSequenced, isSequenced = _c === void 0 ? true : _c, _d = _b.qametsQatan, qametsQatan = _d === void 0 ? false : _d, _e = _b.isSimple, isSimple = _e === void 0 ? false : _e;
-    var normalized = text.normalize("NFKD");
-    return transliterate_1.Transliterate(normalized, { isSequenced: isSequenced, qametsQatan: qametsQatan, isSimple: isSimple });
-};
-exports.remove = function (text, _a) {
-    var _b = (_a === void 0 ? {} : _a).removeVowels, removeVowels = _b === void 0 ? false : _b;
-    var normalized = text.normalize("NFKD");
-    var removed = remove_1.Remove(normalized, { removeVowels: removeVowels });
-    var noMetheg = removed.replace(/\u{05BD}/gu, "");
-    return noMetheg;
-};
-exports.sequence = function (text) {
-    var normalized = text.normalize("NFKD");
-    return sequence_1.Sequence(normalized);
-};
+exports.transliterate = exports.Text = exports.sequence = exports.Schema = exports.remove = void 0;
+const havarotjs_1 = require("havarotjs");
+Object.defineProperty(exports, "Text", { enumerable: true, get: function () { return havarotjs_1.Text; } });
+const transliterate_1 = require("./transliterate");
+Object.defineProperty(exports, "transliterate", { enumerable: true, get: function () { return transliterate_1.transliterate; } });
+const sequence_1 = require("./sequence");
+Object.defineProperty(exports, "sequence", { enumerable: true, get: function () { return sequence_1.sequence; } });
+const remove_1 = require("./remove");
+Object.defineProperty(exports, "remove", { enumerable: true, get: function () { return remove_1.remove; } });
+const schema_1 = require("./schema");
+Object.defineProperty(exports, "Schema", { enumerable: true, get: function () { return schema_1.Schema; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,yCAAiC;AAME,qFAN1B,gBAAI,OAM0B;AALvC,mDAAgD;AAKP,8FALhC,6BAAa,OAKgC;AAJtD,yCAAsC;AAIb,yFAJhB,mBAAQ,OAIgB;AAHjC,qCAAkC;AAGzB,uFAHA,eAAM,OAGA;AAFf,qCAAkC;AAEjB,uFAFR,eAAM,OAEQ"}