From 22a25ded9f7d9c9a96cce8d1bc12475ca0434201 Mon Sep 17 00:00:00 2001 From: Minteck Date: Wed, 9 Feb 2022 17:58:07 +0100 Subject: Major update --- node_modules/nth-check/lib/compile.d.ts | 19 ++++++++ node_modules/nth-check/lib/compile.d.ts.map | 1 + node_modules/nth-check/lib/compile.js | 55 +++++++++++++++++++++ node_modules/nth-check/lib/index.d.ts | 28 +++++++++++ node_modules/nth-check/lib/index.d.ts.map | 1 + node_modules/nth-check/lib/index.js | 34 +++++++++++++ node_modules/nth-check/lib/parse.d.ts | 9 ++++ node_modules/nth-check/lib/parse.d.ts.map | 1 + node_modules/nth-check/lib/parse.js | 76 +++++++++++++++++++++++++++++ 9 files changed, 224 insertions(+) create mode 100644 node_modules/nth-check/lib/compile.d.ts create mode 100644 node_modules/nth-check/lib/compile.d.ts.map create mode 100644 node_modules/nth-check/lib/compile.js create mode 100644 node_modules/nth-check/lib/index.d.ts create mode 100644 node_modules/nth-check/lib/index.d.ts.map create mode 100644 node_modules/nth-check/lib/index.js create mode 100644 node_modules/nth-check/lib/parse.d.ts create mode 100644 node_modules/nth-check/lib/parse.d.ts.map create mode 100644 node_modules/nth-check/lib/parse.js (limited to 'node_modules/nth-check/lib') diff --git a/node_modules/nth-check/lib/compile.d.ts b/node_modules/nth-check/lib/compile.d.ts new file mode 100644 index 0000000..03a0be3 --- /dev/null +++ b/node_modules/nth-check/lib/compile.d.ts @@ -0,0 +1,19 @@ +/** + * 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 + * 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` + */ +export declare function compile(parsed: [a: number, b: number]): (index: number) => boolean; +//# sourceMappingURL=compile.d.ts.map \ No newline at end of file diff --git a/node_modules/nth-check/lib/compile.d.ts.map b/node_modules/nth-check/lib/compile.d.ts.map new file mode 100644 index 0000000..d8645d6 --- /dev/null +++ b/node_modules/nth-check/lib/compile.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CACnB,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,GAC/B,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAgC5B"} \ No newline at end of file diff --git a/node_modules/nth-check/lib/compile.js b/node_modules/nth-check/lib/compile.js new file mode 100644 index 0000000..1cf3b09 --- /dev/null +++ b/node_modules/nth-check/lib/compile.js @@ -0,0 +1,55 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.compile = void 0; +var boolbase_1 = 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 + * 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.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.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; diff --git a/node_modules/nth-check/lib/index.d.ts b/node_modules/nth-check/lib/index.d.ts new file mode 100644 index 0000000..dc12691 --- /dev/null +++ b/node_modules/nth-check/lib/index.d.ts @@ -0,0 +1,28 @@ +import { parse } from "./parse"; +import { compile } from "./compile"; +export { parse, compile }; +/** + * Parses and compiles a formula to a highly optimized function. + * Combination of `parse` and `compile`. + * + * If the formula doesn't match any elements, + * it returns [`boolbase`](https://github.com/fb55/boolbase)'s `falseFunc`. + * Otherwise, a function accepting an _index_ is returned, which returns + * whether or not the passed _index_ matches the formula. + * + * Note: The nth-rule starts counting at `1`, the returned function at `0`. + * + * @param formula The formula to compile. + * @example + * const check = nthCheck("2n+3"); + * + * check(0); // `false` + * check(1); // `false` + * check(2); // `true` + * check(3); // `false` + * check(4); // `true` + * check(5); // `false` + * check(6); // `true` + */ +export default function nthCheck(formula: string): (index: number) => boolean; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/node_modules/nth-check/lib/index.d.ts.map b/node_modules/nth-check/lib/index.d.ts.map new file mode 100644 index 0000000..eabcd19 --- /dev/null +++ b/node_modules/nth-check/lib/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAE5E"} \ No newline at end of file diff --git a/node_modules/nth-check/lib/index.js b/node_modules/nth-check/lib/index.js new file mode 100644 index 0000000..afa219d --- /dev/null +++ b/node_modules/nth-check/lib/index.js @@ -0,0 +1,34 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.compile = exports.parse = void 0; +var parse_1 = require("./parse"); +Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parse_1.parse; } }); +var compile_1 = require("./compile"); +Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return compile_1.compile; } }); +/** + * Parses and compiles a formula to a highly optimized function. + * Combination of `parse` and `compile`. + * + * If the formula doesn't match any elements, + * it returns [`boolbase`](https://github.com/fb55/boolbase)'s `falseFunc`. + * Otherwise, a function accepting an _index_ is returned, which returns + * whether or not the passed _index_ matches the formula. + * + * Note: The nth-rule starts counting at `1`, the returned function at `0`. + * + * @param formula The formula to compile. + * @example + * const check = nthCheck("2n+3"); + * + * check(0); // `false` + * check(1); // `false` + * check(2); // `true` + * check(3); // `false` + * check(4); // `true` + * check(5); // `false` + * check(6); // `true` + */ +function nthCheck(formula) { + return (0, compile_1.compile)((0, parse_1.parse)(formula)); +} +exports.default = nthCheck; diff --git a/node_modules/nth-check/lib/parse.d.ts b/node_modules/nth-check/lib/parse.d.ts new file mode 100644 index 0000000..b4f817b --- /dev/null +++ b/node_modules/nth-check/lib/parse.d.ts @@ -0,0 +1,9 @@ +/** + * Parses an expression. + * + * @throws An `Error` if parsing fails. + * @returns An array containing the integer step size and the integer offset of the nth rule. + * @example nthCheck.parse("2n+3"); // returns [2, 3] + */ +export declare function parse(formula: string): [a: number, b: number]; +//# sourceMappingURL=parse.d.ts.map \ No newline at end of file diff --git a/node_modules/nth-check/lib/parse.d.ts.map b/node_modules/nth-check/lib/parse.d.ts.map new file mode 100644 index 0000000..b697621 --- /dev/null +++ b/node_modules/nth-check/lib/parse.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,CA6E7D"} \ No newline at end of file diff --git a/node_modules/nth-check/lib/parse.js b/node_modules/nth-check/lib/parse.js new file mode 100644 index 0000000..eaea29b --- /dev/null +++ b/node_modules/nth-check/lib/parse.js @@ -0,0 +1,76 @@ +"use strict"; +// Following http://www.w3.org/TR/css3-selectors/#nth-child-pseudo +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parse = void 0; +// Whitespace as per https://www.w3.org/TR/selectors-3/#lex is " \t\r\n\f" +var whitespace = new Set([9, 10, 12, 13, 32]); +var ZERO = "0".charCodeAt(0); +var NINE = "9".charCodeAt(0); +/** + * Parses an expression. + * + * @throws An `Error` if parsing fails. + * @returns An array containing the integer step size and the integer offset of the nth rule. + * @example nthCheck.parse("2n+3"); // returns [2, 3] + */ +function parse(formula) { + formula = formula.trim().toLowerCase(); + if (formula === "even") { + return [2, 0]; + } + else if (formula === "odd") { + return [2, 1]; + } + // Parse [ ['-'|'+']? INTEGER? {N} [ S* ['-'|'+'] S* INTEGER ]? + var idx = 0; + var a = 0; + var sign = readSign(); + var number = readNumber(); + if (idx < formula.length && formula.charAt(idx) === "n") { + idx++; + a = sign * (number !== null && number !== void 0 ? number : 1); + skipWhitespace(); + if (idx < formula.length) { + sign = readSign(); + skipWhitespace(); + number = readNumber(); + } + else { + sign = number = 0; + } + } + // Throw if there is anything else + if (number === null || idx < formula.length) { + throw new Error("n-th rule couldn't be parsed ('" + formula + "')"); + } + return [a, sign * number]; + function readSign() { + if (formula.charAt(idx) === "-") { + idx++; + return -1; + } + if (formula.charAt(idx) === "+") { + idx++; + } + return 1; + } + function readNumber() { + var start = idx; + var value = 0; + while (idx < formula.length && + formula.charCodeAt(idx) >= ZERO && + formula.charCodeAt(idx) <= NINE) { + value = value * 10 + (formula.charCodeAt(idx) - ZERO); + idx++; + } + // Return `null` if we didn't read anything. + return idx === start ? null : value; + } + function skipWhitespace() { + while (idx < formula.length && + whitespace.has(formula.charCodeAt(idx))) { + idx++; + } + } +} +exports.parse = parse; -- cgit