scripture-guide 1.0.12 → 1.0.14
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/data/scriptdetect.js +84 -0
- package/data/scriptlang.js +160 -0
- package/package.json +2 -1
- package/scriptures-compiled.js +203 -74
- package/scriptures.js +127 -24
- package/test-detect.js +34 -0
- package/test-lang.js +54 -0
|
@@ -0,0 +1,84 @@
|
|
|
1
|
+
|
|
2
|
+
const prepareBlacklist = (lang_extras) => {
|
|
3
|
+
var blacklist = [];
|
|
4
|
+
blacklist.push("\\d{4,}"); // 4 Digit references
|
|
5
|
+
blacklist.push("^Ch\\. \\d+"); //Chapter with no book
|
|
6
|
+
blacklist.push("\\w\\w\\d\\d"); //Words with numbers together KGURO43KEAJFK
|
|
7
|
+
|
|
8
|
+
//Oneoff Blacklist
|
|
9
|
+
blacklist.push("\\bro \\d+\\b"); //lowecase letters followed by numbers
|
|
10
|
+
blacklist.push("\\bETH \\d+\.\\d+\\b");
|
|
11
|
+
blacklist.push("\\b(BC|AD|BCE)[––—−]+\\d+\\b"); //550 BC–330 BC
|
|
12
|
+
blacklist.push("\\b(AC3|PS2|PS3|PS4)\\b"); //Common file extentions
|
|
13
|
+
blacklist.push("\\b(ps|PS)[1-9]\\b"); //Common file extentions'
|
|
14
|
+
|
|
15
|
+
var blacklist_pattern = new RegExp("(" + blacklist.join("|") + ")", 'g');
|
|
16
|
+
|
|
17
|
+
return blacklist_pattern;
|
|
18
|
+
}
|
|
19
|
+
|
|
20
|
+
const preparePattern = (booklist,wordBreak,lang_extras) => {
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
wordBreak = wordBreak || "";
|
|
24
|
+
lang_chapter = lang_extras?.chapter || "";
|
|
25
|
+
lang_verse = lang_extras?.verse || "";
|
|
26
|
+
|
|
27
|
+
var bookregex = booklist.map(b=>{
|
|
28
|
+
return b[0];
|
|
29
|
+
});
|
|
30
|
+
|
|
31
|
+
//Combine Books
|
|
32
|
+
const books = "(?:" + bookregex.join("|") + ")\\s*"; // \\(*
|
|
33
|
+
|
|
34
|
+
//Books that have a digit before them
|
|
35
|
+
var numbooks = [];
|
|
36
|
+
numbooks.push("ne");
|
|
37
|
+
numbooks.push("sam");
|
|
38
|
+
numbooks.push("ki*n*gs");
|
|
39
|
+
numbooks.push("chr");
|
|
40
|
+
numbooks.push("cor");
|
|
41
|
+
numbooks.push("ti");
|
|
42
|
+
numbooks.push("thes");
|
|
43
|
+
numbooks.push("pet");
|
|
44
|
+
numbooks.push("jo*h*n");
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
//Meta data components
|
|
48
|
+
var jst = "(?:[, —\\-]*(?:Joseph Smith[']*s* Translation *o*f*|\\(Joseph Smith[']*s* Translation *o*f*\\)|jst|\\(jst\\))[, \\—\\-)]*)*";
|
|
49
|
+
var ordinals = `(?:[I1-4]*(?:3rd|1st|2n*d|4th|first|sec*o*n*d*\\.*|third|fourt*h*)* *${wordBreak})*`;
|
|
50
|
+
var booksof = "(?:\\s*books* of\\s*)*";
|
|
51
|
+
var prechapter = "(?:\\s|\\-|–|,)*";
|
|
52
|
+
var chapter = `(?:,*\\s*` + ordinals + `${wordBreak}cha*p*t*e*r*s*\\.*,*\\s*)`;
|
|
53
|
+
var verse = `(?:,*\\s*` + ordinals + `${wordBreak}v*ve*r*s*e*s*\\.*,*\\s*)`;
|
|
54
|
+
var versenums = "\\s*[0-9]+"; //[a-f]*
|
|
55
|
+
var joiners = "(?:[,;&\\/](?:\\s*and\\s*)*\\s*(?!$))*";
|
|
56
|
+
var bumper = "(?![^<>]*>)"; //prevents matching inside of quotes
|
|
57
|
+
|
|
58
|
+
|
|
59
|
+
//Punctuations, etc
|
|
60
|
+
var punct = [];
|
|
61
|
+
punct.push("\\s*[:\\-\\.~–—]" + versenums); //[a-z]{0,1} //colons,dots and dashes
|
|
62
|
+
punct.push("\\s*(?:" + chapter + "|" + verse + ")" + versenums); //spelled out chapter and verse words
|
|
63
|
+
punct.push("\\s*(?:;|,|,* *and|&|&| *to *)\\s*[1-9]\\d*(?!\\s*\\.*(" + numbooks.join("|") + "))"); //passage breakers (a new book may appear after)
|
|
64
|
+
//add language overrides
|
|
65
|
+
if(lang_chapter) punct.push(lang_chapter);
|
|
66
|
+
if(lang_verse) punct.push(lang_verse);
|
|
67
|
+
//if(Array.isArray(lang_extras)) punct = [...punct, ...lang_extras];
|
|
68
|
+
|
|
69
|
+
//combine punctuation
|
|
70
|
+
var punct = "(?:[1-9]\\d*(?:" + punct.join("|") + ")*)";
|
|
71
|
+
|
|
72
|
+
//Full Regex
|
|
73
|
+
var match = bumper + "((?:(?:" + jst + `${wordBreak}` + ordinals + booksof + books + prechapter + chapter + "*" + punct + jst + ")" + joiners + ")+)";
|
|
74
|
+
var pattern = new RegExp(match, 'gi');
|
|
75
|
+
|
|
76
|
+
return pattern;
|
|
77
|
+
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
|
|
81
|
+
module.exports = {
|
|
82
|
+
prepareBlacklist,
|
|
83
|
+
preparePattern
|
|
84
|
+
}
|
|
@@ -0,0 +1,160 @@
|
|
|
1
|
+
module.exports = {
|
|
2
|
+
ko:{
|
|
3
|
+
wordBreak: -1,
|
|
4
|
+
books:[
|
|
5
|
+
"창세기","출애굽기","레위기","민수기","신명기","여호수아","사사기","룻기","사무엘상","사무엘하","열왕기상","열왕기하","역대상","역대하","에스라","느헤미야","에스더","욥기","시편","잠언","전도서","아가","이사야","예레미야","예레미야애가","에스겔","다니엘","호세아","요엘","아모스","오바댜","요나","미가","나훔","하박국","스바냐","학개","스가랴","말라기",
|
|
6
|
+
"마태복음","마가복음","누가복음","요한복음","사도행전","로마서","고린도전서","고린도후서","갈라디아서","에페소서","빌립보서","골로새서","데살로니가전서","데살로니가후서","디모데전서","디모데후서","디도서","빌레몬서","히브리서","야고보서","베드로전서","베드로후서","요한일서","요한이서","요한삼서","유다서","요한 계시록",
|
|
7
|
+
"니파이전서","니파이후서","야곱서","이노스서","예이롬서","옴나이서","몰몬의 말씀","모사이야서","앨마서","힐라맨서","제3니파이","제4니파이","몰몬서","이더서","모로나이서",
|
|
8
|
+
"교리와 성약","모세서","아브라함서","조셉 스미스—마태복음","조셉 스미스—역사","신앙개조"
|
|
9
|
+
],
|
|
10
|
+
matchRules:{
|
|
11
|
+
chapter:"장[0-9~-절 -]*",
|
|
12
|
+
verse:"절",
|
|
13
|
+
},
|
|
14
|
+
regex:[
|
|
15
|
+
["창","창세기"],
|
|
16
|
+
["탈출기","출애굽기"],
|
|
17
|
+
["출","출애굽기"],
|
|
18
|
+
["레","레위기"],
|
|
19
|
+
["민","민수기"],
|
|
20
|
+
["신","신명기"],
|
|
21
|
+
["수","여호수아"],
|
|
22
|
+
["판관기","사사기"],
|
|
23
|
+
["삿","사사기"],
|
|
24
|
+
["룻","룻기"],
|
|
25
|
+
["삼상","사무엘 상"],
|
|
26
|
+
["삼하","사무엘 하"],
|
|
27
|
+
["왕상","열왕기 상"],
|
|
28
|
+
["왕하","열왕기 하"],
|
|
29
|
+
["대상","역대상"],
|
|
30
|
+
["역대기 상","역대상"],
|
|
31
|
+
["대하","역대하"],
|
|
32
|
+
["역대기 하","역대하"],
|
|
33
|
+
["스","에스라"],
|
|
34
|
+
["에즈라","에스라"],
|
|
35
|
+
["느","느헤미야"],
|
|
36
|
+
["에","에스더"],
|
|
37
|
+
["에스텔","에스더"],
|
|
38
|
+
["욥","욥기"],
|
|
39
|
+
["시","시편"],
|
|
40
|
+
["잠","잠언"],
|
|
41
|
+
["전","전도서"],
|
|
42
|
+
["코헬렛","전도서"],
|
|
43
|
+
["아","아가"],
|
|
44
|
+
["사","이사야"],
|
|
45
|
+
["렘","예레미야"],
|
|
46
|
+
["애","예레미야애가"],
|
|
47
|
+
["겔","에스겔"],
|
|
48
|
+
["에제키엘","에스겔"],
|
|
49
|
+
["단","다니엘"],
|
|
50
|
+
["호","호세아"],
|
|
51
|
+
["욜","요엘"],
|
|
52
|
+
["암","아모스"],
|
|
53
|
+
["옵","오바댜"],
|
|
54
|
+
["오바디야","오바댜"],
|
|
55
|
+
["욘","요나"],
|
|
56
|
+
["미","미가"],
|
|
57
|
+
["나","나훔"],
|
|
58
|
+
["합","하박국"],
|
|
59
|
+
["하바꾹","하박국"],
|
|
60
|
+
["습","스바냐"],
|
|
61
|
+
["스바니야","스바냐"],
|
|
62
|
+
["학","학개"],
|
|
63
|
+
["하깨","학개"],
|
|
64
|
+
["슥","스가랴"],
|
|
65
|
+
["즈가리야","스가랴"],
|
|
66
|
+
["말","말라기"],
|
|
67
|
+
["마","마태복음"],
|
|
68
|
+
["마태","마태복음"],
|
|
69
|
+
["마태오 복음서","마태복음"],
|
|
70
|
+
["마태오의 복음서","마태복음"],
|
|
71
|
+
["막","마가복음"],
|
|
72
|
+
["마르코 복음서","마가복음"],
|
|
73
|
+
["눅","누가복음"],
|
|
74
|
+
["루카 복음서","누가복음"],
|
|
75
|
+
["누가","누가복음"],
|
|
76
|
+
["요","요한복음"],
|
|
77
|
+
["요한","요한복음"],
|
|
78
|
+
["요한 *복음서*","요한복음"],
|
|
79
|
+
["행","사도행전"],
|
|
80
|
+
["사도","사도행전"],
|
|
81
|
+
["롬","로마서"],
|
|
82
|
+
["로마인들에게 보낸 편지","로마서"],
|
|
83
|
+
["고전","고린도전서"],
|
|
84
|
+
["코린토1서","고린도전서"],
|
|
85
|
+
["고후","고린도후서"],
|
|
86
|
+
["코린토2서","고린도후서"],
|
|
87
|
+
["갈","갈라디아서"],
|
|
88
|
+
["엡","에페소서"],
|
|
89
|
+
["에페소인들에게 보낸 편지","에페소서"],
|
|
90
|
+
["빌","빌립보서"],
|
|
91
|
+
["필리피서","빌립보서"],
|
|
92
|
+
["골","골로새서"],
|
|
93
|
+
["콜로새서","골로새서"],
|
|
94
|
+
["살전","데살로니가전서"],
|
|
95
|
+
["테살로니카1서","데살로니가전서"],
|
|
96
|
+
["살후","데살로니가후서"],
|
|
97
|
+
["테살로니카2서","데살로니가후서"],
|
|
98
|
+
["딤전","디모데전서"],
|
|
99
|
+
["티모테오1서","디모데전서"],
|
|
100
|
+
["딤후","디모데후서"],
|
|
101
|
+
["티모테오2서","디모데후서"],
|
|
102
|
+
["티모테후서","디모데후서"],
|
|
103
|
+
["딛","디도서"],
|
|
104
|
+
["티토서","디도서"],
|
|
105
|
+
["몬","빌레몬서"],
|
|
106
|
+
["필레몬서","빌레몬서"],
|
|
107
|
+
["히","히브리서"],
|
|
108
|
+
["약","야고보서"],
|
|
109
|
+
["벧전","베드로전서"],
|
|
110
|
+
["베드로1서","베드로전서"],
|
|
111
|
+
["벧후","베드로후서"],
|
|
112
|
+
["베드로2서","베드로후서"],
|
|
113
|
+
["요(일|1)","요한일서"],
|
|
114
|
+
["요(이|2)","요한이서"],
|
|
115
|
+
["요(삼|3)","요한삼서"],
|
|
116
|
+
["유","유다서"],
|
|
117
|
+
["유다의 편지","유다서"],
|
|
118
|
+
["계","요한 계시록"],
|
|
119
|
+
["요한 묵시록","요한 계시록"],
|
|
120
|
+
["이노","이노스서"],
|
|
121
|
+
["예이","예이롬서"],
|
|
122
|
+
["옴","옴나이서"],
|
|
123
|
+
["몰말","몰몬의 말씀"],
|
|
124
|
+
["모사","모사이야서"],
|
|
125
|
+
["앨","앨마서"],
|
|
126
|
+
["힐","힐라맨서"],
|
|
127
|
+
["3니","제3니파이"],
|
|
128
|
+
["제3니파이서*","제3니파이"],
|
|
129
|
+
["4니","제4니파이"],
|
|
130
|
+
["제4니파이서*","제4니파이"],
|
|
131
|
+
["몰","몰몬서"],
|
|
132
|
+
["이더","이더서"],
|
|
133
|
+
["모로","모로나이서"],
|
|
134
|
+
["교성","교리와 성약"],
|
|
135
|
+
["모세","모세서"],
|
|
136
|
+
["아브","아브라함서"],
|
|
137
|
+
["조셉 스미스—마태","조셉 스미스—마태복음"],
|
|
138
|
+
["조셉 스미스—역사","조셉 스미스—역사"],
|
|
139
|
+
["신앙개조","신앙개조"]
|
|
140
|
+
|
|
141
|
+
],
|
|
142
|
+
postProcess:(i)=>{
|
|
143
|
+
i = i.replace(/([\u3131-\uD79D]) *([0-9]+)/ig, "$1 $2장 ");
|
|
144
|
+
i = i.replace(/([0-9]+):([0-9]+)-([0-9]+)/g, "$1장 $2~$3절");
|
|
145
|
+
i = i.replace(/[–-]+/g,"~");
|
|
146
|
+
i = i.replace(/\s*:\s*([0-9~]+)/g, "$1절");
|
|
147
|
+
i = i.replace(/;/g, "; ").replace(/\s+/g, " ").trim();
|
|
148
|
+
i = i.replace(/제\s*([3-4])장\s*니파이/g, "제$1니파이");
|
|
149
|
+
return i;
|
|
150
|
+
},
|
|
151
|
+
preProcess:(i)=>{
|
|
152
|
+
i = i.replace(/([0-9]+)장\s*([0-9~-]+)절*/g, "$1:$2");
|
|
153
|
+
i = i.replace("~", "-");
|
|
154
|
+
i = i.replace(/(\d+) *장/g, "$1");
|
|
155
|
+
i = i.replace(/(\d+) *절/g, "$1");
|
|
156
|
+
|
|
157
|
+
return i;
|
|
158
|
+
}
|
|
159
|
+
}
|
|
160
|
+
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "scripture-guide",
|
|
3
|
-
"version": "1.0.
|
|
3
|
+
"version": "1.0.14",
|
|
4
4
|
"description": "A utility for biblical and scripture reference parsing that enables structured queries based on strings of traditional scripture references (e.g. John 3:16). ",
|
|
5
5
|
"main": "scriptures-compiled.js",
|
|
6
6
|
"scripts": {
|
|
@@ -16,6 +16,7 @@
|
|
|
16
16
|
"url": "git://github.com/kckern/ScriptureGuideUtils.git"
|
|
17
17
|
},
|
|
18
18
|
"dependencies": {
|
|
19
|
+
"jest": "^29.7.0",
|
|
19
20
|
"path": "^0.12.7"
|
|
20
21
|
},
|
|
21
22
|
"keywords": [
|
package/scriptures-compiled.js
CHANGED
|
@@ -1,7 +1,68 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
|
|
3
|
+
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
|
|
4
|
+
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
|
5
|
+
function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
|
|
6
|
+
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
|
|
7
|
+
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
|
|
8
|
+
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
|
9
|
+
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
|
|
10
|
+
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
|
|
11
|
+
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
|
|
12
|
+
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
|
13
|
+
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
|
|
14
|
+
var lang = null;
|
|
15
|
+
var wordBreak = "\\b";
|
|
16
|
+
var lang_extra = {};
|
|
3
17
|
var raw_index = require('./data/scriptdata.js');
|
|
4
18
|
var raw_regex = require('./data/scriptregex.js');
|
|
19
|
+
var raw_lang = require('./data/scriptlang.js');
|
|
20
|
+
var _require = require('./data/scriptdetect.js'),
|
|
21
|
+
prepareBlacklist = _require.prepareBlacklist,
|
|
22
|
+
preparePattern = _require.preparePattern;
|
|
23
|
+
var postProcess = function postProcess(i) {
|
|
24
|
+
return i;
|
|
25
|
+
};
|
|
26
|
+
var preProcess = function preProcess(i) {
|
|
27
|
+
return i;
|
|
28
|
+
};
|
|
29
|
+
var setLanguage = function setLanguage(language) {
|
|
30
|
+
var _raw_lang$lang, _raw_lang$lang2, _raw_lang$lang3, _raw_lang$lang4, _raw_lang$lang5, _raw_lang$lang6, _raw_lang$lang7, _raw_lang$lang8, _raw_lang$lang9, _raw_lang$lang10;
|
|
31
|
+
lang = language;
|
|
32
|
+
var new_index = {};
|
|
33
|
+
if ((_raw_lang$lang = raw_lang[lang]) !== null && _raw_lang$lang !== void 0 && _raw_lang$lang.books) {
|
|
34
|
+
for (var i in raw_lang[lang].books) {
|
|
35
|
+
var _Object$keys;
|
|
36
|
+
var book = raw_lang[lang].books[i];
|
|
37
|
+
var original_book = (_Object$keys = Object.keys(raw_index)) === null || _Object$keys === void 0 ? void 0 : _Object$keys[i];
|
|
38
|
+
new_index[book] = raw_index[original_book];
|
|
39
|
+
}
|
|
40
|
+
raw_index = new_index;
|
|
41
|
+
}
|
|
42
|
+
//if(raw_lang[lang]?.regex) raw_regex.books = [];
|
|
43
|
+
var _iterator = _createForOfIteratorHelper((_raw_lang$lang10 = raw_lang[lang]) === null || _raw_lang$lang10 === void 0 ? void 0 : _raw_lang$lang10.regex),
|
|
44
|
+
_step;
|
|
45
|
+
try {
|
|
46
|
+
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
47
|
+
var regexitem = _step.value;
|
|
48
|
+
raw_regex.books.push(regexitem);
|
|
49
|
+
}
|
|
50
|
+
} catch (err) {
|
|
51
|
+
_iterator.e(err);
|
|
52
|
+
} finally {
|
|
53
|
+
_iterator.f();
|
|
54
|
+
}
|
|
55
|
+
if (((_raw_lang$lang2 = raw_lang[lang]) === null || _raw_lang$lang2 === void 0 ? void 0 : _raw_lang$lang2.wordBreak) == -1) wordBreak = "";else wordBreak = ((_raw_lang$lang3 = raw_lang[lang]) === null || _raw_lang$lang3 === void 0 ? void 0 : _raw_lang$lang3.wordBreak) || wordBreak;
|
|
56
|
+
if ((_raw_lang$lang4 = raw_lang[lang]) !== null && _raw_lang$lang4 !== void 0 && _raw_lang$lang4.postProcess) postProcess = (_raw_lang$lang5 = raw_lang[lang]) === null || _raw_lang$lang5 === void 0 ? void 0 : _raw_lang$lang5.postProcess;
|
|
57
|
+
if (typeof postProcess !== 'function') postProcess = function postProcess(i) {
|
|
58
|
+
return i;
|
|
59
|
+
};
|
|
60
|
+
if ((_raw_lang$lang6 = raw_lang[lang]) !== null && _raw_lang$lang6 !== void 0 && _raw_lang$lang6.preProcess) preProcess = (_raw_lang$lang7 = raw_lang[lang]) === null || _raw_lang$lang7 === void 0 ? void 0 : _raw_lang$lang7.preProcess;
|
|
61
|
+
if (typeof preProcess !== 'function') preProcess = function preProcess(i) {
|
|
62
|
+
return i;
|
|
63
|
+
};
|
|
64
|
+
if ((_raw_lang$lang8 = raw_lang[lang]) !== null && _raw_lang$lang8 !== void 0 && _raw_lang$lang8.matchRules) lang_extra = (_raw_lang$lang9 = raw_lang[lang]) === null || _raw_lang$lang9 === void 0 ? void 0 : _raw_lang$lang9.matchRules;
|
|
65
|
+
};
|
|
5
66
|
var lookupReference = function lookupReference(query) {
|
|
6
67
|
var isValidReference = query && typeof query === 'string' && query.length > 0;
|
|
7
68
|
if (!isValidReference) return {
|
|
@@ -17,17 +78,19 @@ var lookupReference = function lookupReference(query) {
|
|
|
17
78
|
|
|
18
79
|
//Lookup each single reference individually, return the set
|
|
19
80
|
var verse_ids = [];
|
|
20
|
-
for (var
|
|
21
|
-
verse_ids = verse_ids.concat(lookupSingleRef(refs[
|
|
81
|
+
for (var i in refs) {
|
|
82
|
+
verse_ids = verse_ids.concat(lookupSingleRef(refs[i]));
|
|
22
83
|
}
|
|
23
84
|
return {
|
|
24
85
|
"query": query,
|
|
25
86
|
"ref": ref,
|
|
87
|
+
//"gen": generateReference(verse_ids),
|
|
26
88
|
"verse_ids": verse_ids
|
|
27
89
|
};
|
|
28
90
|
};
|
|
29
91
|
var lookupSingleRef = function lookupSingleRef(ref) {
|
|
30
|
-
|
|
92
|
+
//todo: better handling of multi-book ranges for unicode
|
|
93
|
+
if (ref.match(/[—-](\d\s)*[A-Za-z\u3131-\uD79D]/ig)) return lookupMultiBookRange(ref);
|
|
31
94
|
var book = getBook(ref);
|
|
32
95
|
if (!book) return [];
|
|
33
96
|
var ranges = getRanges(ref, book);
|
|
@@ -55,7 +118,7 @@ var generateReference = function generateReference(verse_ids) {
|
|
|
55
118
|
verse_ids = validateVerseIds(verse_ids);
|
|
56
119
|
if (!verse_ids) return '';
|
|
57
120
|
var ranges = loadVerseStructure(verse_ids);
|
|
58
|
-
var refs = loadRefsFromRanges(ranges);
|
|
121
|
+
var refs = loadRefsFromRanges(ranges).map(postProcess);
|
|
59
122
|
var ref = refs.join("; ");
|
|
60
123
|
return ref;
|
|
61
124
|
};
|
|
@@ -82,28 +145,58 @@ var lookupMultiBookRange = function lookupMultiBookRange(cleanRef) {
|
|
|
82
145
|
var start = lookupSingleRef(range[0])[0];
|
|
83
146
|
var end = lookupSingleRef(range[1])[0];
|
|
84
147
|
var all_verse_ids = [];
|
|
85
|
-
for (var
|
|
148
|
+
for (var i = start; i <= end; i++) all_verse_ids.push(i);
|
|
86
149
|
return all_verse_ids;
|
|
87
150
|
};
|
|
151
|
+
var strToHash = function strToHash(str) {
|
|
152
|
+
var hash = 0;
|
|
153
|
+
for (var i = 0; i < str.length; i++) {
|
|
154
|
+
hash = hash * 31 + str.charCodeAt(i);
|
|
155
|
+
//max 32
|
|
156
|
+
if (hash > 2147483647) hash = hash % 2147483647;
|
|
157
|
+
}
|
|
158
|
+
return "::".concat(hash, "::");
|
|
159
|
+
};
|
|
88
160
|
var cleanReference = function cleanReference(messyReference) {
|
|
89
|
-
var ref = messyReference.trim();
|
|
161
|
+
var ref = messyReference.replace(/[\s]+/g, " ").trim();
|
|
162
|
+
ref = preProcess(ref);
|
|
90
163
|
|
|
91
164
|
//Build Regex rules
|
|
92
165
|
var regex = raw_regex.pre_rules;
|
|
93
|
-
for (var
|
|
94
|
-
var re = new RegExp(regex[
|
|
95
|
-
ref = ref.replace(re, regex[
|
|
166
|
+
for (var i in regex) {
|
|
167
|
+
var re = new RegExp(regex[i][0], "ig");
|
|
168
|
+
ref = ref.replace(re, regex[i][1]);
|
|
169
|
+
}
|
|
170
|
+
var srcbooks = raw_regex.books;
|
|
171
|
+
var dstbooks = raw_regex.books.map(function (i) {
|
|
172
|
+
return [i[1], i[1]];
|
|
173
|
+
});
|
|
174
|
+
var bookMatchList = [].concat(_toConsumableArray(dstbooks), _toConsumableArray(srcbooks)).sort(function (a, b) {
|
|
175
|
+
return b[0].length - a[0].length;
|
|
176
|
+
});
|
|
177
|
+
regex = bookMatchList;
|
|
178
|
+
var hashCypher = {};
|
|
179
|
+
for (var _i in regex) {
|
|
180
|
+
var _regex$_i = _slicedToArray(regex[_i], 2),
|
|
181
|
+
book = _regex$_i[1];
|
|
182
|
+
var hash = strToHash(book);
|
|
183
|
+
hashCypher[book] = hash;
|
|
96
184
|
}
|
|
97
|
-
regex
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
ref = ref.replace(re, regex[_i4][1]);
|
|
185
|
+
for (var _i2 in regex) {
|
|
186
|
+
var re = new RegExp(wordBreak + regex[_i2][0] + "\\.*" + wordBreak, "ig");
|
|
187
|
+
var replacement = hashCypher[regex[_i2][1]] || regex[_i2][1];
|
|
188
|
+
ref = ref.replace(re, replacement);
|
|
102
189
|
}
|
|
190
|
+
var books = Object.keys(hashCypher);
|
|
191
|
+
var hashes = Object.values(hashCypher);
|
|
192
|
+
ref = ref.replace(new RegExp(hashes.join("|"), "g"), function (match) {
|
|
193
|
+
var bookValue = books[hashes.indexOf(match)];
|
|
194
|
+
return bookValue + " ";
|
|
195
|
+
});
|
|
103
196
|
regex = raw_regex.post_rules;
|
|
104
|
-
for (var
|
|
105
|
-
var re = new RegExp(regex[
|
|
106
|
-
ref = ref.replace(re, regex[
|
|
197
|
+
for (var _i3 in regex) {
|
|
198
|
+
var re = new RegExp(regex[_i3][0], "ig");
|
|
199
|
+
ref = ref.replace(re, regex[_i3][1]);
|
|
107
200
|
}
|
|
108
201
|
|
|
109
202
|
//Treat commas as semicolons in the absence of verses
|
|
@@ -115,8 +208,8 @@ var splitReferences = function splitReferences(compoundReference) {
|
|
|
115
208
|
var refs = compoundReference.split(/\s*;\s*/);
|
|
116
209
|
var runningBook = null;
|
|
117
210
|
var completeRefs = [];
|
|
118
|
-
for (var
|
|
119
|
-
var pieces = refs[
|
|
211
|
+
for (var i in refs) {
|
|
212
|
+
var pieces = refs[i].split(/([0-9:,-]+)$/);
|
|
120
213
|
if (pieces[0].length > 0) runningBook = pieces[0].trim();
|
|
121
214
|
if (pieces[1] == undefined) pieces[1] = '';
|
|
122
215
|
completeRefs.push((runningBook + " " + pieces[1]).trim());
|
|
@@ -137,19 +230,20 @@ var getRanges = function getRanges(ref) {
|
|
|
137
230
|
// Genesis 1,3-5
|
|
138
231
|
if (isChaptersOnly && isSplit && isRange) {
|
|
139
232
|
var chapterRanges = numbers.split(/,/);
|
|
140
|
-
for (var
|
|
233
|
+
for (var i in chapterRanges) {
|
|
141
234
|
//3-5
|
|
142
|
-
if (chapterRanges[
|
|
143
|
-
var chapterStartandEnd = chapterRanges[
|
|
235
|
+
if (chapterRanges[i].match(/-/)) {
|
|
236
|
+
var chapterStartandEnd = chapterRanges[i].split(/-/);
|
|
144
237
|
var startChapter = parseInt(chapterStartandEnd[0], 0);
|
|
145
238
|
var endChapter = parseInt(chapterStartandEnd[1], 0);
|
|
146
|
-
|
|
147
|
-
|
|
239
|
+
var chapterRange = [];
|
|
240
|
+
for (leti = startChapter; i <= endChapter; i++) {
|
|
241
|
+
ranges.push(i + ": 1-X");
|
|
148
242
|
}
|
|
149
243
|
}
|
|
150
244
|
//1
|
|
151
245
|
else {
|
|
152
|
-
ranges.push(chapterRanges[
|
|
246
|
+
ranges.push(chapterRanges[i] + ": 1-X");
|
|
153
247
|
}
|
|
154
248
|
}
|
|
155
249
|
}
|
|
@@ -165,11 +259,11 @@ var getRanges = function getRanges(ref) {
|
|
|
165
259
|
var _chapterStartandEnd = numbers.split(/-/);
|
|
166
260
|
var _startChapter = parseInt(_chapterStartandEnd[0], 0);
|
|
167
261
|
var _endChapter = parseInt(_chapterStartandEnd[1], 0);
|
|
168
|
-
var
|
|
169
|
-
for (
|
|
170
|
-
|
|
262
|
+
var _chapterRange = [];
|
|
263
|
+
for (var _i4 = _startChapter; _i4 <= _endChapter; _i4++) {
|
|
264
|
+
_chapterRange.push(_i4);
|
|
171
265
|
}
|
|
172
|
-
ranges =
|
|
266
|
+
ranges = _chapterRange.map(function (chapter) {
|
|
173
267
|
return chapter + ": 1-X";
|
|
174
268
|
});
|
|
175
269
|
}
|
|
@@ -182,20 +276,19 @@ var getRanges = function getRanges(ref) {
|
|
|
182
276
|
var mostRecentChapter = null;
|
|
183
277
|
var split = numbers.split(/,/);
|
|
184
278
|
var verses = null;
|
|
185
|
-
var
|
|
186
|
-
for (var _i8 in split) {
|
|
279
|
+
for (var _i5 in split) {
|
|
187
280
|
// 2:2 OR 1:1-4
|
|
188
|
-
if (split[
|
|
189
|
-
var pieces = split[
|
|
190
|
-
|
|
281
|
+
if (split[_i5].match(/:/)) {
|
|
282
|
+
var pieces = split[_i5].split(/:/);
|
|
283
|
+
chapter = mostRecentChapter = pieces[0];
|
|
191
284
|
verses = pieces[1];
|
|
192
285
|
}
|
|
193
286
|
//3 or 6-7
|
|
194
287
|
else {
|
|
195
|
-
|
|
196
|
-
verses = split[
|
|
288
|
+
chapter = mostRecentChapter;
|
|
289
|
+
verses = split[_i5];
|
|
197
290
|
}
|
|
198
|
-
ranges.push(
|
|
291
|
+
ranges.push(chapter + ": " + verses.trim());
|
|
199
292
|
}
|
|
200
293
|
}
|
|
201
294
|
// Genesis 1:3,5
|
|
@@ -203,9 +296,9 @@ var getRanges = function getRanges(ref) {
|
|
|
203
296
|
var _split = numbers.split(/,/);
|
|
204
297
|
var _mostRecentChapter = null;
|
|
205
298
|
var _verses = null;
|
|
206
|
-
for (var
|
|
299
|
+
for (var _i6 in _split) {
|
|
207
300
|
//Genesis 1:1-5
|
|
208
|
-
if (_split[
|
|
301
|
+
if (_split[_i6].match(/:/)) {
|
|
209
302
|
var _pieces = numbers.split(/:/);
|
|
210
303
|
chapter = _mostRecentChapter = _pieces[0];
|
|
211
304
|
_verses = _pieces[1];
|
|
@@ -213,7 +306,7 @@ var getRanges = function getRanges(ref) {
|
|
|
213
306
|
//10
|
|
214
307
|
else {
|
|
215
308
|
chapter = _mostRecentChapter;
|
|
216
|
-
_verses = _split[
|
|
309
|
+
_verses = _split[_i6];
|
|
217
310
|
}
|
|
218
311
|
ranges.push(chapter + ": " + _verses.trim());
|
|
219
312
|
}
|
|
@@ -229,16 +322,17 @@ var getRanges = function getRanges(ref) {
|
|
|
229
322
|
_verses2 = _verses2.map(function (v) {
|
|
230
323
|
return parseInt(v.replace(/\D/g, '').trim());
|
|
231
324
|
});
|
|
232
|
-
for (var
|
|
325
|
+
for (var _i7 = _chapters[0]; _i7 <= _chapters[1]; _i7++) {
|
|
233
326
|
var start = 1;
|
|
234
327
|
var end = "X";
|
|
235
|
-
if (_chapters[0] ==
|
|
236
|
-
if (_chapters[1] ==
|
|
237
|
-
ranges.push(
|
|
328
|
+
if (_chapters[0] == _i7) start = _verses2[0];
|
|
329
|
+
if (_chapters[1] == _i7) end = _verses2[_verses2.length - 1];
|
|
330
|
+
ranges.push(_i7 + ": " + start + "-" + end);
|
|
238
331
|
}
|
|
239
332
|
} else {
|
|
240
333
|
ranges = [numbers];
|
|
241
334
|
}
|
|
335
|
+
;
|
|
242
336
|
return ranges;
|
|
243
337
|
};
|
|
244
338
|
var refIndex = null;
|
|
@@ -246,22 +340,22 @@ var verseIdIndex = null;
|
|
|
246
340
|
var loadVerseIds = function loadVerseIds(book, ranges) {
|
|
247
341
|
if (refIndex == null) refIndex = loadRefIndex();
|
|
248
342
|
var verseList = [];
|
|
249
|
-
for (var
|
|
343
|
+
for (var i in ranges)
|
|
250
344
|
//Assumption: 1 range is within a single chapter
|
|
251
345
|
{
|
|
252
|
-
var range = ranges[
|
|
346
|
+
var range = ranges[i];
|
|
253
347
|
var matches = range.match(/(\d+): *([\dX]+)-*([\dX]*)/);
|
|
254
348
|
if (!matches) continue;
|
|
255
|
-
var
|
|
349
|
+
var _chapter = parseInt(matches[1]);
|
|
256
350
|
var start = parseInt(matches[2]);
|
|
257
351
|
var end = matches[3];
|
|
258
352
|
if (end == '') end = start;
|
|
259
|
-
if (end == "X") end = loadMaxVerse(book,
|
|
353
|
+
if (end == "X") end = loadMaxVerse(book, _chapter);else end = parseInt(end);
|
|
260
354
|
for (var verse_num = start; verse_num <= end; verse_num++) {
|
|
261
355
|
if (refIndex[book] == undefined) continue;
|
|
262
|
-
if (refIndex[book][
|
|
263
|
-
if (refIndex[book][
|
|
264
|
-
verseList.push(refIndex[book][
|
|
356
|
+
if (refIndex[book][_chapter] == undefined) continue;
|
|
357
|
+
if (refIndex[book][_chapter][verse_num] == undefined) continue;
|
|
358
|
+
verseList.push(refIndex[book][_chapter][verse_num]);
|
|
265
359
|
}
|
|
266
360
|
}
|
|
267
361
|
return verseList;
|
|
@@ -270,9 +364,9 @@ var loadVerseStructure = function loadVerseStructure(verse_ids) {
|
|
|
270
364
|
if (verseIdIndex == null) verseIdIndex = loadVerseIdIndex();
|
|
271
365
|
var segments = consecutiveSplitter(verse_ids);
|
|
272
366
|
var structure = [];
|
|
273
|
-
for (var
|
|
274
|
-
var min = segments[
|
|
275
|
-
var max = segments[
|
|
367
|
+
for (var i in segments) {
|
|
368
|
+
var min = segments[i][0];
|
|
369
|
+
var max = segments[i][segments[i].length - 1];
|
|
276
370
|
structure.push([verseIdIndex[min], verseIdIndex[max]]);
|
|
277
371
|
}
|
|
278
372
|
return structure;
|
|
@@ -281,13 +375,13 @@ var consecutiveSplitter = function consecutiveSplitter(verse_ids) {
|
|
|
281
375
|
var segments = [];
|
|
282
376
|
var segment = [];
|
|
283
377
|
var previousVerseId = 0;
|
|
284
|
-
for (var
|
|
285
|
-
if (verse_ids[
|
|
378
|
+
for (var i in verse_ids) {
|
|
379
|
+
if (verse_ids[i] != previousVerseId + 1 && previousVerseId != 0) {
|
|
286
380
|
segments.push(segment);
|
|
287
381
|
segment = [];
|
|
288
382
|
}
|
|
289
|
-
segment.push(verse_ids[
|
|
290
|
-
previousVerseId = verse_ids[
|
|
383
|
+
segment.push(verse_ids[i]);
|
|
384
|
+
previousVerseId = verse_ids[i];
|
|
291
385
|
}
|
|
292
386
|
segments.push(segment);
|
|
293
387
|
return segments;
|
|
@@ -295,14 +389,14 @@ var consecutiveSplitter = function consecutiveSplitter(verse_ids) {
|
|
|
295
389
|
var loadRefsFromRanges = function loadRefsFromRanges(ranges) {
|
|
296
390
|
var refs = [];
|
|
297
391
|
var mostRecentBook, mostRecentChapter;
|
|
298
|
-
for (var
|
|
392
|
+
for (var i in ranges) {
|
|
299
393
|
var ref = '';
|
|
300
|
-
var start_bk = ranges[
|
|
301
|
-
var end_bk = ranges[
|
|
302
|
-
var start_ch = ranges[
|
|
303
|
-
var end_ch = ranges[
|
|
304
|
-
var start_vs = ranges[
|
|
305
|
-
var end_vs = ranges[
|
|
394
|
+
var start_bk = ranges[i][0][0];
|
|
395
|
+
var end_bk = ranges[i][1][0];
|
|
396
|
+
var start_ch = ranges[i][0][1];
|
|
397
|
+
var end_ch = ranges[i][1][1];
|
|
398
|
+
var start_vs = ranges[i][0][2];
|
|
399
|
+
var end_vs = ranges[i][1][2];
|
|
306
400
|
if (start_bk == end_bk) {
|
|
307
401
|
if (start_ch == end_ch) {
|
|
308
402
|
if (start_bk == mostRecentBook) start_bk = '';
|
|
@@ -319,8 +413,8 @@ var loadRefsFromRanges = function loadRefsFromRanges(ranges) {
|
|
|
319
413
|
}
|
|
320
414
|
}
|
|
321
415
|
} else {
|
|
322
|
-
if (start_vs == 1) {
|
|
323
|
-
ref = start_bk + " " + start_ch + "-" + end_ch
|
|
416
|
+
if (start_vs == 1 && end_vs == loadMaxVerse(end_bk, end_ch)) {
|
|
417
|
+
ref = start_bk + " " + start_ch + "-" + end_ch;
|
|
324
418
|
} else {
|
|
325
419
|
ref = start_bk + " " + start_ch + ":" + start_vs + "-" + end_ch + ":" + end_vs;
|
|
326
420
|
}
|
|
@@ -347,6 +441,7 @@ var loadRefIndex = function loadRefIndex() {
|
|
|
347
441
|
var refIndex = {};
|
|
348
442
|
var verse_id = 1;
|
|
349
443
|
var book_list = Object.keys(raw_index);
|
|
444
|
+
//if(raw_lang[lang]?.books) book_list = raw_lang[lang].books
|
|
350
445
|
for (var a in book_list) {
|
|
351
446
|
var book_title = book_list[a];
|
|
352
447
|
refIndex[book_title] = {};
|
|
@@ -389,19 +484,53 @@ var loadMaxVerse = function loadMaxVerse(book, chapter) {
|
|
|
389
484
|
if (!bookExists(book)) return 0;
|
|
390
485
|
return raw_index[book][parseInt(chapter) - 1];
|
|
391
486
|
};
|
|
487
|
+
var detectReferences = function detectReferences(content, callBack) {
|
|
488
|
+
var _content$match;
|
|
489
|
+
callBack = callBack ? callBack : function (i) {
|
|
490
|
+
return "[".concat(i, "]");
|
|
491
|
+
};
|
|
492
|
+
var src = raw_regex.books.map(function (i) {
|
|
493
|
+
return i[0];
|
|
494
|
+
});
|
|
495
|
+
var dst = _toConsumableArray(new Set(raw_regex.books.map(function (i) {
|
|
496
|
+
return i[1];
|
|
497
|
+
})));
|
|
498
|
+
var bookMatchList = [].concat(_toConsumableArray(dst), _toConsumableArray(src)).map(function (i) {
|
|
499
|
+
return [i];
|
|
500
|
+
});
|
|
501
|
+
var pattern = preparePattern(bookMatchList, wordBreak = "", lang_extra);
|
|
502
|
+
var blacklist_pattern = prepareBlacklist();
|
|
503
|
+
var matches = ((_content$match = content.match(pattern)) === null || _content$match === void 0 ? void 0 : _content$match.filter(function (i) {
|
|
504
|
+
return !blacklist_pattern.test(i);
|
|
505
|
+
})) || [];
|
|
392
506
|
|
|
393
|
-
//
|
|
394
|
-
|
|
507
|
+
//split by matches
|
|
508
|
+
var pieces = content.split(new RegExp("(".concat(matches.join("|"), ")"), "ig")) || [];
|
|
509
|
+
content = pieces.map(function (i, j) {
|
|
510
|
+
if (j % 2 == 0) return i;
|
|
511
|
+
return callBack(i);
|
|
512
|
+
}).join(" ").replace(/\s+/g, " ").trim();
|
|
513
|
+
return content;
|
|
514
|
+
};
|
|
395
515
|
module.exports = {
|
|
396
516
|
lookupReference: lookupReference,
|
|
397
517
|
generateReference: generateReference,
|
|
398
|
-
|
|
518
|
+
setLanguage: setLanguage,
|
|
519
|
+
detectReferences: detectReferences,
|
|
520
|
+
//Aliases for convenience
|
|
521
|
+
lang: setLanguage,
|
|
522
|
+
language: setLanguage,
|
|
523
|
+
setLang: setLanguage,
|
|
399
524
|
lookup: lookupReference,
|
|
400
|
-
generate: generateReference,
|
|
401
|
-
ref: generateReference,
|
|
402
|
-
gen: generateReference,
|
|
403
525
|
parse: lookupReference,
|
|
404
526
|
read: lookupReference,
|
|
527
|
+
ref2VerseId: lookupReference,
|
|
528
|
+
ref: generateReference,
|
|
529
|
+
gen: generateReference,
|
|
530
|
+
generate: generateReference,
|
|
405
531
|
verseId2Ref: generateReference,
|
|
406
|
-
|
|
532
|
+
detect: detectReferences,
|
|
533
|
+
detectRefs: detectReferences,
|
|
534
|
+
detectScriptures: detectReferences,
|
|
535
|
+
linkRefs: detectReferences
|
|
407
536
|
};
|
package/scriptures.js
CHANGED
|
@@ -1,6 +1,41 @@
|
|
|
1
|
+
let lang = null;
|
|
2
|
+
let wordBreak = "\\b";
|
|
3
|
+
let lang_extra = {};
|
|
4
|
+
let raw_index = require('./data/scriptdata.js');
|
|
5
|
+
let raw_regex = require('./data/scriptregex.js');
|
|
6
|
+
let raw_lang = require('./data/scriptlang.js');
|
|
7
|
+
let {prepareBlacklist, preparePattern} = require('./data/scriptdetect.js');
|
|
8
|
+
let postProcess = (i)=>i;
|
|
9
|
+
let preProcess = (i)=>i;
|
|
10
|
+
|
|
11
|
+
const setLanguage = function(language) {
|
|
12
|
+
lang = language;
|
|
13
|
+
let new_index = {};
|
|
14
|
+
if(raw_lang[lang]?.books) {
|
|
15
|
+
for(let i in raw_lang[lang].books) {
|
|
16
|
+
let book = raw_lang[lang].books[i];
|
|
17
|
+
let original_book = Object.keys(raw_index)?.[i];
|
|
18
|
+
new_index[book] = raw_index[original_book];
|
|
19
|
+
}
|
|
20
|
+
raw_index = new_index;
|
|
21
|
+
}
|
|
22
|
+
//if(raw_lang[lang]?.regex) raw_regex.books = [];
|
|
23
|
+
for(let regexitem of raw_lang[lang]?.regex) {
|
|
24
|
+
raw_regex.books.push(regexitem);
|
|
25
|
+
}
|
|
26
|
+
if(raw_lang[lang]?.wordBreak==-1) wordBreak = "";
|
|
27
|
+
else wordBreak = raw_lang[lang]?.wordBreak || wordBreak;
|
|
28
|
+
|
|
29
|
+
|
|
30
|
+
if(raw_lang[lang]?.postProcess) postProcess = raw_lang[lang]?.postProcess;
|
|
31
|
+
if(typeof postProcess !== 'function') postProcess = (i)=>i;
|
|
32
|
+
|
|
33
|
+
if(raw_lang[lang]?.preProcess) preProcess = raw_lang[lang]?.preProcess;
|
|
34
|
+
if(typeof preProcess !== 'function') preProcess = (i)=>i;
|
|
35
|
+
|
|
36
|
+
if(raw_lang[lang]?.matchRules) lang_extra = raw_lang[lang]?.matchRules;
|
|
37
|
+
}
|
|
1
38
|
|
|
2
|
-
const raw_index = require('./data/scriptdata.js');
|
|
3
|
-
const raw_regex = require('./data/scriptregex.js');
|
|
4
39
|
|
|
5
40
|
const lookupReference = function(query) {
|
|
6
41
|
|
|
@@ -16,6 +51,7 @@ const lookupReference = function(query) {
|
|
|
16
51
|
//Break compound reference into array of single references
|
|
17
52
|
let refs = splitReferences(ref);
|
|
18
53
|
|
|
54
|
+
|
|
19
55
|
//Lookup each single reference individually, return the set
|
|
20
56
|
let verse_ids = [];
|
|
21
57
|
for (let i in refs) {
|
|
@@ -24,13 +60,15 @@ const lookupReference = function(query) {
|
|
|
24
60
|
return {
|
|
25
61
|
"query": query,
|
|
26
62
|
"ref": ref,
|
|
63
|
+
//"gen": generateReference(verse_ids),
|
|
27
64
|
"verse_ids": verse_ids
|
|
28
65
|
};
|
|
29
66
|
}
|
|
30
67
|
|
|
31
68
|
const lookupSingleRef = function(ref) {
|
|
32
69
|
|
|
33
|
-
|
|
70
|
+
//todo: better handling of multi-book ranges for unicode
|
|
71
|
+
if (ref.match(/[—-](\d\s)*[A-Za-z\u3131-\uD79D]/ig)) return lookupMultiBookRange(ref);
|
|
34
72
|
let book = getBook(ref);
|
|
35
73
|
if (!book) return [];
|
|
36
74
|
let ranges = getRanges(ref, book);
|
|
@@ -59,7 +97,8 @@ const generateReference = function(verse_ids) {
|
|
|
59
97
|
if(!verse_ids) return '';
|
|
60
98
|
|
|
61
99
|
let ranges = loadVerseStructure(verse_ids);
|
|
62
|
-
let refs = loadRefsFromRanges(ranges);
|
|
100
|
+
let refs = loadRefsFromRanges(ranges).map(postProcess);
|
|
101
|
+
|
|
63
102
|
let ref = refs.join("; ");
|
|
64
103
|
return ref;
|
|
65
104
|
|
|
@@ -95,9 +134,22 @@ const lookupMultiBookRange = function(cleanRef) { //eg Matthew 15—Mark 2
|
|
|
95
134
|
return all_verse_ids;
|
|
96
135
|
}
|
|
97
136
|
|
|
137
|
+
const strToHash = function(str) {
|
|
138
|
+
let hash = 0;
|
|
139
|
+
for (let i = 0; i < str.length; i++) {
|
|
140
|
+
hash = hash * 31 + str.charCodeAt(i);
|
|
141
|
+
//max 32
|
|
142
|
+
if (hash > 2147483647) hash = hash % 2147483647;
|
|
143
|
+
}
|
|
144
|
+
return `::${hash}::`;
|
|
145
|
+
}
|
|
146
|
+
|
|
98
147
|
|
|
99
148
|
const cleanReference = function(messyReference) {
|
|
100
|
-
let ref = messyReference.trim();
|
|
149
|
+
let ref = messyReference.replace(/[\s]+/g, " ").trim();
|
|
150
|
+
|
|
151
|
+
ref = preProcess(ref);
|
|
152
|
+
|
|
101
153
|
|
|
102
154
|
//Build Regex rules
|
|
103
155
|
let regex = raw_regex.pre_rules;
|
|
@@ -105,12 +157,29 @@ const cleanReference = function(messyReference) {
|
|
|
105
157
|
var re = new RegExp(regex[i][0], "ig");
|
|
106
158
|
ref = ref.replace(re, regex[i][1]);
|
|
107
159
|
}
|
|
108
|
-
|
|
109
|
-
|
|
160
|
+
let srcbooks = raw_regex.books;
|
|
161
|
+
let dstbooks = raw_regex.books.map(i => [i[1], i[1]]);
|
|
162
|
+
let bookMatchList = [...dstbooks, ...srcbooks].sort((a, b) => b[0].length - a[0].length);
|
|
163
|
+
regex = bookMatchList;
|
|
164
|
+
let hashCypher = {};
|
|
110
165
|
for (let i in regex) {
|
|
111
|
-
|
|
112
|
-
|
|
166
|
+
const [,book] = regex[i];
|
|
167
|
+
const hash = strToHash(book);
|
|
168
|
+
hashCypher[book] = hash;
|
|
113
169
|
}
|
|
170
|
+
|
|
171
|
+
for (let i in regex) {
|
|
172
|
+
var re = new RegExp( wordBreak +regex[i][0] + "\\.*"+wordBreak, "ig");
|
|
173
|
+
let replacement = hashCypher[regex[i][1]] || regex[i][1];
|
|
174
|
+
ref = ref.replace(re, replacement);
|
|
175
|
+
}
|
|
176
|
+
const books = Object.keys(hashCypher);
|
|
177
|
+
const hashes = Object.values(hashCypher);
|
|
178
|
+
ref = ref.replace(new RegExp(hashes.join("|"), "g"), function (match) {
|
|
179
|
+
const bookValue = books[hashes.indexOf((match))];
|
|
180
|
+
return bookValue + " ";
|
|
181
|
+
}
|
|
182
|
+
);
|
|
114
183
|
|
|
115
184
|
regex = raw_regex.post_rules;
|
|
116
185
|
for (let i in regex) {
|
|
@@ -122,7 +191,6 @@ const cleanReference = function(messyReference) {
|
|
|
122
191
|
if (!ref.match(/:/)) ref = ref.replace(/,/, ";");
|
|
123
192
|
|
|
124
193
|
let cleanReference = ref.trim();
|
|
125
|
-
|
|
126
194
|
return cleanReference;
|
|
127
195
|
}
|
|
128
196
|
const splitReferences = function(compoundReference) {
|
|
@@ -157,7 +225,8 @@ const getRanges = function(ref) {
|
|
|
157
225
|
let chapterStartandEnd = chapterRanges[i].split(/-/);
|
|
158
226
|
let startChapter = parseInt(chapterStartandEnd[0], 0);
|
|
159
227
|
let endChapter = parseInt(chapterStartandEnd[1], 0);
|
|
160
|
-
|
|
228
|
+
let chapterRange = [];
|
|
229
|
+
for (leti = startChapter; i <= endChapter; i++) {
|
|
161
230
|
ranges.push(i + ": 1-X");
|
|
162
231
|
}
|
|
163
232
|
}
|
|
@@ -178,7 +247,7 @@ const getRanges = function(ref) {
|
|
|
178
247
|
let startChapter = parseInt(chapterStartandEnd[0], 0);
|
|
179
248
|
let endChapter = parseInt(chapterStartandEnd[1], 0);
|
|
180
249
|
let chapterRange = [];
|
|
181
|
-
for (i = startChapter; i <= endChapter; i++) {
|
|
250
|
+
for (let i = startChapter; i <= endChapter; i++) {
|
|
182
251
|
chapterRange.push(i);
|
|
183
252
|
}
|
|
184
253
|
ranges = chapterRange.map(chapter => chapter + ": 1-X");
|
|
@@ -192,7 +261,6 @@ const getRanges = function(ref) {
|
|
|
192
261
|
let mostRecentChapter = null;
|
|
193
262
|
let split = numbers.split(/,/);
|
|
194
263
|
let verses = null;
|
|
195
|
-
let chapter = null;
|
|
196
264
|
for (let i in split) {
|
|
197
265
|
// 2:2 OR 1:1-4
|
|
198
266
|
if (split[i].match(/:/)) {
|
|
@@ -244,7 +312,7 @@ const getRanges = function(ref) {
|
|
|
244
312
|
}
|
|
245
313
|
} else {
|
|
246
314
|
ranges = [numbers];
|
|
247
|
-
}
|
|
315
|
+
};
|
|
248
316
|
return ranges;
|
|
249
317
|
}
|
|
250
318
|
let refIndex = null
|
|
@@ -311,7 +379,6 @@ const loadRefsFromRanges = function(ranges) {
|
|
|
311
379
|
let end_vs = ranges[i][1][2];
|
|
312
380
|
if (start_bk == end_bk) {
|
|
313
381
|
if (start_ch == end_ch) {
|
|
314
|
-
|
|
315
382
|
if (start_bk == mostRecentBook) start_bk = '';
|
|
316
383
|
if (start_bk == mostRecentBook && start_ch == mostRecentChapter) start_ch = '';
|
|
317
384
|
if (start_vs == end_vs) {
|
|
@@ -325,8 +392,8 @@ const loadRefsFromRanges = function(ranges) {
|
|
|
325
392
|
}
|
|
326
393
|
}
|
|
327
394
|
} else {
|
|
328
|
-
if (start_vs == 1) {
|
|
329
|
-
ref = start_bk + " " + start_ch + "-" + end_ch
|
|
395
|
+
if (start_vs == 1 && end_vs == loadMaxVerse(end_bk, end_ch)) {
|
|
396
|
+
ref = start_bk + " " + start_ch + "-" + end_ch;
|
|
330
397
|
} else {
|
|
331
398
|
ref = start_bk + " " + start_ch + ":" + start_vs + "-" + end_ch + ":" + end_vs;
|
|
332
399
|
}
|
|
@@ -350,11 +417,11 @@ const loadRefsFromRanges = function(ranges) {
|
|
|
350
417
|
return refs;
|
|
351
418
|
}
|
|
352
419
|
|
|
353
|
-
|
|
354
420
|
const loadRefIndex = function() {
|
|
355
421
|
let refIndex = {};
|
|
356
422
|
let verse_id = 1;
|
|
357
423
|
let book_list = Object.keys(raw_index);
|
|
424
|
+
//if(raw_lang[lang]?.books) book_list = raw_lang[lang].books
|
|
358
425
|
for (let a in book_list) {
|
|
359
426
|
let book_title = book_list[a];
|
|
360
427
|
refIndex[book_title] = {};
|
|
@@ -408,20 +475,56 @@ const loadMaxVerse = function(book, chapter) {
|
|
|
408
475
|
return raw_index[book][parseInt(chapter) - 1]
|
|
409
476
|
}
|
|
410
477
|
|
|
411
|
-
|
|
478
|
+
|
|
479
|
+
|
|
480
|
+
const detectReferences = (content,callBack) => {
|
|
481
|
+
|
|
482
|
+
callBack = callBack ? callBack : (i)=>{return `[${i}]`};
|
|
483
|
+
|
|
484
|
+
const src = raw_regex.books.map(i => i[0]);
|
|
485
|
+
const dst = [...new Set(raw_regex.books.map(i => i[1]))];
|
|
486
|
+
const bookMatchList = [...dst, ...src].map(i => [i]);
|
|
487
|
+
const pattern = preparePattern(bookMatchList,wordBreak="",lang_extra);
|
|
488
|
+
const blacklist_pattern = prepareBlacklist();
|
|
489
|
+
var matches = content.match(pattern)?.filter(i=>!blacklist_pattern.test(i)) || [];
|
|
490
|
+
|
|
491
|
+
//split by matches
|
|
492
|
+
const pieces = content.split(new RegExp(`(${matches.join("|")})`, "ig")) || [];
|
|
493
|
+
|
|
494
|
+
content = pieces.map((i,j)=>{
|
|
495
|
+
if(j%2==0) return i;
|
|
496
|
+
return callBack(i);
|
|
497
|
+
}).join(" ").replace(/\s+/g," ").trim();
|
|
498
|
+
|
|
499
|
+
return content;
|
|
500
|
+
}
|
|
501
|
+
|
|
412
502
|
|
|
413
503
|
|
|
414
504
|
|
|
415
505
|
module.exports = {
|
|
416
506
|
lookupReference,
|
|
417
507
|
generateReference,
|
|
418
|
-
|
|
508
|
+
setLanguage,
|
|
509
|
+
detectReferences,
|
|
510
|
+
|
|
511
|
+
//Aliases for convenience
|
|
512
|
+
lang: setLanguage,
|
|
513
|
+
language: setLanguage,
|
|
514
|
+
setLang: setLanguage,
|
|
515
|
+
|
|
419
516
|
lookup: lookupReference,
|
|
420
|
-
generate: generateReference,
|
|
421
|
-
ref: generateReference,
|
|
422
|
-
gen: generateReference,
|
|
423
517
|
parse: lookupReference,
|
|
424
518
|
read: lookupReference,
|
|
425
|
-
verseId2Ref: generateReference,
|
|
426
519
|
ref2VerseId: lookupReference,
|
|
520
|
+
|
|
521
|
+
ref: generateReference,
|
|
522
|
+
gen: generateReference,
|
|
523
|
+
generate: generateReference,
|
|
524
|
+
verseId2Ref: generateReference,
|
|
525
|
+
|
|
526
|
+
detect: detectReferences,
|
|
527
|
+
detectRefs: detectReferences,
|
|
528
|
+
detectScriptures: detectReferences,
|
|
529
|
+
linkRefs: detectReferences,
|
|
427
530
|
}
|
package/test-detect.js
ADDED
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
const { ko } = require("./data/scriptlang.js");
|
|
2
|
+
const {lookup, generateReference, setLanguage, detectReferences}= require("./scriptures.js");
|
|
3
|
+
|
|
4
|
+
|
|
5
|
+
const lines = [
|
|
6
|
+
"Please refer to Genesis 20 in the bible",
|
|
7
|
+
"Please refer to 3 Nephi 5:1-3 in the Book of Mormon"
|
|
8
|
+
]
|
|
9
|
+
|
|
10
|
+
lines.forEach(l=>{
|
|
11
|
+
const result = detectReferences(l);
|
|
12
|
+
console.log({result});
|
|
13
|
+
});
|
|
14
|
+
|
|
15
|
+
setLanguage("ko");
|
|
16
|
+
|
|
17
|
+
const ko_lines = [
|
|
18
|
+
"성경의 창세기 20장을 참조하십시오.",
|
|
19
|
+
"이제 제3니파이서 5:1-3을 참조하십시오.",
|
|
20
|
+
"이제 제4니파이서 1:4~5절 참조하십시오.",
|
|
21
|
+
"이제 제4니파이서 1장4~5절 참조하십시오.",
|
|
22
|
+
"이제 제4니파이서 1장 4~5절 참조하십시오.",
|
|
23
|
+
"이제 제4니파이서 1.4~5절 참조하십시오.",
|
|
24
|
+
"이제 제4니파이서 4~5절 참조하십시오.",
|
|
25
|
+
"이제 모세서 3장 참조하십시오."
|
|
26
|
+
]
|
|
27
|
+
ko_lines.forEach(l=>{
|
|
28
|
+
let callback = (string)=>{
|
|
29
|
+
const verse_ids = lookup(string).verse_ids;
|
|
30
|
+
return JSON.stringify({string,verse_ids});
|
|
31
|
+
}
|
|
32
|
+
const result = detectReferences(l,callback);
|
|
33
|
+
console.log({result});
|
|
34
|
+
});
|
package/test-lang.js
ADDED
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
const {lookup, generateReference, setLanguage, detectReferences}= require("./scriptures.js");
|
|
2
|
+
|
|
3
|
+
|
|
4
|
+
setLanguage("ko");
|
|
5
|
+
//korean tests
|
|
6
|
+
const lookUpTests = [
|
|
7
|
+
"계 10:4-20",
|
|
8
|
+
"요한복음 4장 3~14절",
|
|
9
|
+
"티모테후서 2장3-4",
|
|
10
|
+
"창세기 1:1-2",
|
|
11
|
+
"출 20:2-20",
|
|
12
|
+
]
|
|
13
|
+
|
|
14
|
+
lookUpTests.forEach(t=>{
|
|
15
|
+
const result = lookup(t);
|
|
16
|
+
console.log({result});
|
|
17
|
+
});
|
|
18
|
+
|
|
19
|
+
|
|
20
|
+
let testcases = [
|
|
21
|
+
["Simple reference", "출애굽기 1:1"],
|
|
22
|
+
["Simple chapter", "창세기 2"],
|
|
23
|
+
["Split chapters", "창세기 1,3"],
|
|
24
|
+
["Chapter range", "출애굽기 3-5"],
|
|
25
|
+
["Chapter range and split", "출애굽기 3-5,8"],
|
|
26
|
+
["Verse range", "출애굽기 20:1-10"],
|
|
27
|
+
["Verse range and split", "출애굽기 20:1-5,10"],
|
|
28
|
+
["Verse Split", "출애굽기 20:5,10"],
|
|
29
|
+
["Verse range spanning multiple chapters", "출애굽기 1:5-4:3"],
|
|
30
|
+
["Chapter range ending in partial chapter", "출애굽기 3-4:10"],
|
|
31
|
+
["Chapter range spanning multiple books", "창세기 30 - 출애굽기 2"],
|
|
32
|
+
["Chapter range spanning multiple books, ending in partial chapter", "창세기 30 - 출애굽기 2:5"],
|
|
33
|
+
["Chapter range spanning multiple books, starting in partial chapter", "창세기 30:10 - 출애굽기 2"],
|
|
34
|
+
["Chapter range spanning multiple books, starting and ending with partial chapters", "창세기 30:10 - 출애굽기 2:5"],
|
|
35
|
+
["Compound reference in same book","출애굽기 5:1;6:2;8:5"],
|
|
36
|
+
["Compound reference in different books","출애굽기 5:1; 레위기 6:2; 민수기 8:5"],
|
|
37
|
+
["Compound reference ranges in different books","출애굽기 5:1-3; 레위기 6:2-5; 민수기 8:5-6"],
|
|
38
|
+
["Entire Book Range","창세기 - 민수기"],
|
|
39
|
+
["Abbreviation detection","마2.5;막3;눅4;요5.2-6;1요일1.5,7-8;3요삼1.1"],
|
|
40
|
+
["Numbered Books","요삼1.1"],
|
|
41
|
+
];
|
|
42
|
+
|
|
43
|
+
for (let i in testcases)
|
|
44
|
+
{
|
|
45
|
+
console.log("\n===================\n\nTEST CASE #"+(parseInt(i)+1)+": "+testcases[i][0]);
|
|
46
|
+
console.log("Input: ");
|
|
47
|
+
console.log([testcases[i][1]]);
|
|
48
|
+
output = lookup(testcases[i][1]);
|
|
49
|
+
console.log("Output: ");
|
|
50
|
+
console.log(output);
|
|
51
|
+
ref = generateReference(output.verse_ids);
|
|
52
|
+
console.log("Reference generated from verse ids: ");
|
|
53
|
+
console.log([ref]);
|
|
54
|
+
}
|