scripture-guide 1.0.75 → 1.0.76
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/dist/scriptures.cjs +619 -0
- package/dist/scriptures.mjs +617 -0
- package/package.json +9 -9
- package/scriptures.cjs +0 -2089
- package/scriptures.mjs +0 -1503
- /package/{scriptures.d.ts → dist/scriptures.d.ts} +0 -0
|
@@ -0,0 +1,617 @@
|
|
|
1
|
+
import raw_index_orig from '../data/scriptdata.mjs';
|
|
2
|
+
import raw_regex_orig from '../data/scriptregex.mjs';
|
|
3
|
+
import raw_lang from '../data/scriptlang.mjs';
|
|
4
|
+
import { processReferenceDetection } from './scriptdetect.mjs';
|
|
5
|
+
|
|
6
|
+
// Browser localStorage key for language preference
|
|
7
|
+
const LANGUAGE_STORAGE_KEY = 'scriptureGuideUtils_language';
|
|
8
|
+
|
|
9
|
+
// Helper function to safely access localStorage
|
|
10
|
+
const getStoredLanguage = () => {
|
|
11
|
+
try {
|
|
12
|
+
if (typeof localStorage !== 'undefined') {
|
|
13
|
+
return localStorage.getItem(LANGUAGE_STORAGE_KEY);
|
|
14
|
+
}
|
|
15
|
+
} catch (e) {
|
|
16
|
+
// localStorage might not be available in some environments
|
|
17
|
+
}
|
|
18
|
+
return null;
|
|
19
|
+
};
|
|
20
|
+
|
|
21
|
+
const setStoredLanguage = (language) => {
|
|
22
|
+
try {
|
|
23
|
+
if (typeof localStorage !== 'undefined') {
|
|
24
|
+
if (language) {
|
|
25
|
+
localStorage.setItem(LANGUAGE_STORAGE_KEY, language);
|
|
26
|
+
} else {
|
|
27
|
+
localStorage.removeItem(LANGUAGE_STORAGE_KEY);
|
|
28
|
+
}
|
|
29
|
+
}
|
|
30
|
+
} catch (e) {
|
|
31
|
+
// localStorage might not be available in some environments
|
|
32
|
+
}
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
// Global default language (can be overridden by localStorage)
|
|
36
|
+
let defaultLanguage = null;
|
|
37
|
+
|
|
38
|
+
const setLanguage = function(language) {
|
|
39
|
+
defaultLanguage = language;
|
|
40
|
+
setStoredLanguage(language);
|
|
41
|
+
};
|
|
42
|
+
|
|
43
|
+
const getEffectiveLanguage = function(explicitLanguage) {
|
|
44
|
+
// Priority: explicit parameter > stored language > default language > 'en'
|
|
45
|
+
return explicitLanguage || getStoredLanguage() || defaultLanguage || 'en';
|
|
46
|
+
};
|
|
47
|
+
|
|
48
|
+
const lookupReference = function(query, language = null) {
|
|
49
|
+
const isValidReference = query && typeof query === 'string' && query.length > 0;
|
|
50
|
+
if (!isValidReference) return {
|
|
51
|
+
"query": query,
|
|
52
|
+
"ref": "",
|
|
53
|
+
"verse_ids": []
|
|
54
|
+
};
|
|
55
|
+
|
|
56
|
+
// Get effective language (explicit > stored > default > 'en')
|
|
57
|
+
const effectiveLanguage = getEffectiveLanguage(language);
|
|
58
|
+
const config = getLanguageConfig(effectiveLanguage);
|
|
59
|
+
|
|
60
|
+
//Cleanup
|
|
61
|
+
let ref = cleanReference(query, config);
|
|
62
|
+
//Break compound reference into array of single references
|
|
63
|
+
let refs = splitReferences(ref, config);
|
|
64
|
+
|
|
65
|
+
//Lookup each single reference individually, return the set
|
|
66
|
+
let verse_ids = [];
|
|
67
|
+
for (let i in refs) {
|
|
68
|
+
verse_ids = verse_ids.concat(lookupSingleRef(refs[i], config));
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
// Fallback to English if no results found and language was specified
|
|
72
|
+
if(!verse_ids?.length && effectiveLanguage && effectiveLanguage !== 'en') {
|
|
73
|
+
const results = lookupReference(query, 'en');
|
|
74
|
+
return results;
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
return {
|
|
78
|
+
"query": query,
|
|
79
|
+
"ref": ref,
|
|
80
|
+
"verse_ids": verse_ids
|
|
81
|
+
};
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
const lookupSingleRef = function(ref, config) {
|
|
85
|
+
const booksWithDashRegex = /^(joseph|조셉)/i; // TODO: get from config
|
|
86
|
+
//todo: better handling of multi-book ranges for unicode
|
|
87
|
+
if (!booksWithDashRegex.test(ref) && ref.match(/[—-](\d\s)*[\D]/ig)) return lookupMultiBookRange(ref, config);
|
|
88
|
+
let book = getBook(ref, config);
|
|
89
|
+
if (!book) return [];
|
|
90
|
+
let ranges = getRanges(ref, book);
|
|
91
|
+
let verse_ids = loadVerseIds(book, ranges, config);
|
|
92
|
+
return verse_ids;
|
|
93
|
+
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
const validateVerseIds = function(verse_ids) {
|
|
97
|
+
|
|
98
|
+
if(!verse_ids) return false;
|
|
99
|
+
if(typeof verse_ids === 'string') verse_ids = verse_ids.split(/[,;]/);
|
|
100
|
+
if(!Array.isArray(verse_ids)) verse_ids = [verse_ids];
|
|
101
|
+
verse_ids = verse_ids.map(v => parseInt(v));
|
|
102
|
+
verse_ids = verse_ids.filter(v => !isNaN(v));
|
|
103
|
+
if(verse_ids.length == 0) return false;
|
|
104
|
+
//if array of non zero integers
|
|
105
|
+
if(verse_ids.filter(v => v > 0).length == verse_ids.length) return verse_ids;
|
|
106
|
+
return false;
|
|
107
|
+
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
const generateReference = function(verse_ids, language = null) {
|
|
111
|
+
|
|
112
|
+
verse_ids = validateVerseIds(verse_ids);
|
|
113
|
+
if(!verse_ids) return '';
|
|
114
|
+
|
|
115
|
+
const effectiveLanguage = getEffectiveLanguage(language);
|
|
116
|
+
const config = getLanguageConfig(effectiveLanguage);
|
|
117
|
+
let ranges = loadVerseStructure(verse_ids, config);
|
|
118
|
+
let refs = loadRefsFromRanges(ranges, config);
|
|
119
|
+
|
|
120
|
+
let ref = refs.join("; ");
|
|
121
|
+
return ref;
|
|
122
|
+
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
|
|
126
|
+
const lookupMultiBookRange = function(cleanRef, config) { //eg Matthew 15—Mark 2
|
|
127
|
+
|
|
128
|
+
let range = cleanRef.split(/[—-]/);
|
|
129
|
+
if (!range[0].match(/[:]/)) {
|
|
130
|
+
if (range[0].match(/\d+\s*$/)) range[0] = range[0].trim() + ":" + 1;
|
|
131
|
+
else range[0] = range[0].trim() + " 1:1";
|
|
132
|
+
}
|
|
133
|
+
if (!range[1].match(/[:]/)) {
|
|
134
|
+
|
|
135
|
+
let matches = range[1].match(/(.*?)\s(\d+)$/);
|
|
136
|
+
if (matches === null) {
|
|
137
|
+
//find end of book
|
|
138
|
+
let maxChapter = loadMaxChapter(range[1], config);
|
|
139
|
+
let maxverse = loadMaxVerse(range[1], maxChapter, config);
|
|
140
|
+
range[1] = range[1] + " " + maxChapter + ":" + maxverse;
|
|
141
|
+
// console.log(range);
|
|
142
|
+
} else {
|
|
143
|
+
let maxverse = loadMaxVerse(cleanReference(matches[1], config), matches[2], config);
|
|
144
|
+
range[1] = range[1] + ":" + maxverse;
|
|
145
|
+
}
|
|
146
|
+
}
|
|
147
|
+
let start = lookupSingleRef(range[0], config)[0];
|
|
148
|
+
let end = lookupSingleRef(range[1], config)[0];
|
|
149
|
+
let all_verse_ids = [];
|
|
150
|
+
for (let i = start; i <= end; i++) all_verse_ids.push(i);
|
|
151
|
+
return all_verse_ids;
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
const strToHash = function(str) {
|
|
155
|
+
let hash = 0;
|
|
156
|
+
for (let i = 0; i < str.length; i++) {
|
|
157
|
+
hash = hash * 31 + str.charCodeAt(i);
|
|
158
|
+
//max 32
|
|
159
|
+
if (hash > 2147483647) hash = hash % 2147483647;
|
|
160
|
+
}
|
|
161
|
+
return `==${hash}==`;
|
|
162
|
+
}
|
|
163
|
+
|
|
164
|
+
|
|
165
|
+
const cleanReference = function(messyReference, config) {
|
|
166
|
+
|
|
167
|
+
let ref = messyReference.replace(/[\s]+/g, " ").trim();
|
|
168
|
+
|
|
169
|
+
//Build Regex rules
|
|
170
|
+
let regex = config.raw_regex.pre_rules;
|
|
171
|
+
for (let i in regex) {
|
|
172
|
+
var re = new RegExp(regex[i][0], "ig");
|
|
173
|
+
ref = ref.replace(re, regex[i][1]);
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
//Turn dots into colons
|
|
177
|
+
ref = ref.replace(/(\d+)[.](\d+)/g, "$1:$2");
|
|
178
|
+
ref = ref.replace(/[.]/g, "");
|
|
179
|
+
|
|
180
|
+
//Treat commas as semicolons in the absence of verses
|
|
181
|
+
//add spaces after semicolons
|
|
182
|
+
ref = ref.replace(/;/g, "; ");
|
|
183
|
+
//add space before numbers
|
|
184
|
+
ref = ref.replace(/^([0-9;,:-]+)(\d+)/g, "$1 $2");
|
|
185
|
+
//spaces around book ranges !!! Breaks vietnamese, which uses dashes (optionally) instead of spaces in book names
|
|
186
|
+
ref = ref.replace(/([–-])(\D+)/g, " $1 $2 ");
|
|
187
|
+
|
|
188
|
+
//Handle non-latin languages because \b only works for latin alphabet
|
|
189
|
+
const [wordBreak, buffer] = config.raw_regex.spacing || ["\\b", ""];
|
|
190
|
+
|
|
191
|
+
let srcbooks = config.raw_regex.books;
|
|
192
|
+
let dstbooks = buffer ? config.raw_regex.books.map(i => [i[1], i[1]]) : [];
|
|
193
|
+
let bookMatchList = [...dstbooks, ...srcbooks].sort((a, b) => b[0].length - a[0].length);
|
|
194
|
+
regex = bookMatchList;
|
|
195
|
+
let hashCypher = {};
|
|
196
|
+
for (let i in regex) {
|
|
197
|
+
const [,book] = regex[i];
|
|
198
|
+
const hash = strToHash(book);
|
|
199
|
+
hashCypher[book] = hash;
|
|
200
|
+
}
|
|
201
|
+
for (let i in regex) {
|
|
202
|
+
var re = new RegExp( wordBreak + buffer + regex[i][0] + buffer + "\\.*"+wordBreak, "ig");
|
|
203
|
+
let replacement = hashCypher[regex[i][1]] || regex[i][1];
|
|
204
|
+
ref = (buffer+ref+buffer).replace(re, replacement).trim();
|
|
205
|
+
}
|
|
206
|
+
const books = Object.keys(hashCypher);
|
|
207
|
+
const hashes = Object.values(hashCypher);
|
|
208
|
+
ref = ref.replace(new RegExp(hashes.join("|"), "g"), function (match) {
|
|
209
|
+
const bookValue = books[hashes.indexOf((match))];
|
|
210
|
+
return bookValue + " ";
|
|
211
|
+
}
|
|
212
|
+
);
|
|
213
|
+
|
|
214
|
+
|
|
215
|
+
//Cleanup
|
|
216
|
+
ref = ref.replace(/\s+/g, " "); //remove double spaces
|
|
217
|
+
ref = ref.replace(/\s*[~–-]\s*/g, "-"); //remove spaces around dashes
|
|
218
|
+
ref = ref.replace(/;(\S+)/g, "; $1"); //add space after semicolons
|
|
219
|
+
|
|
220
|
+
let cleanReference = ref.trim();
|
|
221
|
+
|
|
222
|
+
cleanReference = handleSingleChapterBookRefs(cleanReference, config);
|
|
223
|
+
if (!cleanReference.match(/:/)) cleanReference = cleanReference.replace(/,/, "; ");
|
|
224
|
+
return cleanReference;
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
const handleSingleChapterBookRefs = function(ref, config) {
|
|
228
|
+
|
|
229
|
+
const singleChapterBooks = Object.keys(config.raw_index).filter(book => loadMaxChapter(book, config) == 1);
|
|
230
|
+
const [matchingBook] = singleChapterBooks.filter(book => ref.match(new RegExp(`^${book} \\d+`)));
|
|
231
|
+
if(new RegExp(`^${matchingBook} 1:`).test(ref)) return ref;
|
|
232
|
+
if(new RegExp(`^${matchingBook} 1$`).test(ref)) return ref;
|
|
233
|
+
ref = ref.replace(new RegExp(`^${matchingBook} (\\d+)`), `${matchingBook} 1:$1`);
|
|
234
|
+
return ref;
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
const splitReferences = function(compoundReference, config) {
|
|
238
|
+
let refs = compoundReference.split(/\s*;\s*/);
|
|
239
|
+
let runningBook = "";
|
|
240
|
+
let completeRefs = [];
|
|
241
|
+
for (let i in refs) {
|
|
242
|
+
const ref = refs[i];
|
|
243
|
+
let pieces = ref.split(/([0-9:,-]+)$/);
|
|
244
|
+
const firstPiece = pieces[0].trim();
|
|
245
|
+
runningBook = bookExists(firstPiece, config) ? firstPiece : runningBook;
|
|
246
|
+
const needsPreBook = !bookExists(firstPiece, config);
|
|
247
|
+
const preBook = needsPreBook && runningBook ? runningBook : "";
|
|
248
|
+
completeRefs.push((preBook + " " + ref).trim());
|
|
249
|
+
}
|
|
250
|
+
return completeRefs;
|
|
251
|
+
}
|
|
252
|
+
const getBook = function(ref, config) {
|
|
253
|
+
let book = ref.replace(/([ 0-9:,-]+)$/, '').trim();
|
|
254
|
+
book = book.replace(/-/g, "—");
|
|
255
|
+
if (bookExists(book, config)) return book;
|
|
256
|
+
return false;
|
|
257
|
+
}
|
|
258
|
+
const getRanges = function(ref) {
|
|
259
|
+
let ranges = [];
|
|
260
|
+
let numbers = ref.replace(/.*?([0-9: ,-]+)$/, '$1').trim();
|
|
261
|
+
numbers=numbers.replace(/^(\d+)-(\d+):(\d+)$/g, '$1:1-$2:$3'); //implict first verse
|
|
262
|
+
let isChaptersOnly = numbers.match(/:/) ? false : true;
|
|
263
|
+
let isRange = !numbers.match(/-/) ? false : true;
|
|
264
|
+
let isSplit = !numbers.match(/,/) ? false : true;
|
|
265
|
+
// Genesis 1,3-5
|
|
266
|
+
if (isChaptersOnly && isSplit && isRange) {
|
|
267
|
+
let chapterRanges = numbers.split(/,/);
|
|
268
|
+
for (let i in chapterRanges) {
|
|
269
|
+
//3-5
|
|
270
|
+
if (chapterRanges[i].match(/-/)) {
|
|
271
|
+
let chapterStartandEnd = chapterRanges[i].split(/-/);
|
|
272
|
+
let startChapter = parseInt(chapterStartandEnd[0], 0);
|
|
273
|
+
let endChapter = parseInt(chapterStartandEnd[1], 0);
|
|
274
|
+
let chapterRange = [];
|
|
275
|
+
for (leti = startChapter; i <= endChapter; i++) {
|
|
276
|
+
ranges.push(i + ": 1-X");
|
|
277
|
+
}
|
|
278
|
+
}
|
|
279
|
+
//1
|
|
280
|
+
else {
|
|
281
|
+
ranges.push(chapterRanges[i] + ": 1-X");
|
|
282
|
+
}
|
|
283
|
+
}
|
|
284
|
+
}
|
|
285
|
+
// Genesis 1,3
|
|
286
|
+
else if (isChaptersOnly && isSplit) {
|
|
287
|
+
let chapters = numbers.split(/,/);
|
|
288
|
+
ranges = chapters.map(chapter => chapter + ": 1-X");
|
|
289
|
+
}
|
|
290
|
+
//Genesis 1-2 (ch-ch)
|
|
291
|
+
else if (isChaptersOnly && isRange) {
|
|
292
|
+
let chapterStartandEnd = numbers.split(/-/);
|
|
293
|
+
let startChapter = parseInt(chapterStartandEnd[0], 0);
|
|
294
|
+
let endChapter = parseInt(chapterStartandEnd[1], 0);
|
|
295
|
+
let chapterRange = [];
|
|
296
|
+
for (let i = startChapter; i <= endChapter; i++) {
|
|
297
|
+
chapterRange.push(i);
|
|
298
|
+
}
|
|
299
|
+
ranges = chapterRange.map(chapter => chapter + ": 1-X");
|
|
300
|
+
}
|
|
301
|
+
//Genesis 1
|
|
302
|
+
else if (isChaptersOnly) {
|
|
303
|
+
ranges = [numbers + ": 1-X"];
|
|
304
|
+
}
|
|
305
|
+
//Genesis 1:1-5,10
|
|
306
|
+
else if (isRange && isSplit) {
|
|
307
|
+
let mostRecentChapter = null;
|
|
308
|
+
let split = numbers.split(/,/);
|
|
309
|
+
let chapter = null;
|
|
310
|
+
let verses = null;
|
|
311
|
+
for (let i in split) {
|
|
312
|
+
// 2:2 OR 1:1-4
|
|
313
|
+
if (split[i].match(/:/)) {
|
|
314
|
+
let pieces = split[i].split(/:/);
|
|
315
|
+
chapter = mostRecentChapter = pieces[0];
|
|
316
|
+
verses = pieces[1];
|
|
317
|
+
}
|
|
318
|
+
//3 or 6-7
|
|
319
|
+
else {
|
|
320
|
+
chapter = mostRecentChapter;
|
|
321
|
+
verses = split[i];
|
|
322
|
+
}
|
|
323
|
+
ranges.push(chapter + ": " + verses.trim());
|
|
324
|
+
}
|
|
325
|
+
}
|
|
326
|
+
// Genesis 1:3,5
|
|
327
|
+
else if (isSplit) {
|
|
328
|
+
let split = numbers.split(/,/);
|
|
329
|
+
let mostRecentChapter = null;
|
|
330
|
+
let chapter = null;
|
|
331
|
+
let verses = null;
|
|
332
|
+
for (let i in split) {
|
|
333
|
+
//Genesis 1:1-5
|
|
334
|
+
if (split[i].match(/:/)) {
|
|
335
|
+
let pieces = numbers.split(/:/);
|
|
336
|
+
chapter = mostRecentChapter = pieces[0];
|
|
337
|
+
verses = pieces[1];
|
|
338
|
+
}
|
|
339
|
+
//10
|
|
340
|
+
else {
|
|
341
|
+
chapter = mostRecentChapter;
|
|
342
|
+
verses = split[i];
|
|
343
|
+
}
|
|
344
|
+
ranges.push(chapter + ": " + verses.trim());
|
|
345
|
+
}
|
|
346
|
+
}
|
|
347
|
+
//Genesis 1:1-10 (cv-v) OR Exodus 1-2:15 (c-cv) OR Leviticus 1:10-2:5 (cv-cv)
|
|
348
|
+
else if (isRange) {
|
|
349
|
+
let chapters = numbers.match(/((\d+)[:]|^\d+)/g);
|
|
350
|
+
let verses = numbers.match(/[:-](\d+)/g);
|
|
351
|
+
if (chapters.length == 1) chapters.push(chapters[0]);
|
|
352
|
+
chapters = chapters.map(c => parseInt(c.replace(/\D/g, '').trim()));
|
|
353
|
+
verses = verses.map(v => parseInt(v.replace(/\D/g, '').trim()));
|
|
354
|
+
for (let i = chapters[0]; i <= chapters[1]; i++) {
|
|
355
|
+
let start = 1;
|
|
356
|
+
let end = "X";
|
|
357
|
+
if (chapters[0] == i) start = verses[0];
|
|
358
|
+
if (chapters[1] == i) end = verses[verses.length - 1];
|
|
359
|
+
ranges.push(i + ": " + start + "-" + end);
|
|
360
|
+
}
|
|
361
|
+
} else {
|
|
362
|
+
ranges = [numbers];
|
|
363
|
+
};
|
|
364
|
+
return ranges;
|
|
365
|
+
}
|
|
366
|
+
const loadVerseIds = function(book, ranges, config) {
|
|
367
|
+
let refIndex = loadRefIndex(config);
|
|
368
|
+
let verseList = [];
|
|
369
|
+
for (let i in ranges) //Assumption: 1 range is within a single chapter
|
|
370
|
+
{
|
|
371
|
+
let range = ranges[i];
|
|
372
|
+
let matches = range.match(/(\d+): *([\dX]+)-*([\dX]*)/);
|
|
373
|
+
if(!matches) continue;
|
|
374
|
+
let chapter = parseInt(matches[1]);
|
|
375
|
+
let start = parseInt(matches[2]);
|
|
376
|
+
let end = matches[3];
|
|
377
|
+
if (end == '') end = start;
|
|
378
|
+
if (end == "X") end = loadMaxVerse(book, chapter, config);
|
|
379
|
+
else end = parseInt(end);
|
|
380
|
+
for (let verse_num = start; verse_num <= end; verse_num++) {
|
|
381
|
+
if (refIndex[book] == undefined) continue;
|
|
382
|
+
if (refIndex[book][chapter] == undefined) continue;
|
|
383
|
+
if (refIndex[book][chapter][verse_num] == undefined) continue;
|
|
384
|
+
verseList.push(refIndex[book][chapter][verse_num]);
|
|
385
|
+
}
|
|
386
|
+
}
|
|
387
|
+
return verseList;
|
|
388
|
+
}
|
|
389
|
+
const loadVerseStructure = function(verse_ids, config) {
|
|
390
|
+
let verseIdIndex = loadVerseIdIndex(config);
|
|
391
|
+
let segments = consecutiveSplitter(verse_ids);
|
|
392
|
+
let structure = [];
|
|
393
|
+
for (let i in segments) {
|
|
394
|
+
let min = segments[i][0];
|
|
395
|
+
let max = segments[i][segments[i].length - 1];
|
|
396
|
+
structure.push([verseIdIndex[min], verseIdIndex[max]]);
|
|
397
|
+
}
|
|
398
|
+
return structure;
|
|
399
|
+
}
|
|
400
|
+
const consecutiveSplitter = function(verse_ids) {
|
|
401
|
+
let segments = [];
|
|
402
|
+
let segment = [];
|
|
403
|
+
let previousVerseId = 0;
|
|
404
|
+
for (let i in verse_ids) {
|
|
405
|
+
if (verse_ids[i] != previousVerseId + 1 && previousVerseId != 0) {
|
|
406
|
+
segments.push(segment);
|
|
407
|
+
segment = [];
|
|
408
|
+
}
|
|
409
|
+
segment.push(verse_ids[i]);
|
|
410
|
+
previousVerseId = verse_ids[i];
|
|
411
|
+
}
|
|
412
|
+
segments.push(segment);
|
|
413
|
+
return segments;
|
|
414
|
+
}
|
|
415
|
+
const loadRefsFromRanges = function(ranges, config) {
|
|
416
|
+
let refs = [];
|
|
417
|
+
let mostRecentBook, mostRecentChapter;
|
|
418
|
+
for (let i in ranges) {
|
|
419
|
+
let ref = '';
|
|
420
|
+
let start_bk = ranges[i][0][0];
|
|
421
|
+
let end_bk = ranges[i][1][0];
|
|
422
|
+
let start_ch = ranges[i][0][1];
|
|
423
|
+
let end_ch = ranges[i][1][1];
|
|
424
|
+
let start_vs = ranges[i][0][2];
|
|
425
|
+
let end_vs = ranges[i][1][2];
|
|
426
|
+
if (start_bk == end_bk) {
|
|
427
|
+
if (start_ch == end_ch) {
|
|
428
|
+
if (start_bk == mostRecentBook) start_bk = '';
|
|
429
|
+
if (start_bk == mostRecentBook && start_ch == mostRecentChapter) start_ch = '';
|
|
430
|
+
if (start_vs == end_vs) {
|
|
431
|
+
ref = start_bk + " " + start_ch + ":" + start_vs;
|
|
432
|
+
} else {
|
|
433
|
+
if (start_vs == 1 && end_vs == loadMaxVerse(start_bk, start_ch, config)) //whole chapter
|
|
434
|
+
{
|
|
435
|
+
ref = start_bk + " " + start_ch;
|
|
436
|
+
} else {
|
|
437
|
+
ref = start_bk + " " + start_ch + ":" + start_vs + "-" + end_vs;
|
|
438
|
+
}
|
|
439
|
+
}
|
|
440
|
+
} else {
|
|
441
|
+
if (start_vs == 1 && end_vs == loadMaxVerse(end_bk, end_ch, config)) {
|
|
442
|
+
ref = start_bk + " " + start_ch + "-" + end_ch;
|
|
443
|
+
} else {
|
|
444
|
+
ref = start_bk + " " + start_ch + ":" + start_vs + "-" + end_ch + ":" + end_vs;
|
|
445
|
+
}
|
|
446
|
+
}
|
|
447
|
+
} else {
|
|
448
|
+
if (start_vs == 1 && end_vs == loadMaxVerse(end_bk, end_ch, config)) {
|
|
449
|
+
ref = start_bk + " " + start_ch + " - " + end_bk + " " + end_ch;
|
|
450
|
+
} else if (end_vs == loadMaxVerse(end_bk, end_ch, config)) {
|
|
451
|
+
ref = start_bk + " " + start_ch + ":" + start_vs + " - " + end_bk + " " + end_ch;
|
|
452
|
+
} else if (start_vs == 1) {
|
|
453
|
+
ref = start_bk + " " + start_ch + " - " + end_bk + " " + end_ch + ":" + end_vs;
|
|
454
|
+
} else {
|
|
455
|
+
ref = start_bk + " " + start_ch + ":" + start_vs + " - " + end_bk + " " + end_ch + ":" + end_vs;
|
|
456
|
+
}
|
|
457
|
+
}
|
|
458
|
+
if (start_bk != '') mostRecentBook = start_bk;
|
|
459
|
+
if (start_ch != '') mostRecentChapter = start_ch;
|
|
460
|
+
ref = ref.replace(/^\s+:*/, '').trim();
|
|
461
|
+
|
|
462
|
+
// Apply language-specific post rules
|
|
463
|
+
if (config.raw_regex.post_rules) {
|
|
464
|
+
for (let rule of config.raw_regex.post_rules) {
|
|
465
|
+
const re = new RegExp(rule[0], "ig");
|
|
466
|
+
ref = ref.replace(re, rule[1]);
|
|
467
|
+
}
|
|
468
|
+
}
|
|
469
|
+
|
|
470
|
+
refs.push(ref);
|
|
471
|
+
}
|
|
472
|
+
return refs;
|
|
473
|
+
}
|
|
474
|
+
|
|
475
|
+
const loadRefIndex = function(config) {
|
|
476
|
+
let refIndex = {};
|
|
477
|
+
let verse_id = 1;
|
|
478
|
+
let book_list = Object.keys(config.raw_index);
|
|
479
|
+
for (let a in book_list) {
|
|
480
|
+
let book_title = book_list[a];
|
|
481
|
+
refIndex[book_title] = {};
|
|
482
|
+
for (let b in config.raw_index[book_title]) {
|
|
483
|
+
let chapter_num = parseInt(b) + 1;
|
|
484
|
+
let verse_max = config.raw_index[book_title][b];
|
|
485
|
+
refIndex[book_title][chapter_num] = {};
|
|
486
|
+
for (var verse_num = 1; verse_num <= verse_max; verse_num++) {
|
|
487
|
+
refIndex[book_title][chapter_num][verse_num] = verse_id;
|
|
488
|
+
verse_id++;
|
|
489
|
+
}
|
|
490
|
+
}
|
|
491
|
+
}
|
|
492
|
+
return refIndex;
|
|
493
|
+
}
|
|
494
|
+
|
|
495
|
+
|
|
496
|
+
const loadVerseIdIndex = function(config) {
|
|
497
|
+
let verseIdIndex = [null];
|
|
498
|
+
let book_list = Object.keys(config.raw_index);
|
|
499
|
+
for (let a in book_list) {
|
|
500
|
+
let book_title = book_list[a];
|
|
501
|
+
for (let b in config.raw_index[book_title]) {
|
|
502
|
+
let chapter_num = parseInt(b) + 1;
|
|
503
|
+
let verse_max = config.raw_index[book_title][b];
|
|
504
|
+
for (var verse_num = 1; verse_num <= verse_max; verse_num++) {
|
|
505
|
+
verseIdIndex.push([book_title, chapter_num, verse_num]);
|
|
506
|
+
}
|
|
507
|
+
}
|
|
508
|
+
}
|
|
509
|
+
return verseIdIndex;
|
|
510
|
+
}
|
|
511
|
+
|
|
512
|
+
|
|
513
|
+
const bookExists = function(book, config) {
|
|
514
|
+
if (config.raw_index[book] === undefined) return false;
|
|
515
|
+
return true;
|
|
516
|
+
}
|
|
517
|
+
|
|
518
|
+
|
|
519
|
+
const loadMaxChapter = function(book, config) {
|
|
520
|
+
|
|
521
|
+
if (!bookExists(book, config)) return 0;
|
|
522
|
+
return config.raw_index[book].length;
|
|
523
|
+
}
|
|
524
|
+
|
|
525
|
+
const loadMaxVerse = function(book, chapter, config) {
|
|
526
|
+
|
|
527
|
+
if (!bookExists(book, config)) return 0;
|
|
528
|
+
return config.raw_index[book][parseInt(chapter) - 1]
|
|
529
|
+
}
|
|
530
|
+
|
|
531
|
+
|
|
532
|
+
|
|
533
|
+
const detectReferences = (content, callBack, language = null) => {
|
|
534
|
+
|
|
535
|
+
callBack = callBack ? callBack : (i)=>{return `[${i}]`};
|
|
536
|
+
const effectiveLanguage = getEffectiveLanguage(language);
|
|
537
|
+
const config = getLanguageConfig(effectiveLanguage);
|
|
538
|
+
const src = config.raw_regex.books.map(i => i[0]);
|
|
539
|
+
const dst = [...new Set(config.raw_regex.books.map(i => i[1]))];
|
|
540
|
+
const books = [...dst, ...src];
|
|
541
|
+
return processReferenceDetection(content, books, config.lang_extra, (query) => lookupReference(query, effectiveLanguage), callBack);
|
|
542
|
+
|
|
543
|
+
}
|
|
544
|
+
|
|
545
|
+
const getLanguageConfig = function(language) {
|
|
546
|
+
// Default to English if no language specified or not found
|
|
547
|
+
const effectiveLanguage = language && raw_lang[language] ? language : 'en';
|
|
548
|
+
|
|
549
|
+
const config = {
|
|
550
|
+
language: effectiveLanguage,
|
|
551
|
+
raw_index: raw_index_orig,
|
|
552
|
+
raw_regex: {...raw_regex_orig},
|
|
553
|
+
lang_extra: {},
|
|
554
|
+
wordBreak: "\\b"
|
|
555
|
+
};
|
|
556
|
+
|
|
557
|
+
// For English or if language not found, use defaults
|
|
558
|
+
if (effectiveLanguage === 'en' || !raw_lang[effectiveLanguage]) {
|
|
559
|
+
return config;
|
|
560
|
+
}
|
|
561
|
+
|
|
562
|
+
// Process language-specific data
|
|
563
|
+
const langData = raw_lang[effectiveLanguage];
|
|
564
|
+
|
|
565
|
+
if(langData.books) {
|
|
566
|
+
config.raw_regex.books = [];
|
|
567
|
+
let new_index = {};
|
|
568
|
+
const bookList = Object.keys(langData.books);
|
|
569
|
+
for(let book of bookList) {
|
|
570
|
+
const book_index = bookList.indexOf(book);
|
|
571
|
+
const original_bookname = Object.keys(raw_index_orig)?.[book_index];
|
|
572
|
+
if (original_bookname) {
|
|
573
|
+
new_index[book] = raw_index_orig[original_bookname];
|
|
574
|
+
}
|
|
575
|
+
const matches = [book, ...langData.books[book]];
|
|
576
|
+
config.raw_regex.books = config.raw_regex.books.concat(matches.map(i => [i, book]));
|
|
577
|
+
}
|
|
578
|
+
config.raw_index = new_index;
|
|
579
|
+
}
|
|
580
|
+
|
|
581
|
+
config.raw_regex.pre_rules = langData.pre_rules || config.raw_regex.pre_rules;
|
|
582
|
+
config.raw_regex.post_rules = langData.post_rules || config.raw_regex.post_rules;
|
|
583
|
+
config.raw_regex.spacing = langData.spacing || ["\\b", ""];
|
|
584
|
+
config.lang_extra = langData.matchRules || {};
|
|
585
|
+
config.wordBreak = langData.wordBreak || "\\b";
|
|
586
|
+
|
|
587
|
+
return config;
|
|
588
|
+
}
|
|
589
|
+
|
|
590
|
+
|
|
591
|
+
export {
|
|
592
|
+
lookupReference,
|
|
593
|
+
generateReference,
|
|
594
|
+
setLanguage,
|
|
595
|
+
detectReferences,
|
|
596
|
+
|
|
597
|
+
//Aliases for convenience
|
|
598
|
+
setLanguage as lang,
|
|
599
|
+
setLanguage as language,
|
|
600
|
+
setLanguage as setLang,
|
|
601
|
+
|
|
602
|
+
lookupReference as lookup,
|
|
603
|
+
lookupReference as parse,
|
|
604
|
+
lookupReference as read,
|
|
605
|
+
lookupReference as ref2VerseId,
|
|
606
|
+
|
|
607
|
+
generateReference as ref,
|
|
608
|
+
generateReference as gen,
|
|
609
|
+
generateReference as generate,
|
|
610
|
+
generateReference as verseId2Ref,
|
|
611
|
+
|
|
612
|
+
detectReferences as detect,
|
|
613
|
+
detectReferences as detectScriptureReferences,
|
|
614
|
+
detectReferences as detectRefs,
|
|
615
|
+
detectReferences as detectScriptures,
|
|
616
|
+
detectReferences as linkRefs,
|
|
617
|
+
};
|
package/package.json
CHANGED
|
@@ -1,23 +1,23 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "scripture-guide",
|
|
3
|
-
"version": "1.0.
|
|
3
|
+
"version": "1.0.76",
|
|
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
|
-
"main": "scriptures.cjs",
|
|
6
|
-
"module": "scriptures.mjs",
|
|
7
|
-
"types": "scriptures.d.ts",
|
|
5
|
+
"main": "dist/scriptures.cjs",
|
|
6
|
+
"module": "dist/scriptures.mjs",
|
|
7
|
+
"types": "dist/scriptures.d.ts",
|
|
8
8
|
"type": "module",
|
|
9
9
|
"exports": {
|
|
10
10
|
".": {
|
|
11
|
-
"import": "./scriptures.mjs",
|
|
12
|
-
"require": "./scriptures.cjs",
|
|
13
|
-
"types": "./scriptures.d.ts"
|
|
11
|
+
"import": "./dist/scriptures.mjs",
|
|
12
|
+
"require": "./dist/scriptures.cjs",
|
|
13
|
+
"types": "./dist/scriptures.d.ts"
|
|
14
14
|
}
|
|
15
15
|
},
|
|
16
16
|
"scripts": {
|
|
17
17
|
"start": "node test/test.js",
|
|
18
18
|
"test": "node test/test.js",
|
|
19
|
-
"build": "node
|
|
20
|
-
"embed": "node
|
|
19
|
+
"build": "node build/build.cjs && npx babel dist/scriptures.mjs -o dist/scriptures.cjs",
|
|
20
|
+
"embed": "node build/build.cjs",
|
|
21
21
|
"prepublishOnly": "npm version patch && npm run build"
|
|
22
22
|
},
|
|
23
23
|
"author": "",
|