/*
           * Added to make the test `null is null` evaluate truthily.
           * Otherwise, Nunjucks will look up null in the context and
           * return `undefined`, which is not what we want. This *may* have
           * consequences is someone is using null in their templates as a
           * variable.
           */

/*
     * Store the tag names in variables in case someone ever wants to
     * customize this.
     */

/* 0 */

/* 1 */

/* 10 */

/* 11 */

/* 12 */

/* 13 */

/* 14 */

/* 15 */

/* 16 */

/* 17 */

/* 18 */

/* 19 */

/* 2 */

/* 20 */

/* 21 */

/* 22 */

/* 23 */

/* 24 */

/* 25 */

/* 3 */

/* 4 */

/* 5 */

/* 6 */

/* 7 */

/* 8 */

/* 9 */

/* WEBPACK VAR INJECTION */

/* eslint-disable camelcase */

/* eslint-disable no-restricted-syntax */

/* globals self */

/*! Browser bundle of nunjucks 3.2.4  */

/*#__PURE__*/

/**
 * @param {string}   attribute      Attribute value. Dots allowed.
 * @returns {function(Object): *}
 */

/**
 * A no-op template, for use with {% include ignore missing %}
 */

/**
 * Calls a task as soon as possible after returning, in its own event, with priority
 * over other events like animation, reflow, and repaint. An error thrown from an
 * event will not interrupt, nor even substantially slow down the processing of
 * other events, but will be rather postponed to a lower priority event.
 * @param {{call}} task A callable object, typically a function that takes no
 * arguments.
 */

/**
 * Construct select or reject filter
 *
 * @param {boolean} expectedTestResult
 * @returns {function(array, string, *): array}
 */

/**
 * 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 }
 */

/**
 * 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 }
 */

/**
 * Returns `true` if the arguments are strictly equal.
 * @param { any } one
 * @param { any } two
 */

/**
 * Returns `true` if the object is a function, otherwise `false`.
 * @param { any } value
 * @returns { boolean }
 */

/**
 * Returns `true` if the object is strictly not `undefined`.
 * @param { any } value
 * @returns { boolean }
 */

/**
 * Returns `true` if the operand (one) is divisble by the test's argument
 * (two).
 * @param { number } one
 * @param { number } two
 * @returns { boolean }
 */

/**
 * Returns `true` if the operand (one) is greater or equal to the test's
 * argument (two).
 * @param { number } one
 * @param { number } two
 * @returns { boolean }
 */

/**
 * Returns `true` if the operand (one) is greater than the test's argument
 * (two).
 * @param { number } one
 * @param { number } two
 * @returns { boolean }
 */

/**
 * 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 }
 */

/**
 * Returns `true` if the operand (one) is less than the test's passed argument
 * (two).
 * @param { number } one
 * @param { number } two
 * @returns { boolean }
 */

/**
 * Returns `true` if the string is lowercased.
 * @param { string } value
 * @returns { boolean }
 */

/**
 * Returns `true` if the string is uppercased.
 * @param { string } value
 * @returns { boolean }
 */

/**
 * Returns `true` if the value is *not* evenly divisible by 2.
 * @param { number } value
 * @returns { boolean }
 */

/**
 * Returns `true` if the value is a string, `false` if not.
 * @param { any } value
 * @returns { boolean }
 */

/**
 * Returns `true` if the value is evenly divisible by 2.
 * @param { number } value
 * @returns { boolean }
 */

/**
 * 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 }
 */

/**
 * 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 }
 */

/**
 * Returns `true` if the value is undefined.
 * @param { any } value
 * @returns { boolean }
 */

/**
 * Returns true if the string has been escaped (i.e., is a SafeString).
 * @param { any } value
 * @returns { boolean }
 */

/**
 * Returns true if the value is strictly equal to `null`.
 * @param { any }
 * @returns { boolean }
 */

/**
 * Returns true if value is a number.
 * @param { any }
 * @returns { boolean }
 */

/************************************************************************/

/******/

/***/

//

//                              'Hello madam how are you' +

//                              '{% endfilter %}'));

//         channel.port2.postMessage(0);

//         setImmediate(callback);

//       A custom loader will be necessary to load your custom wrapper.

//       By default, templates are stored in a global variable used by the runtime.

//       Customize the output format to store the compiled template.

//     channel.port1.onmessage = callback;

//     console.log(util.inspect(t));

//     return function requestCall() {

//     var channel = new MessageChannel();

//     };

//  the library)

// "Software"), to deal in the Software without restriction, including

// # of replacements made

// 'caller' kwarg which is a Caller node.

// (the full trace from within nunjucks may confuse developers using

// * asFunction: generate a callable function

// * env: the Environment to use (gets extensions and async filters from it)

// * exclude: which file/folders to exclude (folders are auto-included, files are auto-excluded)

// * force: keep compiling on error

// * include: which file/folders to include (folders are auto-included, files are auto-excluded)

// * isString: input is a string, not a file path

// * name: name of the template (auto-generated when compiling a directory)

// * wrapper: function(templates, opts) {...}

// - Android 4-4.3

// - Chrome 26-34

// - Firefox 14-29

// - Internet Explorer 11

// - Safari 6-7

// - iPad Safari 6-7.1

// - iPhone Safari 7-7.1

// A SafeString object indicates that the string should not be

// A simple class system, more documentation to come

// API can be used when you aren't doing anything async in

// Abstract nodes

// Add to str

// Adding the second element, need to change to array.

// Adjust rawlevel

// Advance the index before calling the task. This ensures that we will

// Aliases

// All data removed, collapse to avoid unnecessary nodes

// Allow variables with dots by automatically creating the

// Always returns None

// An exception thrown by a task will permanently interrupt the processing of

// And pull out all the chars one at a time until we hit a

// At least give some kind of context to the user

// Backwards-compat with node 0.10.x

// Bind each declared var

// By default EventEmitters will print a warning if more than 10 listeners are

// By default, the cache is turned off because there's no way

// Caching and cache busting

// Cast Numbers in the search term to string

// Cast numbers in the replacement to string

// Catch compile errors for async rendering

// Check for flags.

// Check for listener leak

// Check if module is in cache

// Compile it as normal.

// Continually consume text, breaking on the tag delimiter

// Copy it

// Copyright Joyent, Inc. and other Node contributors.

// Create a new module (and put it into the cache)

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// Don't stop generating the output if we're

// Emits a 'removeListener' event if and only if the listener was removed.

// Equivalent to push, but avoids a function call.

// Even if we were, there is another bug in Internet Explorer 10.

// EventEmitters, we do not listen for `error` events here.

// EventTarget does not have `error` event semantics like Node

// Execute the module function

// Exit when there's nothing to match

// Expose the arguments to the template. Don't need to use

// Expose the keyword arguments

// Expose the macro to the templates

// Extract all matching chars (no default, so charString must be

// Extract all non-matching chars, with the default matching set

// Extract until the end of the regex -- / ends it, \/ does not.

// Fields should never be undefined, but null. It makes

// Flag the module as loaded

// For reasons explained above, we are also unable to use `setImmediate`

// For the jinja regexp, see

// Function call

// Generate a typical array iteration

// Grab the next chunk of src string and add it with the

// Has to be tied to an environment so we can tap into its globals.

// However, `flush` does not make any arrangements to be called again if an

// However, if we ever elect to use timers in Safari, the prevalent work-around

// However, since this timer gets frequently dropped in Firefox

// I put this right after "in" in the operator precedence stack. That can

// IE does not have builtin `{ once: true }` support so we

// If a task throws an exception, `flush` ensures that its state will remain

// If breakOnMatch is false, a non-matching char stops it.

// If breakOnMatch is true, a matching char stops it.

// If by now, we don't have a string, throw it back

// If false, strings can be manually escaped using the `escape` filter.

// If it is a start tag, stop looping

// If it is something other than number or string,

// If item is not an object, and we still got parts to handle, it means

// If multiple names are passed, we need to bind them

// If set to true, returns the full trace from the error point,

// If the last token has "-" we need to trim the

// If the object is an object, return any of the methods that Python would

// If the user is using the async API, *always* call it

// If the word has no length, bail. This can happen for str with

// If there is a parent frame, we are being called from internal

// If there is no 'error' event listener then throw.

// If true, this will make the system throw errors if trying

// If we are executing outside a block (creating a top-level

// If we call `asap` within tasks scheduled by `asap`, the queue will

// If we don't encounter a colon while parsing, this is not a slice,

// Ignore comments, otherwise this should be an error

// In a web browser, exceptions are not fatal. However, to avoid

// Increment our pointer in the src string

// Instead, we periodically shift 1024 tasks off the queue.

// It does not match any tag, so add the character and

// It is a requirement that start and end tags are composed of

// It is not sufficient to assign `setImmediate` to `requestFlush` because

// It's easy to use precompiled templates: just include them

// Iterate over the key/values of an object

// Its name will be periodically randomized to break any code that

// Its name will be periodically randomized to break any code that depends on

// Keep track of line/col info at runtime by settings

// Keyword arguments that should be passed as

// LIFO order

// Load entry module and return exports

// Look for upcoming raw blocks (ignore all other kinds of blocks)

// Lookup the variable names for each identifier and create

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// MIT license (by Elan Shanker).

// Make a duplicate of ctx

// Make a literal string because it's not a variable

// Making this a function instead so it returns a new object

// Manually shift all values starting at the index back to the

// Mimic the python behaviour: empty string is replaced

// Move forward whatever was matched

// Move tokenizer to beginning of endraw block

// Must use `global` or `self` instead of `window` to work in both frames and web

// MutationObservers are desirable because they have high priority and work

// MutationObservers, so we don't need to fall back in that case.

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// Never forget.

// No error code for this since it is a Warning

// Note: The comments on the `throw` lines are intentional, they show

// Note: This relies on js allowing scope across

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// Object.prototype.hasOwnProperty.call

// Obviously not all Emitters should be limited to 10. This function allows

// Once a flush has been requested, no further calls to `requestFlush` are

// Only in the browser please

// Only proceed if the first character doesn't meet our condition

// Optimize the case of one listener. Don't need the extra array object.

// Otherwise, if we are in a block parse it as code

// Output

// Output the name of what we're calling so we can get friendly errors

// Parse out the template text, breaking on tag

// Permission is hereby granted, free of charge, to any person obtaining a

// Positional arguments that should be passed in as

// Prevent leaking memory for long chains of recursive calls to `asap`.

// Print the AST in a nicely formatted tree format for debuggin

// Pull out characters until a breaking char is hit.

// Quoted argument names

// RawTasks are recycled to reduce GC churn.

// Re-assign `events` because a newListener handler could have caused the

// Reference

// Remove block leading whitespace from beginning of the string

// Reset to state before original parseAggregate called

// Resolve name relative to parentName

// Return the exports of the module

// Run the extension preprocessors against the source.

// Run the rootRenderFunc to populate the context with exported vars

// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that

// Safari 6.0 has a problem where timers will get lost while the user is

// Safari 6.0.5 (at least) intermittently fails to create message ports on a

// Same for the succeeding block start token

// Save the current parent method

// See if it's an aggregate type, we need to push the

// See if there are any more replacements to be made

// See if this is a strict equality/inequality comparator

// Set back one accounting for opening bracket/parens

// Set parent to the previous method, call, and restore

// ShortCircuits

// Since we are manually advancing past the block end,

// Skip CRLF newline

// Skip newline

// Skip past 'r/'.

// Some of this code is ugly, but it keeps the generated code

// Special check for the block end tag

// Special check for variable end tag (see above)

// Stop iterating by returning the node

// TEMPLATES in production!)

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// TODO: I'm not really sure if this type check is worth it or

// TODO: check for errors

// TODO: it is confusing to export something called 'default'

// TODO: this could be optimized (don't use regex)

// TODO: this is actually a bug in the compiled template (because waterfall

// Tag arguments are passed normally to the call. Note

// TemplateData is a special case because it is never

// The above copyright notice and this permission notice shall be included

// The autoescape flag sets global autoescaping. If true,

// The dev flag determines the trace that'll be shown on errors.

// The filesystem loader is only available server-side

// The first two args are line/col numbers, so offset by 2

// The flush function processes all tasks that have been scheduled with

// The following options are available:

// The message channel technique was discovered by Malte Ubl and was the

// The module cache

// The object could be an arroy or object. Note that the

// The possible flags are according to https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/RegExp)

// The require function

// The sole purpose of wrapping the task is to catch the exception and recycle

// They are implemented in all modern browsers.

// This hook exists purely for testing purposes.

// This is for `asap.js` only.

// This is hacky, but this is just a debugging function anyway

// This is one of the most called functions, so optimize for

// This is useful to prevent an error thrown in a task from stalling the event

// This must be called like `nunjucks.installCompat` so that `this`

// This shares some code with the For tag, but not enough to

// This works if eval is allowed (see CSP)

// This works if the window reference is available

// This works in non-strict mode

// To avoid recursion in the case that type === "newListener"! Before

// Type check the definition of the args

// USE OR OTHER DEALINGS IN THE SOFTWARE.

// Unfortunately necessary for backwards compatibility

// Unhandled 'error' event

// Unless they marked the dev flag, show them a trace from here

// Use the fastest means possible to execute a task in its own turn, with

// Was not a CRLF, so go back

// We are not at whitespace or a delimiter, so extract the

// We are running this for every var, but it's very

// We could hit the end of the template in the middle of

// We default `async` to false so that the simple synchronous

// We dispatch a timeout with a specified delay of 0 for engines that

// We expect a key/value pair for dicts, separated by a

// We have nothing else to parse

// We hit some whitespace

// We return undefined, instead of nothing here, so it's

// We support a synchronous API to make it easier to migrate

// We want to exclude the last "endraw"

// We wrap tasks with recyclable task objects.  A task object implements

// We've either reached the end, or done the max # of

// We've hit a delimiter (a special char like a bracket)

// We've hit a string

// Whichever timer succeeds will cancel both timers and

// __webpack_public_path__

// _extractUntil

// `call`, just like a function.

// `if`, so if this happens we need to capture the parent

// `process.on("uncaughtException")` or by a domain.

// `rawAsap` unless and until one of those tasks throws an exception.

// `requestFlush` is implemented using a strategy based on data collected from

// `requestFlush` requests that the high priority event queue be flushed as

// `setImmediate` must be called *by name* and therefore must be wrapped in a

// `setTimeout` does not call the passed callback if the delay is less than

// a call block is parsed as a normal FunCall, but with an added

// added to it. This is a useful default which helps finding memory leaks.

// adding it to the listeners, first emit "newListener".

// advance until a start of a case, a default case or an endswitch.

// again when the parent template runs. Note that blocks

// alias

// an email address of the form username@domain.tld

// an event 20 times per second until it succeeds.

// and compiled each time. (Remember, PRECOMPILE YOUR

// and of course, revert back to the old buffer id

// and return the switch node.

// anything

// anything async work, the whole thing is actually run

// appropriately

// approximately 7 in web workers in Firefox 8 through 18, and sometimes not

// as fast as possible. ForAsync also shares some of this, but

// asynchronously even if the template was synchronous.

// autoescaped, so simply output it for optimization

// autoescaped. This happens magically because autoescaping only

// basically an anonymous "macro expression"

// because blocks can have side effects, but it seems like a

// before you configure nunjucks and this will automatically

// begin flushing on the next task the task throws an error.

// beginning of the queue.

// between events.

// block), we really don't want to execute its code because it

// blocks twice

// blocks, in case this is created inside an `if`

// body of the loop is duplicated for each condition, but

// breaking char

// breaks on delimiters so we can assume the token parsing

// but not in parallel.

// by adding empty string in between

// by replacement e.g. "abc"|replace("", ".") -> .a.b.c.

// by returning next token (block start)

// call `rawAsap.requestFlush` if an exception is thrown.

// callable (i.e., has args) and not a symbol.

// can reliably accommodate that request. This will usually be snapped

// carry on

// causing a return from the top-most render function). But fixing that

// characters and checking to see if it's a start tag.

// check if the next token is 'not'

// closure.

// code of another template, and the internal system

// colon

// compile the arguments for the callable if they exist

// consistent and will resume where it left off when called again.

// copy of this software and associated documentation files (the

// copy-on-write version of map

// create an Is node using the next node and the info from our Is node.

// create new variables for our cases and default case.

// current delimiter token back on

// current returns current character

// currentStr returns what's left of the unparsed string

// defaults to false

// defaults to true

// define getter function for harmony exports

// deliberately include properties from the object's prototype

// delimiter characters (%{}[] etc), and our code always

// delimiters because we need to look for block/variable start

// depends on its existence.

// depends on the sync/async nature of the parent template

// distribute, sublicense, and/or sell copies of the Software, and to permit

// doesn't consume these elsewhere

// each time it's called. That way, if something like an environment

// easier to handle this case. if(!global) { ...}

// either ensure that no exceptions are thrown from your task, or to manually

// emit removeListener for all listeners on all events

// ensure concatenation instead of addition

// eslint-disable-line consistent-return

// eslint-disable-line dot-notation

// eslint-disable-line for-direction

// eslint-disable-line guard-for-in, no-restricted-syntax

// eslint-disable-line no-constant-condition

// eslint-disable-line no-nested-ternary

// eslint-disable-line no-new-func

// eslint-disable-line no-self-compare

// eslint-disable-next-line no-restricted-syntax

// even then.

// events in browsers.

// every available SauceLabs Selenium web driver worker at time of writing.

// every string variable will be escaped by default.

// exception is thrown by a task, that the task queue will continue flushing as

// exception is thrown.

// execute the callback.

// existing code to async. This works because if you don't do

// explicit)

// expose the module cache

// expose the modules object (__webpack_modules__)

// extends is a dynamic tag and can occur within a block like

// fail early if we get some unexpected tag.

// fetch above would actually run sync and we'll have a

// finds the '~' for string concatenation

// first, we need to try to get the name of the test function, if it's a

// following conditions:

// forcing compilation.

// from http://blog.gerv.net/2011/05/html5_email_address_regexp/

// function makeRequestCallFromMessageChannel(callback) {

// function makeRequestCallFromSetImmediate(callback) {

// g can still be undefined, but nothing to do about it...

// get our next case

// get the body of the case node and add it to the array of cases.

// get the next node

// getDefaultExport function for compatibility with non-harmony modules

// grow, but to avoid an O(n) walk for every task we execute, we don't

// happen in development. PRECOMPILE YOUR TEMPLATES.

// have WebKitMutationObserver but not un-prefixed MutationObserver.

// have to do it manually.

// http://www.nonblocking.io/2011/06/windownexttick.html

// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593

// https://github.com/mitsuhiko/jinja2/blob/f15b814dcba6aa12bc74d1f7d0c881d55f7126be/jinja2/utils.py#L20-L23

// i.e., not slim mode

// if # of replacements to perform is 0, or the string to does

// if it wasn't 'not', put it back

// if the lookup fails.

// if this WebLoader isn't running asynchronously, the

// if this is true, writes (set) should never propagate upwards past

// if we have a Not, create a Not node from our Is node.

// if we'd found a 'not' but this wasn't an 'in', put back the 'not'

// in all copies or substantial portions of the Software.

// is to add a scroll event listener that calls for a flush.

// its existence.

// key/value iteration

// keyword arguments (essentially default values)

// leading whitespace of the data. This is marked with

// let res = '';

// like (x, y, z) returns the last value, and x and y can be

// look for a not

// look for an is

// lower priority turn.

// mutation observers, so that implementation is used instead.

// necessary until the next `flush` completes.

// need to keep track of whitespace control (normally

// nested structure

// new ones if necessary

// nodes.printNodes(ast);

// nodes.printNodes(n);

// not contain the old value, return the string

// not listening for removeListener, no need to emit

// not much.

// not one of ours, cast it

// not.

// object as the last argument, if they exist.

// obviously be changed to be closer to Jinja.

// occurs on primitive string objects.

// only maps and object hashes

// only show lineno + colno next to path of template

// or when we've found the matching "endraw" block

// original foundation for this library.

// otherwise bail because EOF

// otherwise provide.

// otherwise will return trace starting from Template.render

// our looping, so check for the null return value from

// page's first load. Thankfully, this version of Safari supports

// parse the switch expression

// persons to whom the Software is furnished to do so, subject to the

// pick it up and use it

// positional arguments, i.e. the caller explicitly

// preserve fall-throughs

// priority over other events including IO, animation, reflow, and redraw

// queue if the exception handled by Node.js’s

// random names because the function

// rawAsap provides everything we need except exception management.

// reference

// references the nunjucks instance

// reliably everywhere they are implemented.

// replacement, to the result

// replacements, tack on any remaining string

// result here

// return the node.

// return the original string

// scrolling. This problem does not impact ASAP because Safari 6.0 supports

// shift tasks off the queue after they have been executed.

// skip the start symbol and get the case expression

// slowing down the queue of pending tasks, we rethrow the error in a

// so re-raise the original exception.

// so the set block writes to the capture output instead of the buffer

// soon as possible, but if you use `rawAsap` directly, you are responsible to

// soon as possible.

// subsequent tasks. The higher level `asap` function ensures that if an

// sync ajax request, but that's ok because it should *only*

// synchronously.

// tags (don't use the full delimChars for optimization)

// tasks are both not passing errors up the chain of callbacks AND are not

// template in the top-level scope

// template). This may have behavioral differences from jinja

// testing easier to normalize values.

// text and parse it

// that keyword arguments are turned into a single js

// that something goes wrong. Just roll out to undefined in that case.

// that to be increased. Set to zero for unlimited.

// the `dropLeadingWhitespace` variable.

// the task object after its single use.

// the typical case where the name isn't in the globals

// this fixes autoescape for templates referenced in symbols

// this frame to its parent (though reads may).

// this is done in `advanceAfterBlockEnd`

// this is the first case. it could also be an endswitch, we'll check.

// this._events to be assigned to a new object

// to "watch" templates over HTTP, so they are re-downloaded

// to a 4 milisecond delay, but once we're flushing, there's no delay

// to be inherited, so force an async callback

// to everything

// to output a null or undefined value

// trailing whitespace.

// uncommon to assign to multiple vars anyway

// under any circumstances.

// up in Node's output if this results in an unhandled exception.

// url that ends in .com, .org or .net that is not an email address

// url that starts with http or https

// url that starts with www.

// used the name of a positional arg

// uses it, they will each have their own copy.

// var ast = transform(parser.parse(src, [new FooExtension()]), ['bar']);

// var l = lexer.lex('{%- if x -%}\n hello {% endif %}');

// var n = p.parseAsRoot();

// var p = new Parser(lexer.lex('hello {% filter title %}' +

// var parser = require('./parser');

// var src = 'hello {% foo %}{% endfoo %} end';

// var t;

// var util = require('util');

// variables within an expression. An expression in javascript

// waste of performance to always execute huge top-level

// we are optimizing for speed over size.

// we either have a default case or a switch end.

// we need to temporarily override the current buffer id as 'output'

// webpackBootstrap

// where error occurred

// wherever else they are invoked (like used in a parent

// while we're dealing with new cases nodes...

// while((t = l.nextToken())) {

// will create a new run-time scope for us

// will execute twice: once when the child template runs and

// will require a more substantial change to the compiler.

// within blocks will *always* execute immediately *and*

// without limitation the rights to use, copy, modify, merge, publish,

// workers, we enlist an interval handle that will try to fire

// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.

// worry about. This iterates across an object asynchronously,

// your templates (which is most of the time). This performs a

// }
