awoken-bible-reference
Version:
Bible verse reference parser, generator and manipulator
1,715 lines (1,710 loc) • 97.6 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b ||= {})
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/parsimmon/src/parsimmon.js
var require_parsimmon = __commonJS({
"node_modules/parsimmon/src/parsimmon.js"(exports, module2) {
"use strict";
function Parsimmon(action) {
if (!(this instanceof Parsimmon)) {
return new Parsimmon(action);
}
this._ = action;
}
var _ = Parsimmon.prototype;
function times(n, f) {
var i = 0;
for (i; i < n; i++) {
f(i);
}
}
function forEach(f, arr) {
times(arr.length, function(i) {
f(arr[i], i, arr);
});
}
function reduce(f, seed, arr) {
forEach(function(elem, i, arr2) {
seed = f(seed, elem, i, arr2);
}, arr);
return seed;
}
function map(f, arr) {
return reduce(
function(acc, elem, i, a) {
return acc.concat([f(elem, i, a)]);
},
[],
arr
);
}
function lshiftBuffer(input) {
var asTwoBytes = reduce(
function(a, v, i, b) {
return a.concat(
i === b.length - 1 ? Buffer.from([v, 0]).readUInt16BE(0) : b.readUInt16BE(i)
);
},
[],
input
);
return Buffer.from(
map(function(x) {
return (x << 1 & 65535) >> 8;
}, asTwoBytes)
);
}
function consumeBitsFromBuffer(n, input) {
var state = { v: 0, buf: input };
times(n, function() {
state = {
v: state.v << 1 | bitPeekBuffer(state.buf),
buf: lshiftBuffer(state.buf)
};
});
return state;
}
function bitPeekBuffer(input) {
return input[0] >> 7;
}
function sum(numArr) {
return reduce(
function(x, y) {
return x + y;
},
0,
numArr
);
}
function find(pred, arr) {
return reduce(
function(found, elem) {
return found || (pred(elem) ? elem : found);
},
null,
arr
);
}
function bufferExists() {
return typeof Buffer !== "undefined";
}
function setExists() {
if (Parsimmon._supportsSet !== void 0) {
return Parsimmon._supportsSet;
}
var exists = typeof Set !== "undefined";
Parsimmon._supportsSet = exists;
return exists;
}
function ensureBuffer() {
if (!bufferExists()) {
throw new Error(
"Buffer global does not exist; please use webpack if you need to parse Buffers in the browser."
);
}
}
function bitSeq(alignments) {
ensureBuffer();
var totalBits = sum(alignments);
if (totalBits % 8 !== 0) {
throw new Error(
"The bits [" + alignments.join(", ") + "] add up to " + totalBits + " which is not an even number of bytes; the total should be divisible by 8"
);
}
var bytes = totalBits / 8;
var tooBigRange = find(function(x) {
return x > 48;
}, alignments);
if (tooBigRange) {
throw new Error(
tooBigRange + " bit range requested exceeds 48 bit (6 byte) Number max."
);
}
return new Parsimmon(function(input, i) {
var newPos = bytes + i;
if (newPos > input.length) {
return makeFailure(i, bytes.toString() + " bytes");
}
return makeSuccess(
newPos,
reduce(
function(acc, bits) {
var state = consumeBitsFromBuffer(bits, acc.buf);
return {
coll: acc.coll.concat(state.v),
buf: state.buf
};
},
{ coll: [], buf: input.slice(i, newPos) },
alignments
).coll
);
});
}
function bitSeqObj(namedAlignments) {
ensureBuffer();
var seenKeys = {};
var totalKeys = 0;
var fullAlignments = map(function(item) {
if (isArray(item)) {
var pair = item;
if (pair.length !== 2) {
throw new Error(
"[" + pair.join(", ") + "] should be length 2, got length " + pair.length
);
}
assertString(pair[0]);
assertNumber(pair[1]);
if (Object.prototype.hasOwnProperty.call(seenKeys, pair[0])) {
throw new Error("duplicate key in bitSeqObj: " + pair[0]);
}
seenKeys[pair[0]] = true;
totalKeys++;
return pair;
} else {
assertNumber(item);
return [null, item];
}
}, namedAlignments);
if (totalKeys < 1) {
throw new Error(
"bitSeqObj expects at least one named pair, got [" + namedAlignments.join(", ") + "]"
);
}
var namesOnly = map(function(pair) {
return pair[0];
}, fullAlignments);
var alignmentsOnly = map(function(pair) {
return pair[1];
}, fullAlignments);
return bitSeq(alignmentsOnly).map(function(parsed) {
var namedParsed = map(function(name, i) {
return [name, parsed[i]];
}, namesOnly);
return reduce(
function(obj, kv) {
if (kv[0] !== null) {
obj[kv[0]] = kv[1];
}
return obj;
},
{},
namedParsed
);
});
}
function parseBufferFor(other, length) {
return new Parsimmon(function(input, i) {
ensureBuffer();
if (i + length > input.length) {
return makeFailure(i, length + " bytes for " + other);
}
return makeSuccess(i + length, input.slice(i, i + length));
});
}
function parseBuffer(length) {
return parseBufferFor("buffer", length).map(function(unsafe) {
return Buffer.from(unsafe);
});
}
function encodedString(encoding, length) {
return parseBufferFor("string", length).map(function(buff) {
return buff.toString(encoding);
});
}
function isInteger(value) {
return typeof value === "number" && Math.floor(value) === value;
}
function assertValidIntegerByteLengthFor(who, length) {
if (!isInteger(length) || length < 0 || length > 6) {
throw new Error(who + " requires integer length in range [0, 6].");
}
}
function uintBE(length) {
assertValidIntegerByteLengthFor("uintBE", length);
return parseBufferFor("uintBE(" + length + ")", length).map(function(buff) {
return buff.readUIntBE(0, length);
});
}
function uintLE(length) {
assertValidIntegerByteLengthFor("uintLE", length);
return parseBufferFor("uintLE(" + length + ")", length).map(function(buff) {
return buff.readUIntLE(0, length);
});
}
function intBE(length) {
assertValidIntegerByteLengthFor("intBE", length);
return parseBufferFor("intBE(" + length + ")", length).map(function(buff) {
return buff.readIntBE(0, length);
});
}
function intLE(length) {
assertValidIntegerByteLengthFor("intLE", length);
return parseBufferFor("intLE(" + length + ")", length).map(function(buff) {
return buff.readIntLE(0, length);
});
}
function floatBE() {
return parseBufferFor("floatBE", 4).map(function(buff) {
return buff.readFloatBE(0);
});
}
function floatLE() {
return parseBufferFor("floatLE", 4).map(function(buff) {
return buff.readFloatLE(0);
});
}
function doubleBE() {
return parseBufferFor("doubleBE", 8).map(function(buff) {
return buff.readDoubleBE(0);
});
}
function doubleLE() {
return parseBufferFor("doubleLE", 8).map(function(buff) {
return buff.readDoubleLE(0);
});
}
function toArray(arrLike) {
return Array.prototype.slice.call(arrLike);
}
function isParser(obj) {
return obj instanceof Parsimmon;
}
function isArray(x) {
return {}.toString.call(x) === "[object Array]";
}
function isBuffer(x) {
return bufferExists() && Buffer.isBuffer(x);
}
function makeSuccess(index2, value) {
return {
status: true,
index: index2,
value,
furthest: -1,
expected: []
};
}
function makeFailure(index2, expected) {
if (!isArray(expected)) {
expected = [expected];
}
return {
status: false,
index: -1,
value: null,
furthest: index2,
expected
};
}
function mergeReplies(result, last) {
if (!last) {
return result;
}
if (result.furthest > last.furthest) {
return result;
}
var expected = result.furthest === last.furthest ? union(result.expected, last.expected) : last.expected;
return {
status: result.status,
index: result.index,
value: result.value,
furthest: last.furthest,
expected
};
}
var lineColumnIndex = {};
function makeLineColumnIndex(input, i) {
if (isBuffer(input)) {
return {
offset: i,
line: -1,
column: -1
};
}
if (!(input in lineColumnIndex)) {
lineColumnIndex[input] = {};
}
var inputIndex = lineColumnIndex[input];
var prevLine = 0;
var newLines = 0;
var lineStart = 0;
var j = i;
while (j >= 0) {
if (j in inputIndex) {
prevLine = inputIndex[j].line;
if (lineStart === 0) {
lineStart = inputIndex[j].lineStart;
}
break;
}
if (input.charAt(j) === "\n" || input.charAt(j) === "\r" && input.charAt(j + 1) !== "\n") {
newLines++;
if (lineStart === 0) {
lineStart = j + 1;
}
}
j--;
}
var lineWeAreUpTo = prevLine + newLines;
var columnWeAreUpTo = i - lineStart;
inputIndex[i] = { line: lineWeAreUpTo, lineStart };
return {
offset: i,
line: lineWeAreUpTo + 1,
column: columnWeAreUpTo + 1
};
}
function union(xs, ys) {
if (setExists() && Array.from) {
var set = new Set(xs);
for (var y = 0; y < ys.length; y++) {
set.add(ys[y]);
}
var arr = Array.from(set);
arr.sort();
return arr;
}
var obj = {};
for (var i = 0; i < xs.length; i++) {
obj[xs[i]] = true;
}
for (var j = 0; j < ys.length; j++) {
obj[ys[j]] = true;
}
var keys = [];
for (var k in obj) {
if ({}.hasOwnProperty.call(obj, k)) {
keys.push(k);
}
}
keys.sort();
return keys;
}
function assertParser(p) {
if (!isParser(p)) {
throw new Error("not a parser: " + p);
}
}
function get(input, i) {
if (typeof input === "string") {
return input.charAt(i);
}
return input[i];
}
function assertArray(x) {
if (!isArray(x)) {
throw new Error("not an array: " + x);
}
}
function assertNumber(x) {
if (typeof x !== "number") {
throw new Error("not a number: " + x);
}
}
function assertRegexp(x) {
if (!(x instanceof RegExp)) {
throw new Error("not a regexp: " + x);
}
var f = flags(x);
for (var i = 0; i < f.length; i++) {
var c = f.charAt(i);
if (c !== "i" && c !== "m" && c !== "u" && c !== "s") {
throw new Error('unsupported regexp flag "' + c + '": ' + x);
}
}
}
function assertFunction(x) {
if (typeof x !== "function") {
throw new Error("not a function: " + x);
}
}
function assertString(x) {
if (typeof x !== "string") {
throw new Error("not a string: " + x);
}
}
var linesBeforeStringError = 2;
var linesAfterStringError = 3;
var bytesPerLine = 8;
var bytesBefore = bytesPerLine * 5;
var bytesAfter = bytesPerLine * 4;
var defaultLinePrefix = " ";
function repeat(string2, amount) {
return new Array(amount + 1).join(string2);
}
function formatExpected(expected) {
if (expected.length === 1) {
return "Expected:\n\n" + expected[0];
}
return "Expected one of the following: \n\n" + expected.join(", ");
}
function leftPad(str, pad, char) {
var add = pad - str.length;
if (add <= 0) {
return str;
}
return repeat(char, add) + str;
}
function toChunks(arr, chunkSize) {
var length = arr.length;
var chunks = [];
var chunkIndex = 0;
if (length <= chunkSize) {
return [arr.slice()];
}
for (var i = 0; i < length; i++) {
if (!chunks[chunkIndex]) {
chunks.push([]);
}
chunks[chunkIndex].push(arr[i]);
if ((i + 1) % chunkSize === 0) {
chunkIndex++;
}
}
return chunks;
}
function rangeFromIndexAndOffsets(i, before, after, length) {
return {
from: i - before > 0 ? i - before : 0,
to: i + after > length ? length : i + after
};
}
function byteRangeToRange(byteRange) {
if (byteRange.from === 0 && byteRange.to === 1) {
return {
from: byteRange.from,
to: byteRange.to
};
}
return {
from: byteRange.from / bytesPerLine,
to: Math.floor(byteRange.to / bytesPerLine)
};
}
function formatGot(input, error) {
var index2 = error.index;
var i = index2.offset;
var verticalMarkerLength = 1;
var column;
var lineWithErrorIndex;
var lines;
var lineRange;
var lastLineNumberLabelLength;
if (i === input.length) {
return "Got the end of the input";
}
if (isBuffer(input)) {
var byteLineWithErrorIndex = i - i % bytesPerLine;
var columnByteIndex = i - byteLineWithErrorIndex;
var byteRange = rangeFromIndexAndOffsets(
byteLineWithErrorIndex,
bytesBefore,
bytesAfter + bytesPerLine,
input.length
);
var bytes = input.slice(byteRange.from, byteRange.to);
var bytesInChunks = toChunks(bytes.toJSON().data, bytesPerLine);
var byteLines = map(function(byteRow) {
return map(function(byteValue) {
return leftPad(byteValue.toString(16), 2, "0");
}, byteRow);
}, bytesInChunks);
lineRange = byteRangeToRange(byteRange);
lineWithErrorIndex = byteLineWithErrorIndex / bytesPerLine;
column = columnByteIndex * 3;
if (columnByteIndex >= 4) {
column += 1;
}
verticalMarkerLength = 2;
lines = map(function(byteLine) {
return byteLine.length <= 4 ? byteLine.join(" ") : byteLine.slice(0, 4).join(" ") + " " + byteLine.slice(4).join(" ");
}, byteLines);
lastLineNumberLabelLength = ((lineRange.to > 0 ? lineRange.to - 1 : lineRange.to) * 8).toString(16).length;
if (lastLineNumberLabelLength < 2) {
lastLineNumberLabelLength = 2;
}
} else {
var inputLines = input.split(/\r\n|[\n\r\u2028\u2029]/);
column = index2.column - 1;
lineWithErrorIndex = index2.line - 1;
lineRange = rangeFromIndexAndOffsets(
lineWithErrorIndex,
linesBeforeStringError,
linesAfterStringError,
inputLines.length
);
lines = inputLines.slice(lineRange.from, lineRange.to);
lastLineNumberLabelLength = lineRange.to.toString().length;
}
var lineWithErrorCurrentIndex = lineWithErrorIndex - lineRange.from;
if (isBuffer(input)) {
lastLineNumberLabelLength = ((lineRange.to > 0 ? lineRange.to - 1 : lineRange.to) * 8).toString(16).length;
if (lastLineNumberLabelLength < 2) {
lastLineNumberLabelLength = 2;
}
}
var linesWithLineNumbers = reduce(
function(acc, lineSource, index3) {
var isLineWithError = index3 === lineWithErrorCurrentIndex;
var prefix = isLineWithError ? "> " : defaultLinePrefix;
var lineNumberLabel;
if (isBuffer(input)) {
lineNumberLabel = leftPad(
((lineRange.from + index3) * 8).toString(16),
lastLineNumberLabelLength,
"0"
);
} else {
lineNumberLabel = leftPad(
(lineRange.from + index3 + 1).toString(),
lastLineNumberLabelLength,
" "
);
}
return [].concat(
acc,
[prefix + lineNumberLabel + " | " + lineSource],
isLineWithError ? [
defaultLinePrefix + repeat(" ", lastLineNumberLabelLength) + " | " + leftPad("", column, " ") + repeat("^", verticalMarkerLength)
] : []
);
},
[],
lines
);
return linesWithLineNumbers.join("\n");
}
function formatError(input, error) {
return [
"\n",
"-- PARSING FAILED " + repeat("-", 50),
"\n\n",
formatGot(input, error),
"\n\n",
formatExpected(error.expected),
"\n"
].join("");
}
function flags(re) {
if (re.flags !== void 0) {
return re.flags;
}
return [
re.global ? "g" : "",
re.ignoreCase ? "i" : "",
re.multiline ? "m" : "",
re.unicode ? "u" : "",
re.sticky ? "y" : ""
].join("");
}
function anchoredRegexp(re) {
return RegExp("^(?:" + re.source + ")", flags(re));
}
function seq() {
var parsers = [].slice.call(arguments);
var numParsers = parsers.length;
for (var j = 0; j < numParsers; j += 1) {
assertParser(parsers[j]);
}
return Parsimmon(function(input, i) {
var result;
var accum = new Array(numParsers);
for (var j2 = 0; j2 < numParsers; j2 += 1) {
result = mergeReplies(parsers[j2]._(input, i), result);
if (!result.status) {
return result;
}
accum[j2] = result.value;
i = result.index;
}
return mergeReplies(makeSuccess(i, accum), result);
});
}
function seqObj() {
var seenKeys = {};
var totalKeys = 0;
var parsers = toArray(arguments);
var numParsers = parsers.length;
for (var j = 0; j < numParsers; j += 1) {
var p = parsers[j];
if (isParser(p)) {
continue;
}
if (isArray(p)) {
var isWellFormed = p.length === 2 && typeof p[0] === "string" && isParser(p[1]);
if (isWellFormed) {
var key = p[0];
if (Object.prototype.hasOwnProperty.call(seenKeys, key)) {
throw new Error("seqObj: duplicate key " + key);
}
seenKeys[key] = true;
totalKeys++;
continue;
}
}
throw new Error(
"seqObj arguments must be parsers or [string, parser] array pairs."
);
}
if (totalKeys === 0) {
throw new Error("seqObj expects at least one named parser, found zero");
}
return Parsimmon(function(input, i) {
var result;
var accum = {};
for (var j2 = 0; j2 < numParsers; j2 += 1) {
var name;
var parser;
if (isArray(parsers[j2])) {
name = parsers[j2][0];
parser = parsers[j2][1];
} else {
name = null;
parser = parsers[j2];
}
result = mergeReplies(parser._(input, i), result);
if (!result.status) {
return result;
}
if (name) {
accum[name] = result.value;
}
i = result.index;
}
return mergeReplies(makeSuccess(i, accum), result);
});
}
function seqMap() {
var args = [].slice.call(arguments);
if (args.length === 0) {
throw new Error("seqMap needs at least one argument");
}
var mapper = args.pop();
assertFunction(mapper);
return seq.apply(null, args).map(function(results) {
return mapper.apply(null, results);
});
}
function createLanguage(parsers) {
var language = {};
for (var key in parsers) {
if ({}.hasOwnProperty.call(parsers, key)) {
(function(key2) {
var func = function() {
return parsers[key2](language);
};
language[key2] = lazy(func);
})(key);
}
}
return language;
}
function alt() {
var parsers = [].slice.call(arguments);
var numParsers = parsers.length;
if (numParsers === 0) {
return fail("zero alternates");
}
for (var j = 0; j < numParsers; j += 1) {
assertParser(parsers[j]);
}
return Parsimmon(function(input, i) {
var result;
for (var j2 = 0; j2 < parsers.length; j2 += 1) {
result = mergeReplies(parsers[j2]._(input, i), result);
if (result.status) {
return result;
}
}
return result;
});
}
function sepBy(parser, separator) {
return sepBy1(parser, separator).or(succeed([]));
}
function sepBy1(parser, separator) {
assertParser(parser);
assertParser(separator);
var pairs = separator.then(parser).many();
return seqMap(parser, pairs, function(r, rs) {
return [r].concat(rs);
});
}
_.parse = function(input) {
if (typeof input !== "string" && !isBuffer(input)) {
throw new Error(
".parse must be called with a string or Buffer as its argument"
);
}
var parseResult = this.skip(eof)._(input, 0);
var result;
if (parseResult.status) {
result = {
status: true,
value: parseResult.value
};
} else {
result = {
status: false,
index: makeLineColumnIndex(input, parseResult.furthest),
expected: parseResult.expected
};
}
delete lineColumnIndex[input];
return result;
};
_.tryParse = function(str) {
var result = this.parse(str);
if (result.status) {
return result.value;
} else {
var msg = formatError(str, result);
var err = new Error(msg);
err.type = "ParsimmonError";
err.result = result;
throw err;
}
};
_.assert = function(condition, errorMessage) {
return this.chain(function(value) {
return condition(value) ? succeed(value) : fail(errorMessage);
});
};
_.or = function(alternative) {
return alt(this, alternative);
};
_.trim = function(parser) {
return this.wrap(parser, parser);
};
_.wrap = function(leftParser, rightParser) {
return seqMap(leftParser, this, rightParser, function(left, middle) {
return middle;
});
};
_.thru = function(wrapper) {
return wrapper(this);
};
_.then = function(next) {
assertParser(next);
return seq(this, next).map(function(results) {
return results[1];
});
};
_.many = function() {
var self = this;
return Parsimmon(function(input, i) {
var accum = [];
var result = void 0;
for (; ; ) {
result = mergeReplies(self._(input, i), result);
if (result.status) {
if (i === result.index) {
throw new Error(
"infinite loop detected in .many() parser --- calling .many() on a parser which can accept zero characters is usually the cause"
);
}
i = result.index;
accum.push(result.value);
} else {
return mergeReplies(makeSuccess(i, accum), result);
}
}
});
};
_.tieWith = function(separator) {
assertString(separator);
return this.map(function(args) {
assertArray(args);
if (args.length) {
assertString(args[0]);
var s = args[0];
for (var i = 1; i < args.length; i++) {
assertString(args[i]);
s += separator + args[i];
}
return s;
} else {
return "";
}
});
};
_.tie = function() {
return this.tieWith("");
};
_.times = function(min, max) {
var self = this;
if (arguments.length < 2) {
max = min;
}
assertNumber(min);
assertNumber(max);
return Parsimmon(function(input, i) {
var accum = [];
var result = void 0;
var prevResult = void 0;
for (var times2 = 0; times2 < min; times2 += 1) {
result = self._(input, i);
prevResult = mergeReplies(result, prevResult);
if (result.status) {
i = result.index;
accum.push(result.value);
} else {
return prevResult;
}
}
for (; times2 < max; times2 += 1) {
result = self._(input, i);
prevResult = mergeReplies(result, prevResult);
if (result.status) {
i = result.index;
accum.push(result.value);
} else {
break;
}
}
return mergeReplies(makeSuccess(i, accum), prevResult);
});
};
_.result = function(res) {
return this.map(function() {
return res;
});
};
_.atMost = function(n) {
return this.times(0, n);
};
_.atLeast = function(n) {
return seqMap(this.times(n), this.many(), function(init, rest) {
return init.concat(rest);
});
};
_.map = function(fn) {
assertFunction(fn);
var self = this;
return Parsimmon(function(input, i) {
var result = self._(input, i);
if (!result.status) {
return result;
}
return mergeReplies(makeSuccess(result.index, fn(result.value)), result);
});
};
_.contramap = function(fn) {
assertFunction(fn);
var self = this;
return Parsimmon(function(input, i) {
var result = self.parse(fn(input.slice(i)));
if (!result.status) {
return result;
}
return makeSuccess(i + input.length, result.value);
});
};
_.promap = function(f, g) {
assertFunction(f);
assertFunction(g);
return this.contramap(f).map(g);
};
_.skip = function(next) {
return seq(this, next).map(function(results) {
return results[0];
});
};
_.mark = function() {
return seqMap(index, this, index, function(start, value, end2) {
return {
start,
value,
end: end2
};
});
};
_.node = function(name) {
return seqMap(index, this, index, function(start, value, end2) {
return {
name,
value,
start,
end: end2
};
});
};
_.sepBy = function(separator) {
return sepBy(this, separator);
};
_.sepBy1 = function(separator) {
return sepBy1(this, separator);
};
_.lookahead = function(x) {
return this.skip(lookahead(x));
};
_.notFollowedBy = function(x) {
return this.skip(notFollowedBy(x));
};
_.desc = function(expected) {
if (!isArray(expected)) {
expected = [expected];
}
var self = this;
return Parsimmon(function(input, i) {
var reply = self._(input, i);
if (!reply.status) {
reply.expected = expected;
}
return reply;
});
};
_.fallback = function(result) {
return this.or(succeed(result));
};
_.ap = function(other) {
return seqMap(other, this, function(f, x) {
return f(x);
});
};
_.chain = function(f) {
var self = this;
return Parsimmon(function(input, i) {
var result = self._(input, i);
if (!result.status) {
return result;
}
var nextParser = f(result.value);
return mergeReplies(nextParser._(input, result.index), result);
});
};
function string(str) {
assertString(str);
var expected = "'" + str + "'";
return Parsimmon(function(input, i) {
var j = i + str.length;
var head = input.slice(i, j);
if (head === str) {
return makeSuccess(j, head);
} else {
return makeFailure(i, expected);
}
});
}
function byte(b) {
ensureBuffer();
assertNumber(b);
if (b > 255) {
throw new Error(
"Value specified to byte constructor (" + b + "=0x" + b.toString(16) + ") is larger in value than a single byte."
);
}
var expected = (b > 15 ? "0x" : "0x0") + b.toString(16);
return Parsimmon(function(input, i) {
var head = get(input, i);
if (head === b) {
return makeSuccess(i + 1, head);
} else {
return makeFailure(i, expected);
}
});
}
function regexp(re, group) {
assertRegexp(re);
if (arguments.length >= 2) {
assertNumber(group);
} else {
group = 0;
}
var anchored = anchoredRegexp(re);
var expected = "" + re;
return Parsimmon(function(input, i) {
var match = anchored.exec(input.slice(i));
if (match) {
if (0 <= group && group <= match.length) {
var fullMatch = match[0];
var groupMatch = match[group];
return makeSuccess(i + fullMatch.length, groupMatch);
}
var message = "valid match group (0 to " + match.length + ") in " + expected;
return makeFailure(i, message);
}
return makeFailure(i, expected);
});
}
function succeed(value) {
return Parsimmon(function(input, i) {
return makeSuccess(i, value);
});
}
function fail(expected) {
return Parsimmon(function(input, i) {
return makeFailure(i, expected);
});
}
function lookahead(x) {
if (isParser(x)) {
return Parsimmon(function(input, i) {
var result = x._(input, i);
result.index = i;
result.value = "";
return result;
});
} else if (typeof x === "string") {
return lookahead(string(x));
} else if (x instanceof RegExp) {
return lookahead(regexp(x));
}
throw new Error("not a string, regexp, or parser: " + x);
}
function notFollowedBy(parser) {
assertParser(parser);
return Parsimmon(function(input, i) {
var result = parser._(input, i);
var text = input.slice(i, result.index);
return result.status ? makeFailure(i, 'not "' + text + '"') : makeSuccess(i, null);
});
}
function test(predicate) {
assertFunction(predicate);
return Parsimmon(function(input, i) {
var char = get(input, i);
if (i < input.length && predicate(char)) {
return makeSuccess(i + 1, char);
} else {
return makeFailure(i, "a character/byte matching " + predicate);
}
});
}
function oneOf(str) {
var expected = str.split("");
for (var idx = 0; idx < expected.length; idx++) {
expected[idx] = "'" + expected[idx] + "'";
}
return test(function(ch) {
return str.indexOf(ch) >= 0;
}).desc(expected);
}
function noneOf(str) {
return test(function(ch) {
return str.indexOf(ch) < 0;
}).desc("none of '" + str + "'");
}
function custom(parsingFunction) {
return Parsimmon(parsingFunction(makeSuccess, makeFailure));
}
function range(begin, end2) {
return test(function(ch) {
return begin <= ch && ch <= end2;
}).desc(begin + "-" + end2);
}
function takeWhile(predicate) {
assertFunction(predicate);
return Parsimmon(function(input, i) {
var j = i;
while (j < input.length && predicate(get(input, j))) {
j++;
}
return makeSuccess(j, input.slice(i, j));
});
}
function lazy(desc, f) {
if (arguments.length < 2) {
f = desc;
desc = void 0;
}
var parser = Parsimmon(function(input, i) {
parser._ = f()._;
return parser._(input, i);
});
if (desc) {
return parser.desc(desc);
} else {
return parser;
}
}
function empty() {
return fail("fantasy-land/empty");
}
_.concat = _.or;
_.empty = empty;
_.of = succeed;
_["fantasy-land/ap"] = _.ap;
_["fantasy-land/chain"] = _.chain;
_["fantasy-land/concat"] = _.concat;
_["fantasy-land/empty"] = _.empty;
_["fantasy-land/of"] = _.of;
_["fantasy-land/map"] = _.map;
var index = Parsimmon(function(input, i) {
return makeSuccess(i, makeLineColumnIndex(input, i));
});
var any = Parsimmon(function(input, i) {
if (i >= input.length) {
return makeFailure(i, "any character/byte");
}
return makeSuccess(i + 1, get(input, i));
});
var all = Parsimmon(function(input, i) {
return makeSuccess(input.length, input.slice(i));
});
var eof = Parsimmon(function(input, i) {
if (i < input.length) {
return makeFailure(i, "EOF");
}
return makeSuccess(i, null);
});
var digit = regexp(/[0-9]/).desc("a digit");
var digits = regexp(/[0-9]*/).desc("optional digits");
var letter = regexp(/[a-z]/i).desc("a letter");
var letters = regexp(/[a-z]*/i).desc("optional letters");
var optWhitespace = regexp(/\s*/).desc("optional whitespace");
var whitespace = regexp(/\s+/).desc("whitespace");
var cr = string("\r");
var lf = string("\n");
var crlf = string("\r\n");
var newline = alt(crlf, lf, cr).desc("newline");
var end = alt(newline, eof);
Parsimmon.all = all;
Parsimmon.alt = alt;
Parsimmon.any = any;
Parsimmon.cr = cr;
Parsimmon.createLanguage = createLanguage;
Parsimmon.crlf = crlf;
Parsimmon.custom = custom;
Parsimmon.digit = digit;
Parsimmon.digits = digits;
Parsimmon.empty = empty;
Parsimmon.end = end;
Parsimmon.eof = eof;
Parsimmon.fail = fail;
Parsimmon.formatError = formatError;
Parsimmon.index = index;
Parsimmon.isParser = isParser;
Parsimmon.lazy = lazy;
Parsimmon.letter = letter;
Parsimmon.letters = letters;
Parsimmon.lf = lf;
Parsimmon.lookahead = lookahead;
Parsimmon.makeFailure = makeFailure;
Parsimmon.makeSuccess = makeSuccess;
Parsimmon.newline = newline;
Parsimmon.noneOf = noneOf;
Parsimmon.notFollowedBy = notFollowedBy;
Parsimmon.of = succeed;
Parsimmon.oneOf = oneOf;
Parsimmon.optWhitespace = optWhitespace;
Parsimmon.Parser = Parsimmon;
Parsimmon.range = range;
Parsimmon.regex = regexp;
Parsimmon.regexp = regexp;
Parsimmon.sepBy = sepBy;
Parsimmon.sepBy1 = sepBy1;
Parsimmon.seq = seq;
Parsimmon.seqMap = seqMap;
Parsimmon.seqObj = seqObj;
Parsimmon.string = string;
Parsimmon.succeed = succeed;
Parsimmon.takeWhile = takeWhile;
Parsimmon.test = test;
Parsimmon.whitespace = whitespace;
Parsimmon["fantasy-land/empty"] = empty;
Parsimmon["fantasy-land/of"] = succeed;
Parsimmon.Binary = {
bitSeq,
bitSeqObj,
byte,
buffer: parseBuffer,
encodedString,
uintBE,
uint8BE: uintBE(1),
uint16BE: uintBE(2),
uint32BE: uintBE(4),
uintLE,
uint8LE: uintLE(1),
uint16LE: uintLE(2),
uint32LE: uintLE(4),
intBE,
int8BE: intBE(1),
int16BE: intBE(2),
int32BE: intBE(4),
intLE,
int8LE: intLE(1),
int16LE: intLE(2),
int32LE: intLE(4),
floatBE: floatBE(),
floatLE: floatLE(),
doubleBE: doubleBE(),
doubleLE: doubleLE()
};
module2.exports = Parsimmon;
}
});
// src/index.ts
var src_exports = {};
__export(src_exports, {
AwokenRef: () => lib_default,
createVersification: () => createVersification,
default: () => src_default
});
module.exports = __toCommonJS(src_exports);
// src/vidx.ts
function toVidx(versification, verse) {
return versification.book[verse.book][verse.chapter].cumulative_verse + verse.verse - 1;
}
function fromVidx(versification, vidx) {
let b_idx;
for (b_idx = 1; b_idx < versification.order.length; ++b_idx) {
if (versification.order[b_idx].chapters[0].cumulative_verse > vidx) {
break;
}
}
--b_idx;
let book = versification.order[b_idx];
let c_idx;
for (c_idx = 1; c_idx < book.chapters.length; ++c_idx) {
if (book.chapters[c_idx].cumulative_verse > vidx) {
break;
}
}
--c_idx;
return {
book: book.id,
chapter: c_idx + 1,
verse: vidx - book.chapters[c_idx].cumulative_verse + 1
};
}
function countVerses(v, ref) {
if (ref.is_range) {
return toVidx(v, ref.end) - toVidx(v, ref.start) + 1;
} else {
return 1;
}
}
function firstNVerses(v, refs, n) {
if (n === 0 || refs.length === 0) {
return [];
}
if (refs.length === 1) {
let ref = refs[0];
let count = countVerses(v, ref);
if (count <= n) {
return refs;
}
let range = ref;
if (n == 1) {
return [range.start];
}
return [{
is_range: true,
start: range.start,
end: fromVidx(v, toVidx(v, range.start) + n - 1)
}];
}
let result = [];
let used = 0;
for (let i = 0; i < refs.length && used < n; ++i) {
let more = firstNVerses(v, [refs[i]], n - used);
used += countVerses(v, more[0]);
result.push(more[0]);
}
return result;
}
// src/geometry.ts
function combineRanges(refs) {
let v = this.versification;
let ranges = _toLineSegmentsUnsorted(this, refs);
ranges = ranges.sort((a, b) => a.min - b.min);
let out_ranges = [];
let cur_r = null;
for (let new_r of ranges) {
if (cur_r == null) {
cur_r = new_r;
continue;
}
if (new_r.min > cur_r.max + 1) {
out_ranges.push(cur_r);
cur_r = new_r;
continue;
}
if (new_r.max > cur_r.max) {
cur_r.max = new_r.max;
}
;
}
if (cur_r) {
out_ranges.push(cur_r);
}
return out_ranges.map((x) => _fromLineSegment(this, x));
}
function createIntersectionSet(x) {
return { segments: _toLineSegments(this, x) };
}
function getIntersection(x, y) {
let a = _toLineSegments(this, x);
let b = _toLineSegments(this, y);
let ai = 0;
let bi = 0;
let out = [];
while (ai < a.length && bi < b.length) {
let intersection = _intersectLineSegment(a[ai], b[bi]);
if (intersection === null) {
if (a[ai].max < b[bi].max) {
++ai;
} else {
++bi;
}
continue;
}
out.push(_fromLineSegment(this, intersection));
a[ai].min = intersection.max + 1;
b[bi].min = intersection.max + 1;
if (a[ai].min >= a[ai].max) {
++ai;
}
if (b[bi].min >= b[bi].max) {
++bi;
}
}
return out;
}
function intersects(x, y) {
let a = _toLineSegments(this, x);
let b = _toLineSegments(this, y);
let [needles, haystack] = a.length > b.length ? [b, a] : [a, b];
for (let needle of needles) {
let minLo = 0;
let minHi = haystack.length - 1;
while (minLo < minHi - 1) {
let center = minLo + Math.ceil((minHi - minLo) / 2);
while (minLo < minHi - 1 && haystack[center].min < needle.min) {
minLo = center;
center = minLo + Math.ceil((minHi - minLo) / 2);
}
minHi = center;
}
for (let i = minLo; i < haystack.length; ++i) {
if (needle.max < haystack[i].min) {
break;
}
if (_intersectLineSegment(needle, haystack[i])) {
return true;
}
}
}
return false;
}
function contains(outer, inner) {
let a = _toLineSegments(this, outer);
let b = _toLineSegments(this, inner);
let ai = 0, bi = 0;
while (bi < b.length) {
while (a[ai].max < b[bi].min) {
++ai;
if (ai >= a.length) {
return false;
}
}
while (bi < b.length && b[bi].min <= a[ai].max) {
if (a[ai].min > b[bi].min || b[bi].max > a[ai].max) {
return false;
}
++bi;
}
}
return true;
}
function getUnion(a, b) {
let x = "length" in a ? a : [a];
let y = "length" in b ? b : [b];
return combineRanges.bind(this)([...x, ...y]);
}
function getDifference(x, y) {
let a = _toLineSegments(this, x);
let b = _toLineSegments(this, y);
let result = [];
let ai = 0, bi = 0;
while (ai < a.length && bi < b.length) {
let inter = _intersectLineSegment(a[ai], b[bi]);
if (inter) {
if (a[ai].min < inter.min) {
result.push(_fromLineSegment(this, { min: a[ai].min, max: inter.min - 1 }));
}
a[ai].min = inter.max + 1;
b[bi].min = inter.max + 1;
if (a[ai].min > a[ai].max) {
++ai;
}
if (b[bi].min > b[bi].max) {
++bi;
}
} else {
if (a[ai].min < b[bi].min) {
result.push(_fromLineSegment(this, a[ai]));
++ai;
} else {
++bi;
}
}
}
while (ai < a.length) {
result.push(_fromLineSegment(this, a[ai]));
++ai;
}
return result;
}
function indexOf(array, verse) {
let blocks = _toLineSegmentsUnsorted(this, array);
let idx = toVidx(this.versification, verse);
let offset = 0;
for (let b of blocks) {
if (idx >= b.min && idx <= b.max) {
return offset + (idx - b.min);
} else {
offset += b.max - b.min + 1;
}
}
return -1;
}
function verseAtIndex(array, index) {
let blocks = _toLineSegmentsUnsorted(this, array);
let offset = 0;
for (let b of blocks) {
let max_offset = offset + (b.max - b.min);
if (index >= offset && index <= max_offset) {
return fromVidx(this.versification, b.min + index - offset);
} else {
offset = max_offset + 1;
}
}
return void 0;
}
function _toLineSegmentsUnsorted(lib, input) {
let in_arr = "length" in input ? input : [input];
return in_arr.map((x) => {
if (x.is_range) {
return { min: toVidx(lib.versification, x.start), max: toVidx(lib.versification, x.end) };
} else {
let val = toVidx(lib.versification, x);
return { min: val, max: val };
}
});
}
function _toLineSegments(lib, input) {
if ("segments" in input) {
return input.segments;
}
let in_arr = "length" in input ? input : [input];
return _toLineSegmentsUnsorted(lib, combineRanges.bind(lib)(in_arr));
}
function _fromLineSegment(lib, line) {
if (line.min === line.max) {
return fromVidx(lib.versification, line.min);
} else {
return {
is_range: true,
start: fromVidx(lib.versification, line.min),
end: fromVidx(lib.versification, line.max)
};
}
}
function _intersectLineSegment(a, b) {
let min = Math.max(a.min, b.min);
let max = Math.min(b.max, a.max);
if (min <= max) {
return { min, max };
} else {
return null;
}
}
// src/range-manip.ts
function makeRange(book, chapter) {
return _makeRange(this.versification, book, chapter);
}
function makeBookRange(book_start, book_end) {
return _makeBookRange(this.versification, book_start, book_end);
}
function splitByBook(refs, expand_verses) {
return Array.from(iterateByBook.bind(this)(refs, expand_verses));
}
function splitByChapter(refs, expand_verses) {
return Array.from(iterateByChapter.bind(this)(refs, expand_verses));
}
function splitByVerse(refs) {
return Array.from(iterateByVerse.bind(this)(refs));
}
function iterateByBook(refs, expand_verses) {
if (expand_verses === void 0) {
expand_verses = false;
}
if (!("length" in refs)) {
refs = [refs];
}
return _iterateBookRanges(this.versification, refs, expand_verses);
}
function iterateByChapter(refs, expand_verses) {
if (expand_verses === void 0) {
expand_verses = false;
}
if (!("length" in refs)) {
refs = [refs];
}
return _iterateChapterRanges(this.versification, refs, expand_verses);
}
function iterateByVerse(refs) {
if (!("length" in refs)) {
refs = [refs];
}
return _iterateVerses(this.versification, refs);
}
function nextVerse(ref, opts = {}) {
let v = ref.is_range ? ref.end : ref;
let cur_book = this.versification.book[v.book];
let cur_chpt = cur_book == null ? void 0 : cur_book.chapters[v.chapter - 1];
if (!cur_book || !cur_chpt) {
throw new Error("Invalid input reference to nextVerse!");
}
if (v.verse + 1 < cur_chpt.verse_count) {
return { book: v.book, chapter: v.chapter, verse: v.verse + 1 };
}
if (opts.constrain_chapter) {
return null;
}
let next = nextChapter.bind(this)(ref, opts.constrain_book);
if (next) {
return next.start;
}
return null;
}
function previousVerse(ref, opts = {}) {
let v = ref.is_range ? ref.end : ref;
if (v.verse > 1) {
return { book: v.book, chapter: v.chapter, verse: v.verse - 1 };
}
if (opts.constrain_chapter) {
return null;
}
let prev = previousChapter.bind(this)(ref, opts.constrain_book);
if (prev) {
return prev.end;
}
return null;
}
function nextChapter(ref, constrain_book) {
let r = ref.is_range ? ref.end : ref;
let cur_book = this.versification.book[r.book];
if (cur_book === void 0) {
throw new Error("Invalid input reference to nextChapter!");
}
if (r.chapter < cur_book.chapters.length) {
return _makeRange(this.versification, r.book, r.chapter + 1);
} else {
if (constrain_book) {
return null;
}
if (cur_book.index + 1 < this.versification.order.length) {
return _makeRange(this.versification, this.versification.order[cur_book.index + 1].id, 1);
} else {
return null;
}
}
}
function previousChapter(ref, constrain_book) {
let r = ref.is_range ? ref.start : ref;
let new_book_id = r.book;
let new_chapter = 0;
if (r.chapter <= 1) {
if (constrain_book) {
return null;
}
let old_book = this.versification.book[r.book];
if (old_book === void 0) {
throw new Error("Invalid input reference to previousChapter");
}
if (old_book.index === 0) {
return null;
}
let new_book = this.versification.order[old_book.index - 1];
new_book_id = new_book.id;
new_chapter = new_book.chapters.length;
} else {
new_chapter = r.chapter - 1;
}
return _makeRange(this.versification, new_book_id, new_chapter);
}
function nextBook(ref) {
let r = ref.is_range ? ref.end : ref;
let cur_book = this.versification.book[r.book];
if (cur_book.index + 1 < this.versification.order.length) {
return _makeRange(this.versification, this.versification.order[cur_book.index + 1].id);
} else {
return null;
}
}
function previousBook(ref) {
let r = ref.is_range ? ref.start : ref;
let cur_book = this.versification.book[r.book];
if (cur_book.index > 0) {
return _makeRange(this.versification, this.versification.order[cur_book.index - 1].id);
} else {
return null;
}
}
function isFullBook(ref) {
if (!ref.is_range) {
return false;
}
let book_id = ref.start.book;
if (ref.end.book != book_id) {
return false;
}
return ref.start.chapter === 1 && ref.start.verse === 1 && ref.end.chapter === this.versification.book[book_id].chapters.length && ref.end.verse === this.versification.book[book_id][ref.end.chapter].verse_count;
}
function isFullChapter(ref) {
if (!ref.is_range) {
return false;
}
let book_id = ref.start.book;
if (ref.end.book != book_id) {
return false;
}
return ref.start.chapter === ref.end.chapter && ref.start.verse === 1 && ref.end.verse === this.versification.book[book_id][ref.start.chapter].verse_count;
}
function groupByBook(refs) {
let buckets = {};