@jaredwray/fumanchu
Version:
Handlebars + Helpers = Fumanchu
1,618 lines (1,596 loc) • 65.8 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
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(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
// helpers/lib/utils/falsey.js
var require_falsey = __commonJS({
"helpers/lib/utils/falsey.js"(exports2, module2) {
"use strict";
function falsey(val, keywords) {
if (!val) {
return true;
}
let words = keywords || [
"0",
"false",
"nada",
"nil",
"nay",
"nah",
"negative",
"no",
"none",
"nope",
"nul",
"null",
"nix",
"nyet",
"uh-uh",
"veto",
"zero"
];
if (!Array.isArray(words)) {
words = [words];
}
const lower = typeof val === "string" ? val.toLowerCase() : null;
for (const word of words) {
if (word === val) {
return true;
}
if (word === lower) {
return true;
}
}
return false;
}
module2.exports = falsey;
}
});
// helpers/lib/utils/utils.js
var require_utils = __commonJS({
"helpers/lib/utils/utils.js"(exports2, module2) {
"use strict";
var utils = require("lazy-cache")(require);
var falsey = require_falsey();
var fn = require;
require = utils;
require("array-sort", "sortBy");
require("arr-flatten", "flatten");
require("to-gfm-code-block", "block");
require("html-tag", "tag");
require("kind-of", "typeOf");
require("is-glob");
require("micromatch", "mm");
utils.falsey = falsey;
require("is-even");
require("is-number");
require("create-frame");
require("get-object");
require("get-value", "get");
require("for-own");
require("relative");
require = fn;
module2.exports = utils;
}
});
// helpers/lib/utils/index.js
var require_utils2 = __commonJS({
"helpers/lib/utils/index.js"(exports2, module2) {
"use strict";
var util = require("handlebars-utils");
var utils = require_utils();
utils.contains = function(val, obj, start) {
if (val == null || obj == null || !utils.isNumber(val.length)) {
return false;
}
return val.indexOf(obj, start) !== -1;
};
utils.chop = function(str) {
if (!util.isString(str)) return "";
var re = /^[-_.\W\s]+|[-_.\W\s]+$/g;
if (str.length > 1e3) {
throw new Error("utils.chop() regex is too long!");
}
return str.trim().replace(re, "");
};
utils.changecase = function(str, fn) {
if (!util.isString(str)) return "";
if (str.length === 1) {
return str.toLowerCase();
}
str = utils.chop(str).toLowerCase();
if (typeof fn !== "function") {
fn = utils.identity;
}
var re = /[-_.\W\s]+(\w|$)/g;
return str.replace(re, function(_, ch) {
return fn(ch);
});
};
utils.random = function(min, max) {
return min + Math.floor(Math.random() * (max - min + 1));
};
module2.exports = utils;
}
});
// helpers/lib/array.js
var require_array = __commonJS({
"helpers/lib/array.js"(exports2, module2) {
"use strict";
var util = require("handlebars-utils");
var utils = require_utils2();
var helpers3 = module2.exports;
helpers3.after = function(array, n) {
if (util.isUndefined(array)) return "";
return array.slice(n);
};
helpers3.arrayify = function(value) {
return value ? Array.isArray(value) ? value : [value] : [];
};
helpers3.before = function(array, n) {
if (util.isUndefined(array)) return "";
return array.slice(0, -n);
};
helpers3.eachIndex = function(array, options) {
var result = "";
for (var i = 0; i < array.length; i++) {
result += options.fn({ item: array[i], index: i });
}
return result;
};
helpers3.filter = function(array, value, options) {
var content = "";
var results = [];
var prop = options.hash && (options.hash.property || options.hash.prop);
if (prop) {
results = array.filter(function(val) {
return value === utils.get(val, prop);
});
} else {
results = array.filter(function(v) {
return value === v;
});
}
if (results && results.length > 0) {
for (var i = 0; i < results.length; i++) {
content += options.fn(results[i]);
}
return content;
}
return options.inverse(this);
};
helpers3.first = function(array, n) {
if (util.isUndefined(array)) return "";
if (!utils.isNumber(n)) {
return array[0];
}
return array.slice(0, n);
};
helpers3.forEach = function(array, options) {
var data = utils.createFrame(options, options.hash);
var len = array.length;
var buffer = "";
var i = -1;
while (++i < len) {
var item = array[i];
data.index = i;
item.index = i + 1;
item.total = len;
item.isFirst = i === 0;
item.isLast = i === len - 1;
buffer += options.fn(item, { data });
}
return buffer;
};
helpers3.inArray = function(array, value, options) {
return util.value(util.indexOf(array, value) > -1, this, options);
};
helpers3.isArray = function(value) {
return Array.isArray(value);
};
helpers3.itemAt = function(array, idx) {
array = util.result(array);
if (Array.isArray(array)) {
idx = utils.isNumber(idx) ? +idx : 0;
if (idx < 0) {
return array[array.length + idx];
}
if (idx < array.length) {
return array[idx];
}
}
};
helpers3.join = function(array, separator) {
if (typeof array === "string") return array;
if (!Array.isArray(array)) return "";
separator = util.isString(separator) ? separator : ", ";
return array.join(separator);
};
helpers3.equalsLength = function(value, length, options) {
if (util.isOptions(length)) {
options = length;
length = 0;
}
var len = 0;
if (typeof value === "string" || Array.isArray(value)) {
len = value.length;
}
return util.value(len === length, this, options);
};
helpers3.last = function(value, n) {
if (!Array.isArray(value) && typeof value !== "string") {
return "";
}
if (!utils.isNumber(n)) {
return value[value.length - 1];
}
return value.slice(-Math.abs(n));
};
helpers3.length = function(value) {
if (util.isObject(value) && !util.isOptions(value)) {
value = Object.keys(value);
}
if (typeof value === "string" || Array.isArray(value)) {
return value.length;
}
return 0;
};
helpers3.lengthEqual = helpers3.equalsLength;
helpers3.map = function(array, iter) {
if (!Array.isArray(array)) return "";
var len = array.length;
var res = new Array(len);
var i = -1;
if (typeof iter !== "function") {
return array;
}
while (++i < len) {
res[i] = iter(array[i], i, array);
}
return res;
};
helpers3.pluck = function(arr, prop) {
if (util.isUndefined(arr)) return "";
var res = [];
for (var i = 0; i < arr.length; i++) {
var val = utils.get(arr[i], prop);
if (typeof val !== "undefined") {
res.push(val);
}
}
return res;
};
helpers3.reverse = function(val) {
if (Array.isArray(val)) {
val.reverse();
return val;
}
if (val && typeof val === "string") {
return val.split("").reverse().join("");
}
};
helpers3.some = function(array, iter, options) {
if (Array.isArray(array)) {
for (var i = 0; i < array.length; i++) {
if (iter(array[i], i, array)) {
return options.fn(this);
}
}
}
return options.inverse(this);
};
helpers3.sort = function(array, options) {
if (!Array.isArray(array)) return "";
if (utils.get(options, "hash.reverse")) {
return array.sort().reverse();
}
return array.sort();
};
helpers3.sortBy = function(array, prop, options) {
if (!Array.isArray(array)) return "";
var args = [].slice.call(arguments);
args.pop();
if (!util.isString(prop) && typeof prop !== "function") {
return array.sort();
}
return utils.sortBy.apply(null, args);
};
helpers3.withAfter = function(array, idx, options) {
if (!Array.isArray(array)) return "";
array = array.slice(idx);
var result = "";
for (var i = 0; i < array.length; i++) {
result += options.fn(array[i]);
}
return result;
};
helpers3.withBefore = function(array, idx, options) {
if (!Array.isArray(array)) return "";
array = array.slice(0, -idx);
var result = "";
for (var i = 0; i < array.length; i++) {
result += options.fn(array[i]);
}
return result;
};
helpers3.withFirst = function(array, idx, options) {
if (util.isUndefined(array)) return "";
array = util.result(array);
if (!util.isUndefined(idx)) {
idx = parseFloat(util.result(idx));
}
if (util.isUndefined(idx)) {
options = idx;
return options.fn(array[0]);
}
array = array.slice(0, idx);
var result = "";
for (var i = 0; i < array.length; i++) {
result += options.fn(array[i]);
}
return result;
};
helpers3.withGroup = function(array, size, options) {
var result = "";
if (Array.isArray(array) && array.length > 0) {
var subcontext = [];
for (var i = 0; i < array.length; i++) {
if (i > 0 && i % size === 0) {
result += options.fn(subcontext);
subcontext = [];
}
subcontext.push(array[i]);
}
result += options.fn(subcontext);
}
return result;
};
helpers3.withLast = function(array, idx, options) {
if (util.isUndefined(array)) return "";
array = util.result(array);
if (!util.isUndefined(idx)) {
idx = parseFloat(util.result(idx));
}
if (util.isUndefined(idx)) {
options = idx;
return options.fn(array[array.length - 1]);
}
array = array.slice(-idx);
var len = array.length, i = -1;
var result = "";
while (++i < len) {
result += options.fn(array[i]);
}
return result;
};
helpers3.withSort = function(array, prop, options) {
if (util.isUndefined(array)) return "";
var result = "";
if (util.isUndefined(prop)) {
options = prop;
array = array.sort();
if (utils.get(options, "hash.reverse")) {
array = array.reverse();
}
for (var i = 0, len = array.length; i < len; i++) {
result += options.fn(array[i]);
}
return result;
}
array.sort(function(a, b) {
a = utils.get(a, prop);
b = utils.get(b, prop);
return a > b ? 1 : a < b ? -1 : 0;
});
if (utils.get(options, "hash.reverse")) {
array = array.reverse();
}
var alen = array.length, j = -1;
while (++j < alen) {
result += options.fn(array[j]);
}
return result;
};
helpers3.unique = function(array, options) {
if (util.isUndefined(array)) return "";
return array.filter(function(item, index, arr) {
return arr.indexOf(item) === index;
});
};
}
});
// helpers/lib/code.js
var require_code = __commonJS({
"helpers/lib/code.js"(exports2, module2) {
"use strict";
var fs = require("fs");
var path = require("path");
var utils = require_utils2();
var helpers3 = module2.exports;
helpers3.embed = function embed(filepath, ext) {
ext = typeof ext !== "string" ? path.extname(filepath).slice(1) : ext;
var code = fs.readFileSync(filepath, "utf8");
if (ext === "markdown" || ext === "md") {
ext = "markdown";
code = code.split("`").join("`");
}
return utils.block(code, ext).trim() + "\n";
};
helpers3.gist = function(id) {
return utils.tag("script", { src: "https://gist.github.com/" + id + ".js" });
};
helpers3.jsfiddle = function jsFiddle(options) {
var attr = Object.assign({}, options && options.hash);
if (typeof attr.id === "undefined") {
throw new Error("jsfiddle helper expects an `id`");
}
attr.id = "http://jsfiddle.net/" + attr.id;
attr.width = attr.width || "100%";
attr.height = attr.height || "300";
attr.skin = attr.skin || "/presentation/";
attr.tabs = (attr.tabs || "result,js,html,css") + attr.skin;
attr.src = attr.id + "/embedded/" + attr.tabs;
attr.allowfullscreen = attr.allowfullscreen || "allowfullscreen";
attr.frameborder = attr.frameborder || "0";
delete attr.tabs;
delete attr.skin;
delete attr.id;
return utils.tag("iframe", attr);
};
}
});
// helpers/lib/object.js
var require_object = __commonJS({
"helpers/lib/object.js"(exports2, module2) {
"use strict";
var hasOwn = Object.hasOwnProperty;
var util = require("handlebars-utils");
var array = require_array();
var utils = require_utils2();
var helpers3 = module2.exports;
helpers3.extend = function() {
var args = [].slice.call(arguments);
var opts = {};
if (util.isOptions(args[args.length - 1])) {
opts = args.pop().hash;
args.push(opts);
}
var context = {};
for (var i = 0; i < args.length; i++) {
var obj = args[i];
if (util.isObject(obj)) {
var keys = Object.keys(obj);
for (var j = 0; j < keys.length; j++) {
var key = keys[j];
context[key] = obj[key];
}
}
}
return context;
};
helpers3.forIn = function(obj, options) {
if (!util.isOptions(options)) {
return obj.inverse(this);
}
var data = utils.createFrame(options, options.hash);
var result = "";
for (var key in obj) {
data.key = key;
result += options.fn(obj[key], { data });
}
return result;
};
helpers3.forOwn = function(obj, options) {
if (!util.isOptions(options)) {
return obj.inverse(this);
}
var data = utils.createFrame(options, options.hash);
var result = "";
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
data.key = key;
result += options.fn(obj[key], { data });
}
}
return result;
};
helpers3.toPath = function() {
var prop = [];
for (var i = 0; i < arguments.length; i++) {
if (typeof arguments[i] === "string" || typeof arguments[i] === "number") {
prop.push(arguments[i]);
}
}
return prop.join(".");
};
helpers3.get = function(prop, context, options) {
var val = utils.get(context, prop);
if (options && options.fn) {
return val ? options.fn(val) : options.inverse(context);
}
return val;
};
helpers3.getObject = function(prop, context) {
return utils.getObject(context, prop);
};
helpers3.hasOwn = function(context, key) {
return hasOwn.call(context, key);
};
helpers3.isObject = function(value) {
return utils.typeOf(value) === "object";
};
helpers3.JSONparse = function(str, options) {
return JSON.parse(str);
};
helpers3.JSONstringify = function(obj, indent) {
if (!utils.isNumber(indent)) {
indent = 0;
}
return JSON.stringify(obj, null, indent);
};
helpers3.merge = function(context) {
var args = [].slice.call(arguments);
var opts = {};
if (util.isOptions(args[args.length - 1])) {
opts = args.pop().hash;
args.push(opts);
}
return Object.assign.apply(null, args);
};
helpers3.parseJSON = helpers3.JSONparse;
helpers3.pick = function(props, context, options) {
var keys = array.arrayify(props);
var len = keys.length, i = -1;
var result = {};
while (++i < len) {
result = helpers3.extend({}, result, utils.getObject(context, keys[i]));
}
if (options.fn) {
if (Object.keys(result).length) {
return options.fn(result);
}
return options.inverse(context);
}
return result;
};
helpers3.stringify = helpers3.JSONstringify;
}
});
// helpers/lib/collection.js
var require_collection = __commonJS({
"helpers/lib/collection.js"(exports2, module2) {
"use strict";
var util = require("handlebars-utils");
var object = require_object();
var array = require_array();
var forEach = array.forEach;
var forOwn = object.forOwn;
var helpers3 = module2.exports;
helpers3.isEmpty = function(collection, options) {
if (!util.isOptions(options)) {
options = collection;
return util.fn(true, this, options);
}
if (Array.isArray(collection) && !collection.length) {
return util.fn(true, this, options);
}
var keys = Object.keys(collection);
var isEmpty = typeof collection === "object" && !keys.length;
return util.value(isEmpty, this, options);
};
helpers3.iterate = function(collection, options) {
if (Array.isArray(collection)) {
return forEach.apply(null, arguments);
}
if (util.isObject(collection)) {
return forOwn.apply(null, arguments);
}
return options.inverse(this);
};
}
});
// helpers/lib/comparison.js
var require_comparison = __commonJS({
"helpers/lib/comparison.js"(exports2, module2) {
"use strict";
var has = require("has-value");
var util = require("handlebars-utils");
var utils = require_utils2();
var helpers3 = module2.exports;
helpers3.and = function() {
var len = arguments.length - 1;
var options = arguments[len];
var val = true;
for (var i = 0; i < len; i++) {
if (!arguments[i]) {
val = false;
break;
}
}
return util.value(val, this, options);
};
helpers3.compare = function(a, operator, b, options) {
if (arguments.length < 4) {
throw new Error("handlebars Helper {{compare}} expects 4 arguments");
}
var result;
switch (operator) {
case "==":
result = a == b;
break;
case "===":
result = a === b;
break;
case "!=":
result = a != b;
break;
case "!==":
result = a !== b;
break;
case "<":
result = a < b;
break;
case ">":
result = a > b;
break;
case "<=":
result = a <= b;
break;
case ">=":
result = a >= b;
break;
case "typeof":
result = typeof a === b;
break;
default: {
throw new Error("helper {{compare}}: invalid operator: `" + operator + "`");
}
}
return util.value(result, this, options);
};
helpers3.contains = function(collection, value, startIndex, options) {
if (typeof startIndex === "object") {
options = startIndex;
startIndex = void 0;
}
var val = utils.contains(collection, value, startIndex);
return util.value(val, this, options);
};
helpers3.default = function() {
for (var i = 0; i < arguments.length - 1; i++) {
if (arguments[i] != null) return arguments[i];
}
return "";
};
helpers3.eq = function(a, b, options) {
if (arguments.length === 2) {
options = b;
b = options.hash.compare;
}
return util.value(a === b, this, options);
};
helpers3.gt = function(a, b, options) {
if (arguments.length === 2) {
options = b;
b = options.hash.compare;
}
return util.value(a > b, this, options);
};
helpers3.gte = function(a, b, options) {
if (arguments.length === 2) {
options = b;
b = options.hash.compare;
}
return util.value(a >= b, this, options);
};
helpers3.has = function(value, pattern, options) {
if (util.isOptions(value)) {
options = value;
pattern = null;
value = null;
}
if (util.isOptions(pattern)) {
options = pattern;
pattern = null;
}
if (value === null) {
return util.value(false, this, options);
}
if (arguments.length === 2) {
return util.value(has(this, value), this, options);
}
if ((Array.isArray(value) || util.isString(value)) && util.isString(pattern)) {
if (value.indexOf(pattern) > -1) {
return util.fn(true, this, options);
}
}
if (util.isObject(value) && util.isString(pattern) && pattern in value) {
return util.fn(true, this, options);
}
return util.inverse(false, this, options);
};
helpers3.isFalsey = function(val, options) {
return util.value(utils.falsey(val), this, options);
};
helpers3.isTruthy = function(val, options) {
return util.value(!utils.falsey(val), this, options);
};
helpers3.ifEven = function(num, options) {
return util.value(utils.isEven(num), this, options);
};
helpers3.ifNth = function(a, b, options) {
var isNth = utils.isNumber(a) && utils.isNumber(b) && b % a === 0;
return util.value(isNth, this, options);
};
helpers3.ifOdd = function(val, options) {
return util.value(!utils.isEven(val), this, options);
};
helpers3.is = function(a, b, options) {
if (arguments.length === 2) {
options = b;
b = options.hash.compare;
}
return util.value(a == b, this, options);
};
helpers3.isnt = function(a, b, options) {
if (arguments.length === 2) {
options = b;
b = options.hash.compare;
}
return util.value(a != b, this, options);
};
helpers3.lt = function(a, b, options) {
if (arguments.length === 2) {
options = b;
b = options.hash.compare;
}
return util.value(a < b, this, options);
};
helpers3.lte = function(a, b, options) {
if (arguments.length === 2) {
options = b;
b = options.hash.compare;
}
return util.value(a <= b, this, options);
};
helpers3.neither = function(a, b, options) {
return util.value(!a && !b, this, options);
};
helpers3.not = function(val, options) {
return util.value(!val, this, options);
};
helpers3.or = function() {
var len = arguments.length - 1;
var options = arguments[len];
var val = false;
for (var i = 0; i < len; i++) {
if (arguments[i]) {
val = true;
break;
}
}
return util.value(val, this, options);
};
helpers3.unlessEq = function(a, b, options) {
if (util.isOptions(b)) {
options = b;
b = options.hash.compare;
}
return util.value(a !== b, this, options);
};
helpers3.unlessGt = function(a, b, options) {
if (util.isOptions(b)) {
options = b;
b = options.hash.compare;
}
return util.value(a <= b, this, options);
};
helpers3.unlessLt = function(a, b, options) {
if (util.isOptions(b)) {
options = b;
b = options.hash.compare;
}
return util.value(a >= b, this, options);
};
helpers3.unlessGteq = function(a, b, options) {
if (util.isOptions(b)) {
options = b;
b = options.hash.compare;
}
return util.value(a < b, this, options);
};
helpers3.unlessLteq = function(a, b, options) {
if (util.isOptions(b)) {
options = b;
b = options.hash.compare;
}
return util.value(a > b, this, options);
};
}
});
// helpers/lib/date.js
var require_date = __commonJS({
"helpers/lib/date.js"(exports2, module2) {
"use strict";
var helpers3 = module2.exports;
helpers3.year = require("year");
helpers3.moment = helpers3.date = require("helper-date");
}
});
// helpers/lib/number.js
var require_number = __commonJS({
"helpers/lib/number.js"(exports2, module2) {
"use strict";
var isNumber = require("is-number");
var util = require("handlebars-utils");
var utils = require_utils2();
var helpers3 = module2.exports;
helpers3.bytes = function(number, precision, options) {
if (number == null) return "0 B";
if (!utils.isNumber(number)) {
number = number.length;
if (!number) return "0 B";
}
if (!utils.isNumber(precision)) {
precision = 2;
}
var abbr = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
precision = Math.pow(10, precision);
number = Number(number);
var len = abbr.length - 1;
while (len-- >= 0) {
var size = Math.pow(10, len * 3);
if (size <= number + 1) {
number = Math.round(number * precision / size) / precision;
number += " " + abbr[len];
break;
}
}
return number;
};
helpers3.addCommas = function(num) {
return num.toString().replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,");
};
helpers3.phoneNumber = function(num) {
num = num.toString();
return "(" + num.substr(0, 3) + ") " + num.substr(3, 3) + "-" + num.substr(6, 4);
};
helpers3.toAbbr = function(number, precision) {
if (!utils.isNumber(number)) {
number = 0;
}
if (util.isUndefined(precision)) {
precision = 2;
}
number = Number(number);
precision = Math.pow(10, precision);
var abbr = ["k", "m", "b", "t", "q"];
var len = abbr.length - 1;
while (len >= 0) {
var size = Math.pow(10, (len + 1) * 3);
if (size <= number + 1) {
number = Math.round(number * precision / size) / precision;
number += abbr[len];
break;
}
len--;
}
return number;
};
helpers3.toExponential = function(number, digits) {
if (!utils.isNumber(number)) {
number = 0;
}
if (util.isUndefined(digits)) {
digits = 0;
}
return Number(number).toExponential(digits);
};
helpers3.toFixed = function(number, digits) {
if (!utils.isNumber(number)) {
number = 0;
}
if (!isNumber(digits)) {
digits = 0;
}
return Number(number).toFixed(digits);
};
helpers3.toFloat = function(number) {
return parseFloat(number);
};
helpers3.toInt = function(number) {
return parseInt(number, 10);
};
helpers3.toPrecision = function(number, precision) {
if (!utils.isNumber(number)) {
number = 0;
}
if (!isNumber(precision)) {
precision = 1;
}
return Number(number).toPrecision(precision);
};
}
});
// helpers/lib/fs.js
var require_fs = __commonJS({
"helpers/lib/fs.js"(exports2, module2) {
"use strict";
var fs = require("fs");
var path = require("path");
var util = require("handlebars-utils");
var utils = require_utils2();
var number = require_number();
var helpers3 = module2.exports;
helpers3.fileSize = number.bytes;
helpers3.read = function(filepath, options) {
return fs.readFileSync(filepath, "utf8");
};
helpers3.readdir = function(dir, filter) {
var files = fs.readdirSync(dir);
files = files.map(function(fp) {
return path.join(dir, fp);
});
if (util.isOptions(filter)) {
return files;
}
if (typeof filter === "function") {
return filter(files);
}
if (utils.typeOf(filter) === "regexp") {
return files.filter(function(fp) {
return filter.test(fp);
});
}
if (utils.isGlob(filter)) {
const isMatch = utils.mm.matcher(filter);
const result = [];
for (let i = 0; i < files.length; i++) {
if (isMatch(files[i])) {
result.push(files[i]);
}
}
return result;
}
if (["isFile", "isDirectory"].indexOf(filter) !== -1) {
return files.filter(function(fp) {
var stat = fs.statSync(fp);
return stat[filter]();
});
}
return files;
};
}
});
// helpers/lib/utils/html.js
var require_html = __commonJS({
"helpers/lib/utils/html.js"(exports2, module2) {
"use strict";
var util = require("handlebars-utils");
var striptags = require("striptags");
var html = module2.exports;
html.condense = function(str) {
return str.replace(/(\r\n|\r|\n|\u2028|\u2029) {2,}/g, "\n");
};
html.padcomments = function(str) {
return str.replace(/(\s*<!--)/g, "\n$1");
};
html.parseAttributes = function parseAttributes(hash) {
return Object.keys(hash).map(function(key) {
var val = String(hash[key]).replace(/^['"]|["']$/g, "");
return key + '="' + val + '"';
}).join(" ");
};
html.sanitize = function(str) {
if (!util.isString(str)) return "";
return striptags(str).trim();
};
html.toAttributes = function toAttributes(hash) {
var res = "";
var keys = Object.keys(hash);
for (var i = 0; i < keys.length; i++) {
var val = hash[keys[i]];
if (val === true) {
res += " " + keys[i];
} else {
res += " " + keys[i] + '="' + String(val) + '"';
}
}
return res;
};
}
});
// helpers/lib/html.js
var require_html2 = __commonJS({
"helpers/lib/html.js"(exports2, module2) {
"use strict";
var path = require("path");
var util = require("handlebars-utils");
var html = require_html();
var utils = require_utils2();
var parseAttr = html.parseAttributes;
var helpers3 = module2.exports;
helpers3.attr = function(options) {
var val = parseAttr(options && options.hash || {});
return val.trim() ? " " + val : "";
};
helpers3.css = function(list, options) {
if (arguments.length < 2) {
options = list;
list = [];
}
var styles = util.arrayify(list);
var assets = "";
if (this && this.options) {
assets = this.options.assets || "";
}
if (options.hash.href) {
styles = util.arrayify(options.hash.href);
}
return styles.map(function(item) {
var ext = path.extname(item);
var fp = item;
if (!/(^\/\/)|(:\/\/)/.test(item)) {
fp = path.posix.join(assets, item);
}
if (ext === ".less") {
return '<link type="text/css" rel="stylesheet/less" href="' + fp + '">';
}
return '<link type="text/css" rel="stylesheet" href="' + fp + '">';
}).join("\n");
};
helpers3.js = function(context) {
if (utils.typeOf(context) === "object") {
var attr = parseAttr(context.hash);
return "<script" + (attr ? " " + attr : "") + "></script>";
}
if (utils.typeOf(context) === "string") {
return '<script src="' + context + '"></script>';
}
context = util.arrayify(context);
return context.map(function(fp) {
return path.extname(fp) === ".coffee" ? utils.tag("script", { type: "text/coffeescript", src: fp }) : utils.tag("script", { src: fp });
}).join("\n");
};
helpers3.sanitize = function(str) {
return html.sanitize(str);
};
helpers3.ul = function(context, options) {
return "<ul " + parseAttr(options.hash) + ">" + context.map(function(item) {
if (typeof item !== "string") {
item = options.fn(item);
}
return "<li>" + item + "</li>";
}).join("\n") + "</ul>";
};
helpers3.ol = function(context, options) {
return "<ol " + parseAttr(options.hash) + ">" + context.map(function(item) {
if (typeof item !== "string") {
item = options.fn(item);
}
return "<li>" + item + "</li>";
}).join("\n") + "</ol>";
};
helpers3.thumbnailImage = function(context) {
var figure = "";
var image = "";
var link = context.full || false;
var imageAttributes = {
alt: context.alt,
src: context.thumbnail,
width: context.size.width,
height: context.size.height
};
var figureAttributes = { id: "image-" + context.id };
var linkAttributes = { href: link, rel: "thumbnail" };
if (context.classes) {
if (context.classes.image) {
imageAttributes.class = context.classes.image.join(" ");
}
if (context.classes.figure) {
figureAttributes.class = context.classes.figure.join(" ");
}
if (context.classes.link) {
linkAttributes.class = context.classes.link.join(" ");
}
}
figure += "<figure " + parseAttr(figureAttributes) + ">\n";
image += "<img " + parseAttr(imageAttributes) + ">\n";
if (link) {
figure += "<a " + parseAttr(linkAttributes) + ">\n" + image + "</a>\n";
} else {
figure += image;
}
if (context.caption) {
figure += "<figcaption>" + context.caption + "</figcaption>\n";
}
figure += "</figure>";
return figure;
};
}
});
// helpers/lib/i18n.js
var require_i18n = __commonJS({
"helpers/lib/i18n.js"(exports2, module2) {
"use strict";
var util = require("handlebars-utils");
var utils = require_utils2();
var helpers3 = module2.exports;
helpers3.i18n = function(prop, locals, options) {
if (util.isOptions(locals)) {
options = locals;
locals = {};
}
if (!util.isString(prop)) {
throw new Error('{{i18n}} helper expected "key" to be a string');
}
var opts = util.options(this, locals, options);
var context = Object.assign({}, this, opts);
var lang = context.language || context.lang;
if (!util.isString(lang)) {
throw new TypeError('{{i18n}} helper expected "language" to be a string');
}
var cache = context[lang];
if (typeof cache === "undefined") {
throw new Error('{{i18n}} helper cannot find language "' + lang + '"');
}
var result = utils.get(cache, prop);
if (typeof result === "undefined") {
throw new Error('{{i18n}} helper cannot find property "' + prop + '" for language "' + lang + '"');
}
return result;
};
}
});
// helpers/lib/inflection.js
var require_inflection = __commonJS({
"helpers/lib/inflection.js"(exports2, module2) {
"use strict";
var util = require("handlebars-utils");
var helpers3 = module2.exports;
helpers3.inflect = function(count, singular, plural, includeCount) {
var word = count > 1 || count === 0 ? plural : singular;
if (includeCount === true) {
return String(count) + " " + word;
} else {
return word;
}
};
helpers3.ordinalize = function(val) {
var num = Math.abs(Math.round(val));
var str = String(val);
var res = num % 100;
if (util.indexOf([11, 12, 13], res) >= 0) {
return str + "th";
}
switch (num % 10) {
case 1:
return str + "st";
case 2:
return str + "nd";
case 3:
return str + "rd";
default: {
return str + "th";
}
}
};
}
});
// helpers/lib/logging.js
var require_logging = __commonJS({
"helpers/lib/logging.js"(exports2, module2) {
"use strict";
module2.exports = require("logging-helpers");
}
});
// helpers/lib/md.js
var require_md = __commonJS({
"helpers/lib/md.js"(exports2, module2) {
"use strict";
var fs = require("fs");
var path = require("path");
var { Remarkable } = require("remarkable");
var extend = require("extend-shallow");
var exists = require("fs-exists-sync");
var ent = require("ent");
var helper = module2.exports = function(name, options, cb) {
if (typeof options === "function") {
cb = options;
options = {};
}
if (typeof cb !== "function") {
return helper.sync.apply(this, arguments);
}
if (typeof this === "undefined" || typeof this.app === "undefined") {
throw new Error("md async helper expects `app` to be exposed on the context");
}
var opts = extend({ cwd: process.cwd() }, this.options, options);
opts = extend({}, opts, opts.hash);
var md = markdown(opts);
var filepath = path.resolve(opts.cwd, name);
var view;
var str = "";
if (exists(filepath)) {
this.app.create("mdfiles");
str = fs.readFileSync(filepath, "utf8");
view = this.app.mdfile(filepath, { path: filepath, content: str });
} else {
view = this.app.find(name);
}
if (typeof view === "undefined") {
cb(null, "");
return;
}
view.content = ent.decode(md.render(view.content));
this.app.render(view, this.context, function(err, res) {
if (err) return cb(err);
cb(null, res.content);
});
};
helper.sync = function(name, options) {
var ctx = this || {};
var app = ctx.app || {};
var opts = extend({ cwd: process.cwd() }, ctx.options, options);
opts = extend({}, opts, opts.hash);
var md = markdown(opts);
var filepath = path.resolve(opts.cwd, name);
var view;
var html = "";
var str = "";
if (exists(filepath)) {
str = fs.readFileSync(filepath, "utf8");
html = ent.decode(md.render(str));
} else if (app.views) {
view = app.find(name);
if (view) {
html = view.content = ent.decode(md.render(view.content));
}
}
if (view && typeof view.compile === "function") {
view.compile(opts);
var data = ctx.cache ? ctx.cache.data : {};
ctx = extend({}, data, view.data);
return view.fn(ctx);
}
if (typeof this.compile === "function") {
var fn = this.compile(html);
return fn(this);
}
return html;
};
function markdown(options) {
let optsConfig = options || {};
optsConfig.breaks = true;
optsConfig.html = true;
optsConfig.langPrefix = "lang-";
optsConfig.typographer = false;
optsConfig.xhtmlOut = false;
const md = new Remarkable(optsConfig);
return md;
}
}
});
// helpers/lib/markdown.js
var require_markdown = __commonJS({
"helpers/lib/markdown.js"(exports2, module2) {
"use strict";
var hljs = require("highlight.js");
var utils = require("handlebars-utils");
var { Remarkable } = require("remarkable");
var helpers3 = module2.exports;
var markdown;
Object.defineProperty(helpers3, "markdown", {
configurable: true,
enumerable: true,
set: function(val) {
markdown = val;
},
get: function() {
return markdown || (markdown = this.helpersForMarkdown());
}
});
helpers3.md = require_md();
helpers3.helpersForMarkdown = function(config) {
const defaults = { html: true, breaks: true, highlight: helpers3.highlightFormMarkdown };
if (typeof config === "string" || utils.isOptions(config)) {
return markdown2.apply(defaults, arguments);
}
function markdown2(str, locals, options) {
if (typeof str !== "string") {
options = locals;
locals = str;
str = true;
}
if (utils.isOptions(locals)) {
options = locals;
locals = {};
}
const ctx = utils.context(this, locals, options);
let opts = utils.options(this, locals, options);
opts = Object.assign({}, defaults, config, opts);
if (opts.hasOwnProperty("lang")) {
opts.langPrefix = opts.lang;
}
const md = new Remarkable(opts);
const val = utils.value(str, ctx, options);
return md.render(val);
}
return markdown2;
};
helpers3.highlightFormMarkdown = function(code, lang) {
if (lang) {
return hljs.highlight(code, { language: lang }).value;
}
return hljs.highlightAuto(code).value;
};
}
});
// helpers/lib/match.js
var require_match = __commonJS({
"helpers/lib/match.js"(exports2, module2) {
"use strict";
var util = require("handlebars-utils");
var utils = require_utils2();
var helpers3 = module2.exports;
helpers3.match = function(files, patterns, locals, options) {
var opts = util.options(this, locals, options);
if (typeof patterns === "string") {
patterns = patterns.split(/, */);
}
return utils.mm(files, patterns, opts);
};
helpers3.isMatch = function(files, patterns, locals, options) {
var opts = util.options(this, locals, options);
return utils.mm.isMatch(files, patterns, opts);
};
helpers3.mm = function() {
console.log("the {{mm}} helper is depcrecated and will be removed");
console.log("in handlebars-helpers v1.0.0, please use the {{match}}");
console.log("helper instead.");
return helpers3.match.apply(this, arguments);
};
}
});
// helpers/lib/math.js
var require_math = __commonJS({
"helpers/lib/math.js"(exports2, module2) {
"use strict";
var isNumber = require("is-number");
var utils = require_utils2();
var helpers3 = module2.exports;
helpers3.abs = function(num) {
if (!isNumber(num)) {
throw new TypeError("expected a number");
}
return Math.abs(num);
};
helpers3.add = function(a, b) {
if (isNumber(a) && isNumber(b)) {
return Number(a) + Number(b);
}
return "";
};
helpers3.avg = function() {
var args = [].concat.apply([], arguments);
args.pop();
return helpers3.sum(args) / args.length;
};
helpers3.ceil = function(num) {
if (!isNumber(num)) {
throw new TypeError("expected a number");
}
return Math.ceil(num);
};
helpers3.divide = function(a, b) {
if (!isNumber(a)) {
throw new TypeError("expected the first argument to be a number");
}
if (!isNumber(b)) {
throw new TypeError("expected the second argument to be a number");
}
return Number(a) / Number(b);
};
helpers3.floor = function(num) {
if (!isNumber(num)) {
throw new TypeError("expected a number");
}
return Math.floor(num);
};
helpers3.minus = function(a, b) {
if (!isNumber(a)) {
throw new TypeError("expected the first argument to be a number");
}
if (!isNumber(b)) {
throw new TypeError("expected the second argument to be a number");
}
return Number(a) - Number(b);
};
helpers3.modulo = function(a, b) {
if (!isNumber(a)) {
throw new TypeError("expected the first argument to be a number");
}
if (!isNumber(b)) {
throw new TypeError("expected the second argument to be a number");
}
return Number(a) % Number(b);
};
helpers3.multiply = function(a, b) {
if (!isNumber(a)) {
throw new TypeError("expected the first argument to be a number");
}
if (!isNumber(b)) {
throw new TypeError("expected the second argument to be a number");
}
return Number(a) * Number(b);
};
helpers3.plus = function(a, b) {
if (!isNumber(a)) {
throw new TypeError("expected the first argument to be a number");
}
if (!isNumber(b)) {
throw new TypeError("expected the second argument to be a number");
}
return Number(a) + Number(b);
};
helpers3.random = function(min, max) {
if (!isNumber(min)) {
throw new TypeError("expected minimum to be a number");
}
if (!isNumber(max)) {
throw new TypeError("expected maximum to be a number");
}
return utils.random(min, max);
};
helpers3.remainder = function(a, b) {
return a % b;
};
helpers3.round = function(num) {
if (!isNumber(num)) {
throw new TypeError("expected a number");
}
return Math.round(num);
};
helpers3.subtract = function(a, b) {
if (!isNumber(a)) {
throw new TypeError("expected the first argument to be a number");
}
if (!isNumber(b)) {
throw new TypeError("expected the second argument to be a number");
}
return Number(a) - Number(b);
};
helpers3.sum = function() {
var args = [].concat.apply([], arguments);
var len = args.length;
var sum = 0;
while (len--) {
if (utils.isNumber(args[len])) {
sum += Number(args[len]);
}
}
return sum;
};
helpers3.times = function() {
return helpers3.multiply.apply(this, arguments);
};
}
});
// helpers/lib/misc.js
var require_misc = __commonJS({
"helpers/lib/misc.js"(exports2, module2) {
"use strict";
var util = require("handlebars-utils");
var utils = require_utils2();
var helpers3 = module2.exports;
helpers3.frame = require("handlebars-helper-create-frame");
helpers3.option = function(prop, locals, options) {
return utils.get(util.options(this, locals, options), prop);
};
helpers3.noop = function(options) {
return options.fn(this);
};
helpers3.typeOf = require("kind-of");
helpers3.withHash = function(options) {
if (options.hash && Object.keys(options.hash).length) {
return options.fn(options.hash);
} else {
return options.inverse(this);
}
};
}
});
// helpers/lib/path.js
var require_path = __commonJS({
"helpers/lib/path.js"(exports2, module2) {
"use strict";
var util = require("handlebars-utils");
var path = require("path");
var utils = require_utils2();
var helpers3 = module2.exports;
utils.expectedType = (variableName, expectedType, variableValue) => {
const actualType = Object.prototype.toString.call(variableValue).slice(8, -1).toLowerCase();
if (actualType !== expectedType) {
throw new TypeError(`Expected ${variableName} to be of type ${expectedType}, but got ${actualType}`);
}
};
helpers3.absolute = function(filepath, options) {
options = options || { data: {} };
var context = util.options(this, options);
var ctx = Object.assign({}, options.data.root, context);
var cwd = ctx.cwd || process.cwd();
return path.resolve(cwd, filepath);
};
helpers3.dirname = function(filepath, options) {
if (typeof filepath !== "string") {
throw new TypeError(utils.expectedType("filepath", "string", filepath));
}
return path.dirname(filepath);
};
helpers3.relative = function(a, b) {
if (typeof a !== "string") {
throw new TypeError(utils.expectedType("first path", "string", a));
}
if (typeof b !== "string") {
throw new TypeError(utils.expectedType("second path", "string", b));
}
return utils.relative(a, b);
};
helpers3.basename = function(filepath) {
if (typeof filepath !== "string") {
throw new TypeError(utils.expectedType("filepath", "string", filepath));
}
return path.basename(filepath);
};
helpers3.stem = function(filepath) {
if (typeof filepath !== "string") {
throw new TypeError(utils.expectedType("filepath", "string", filepath));
}
return path.basename(filepath, path.