govuk_tech_docs 6.6.0.rc.local.tested → 6.6.0

data/node_modules/nunjucks/src/lib.js

@@ -0,0 +1,325 @@
+'use strict';
+
+var ArrayProto = Array.prototype;
+var ObjProto = Object.prototype;
+var escapeMap = {
+  '&': '&',
+  '"': '"',
+  '\'': ''',
+  '<': '&lt;',
+  '>': '&gt;',
+  '\\': '&#92;'
+};
+var escapeRegex = /[&"'<>\\]/g;
+var _exports = module.exports = {};
+function hasOwnProp(obj, k) {
+  return ObjProto.hasOwnProperty.call(obj, k);
+}
+_exports.hasOwnProp = hasOwnProp;
+function lookupEscape(ch) {
+  return escapeMap[ch];
+}
+function _prettifyError(path, withInternals, err) {
+  if (!err.Update) {
+    // not one of ours, cast it
+    err = new _exports.TemplateError(err);
+  }
+  err.Update(path);
+
+  // Unless they marked the dev flag, show them a trace from here
+  if (!withInternals) {
+    var old = err;
+    err = new Error(old.message);
+    err.name = old.name;
+  }
+  return err;
+}
+_exports._prettifyError = _prettifyError;
+function TemplateError(message, lineno, colno) {
+  var err;
+  var cause;
+  if (message instanceof Error) {
+    cause = message;
+    message = cause.name + ": " + cause.message;
+  }
+  if (Object.setPrototypeOf) {
+    err = new Error(message);
+    Object.setPrototypeOf(err, TemplateError.prototype);
+  } else {
+    err = this;
+    Object.defineProperty(err, 'message', {
+      enumerable: false,
+      writable: true,
+      value: message
+    });
+  }
+  Object.defineProperty(err, 'name', {
+    value: 'Template render error'
+  });
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(err, this.constructor);
+  }
+  var getStack;
+  if (cause) {
+    var stackDescriptor = Object.getOwnPropertyDescriptor(cause, 'stack');
+    getStack = stackDescriptor && (stackDescriptor.get || function () {
+      return stackDescriptor.value;
+    });
+    if (!getStack) {
+      getStack = function getStack() {
+        return cause.stack;
+      };
+    }
+  } else {
+    var stack = new Error(message).stack;
+    getStack = function getStack() {
+      return stack;
+    };
+  }
+  Object.defineProperty(err, 'stack', {
+    get: function get() {
+      return getStack.call(err);
+    }
+  });
+  Object.defineProperty(err, 'cause', {
+    value: cause
+  });
+  err.lineno = lineno;
+  err.colno = colno;
+  err.firstUpdate = true;
+  err.Update = function Update(path) {
+    var msg = '(' + (path || 'unknown path') + ')';
+
+    // only show lineno + colno next to path of template
+    // where error occurred
+    if (this.firstUpdate) {
+      if (this.lineno && this.colno) {
+        msg += " [Line " + this.lineno + ", Column " + this.colno + "]";
+      } else if (this.lineno) {
+        msg += " [Line " + this.lineno + "]";
+      }
+    }
+    msg += '\n ';
+    if (this.firstUpdate) {
+      msg += ' ';
+    }
+    this.message = msg + (this.message || '');
+    this.firstUpdate = false;
+    return this;
+  };
+  return err;
+}
+if (Object.setPrototypeOf) {
+  Object.setPrototypeOf(TemplateError.prototype, Error.prototype);
+} else {
+  TemplateError.prototype = Object.create(Error.prototype, {
+    constructor: {
+      value: TemplateError
+    }
+  });
+}
+_exports.TemplateError = TemplateError;
+function escape(val) {
+  return val.replace(escapeRegex, lookupEscape);
+}
+_exports.escape = escape;
+function isFunction(obj) {
+  return ObjProto.toString.call(obj) === '[object Function]';
+}
+_exports.isFunction = isFunction;
+function isArray(obj) {
+  return ObjProto.toString.call(obj) === '[object Array]';
+}
+_exports.isArray = isArray;
+function isString(obj) {
+  return ObjProto.toString.call(obj) === '[object String]';
+}
+_exports.isString = isString;
+function isObject(obj) {
+  return ObjProto.toString.call(obj) === '[object Object]';
+}
+_exports.isObject = isObject;
+
+/**
+ * @param {string|number} attr
+ * @returns {(string|number)[]}
+ * @private
+ */
+function _prepareAttributeParts(attr) {
+  if (!attr) {
+    return [];
+  }
+  if (typeof attr === 'string') {
+    return attr.split('.');
+  }
+  return [attr];
+}
+
+/**
+ * @param {string}   attribute      Attribute value. Dots allowed.
+ * @returns {function(Object): *}
+ */
+function getAttrGetter(attribute) {
+  var parts = _prepareAttributeParts(attribute);
+  return function attrGetter(item) {
+    var _item = item;
+    for (var i = 0; i < parts.length; i++) {
+      var part = parts[i];
+
+      // If item is not an object, and we still got parts to handle, it means
+      // that something goes wrong. Just roll out to undefined in that case.
+      if (hasOwnProp(_item, part)) {
+        _item = _item[part];
+      } else {
+        return undefined;
+      }
+    }
+    return _item;
+  };
+}
+_exports.getAttrGetter = getAttrGetter;
+function groupBy(obj, val, throwOnUndefined) {
+  var result = {};
+  var iterator = isFunction(val) ? val : getAttrGetter(val);
+  for (var i = 0; i < obj.length; i++) {
+    var value = obj[i];
+    var key = iterator(value, i);
+    if (key === undefined && throwOnUndefined === true) {
+      throw new TypeError("groupby: attribute \"" + val + "\" resolved to undefined");
+    }
+    (result[key] || (result[key] = [])).push(value);
+  }
+  return result;
+}
+_exports.groupBy = groupBy;
+function toArray(obj) {
+  return Array.prototype.slice.call(obj);
+}
+_exports.toArray = toArray;
+function without(array) {
+  var result = [];
+  if (!array) {
+    return result;
+  }
+  var length = array.length;
+  var contains = toArray(arguments).slice(1);
+  var index = -1;
+  while (++index < length) {
+    if (indexOf(contains, array[index]) === -1) {
+      result.push(array[index]);
+    }
+  }
+  return result;
+}
+_exports.without = without;
+function repeat(char_, n) {
+  var str = '';
+  for (var i = 0; i < n; i++) {
+    str += char_;
+  }
+  return str;
+}
+_exports.repeat = repeat;
+function each(obj, func, context) {
+  if (obj == null) {
+    return;
+  }
+  if (ArrayProto.forEach && obj.forEach === ArrayProto.forEach) {
+    obj.forEach(func, context);
+  } else if (obj.length === +obj.length) {
+    for (var i = 0, l = obj.length; i < l; i++) {
+      func.call(context, obj[i], i, obj);
+    }
+  }
+}
+_exports.each = each;
+function map(obj, func) {
+  var results = [];
+  if (obj == null) {
+    return results;
+  }
+  if (ArrayProto.map && obj.map === ArrayProto.map) {
+    return obj.map(func);
+  }
+  for (var i = 0; i < obj.length; i++) {
+    results[results.length] = func(obj[i], i);
+  }
+  if (obj.length === +obj.length) {
+    results.length = obj.length;
+  }
+  return results;
+}
+_exports.map = map;
+function asyncIter(arr, iter, cb) {
+  var i = -1;
+  function next() {
+    i++;
+    if (i < arr.length) {
+      iter(arr[i], i, next, cb);
+    } else {
+      cb();
+    }
+  }
+  next();
+}
+_exports.asyncIter = asyncIter;
+function asyncFor(obj, iter, cb) {
+  var keys = keys_(obj || {});
+  var len = keys.length;
+  var i = -1;
+  function next() {
+    i++;
+    var k = keys[i];
+    if (i < len) {
+      iter(k, obj[k], i, len, next);
+    } else {
+      cb();
+    }
+  }
+  next();
+}
+_exports.asyncFor = asyncFor;
+function indexOf(arr, searchElement, fromIndex) {
+  return Array.prototype.indexOf.call(arr || [], searchElement, fromIndex);
+}
+_exports.indexOf = indexOf;
+function keys_(obj) {
+  /* eslint-disable no-restricted-syntax */
+  var arr = [];
+  for (var k in obj) {
+    if (hasOwnProp(obj, k)) {
+      arr.push(k);
+    }
+  }
+  return arr;
+}
+_exports.keys = keys_;
+function _entries(obj) {
+  return keys_(obj).map(function (k) {
+    return [k, obj[k]];
+  });
+}
+_exports._entries = _entries;
+function _values(obj) {
+  return keys_(obj).map(function (k) {
+    return obj[k];
+  });
+}
+_exports._values = _values;
+function extend(obj1, obj2) {
+  obj1 = obj1 || {};
+  keys_(obj2).forEach(function (k) {
+    obj1[k] = obj2[k];
+  });
+  return obj1;
+}
+_exports._assign = _exports.extend = extend;
+function inOperator(key, val) {
+  if (isArray(val) || isString(val)) {
+    return val.indexOf(key) !== -1;
+  } else if (isObject(val)) {
+    return key in val;
+  }
+  throw new Error('Cannot use "in" operator to search for "' + key + '" in unexpected types.');
+}
+_exports.inOperator = inOperator;

data/node_modules/nunjucks/src/loader.js

@@ -0,0 +1,21 @@
+'use strict';
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+var path = require('path');
+var _require = require('./object'),
+  EmitterObj = _require.EmitterObj;
+module.exports = /*#__PURE__*/function (_EmitterObj) {
+  _inheritsLoose(Loader, _EmitterObj);
+  function Loader() {
+    return _EmitterObj.apply(this, arguments) || this;
+  }
+  var _proto = Loader.prototype;
+  _proto.resolve = function resolve(from, to) {
+    return path.resolve(path.dirname(from), to);
+  };
+  _proto.isRelative = function isRelative(filename) {
+    return filename.indexOf('./') === 0 || filename.indexOf('../') === 0;
+  };
+  return Loader;
+}(EmitterObj);

data/node_modules/nunjucks/src/loaders.js

@@ -0,0 +1,5 @@
+"use strict";
+
+// This file will automatically be rewired to web-loader.js when
+// building for the browser
+module.exports = require('./node-loaders');

data/node_modules/nunjucks/src/node-loaders.js

@@ -0,0 +1,139 @@
+/* eslint-disable no-console */
+
+'use strict';
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+var fs = require('fs');
+var path = require('path');
+var Loader = require('./loader');
+var _require = require('./precompiled-loader.js'),
+  PrecompiledLoader = _require.PrecompiledLoader;
+var chokidar;
+var FileSystemLoader = /*#__PURE__*/function (_Loader) {
+  _inheritsLoose(FileSystemLoader, _Loader);
+  function FileSystemLoader(searchPaths, opts) {
+    var _this;
+    _this = _Loader.call(this) || this;
+    if (typeof opts === 'boolean') {
+      console.log('[nunjucks] Warning: you passed a boolean as the second ' + 'argument to FileSystemLoader, but it now takes an options ' + 'object. See http://mozilla.github.io/nunjucks/api.html#filesystemloader');
+    }
+    opts = opts || {};
+    _this.pathsToNames = {};
+    _this.noCache = !!opts.noCache;
+    if (searchPaths) {
+      searchPaths = Array.isArray(searchPaths) ? searchPaths : [searchPaths];
+      // For windows, convert to forward slashes
+      _this.searchPaths = searchPaths.map(path.normalize);
+    } else {
+      _this.searchPaths = ['.'];
+    }
+    if (opts.watch) {
+      // Watch all the templates in the paths and fire an event when
+      // they change
+      try {
+        chokidar = require('chokidar'); // eslint-disable-line global-require
+      } catch (e) {
+        throw new Error('watch requires chokidar to be installed');
+      }
+      var paths = _this.searchPaths.filter(fs.existsSync);
+      var watcher = chokidar.watch(paths);
+      watcher.on('all', function (event, fullname) {
+        fullname = path.resolve(fullname);
+        if (event === 'change' && fullname in _this.pathsToNames) {
+          _this.emit('update', _this.pathsToNames[fullname], fullname);
+        }
+      });
+      watcher.on('error', function (error) {
+        console.log('Watcher error: ' + error);
+      });
+    }
+    return _this;
+  }
+  var _proto = FileSystemLoader.prototype;
+  _proto.getSource = function getSource(name) {
+    var fullpath = null;
+    var paths = this.searchPaths;
+    for (var i = 0; i < paths.length; i++) {
+      var basePath = path.resolve(paths[i]);
+      var p = path.resolve(paths[i], name);
+
+      // Only allow the current directory and anything
+      // underneath it to be searched
+      if (p.indexOf(basePath) === 0 && fs.existsSync(p)) {
+        fullpath = p;
+        break;
+      }
+    }
+    if (!fullpath) {
+      return null;
+    }
+    this.pathsToNames[fullpath] = name;
+    var source = {
+      src: fs.readFileSync(fullpath, 'utf-8'),
+      path: fullpath,
+      noCache: this.noCache
+    };
+    this.emit('load', name, source);
+    return source;
+  };
+  return FileSystemLoader;
+}(Loader);
+var NodeResolveLoader = /*#__PURE__*/function (_Loader2) {
+  _inheritsLoose(NodeResolveLoader, _Loader2);
+  function NodeResolveLoader(opts) {
+    var _this2;
+    _this2 = _Loader2.call(this) || this;
+    opts = opts || {};
+    _this2.pathsToNames = {};
+    _this2.noCache = !!opts.noCache;
+    if (opts.watch) {
+      try {
+        chokidar = require('chokidar'); // eslint-disable-line global-require
+      } catch (e) {
+        throw new Error('watch requires chokidar to be installed');
+      }
+      _this2.watcher = chokidar.watch();
+      _this2.watcher.on('change', function (fullname) {
+        _this2.emit('update', _this2.pathsToNames[fullname], fullname);
+      });
+      _this2.watcher.on('error', function (error) {
+        console.log('Watcher error: ' + error);
+      });
+      _this2.on('load', function (name, source) {
+        _this2.watcher.add(source.path);
+      });
+    }
+    return _this2;
+  }
+  var _proto2 = NodeResolveLoader.prototype;
+  _proto2.getSource = function getSource(name) {
+    // Don't allow file-system traversal
+    if (/^\.?\.?(\/|\\)/.test(name)) {
+      return null;
+    }
+    if (/^[A-Z]:/.test(name)) {
+      return null;
+    }
+    var fullpath;
+    try {
+      fullpath = require.resolve(name);
+    } catch (e) {
+      return null;
+    }
+    this.pathsToNames[fullpath] = name;
+    var source = {
+      src: fs.readFileSync(fullpath, 'utf-8'),
+      path: fullpath,
+      noCache: this.noCache
+    };
+    this.emit('load', name, source);
+    return source;
+  };
+  return NodeResolveLoader;
+}(Loader);
+module.exports = {
+  FileSystemLoader: FileSystemLoader,
+  PrecompiledLoader: PrecompiledLoader,
+  NodeResolveLoader: NodeResolveLoader
+};