Changed from static to 11ty!

1 files changed, 333 insertions, 0 deletions

diff --git a/node_modules/nunjucks/src/runtime.js b/node_modules/nunjucks/src/runtime.js
new file mode 100644
index 0000000..36eef4d
--- /dev/null
+++ b/node_modules/nunjucks/src/runtime.js
@@ -0,0 +1,333 @@
+'use strict';
+
+var lib = require('./lib');
+var arrayFrom = Array.from;
+var supportsIterators = typeof Symbol === 'function' && Symbol.iterator && typeof arrayFrom === 'function';
+
+// Frames keep track of scoping both at compile-time and run-time so
+// we know how to access variables. Block tags can introduce special
+// variables, for example.
+var Frame = /*#__PURE__*/function () {
+  function Frame(parent, isolateWrites) {
+    this.variables = Object.create(null);
+    this.parent = parent;
+    this.topLevel = false;
+    // if this is true, writes (set) should never propagate upwards past
+    // this frame to its parent (though reads may).
+    this.isolateWrites = isolateWrites;
+  }
+  var _proto = Frame.prototype;
+  _proto.set = function set(name, val, resolveUp) {
+    // Allow variables with dots by automatically creating the
+    // nested structure
+    var parts = name.split('.');
+    var obj = this.variables;
+    var frame = this;
+    if (resolveUp) {
+      if (frame = this.resolve(parts[0], true)) {
+        frame.set(name, val);
+        return;
+      }
+    }
+    for (var i = 0; i < parts.length - 1; i++) {
+      var id = parts[i];
+      if (!obj[id]) {
+        obj[id] = {};
+      }
+      obj = obj[id];
+    }
+    obj[parts[parts.length - 1]] = val;
+  };
+  _proto.get = function get(name) {
+    var val = this.variables[name];
+    if (val !== undefined) {
+      return val;
+    }
+    return null;
+  };
+  _proto.lookup = function lookup(name) {
+    var p = this.parent;
+    var val = this.variables[name];
+    if (val !== undefined) {
+      return val;
+    }
+    return p && p.lookup(name);
+  };
+  _proto.resolve = function resolve(name, forWrite) {
+    var p = forWrite && this.isolateWrites ? undefined : this.parent;
+    var val = this.variables[name];
+    if (val !== undefined) {
+      return this;
+    }
+    return p && p.resolve(name);
+  };
+  _proto.push = function push(isolateWrites) {
+    return new Frame(this, isolateWrites);
+  };
+  _proto.pop = function pop() {
+    return this.parent;
+  };
+  return Frame;
+}();
+function makeMacro(argNames, kwargNames, func) {
+  return function macro() {
+    for (var _len = arguments.length, macroArgs = new Array(_len), _key = 0; _key < _len; _key++) {
+      macroArgs[_key] = arguments[_key];
+    }
+    var argCount = numArgs(macroArgs);
+    var args;
+    var kwargs = getKeywordArgs(macroArgs);
+    if (argCount > argNames.length) {
+      args = macroArgs.slice(0, argNames.length);
+
+      // Positional arguments that should be passed in as
+      // keyword arguments (essentially default values)
+      macroArgs.slice(args.length, argCount).forEach(function (val, i) {
+        if (i < kwargNames.length) {
+          kwargs[kwargNames[i]] = val;
+        }
+      });
+      args.push(kwargs);
+    } else if (argCount < argNames.length) {
+      args = macroArgs.slice(0, argCount);
+      for (var i = argCount; i < argNames.length; i++) {
+        var arg = argNames[i];
+
+        // Keyword arguments that should be passed as
+        // positional arguments, i.e. the caller explicitly
+        // used the name of a positional arg
+        args.push(kwargs[arg]);
+        delete kwargs[arg];
+      }
+      args.push(kwargs);
+    } else {
+      args = macroArgs;
+    }
+    return func.apply(this, args);
+  };
+}
+function makeKeywordArgs(obj) {
+  obj.__keywords = true;
+  return obj;
+}
+function isKeywordArgs(obj) {
+  return obj && Object.prototype.hasOwnProperty.call(obj, '__keywords');
+}
+function getKeywordArgs(args) {
+  var len = args.length;
+  if (len) {
+    var lastArg = args[len - 1];
+    if (isKeywordArgs(lastArg)) {
+      return lastArg;
+    }
+  }
+  return {};
+}
+function numArgs(args) {
+  var len = args.length;
+  if (len === 0) {
+    return 0;
+  }
+  var lastArg = args[len - 1];
+  if (isKeywordArgs(lastArg)) {
+    return len - 1;
+  } else {
+    return len;
+  }
+}
+
+// A SafeString object indicates that the string should not be
+// autoescaped. This happens magically because autoescaping only
+// occurs on primitive string objects.
+function SafeString(val) {
+  if (typeof val !== 'string') {
+    return val;
+  }
+  this.val = val;
+  this.length = val.length;
+}
+SafeString.prototype = Object.create(String.prototype, {
+  length: {
+    writable: true,
+    configurable: true,
+    value: 0
+  }
+});
+SafeString.prototype.valueOf = function valueOf() {
+  return this.val;
+};
+SafeString.prototype.toString = function toString() {
+  return this.val;
+};
+function copySafeness(dest, target) {
+  if (dest instanceof SafeString) {
+    return new SafeString(target);
+  }
+  return target.toString();
+}
+function markSafe(val) {
+  var type = typeof val;
+  if (type === 'string') {
+    return new SafeString(val);
+  } else if (type !== 'function') {
+    return val;
+  } else {
+    return function wrapSafe(args) {
+      var ret = val.apply(this, arguments);
+      if (typeof ret === 'string') {
+        return new SafeString(ret);
+      }
+      return ret;
+    };
+  }
+}
+function suppressValue(val, autoescape) {
+  val = val !== undefined && val !== null ? val : '';
+  if (autoescape && !(val instanceof SafeString)) {
+    val = lib.escape(val.toString());
+  }
+  return val;
+}
+function ensureDefined(val, lineno, colno) {
+  if (val === null || val === undefined) {
+    throw new lib.TemplateError('attempted to output null or undefined value', lineno + 1, colno + 1);
+  }
+  return val;
+}
+function memberLookup(obj, val) {
+  if (obj === undefined || obj === null) {
+    return undefined;
+  }
+  if (typeof obj[val] === 'function') {
+    return function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return obj[val].apply(obj, args);
+    };
+  }
+  return obj[val];
+}
+function callWrap(obj, name, context, args) {
+  if (!obj) {
+    throw new Error('Unable to call `' + name + '`, which is undefined or falsey');
+  } else if (typeof obj !== 'function') {
+    throw new Error('Unable to call `' + name + '`, which is not a function');
+  }
+  return obj.apply(context, args);
+}
+function contextOrFrameLookup(context, frame, name) {
+  var val = frame.lookup(name);
+  return val !== undefined ? val : context.lookup(name);
+}
+function handleError(error, lineno, colno) {
+  if (error.lineno) {
+    return error;
+  } else {
+    return new lib.TemplateError(error, lineno, colno);
+  }
+}
+function asyncEach(arr, dimen, iter, cb) {
+  if (lib.isArray(arr)) {
+    var len = arr.length;
+    lib.asyncIter(arr, function iterCallback(item, i, next) {
+      switch (dimen) {
+        case 1:
+          iter(item, i, len, next);
+          break;
+        case 2:
+          iter(item[0], item[1], i, len, next);
+          break;
+        case 3:
+          iter(item[0], item[1], item[2], i, len, next);
+          break;
+        default:
+          item.push(i, len, next);
+          iter.apply(this, item);
+      }
+    }, cb);
+  } else {
+    lib.asyncFor(arr, function iterCallback(key, val, i, len, next) {
+      iter(key, val, i, len, next);
+    }, cb);
+  }
+}
+function asyncAll(arr, dimen, func, cb) {
+  var finished = 0;
+  var len;
+  var outputArr;
+  function done(i, output) {
+    finished++;
+    outputArr[i] = output;
+    if (finished === len) {
+      cb(null, outputArr.join(''));
+    }
+  }
+  if (lib.isArray(arr)) {
+    len = arr.length;
+    outputArr = new Array(len);
+    if (len === 0) {
+      cb(null, '');
+    } else {
+      for (var i = 0; i < arr.length; i++) {
+        var item = arr[i];
+        switch (dimen) {
+          case 1:
+            func(item, i, len, done);
+            break;
+          case 2:
+            func(item[0], item[1], i, len, done);
+            break;
+          case 3:
+            func(item[0], item[1], item[2], i, len, done);
+            break;
+          default:
+            item.push(i, len, done);
+            func.apply(this, item);
+        }
+      }
+    }
+  } else {
+    var keys = lib.keys(arr || {});
+    len = keys.length;
+    outputArr = new Array(len);
+    if (len === 0) {
+      cb(null, '');
+    } else {
+      for (var _i = 0; _i < keys.length; _i++) {
+        var k = keys[_i];
+        func(k, arr[k], _i, len, done);
+      }
+    }
+  }
+}
+function fromIterator(arr) {
+  if (typeof arr !== 'object' || arr === null || lib.isArray(arr)) {
+    return arr;
+  } else if (supportsIterators && Symbol.iterator in arr) {
+    return arrayFrom(arr);
+  } else {
+    return arr;
+  }
+}
+module.exports = {
+  Frame: Frame,
+  makeMacro: makeMacro,
+  makeKeywordArgs: makeKeywordArgs,
+  numArgs: numArgs,
+  suppressValue: suppressValue,
+  ensureDefined: ensureDefined,
+  memberLookup: memberLookup,
+  contextOrFrameLookup: contextOrFrameLookup,
+  callWrap: callWrap,
+  handleError: handleError,
+  isArray: lib.isArray,
+  keys: lib.keys,
+  SafeString: SafeString,
+  copySafeness: copySafeness,
+  markSafe: markSafe,
+  asyncEach: asyncEach,
+  asyncAll: asyncAll,
+  inOperator: lib.inOperator,
+  fromIterator: fromIterator
+};
\ No newline at end of file