From 7a52ddeba2a68388b544f529d2d92104420f77b0 Mon Sep 17 00:00:00 2001 From: Shipwreckt Date: Fri, 31 Oct 2025 20:02:14 +0000 Subject: Changed from static to 11ty! --- node_modules/nunjucks/src/tests.js | 265 +++++++++++++++++++++++++++++++++++++ 1 file changed, 265 insertions(+) create mode 100644 node_modules/nunjucks/src/tests.js (limited to 'node_modules/nunjucks/src/tests.js') diff --git a/node_modules/nunjucks/src/tests.js b/node_modules/nunjucks/src/tests.js new file mode 100644 index 0000000..9c6ba15 --- /dev/null +++ b/node_modules/nunjucks/src/tests.js @@ -0,0 +1,265 @@ +'use strict'; + +var SafeString = require('./runtime').SafeString; + +/** + * Returns `true` if the object is a function, otherwise `false`. + * @param { any } value + * @returns { boolean } + */ +function callable(value) { + return typeof value === 'function'; +} +exports.callable = callable; + +/** + * Returns `true` if the object is strictly not `undefined`. + * @param { any } value + * @returns { boolean } + */ +function defined(value) { + return value !== undefined; +} +exports.defined = defined; + +/** + * Returns `true` if the operand (one) is divisble by the test's argument + * (two). + * @param { number } one + * @param { number } two + * @returns { boolean } + */ +function divisibleby(one, two) { + return one % two === 0; +} +exports.divisibleby = divisibleby; + +/** + * Returns true if the string has been escaped (i.e., is a SafeString). + * @param { any } value + * @returns { boolean } + */ +function escaped(value) { + return value instanceof SafeString; +} +exports.escaped = escaped; + +/** + * Returns `true` if the arguments are strictly equal. + * @param { any } one + * @param { any } two + */ +function equalto(one, two) { + return one === two; +} +exports.equalto = equalto; + +// Aliases +exports.eq = exports.equalto; +exports.sameas = exports.equalto; + +/** + * Returns `true` if the value is evenly divisible by 2. + * @param { number } value + * @returns { boolean } + */ +function even(value) { + return value % 2 === 0; +} +exports.even = even; + +/** + * Returns `true` if the value is falsy - if I recall correctly, '', 0, false, + * undefined, NaN or null. I don't know if we should stick to the default JS + * behavior or attempt to replicate what Python believes should be falsy (i.e., + * empty arrays, empty dicts, not 0...). + * @param { any } value + * @returns { boolean } + */ +function falsy(value) { + return !value; +} +exports.falsy = falsy; + +/** + * Returns `true` if the operand (one) is greater or equal to the test's + * argument (two). + * @param { number } one + * @param { number } two + * @returns { boolean } + */ +function ge(one, two) { + return one >= two; +} +exports.ge = ge; + +/** + * Returns `true` if the operand (one) is greater than the test's argument + * (two). + * @param { number } one + * @param { number } two + * @returns { boolean } + */ +function greaterthan(one, two) { + return one > two; +} +exports.greaterthan = greaterthan; + +// alias +exports.gt = exports.greaterthan; + +/** + * Returns `true` if the operand (one) is less than or equal to the test's + * argument (two). + * @param { number } one + * @param { number } two + * @returns { boolean } + */ +function le(one, two) { + return one <= two; +} +exports.le = le; + +/** + * Returns `true` if the operand (one) is less than the test's passed argument + * (two). + * @param { number } one + * @param { number } two + * @returns { boolean } + */ +function lessthan(one, two) { + return one < two; +} +exports.lessthan = lessthan; + +// alias +exports.lt = exports.lessthan; + +/** + * Returns `true` if the string is lowercased. + * @param { string } value + * @returns { boolean } + */ +function lower(value) { + return value.toLowerCase() === value; +} +exports.lower = lower; + +/** + * Returns `true` if the operand (one) is less than or equal to the test's + * argument (two). + * @param { number } one + * @param { number } two + * @returns { boolean } + */ +function ne(one, two) { + return one !== two; +} +exports.ne = ne; + +/** + * Returns true if the value is strictly equal to `null`. + * @param { any } + * @returns { boolean } + */ +function nullTest(value) { + return value === null; +} +exports.null = nullTest; + +/** + * Returns true if value is a number. + * @param { any } + * @returns { boolean } + */ +function number(value) { + return typeof value === 'number'; +} +exports.number = number; + +/** + * Returns `true` if the value is *not* evenly divisible by 2. + * @param { number } value + * @returns { boolean } + */ +function odd(value) { + return value % 2 === 1; +} +exports.odd = odd; + +/** + * Returns `true` if the value is a string, `false` if not. + * @param { any } value + * @returns { boolean } + */ +function string(value) { + return typeof value === 'string'; +} +exports.string = string; + +/** + * Returns `true` if the value is not in the list of things considered falsy: + * '', null, undefined, 0, NaN and false. + * @param { any } value + * @returns { boolean } + */ +function truthy(value) { + return !!value; +} +exports.truthy = truthy; + +/** + * Returns `true` if the value is undefined. + * @param { any } value + * @returns { boolean } + */ +function undefinedTest(value) { + return value === undefined; +} +exports.undefined = undefinedTest; + +/** + * Returns `true` if the string is uppercased. + * @param { string } value + * @returns { boolean } + */ +function upper(value) { + return value.toUpperCase() === value; +} +exports.upper = upper; + +/** + * If ES6 features are available, returns `true` if the value implements the + * `Symbol.iterator` method. If not, it's a string or Array. + * + * Could potentially cause issues if a browser exists that has Set and Map but + * not Symbol. + * + * @param { any } value + * @returns { boolean } + */ +function iterable(value) { + if (typeof Symbol !== 'undefined') { + return !!value[Symbol.iterator]; + } else { + return Array.isArray(value) || typeof value === 'string'; + } +} +exports.iterable = iterable; + +/** + * If ES6 features are available, returns `true` if the value is an object hash + * or an ES6 Map. Otherwise just return if it's an object hash. + * @param { any } value + * @returns { boolean } + */ +function mapping(value) { + // only maps and object hashes + var bool = value !== null && value !== undefined && typeof value === 'object' && !Array.isArray(value); + if (Set) { + return bool && !(value instanceof Set); + } else { + return bool; + } +} +exports.mapping = mapping; \ No newline at end of file -- cgit v1.2.3