Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/nth-check/lib/compile.js
f646e1f695a7paginated-inlines

compile.js
View Options

			"use strict";
			var __importDefault = (this && this.__importDefault) \|\| function (mod) {
			return (mod && mod.__esModule) ? mod : { "default": mod };
			};
			Object.defineProperty(exports, "__esModule", { value: true });
			exports.generate = exports.compile = void 0;
			var boolbase_1 = __importDefault(require("boolbase"));
			/**
			* Returns a function that checks if an elements index matches the given rule
			* highly optimized to return the fastest solution.
			*
			* @param parsed A tuple [a, b], as returned by `parse`.
			* @returns A highly optimized function that returns whether an index matches the nth-check.
			* @example
			*
			* ```js
			* const check = nthCheck.compile([2, 3]);
			*
			* check(0); // `false`
			* check(1); // `false`
			* check(2); // `true`
			* check(3); // `false`
			* check(4); // `true`
			* check(5); // `false`
			* check(6); // `true`
			* ```
			*/
			function compile(parsed) {
			var a = parsed[0];
			// Subtract 1 from `b`, to convert from one- to zero-indexed.
			var b = parsed[1] - 1;
			/*
			* When `b <= 0`, `a * n` won't be lead to any matches for `a < 0`.
			* Besides, the specification states that no elements are
			* matched when `a` and `b` are 0.
			*
			* `b < 0` here as we subtracted 1 from `b` above.
			*/
			if (b < 0 && a <= 0)
			return boolbase_1.default.falseFunc;
			// When `a` is in the range -1..1, it matches any element (so only `b` is checked).
			if (a === -1)
			return function (index) { return index <= b; };
			if (a === 0)
			return function (index) { return index === b; };
			// When `b <= 0` and `a === 1`, they match any element.
			if (a === 1)
			return b < 0 ? boolbase_1.default.trueFunc : function (index) { return index >= b; };
			/*
			* Otherwise, modulo can be used to check if there is a match.
			*
			* Modulo doesn't care about the sign, so let's use `a`s absolute value.
			*/
			var absA = Math.abs(a);
			// Get `b mod a`, + a if this is negative.
			var bMod = ((b % absA) + absA) % absA;
			return a > 1
			? function (index) { return index >= b && index % absA === bMod; }
			: function (index) { return index <= b && index % absA === bMod; };
			}
			exports.compile = compile;
			/**
			* Returns a function that produces a monotonously increasing sequence of indices.
			*
			* If the sequence has an end, the returned function will return `null` after
			* the last index in the sequence.
			*
			* @param parsed A tuple [a, b], as returned by `parse`.
			* @returns A function that produces a sequence of indices.
			* @example <caption>Always increasing (2n+3)</caption>
			*
			* ```js
			* const gen = nthCheck.generate([2, 3])
			*
			* gen() // `1`
			* gen() // `3`
			* gen() // `5`
			* gen() // `8`
			* gen() // `11`
			* ```
			*
			* @example <caption>With end value (-2n+10)</caption>
			*
			* ```js
			*
			* const gen = nthCheck.generate([-2, 5]);
			*
			* gen() // 0
			* gen() // 2
			* gen() // 4
			* gen() // null
			* ```
			*/
			function generate(parsed) {
			var a = parsed[0];
			// Subtract 1 from `b`, to convert from one- to zero-indexed.
			var b = parsed[1] - 1;
			var n = 0;
			// Make sure to always return an increasing sequence
			if (a < 0) {
			var aPos_1 = -a;
			// Get `b mod a`
			var minValue_1 = ((b % aPos_1) + aPos_1) % aPos_1;
			return function () {
			var val = minValue_1 + aPos_1 * n++;
			return val > b ? null : val;
			};
			}
			if (a === 0)
			return b < 0
			? // There are no result — always return `null`
			function () { return null; }
			: // Return `b` exactly once
			function () { return (n++ === 0 ? b : null); };
			if (b < 0) {
			b += a * Math.ceil(-b / a);
			}
			return function () { return a * n++ + b; };
			}
			exports.generate = generate;
			//# sourceMappingURL=compile.js.map