extjs-rails 4.1.0.alpha5 → 4.1.0.alpha6

data/app/assets/javascripts/src/ShadowPool.js

@@ -1,43 +0,0 @@
-/**
- * Private utility class that manages the internal Shadow cache.
- * @private
- */
-Ext.define('Ext.ShadowPool', {
-    singleton: true,
-    requires: ['Ext.DomHelper'],
-
-    markup: (function() {
-        return Ext.String.format(
-            '<div class="{0}{1}-shadow" role="presentation"></div>',
-            Ext.baseCSSPrefix,
-            Ext.isIE && !Ext.supports.CSS3BoxShadow ? 'ie' : 'css'
-        );
-    }()),
-
-    shadows: [],
-
-    pull: function() {
-        var sh = this.shadows.shift();
-        if (!sh) {
-            sh = Ext.get(Ext.DomHelper.insertHtml("beforeBegin", document.body.firstChild, this.markup));
-            sh.autoBoxAdjust = false;
-        }
-        return sh;
-    },
-
-    push: function(sh) {
-        this.shadows.push(sh);
-    },
-    
-    reset: function() {
-        var shadows = [].concat(this.shadows),
-            s,
-            sLen    = shadows.length;
-
-        for (s = 0; s < sLen; s++) {
-            shadows[s].remove();
-        }
-
-        this.shadows = [];
-    }
-});

data/app/assets/javascripts/src/Template.js

@@ -1,331 +0,0 @@
-/**
- * Represents an HTML fragment template. Templates may be {@link #compile precompiled} for greater performance.
- *
- * An instance of this class may be created by passing to the constructor either a single argument, or multiple
- * arguments:
- *
- * # Single argument: String/Array
- *
- * The single argument may be either a String or an Array:
- *
- * - String:
- *
- *       var t = new Ext.Template("<div>Hello {0}.</div>");
- *       t.{@link #append}('some-element', ['foo']);
- *
- * - Array:
- *
- *   An Array will be combined with `join('')`.
- *
- *       var t = new Ext.Template([
- *           '<div name="{id}">',
- *               '<span class="{cls}">{name:trim} {value:ellipsis(10)}</span>',
- *           '</div>',
- *       ]);
- *       t.{@link #compile}();
- *       t.{@link #append}('some-element', {id: 'myid', cls: 'myclass', name: 'foo', value: 'bar'});
- *
- * # Multiple arguments: String, Object, Array, ...
- *
- * Multiple arguments will be combined with `join('')`.
- *
- *     var t = new Ext.Template(
- *         '<div name="{id}">',
- *             '<span class="{cls}">{name} {value}</span>',
- *         '</div>',
- *         // a configuration object:
- *         {
- *             compiled: true,      // {@link #compile} immediately
- *         }
- *     );
- *
- * # Notes
- *
- * - For a list of available format functions, see {@link Ext.util.Format}.
- * - `disableFormats` reduces `{@link #apply}` time when no formatting is required.
- */
-Ext.define('Ext.Template', {
-
-    /* Begin Definitions */
-
-    requires: ['Ext.dom.Helper', 'Ext.util.Format'],
-
-    inheritableStatics: {
-        /**
-         * Creates a template from the passed element's value (_display:none_ textarea, preferred) or innerHTML.
-         * @param {String/HTMLElement} el A DOM element or its id
-         * @param {Object} config (optional) Config object
-         * @return {Ext.Template} The created template
-         * @static
-         * @inheritable
-         */
-        from: function(el, config) {
-            el = Ext.getDom(el);
-            return new this(el.value || el.innerHTML, config || '');
-        }
-    },
-
-    /* End Definitions */
-
-    /**
-     * Creates new template.
-     * 
-     * @param {String...} html List of strings to be concatenated into template.
-     * Alternatively an array of strings can be given, but then no config object may be passed.
-     * @param {Object} config (optional) Config object
-     */
-    constructor: function(html) {
-        var me = this,
-            args = arguments,
-            buffer = [],
-            i = 0,
-            length = args.length,
-            value;
-
-        me.initialConfig = {};
-        
-        // Allow an array to be passed here so we can
-        // pass an array of strings and an object
-        // at the end
-        if (length === 1 && Ext.isArray(html)) {
-            args = html;
-            length = args.length;
-        }
-
-        if (length > 1) {
-            for (; i < length; i++) {
-                value = args[i];
-                if (typeof value == 'object') {
-                    Ext.apply(me.initialConfig, value);
-                    Ext.apply(me, value);
-                } else {
-                    buffer.push(value);
-                }
-            }
-        } else {
-            buffer.push(html);
-        }
-
-        // @private
-        me.html = buffer.join('');
-
-        if (me.compiled) {
-            me.compile();
-        }
-    },
-
-    /**
-     * @property {Boolean} isTemplate
-     * `true` in this class to identify an object as an instantiated Template, or subclass thereof.
-     */
-    isTemplate: true,
-
-    /**
-     * @cfg {Boolean} compiled
-     * True to immediately compile the template. Defaults to false.
-     */
-
-    /**
-     * @cfg {Boolean} disableFormats
-     * True to disable format functions in the template. If the template doesn't contain
-     * format functions, setting disableFormats to true will reduce apply time. Defaults to false.
-     */
-    disableFormats: false,
-
-    re: /\{([\w\-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
-
-    /**
-     * Returns an HTML fragment of this template with the specified values applied.
-     *
-     * @param {Object/Array} values The template values. Can be an array if your params are numeric:
-     *
-     *     var tpl = new Ext.Template('Name: {0}, Age: {1}');
-     *     tpl.apply(['John', 25]);
-     *
-     * or an object:
-     *
-     *     var tpl = new Ext.Template('Name: {name}, Age: {age}');
-     *     tpl.apply({name: 'John', age: 25});
-     *
-     * @return {String} The HTML fragment
-     */
-    apply: function(values) {
-        var me = this,
-            useFormat = me.disableFormats !== true,
-            fm = Ext.util.Format,
-            tpl = me,
-            ret;
-
-        if (me.compiled) {
-            return me.compiled(values).join('');
-        }
-
-        function fn(m, name, format, args) {
-            if (format && useFormat) {
-                if (args) {
-                    args = [values[name]].concat(Ext.functionFactory('return ['+ args +'];')());
-                } else {
-                    args = [values[name]];
-                }
-                if (format.substr(0, 5) == "this.") {
-                    return tpl[format.substr(5)].apply(tpl, args);
-                }
-                else {
-                    return fm[format].apply(fm, args);
-                }
-            }
-            else {
-                return values[name] !== undefined ? values[name] : "";
-            }
-        }
-
-        ret = me.html.replace(me.re, fn);
-        return ret;
-    },
-
-    /**
-     * Appends the result of this template to the provided output array.
-     * @param {Object/Array} values The template values. See {@link #apply}.
-     * @param {Array} out The array to which output is pushed.
-     * @return {Array} The given out array.
-     */
-    applyOut: function(values, out) {
-        var me = this;
-
-        if (me.compiled) {
-            out.push.apply(out, me.compiled(values));
-        } else {
-            out.push(me.apply(values));
-        }
-
-        return out;
-    },
-
-    /**
-     * @method applyTemplate
-     * @member Ext.Template
-     * Alias for {@link #apply}.
-     * @inheritdoc Ext.Template#apply
-     */
-    applyTemplate: function () {
-        return this.apply.apply(this, arguments);
-    },
-
-    /**
-     * Sets the HTML used as the template and optionally compiles it.
-     * @param {String} html
-     * @param {Boolean} compile (optional) True to compile the template.
-     * @return {Ext.Template} this
-     */
-    set: function(html, compile) {
-        var me = this;
-        me.html = html;
-        me.compiled = null;
-        return compile ? me.compile() : me;
-    },
-
-    compileARe: /\\/g,
-    compileBRe: /(\r\n|\n)/g,
-    compileCRe: /'/g,
-
-    /**
-     * Compiles the template into an internal function, eliminating the RegEx overhead.
-     * @return {Ext.Template} this
-     */
-    compile: function() {
-        var me = this,
-            fm = Ext.util.Format,
-            useFormat = me.disableFormats !== true,
-            body, bodyReturn;
-
-        function fn(m, name, format, args) {
-            if (format && useFormat) {
-                args = args ? ',' + args: "";
-                if (format.substr(0, 5) != "this.") {
-                    format = "fm." + format + '(';
-                }
-                else {
-                    format = 'this.' + format.substr(5) + '(';
-                }
-            }
-            else {
-                args = '';
-                format = "(values['" + name + "'] == undefined ? '' : ";
-            }
-            return "'," + format + "values['" + name + "']" + args + ") ,'";
-        }
-
-        bodyReturn = me.html.replace(me.compileARe, '\\\\').replace(me.compileBRe, '\\n').replace(me.compileCRe, "\\'").replace(me.re, fn);
-        body = "this.compiled = function(values){ return ['" + bodyReturn + "'];};";
-        eval(body);
-        return me;
-    },
-
-    /**
-     * Applies the supplied values to the template and inserts the new node(s) as the first child of el.
-     *
-     * @param {String/HTMLElement/Ext.Element} el The context element
-     * @param {Object/Array} values The template values. See {@link #applyTemplate} for details.
-     * @param {Boolean} returnElement (optional) true to return a Ext.Element.
-     * @return {HTMLElement/Ext.Element} The new node or Element
-     */
-    insertFirst: function(el, values, returnElement) {
-        return this.doInsert('afterBegin', el, values, returnElement);
-    },
-
-    /**
-     * Applies the supplied values to the template and inserts the new node(s) before el.
-     *
-     * @param {String/HTMLElement/Ext.Element} el The context element
-     * @param {Object/Array} values The template values. See {@link #applyTemplate} for details.
-     * @param {Boolean} returnElement (optional) true to return a Ext.Element.
-     * @return {HTMLElement/Ext.Element} The new node or Element
-     */
-    insertBefore: function(el, values, returnElement) {
-        return this.doInsert('beforeBegin', el, values, returnElement);
-    },
-
-    /**
-     * Applies the supplied values to the template and inserts the new node(s) after el.
-     *
-     * @param {String/HTMLElement/Ext.Element} el The context element
-     * @param {Object/Array} values The template values. See {@link #applyTemplate} for details.
-     * @param {Boolean} returnElement (optional) true to return a Ext.Element.
-     * @return {HTMLElement/Ext.Element} The new node or Element
-     */
-    insertAfter: function(el, values, returnElement) {
-        return this.doInsert('afterEnd', el, values, returnElement);
-    },
-
-    /**
-     * Applies the supplied `values` to the template and appends the new node(s) to the specified `el`.
-     *
-     * For example usage see {@link Ext.Template Ext.Template class docs}.
-     *
-     * @param {String/HTMLElement/Ext.Element} el The context element
-     * @param {Object/Array} values The template values. See {@link #applyTemplate} for details.
-     * @param {Boolean} returnElement (optional) true to return an Ext.Element.
-     * @return {HTMLElement/Ext.Element} The new node or Element
-     */
-    append: function(el, values, returnElement) {
-        return this.doInsert('beforeEnd', el, values, returnElement);
-    },
-
-    doInsert: function(where, el, values, returnElement) {
-        var newNode = Ext.DomHelper.insertHtml(where, Ext.getDom(el), this.apply(values));
-        return returnElement ? Ext.get(newNode) : newNode;
-    },
-
-    /**
-     * Applies the supplied values to the template and overwrites the content of el with the new node(s).
-     *
-     * @param {String/HTMLElement/Ext.Element} el The context element
-     * @param {Object/Array} values The template values. See {@link #applyTemplate} for details.
-     * @param {Boolean} returnElement (optional) true to return a Ext.Element.
-     * @return {HTMLElement/Ext.Element} The new node or Element
-     */
-    overwrite: function(el, values, returnElement) {
-        var newNode = Ext.DomHelper.overwrite(Ext.getDom(el), this.apply(values));
-        return returnElement ? Ext.get(newNode) : newNode;
-    }
-});

data/app/assets/javascripts/src/XTemplate.js

@@ -1,365 +0,0 @@
-/**
- * A template class that supports advanced functionality like:
- *
- * - Autofilling arrays using templates and sub-templates
- * - Conditional processing with basic comparison operators
- * - Basic math function support
- * - Execute arbitrary inline code with special built-in template variables
- * - Custom member functions
- * - Many special tags and built-in operators that aren't defined as part of the API, but are supported in the templates that can be created
- *
- * XTemplate provides the templating mechanism built into {@link Ext.view.View}.
- *
- * The {@link Ext.Template} describes the acceptable parameters to pass to the constructor. The following examples
- * demonstrate all of the supported features.
- *
- * # Sample Data
- *
- * This is the data object used for reference in each code example:
- *
- *     var data = {
- *         name: 'Don Griffin',
- *         title: 'Senior Technomage',
- *         company: 'Sencha Inc.',
- *         drinks: ['Coffee', 'Water', 'More Coffee'],
- *         kids: [
- *             { name: 'Aubrey',  age: 17 },
- *             { name: 'Joshua',  age: 13 },
- *             { name: 'Cale',    age: 10 },
- *             { name: 'Nikol',   age: 5 },
- *             { name: 'Solomon', age: 0 }
- *         ]
- *     };
- *
- * # Auto filling of arrays
- *
- * The **tpl** tag and the **for** operator are used to process the provided data object:
- *
- * - If the value specified in for is an array, it will auto-fill, repeating the template block inside the tpl
- *   tag for each item in the array.
- * - If for="." is specified, the data object provided is examined.
- * - While processing an array, the special variable {#} will provide the current array index + 1 (starts at 1, not 0).
- *
- * Examples:
- *
- *     <tpl for=".">...</tpl>       // loop through array at root node
- *     <tpl for="foo">...</tpl>     // loop through array at foo node
- *     <tpl for="foo.bar">...</tpl> // loop through array at foo.bar node
- *
- * Using the sample data above:
- *
- *     var tpl = new Ext.XTemplate(
- *         '<p>Kids: ',
- *         '<tpl for=".">',       // process the data.kids node
- *             '<p>{#}. {name}</p>',  // use current array index to autonumber
- *         '</tpl></p>'
- *     );
- *     tpl.overwrite(panel.body, data.kids); // pass the kids property of the data object
- *
- * An example illustrating how the **for** property can be leveraged to access specified members of the provided data
- * object to populate the template:
- *
- *     var tpl = new Ext.XTemplate(
- *         '<p>Name: {name}</p>',
- *         '<p>Title: {title}</p>',
- *         '<p>Company: {company}</p>',
- *         '<p>Kids: ',
- *         '<tpl for="kids">',     // interrogate the kids property within the data
- *             '<p>{name}</p>',
- *         '</tpl></p>'
- *     );
- *     tpl.overwrite(panel.body, data);  // pass the root node of the data object
- *
- * Flat arrays that contain values (and not objects) can be auto-rendered using the special **`{.}`** variable inside a
- * loop. This variable will represent the value of the array at the current index:
- *
- *     var tpl = new Ext.XTemplate(
- *         '<p>{name}\'s favorite beverages:</p>',
- *         '<tpl for="drinks">',
- *             '<div> - {.}</div>',
- *         '</tpl>'
- *     );
- *     tpl.overwrite(panel.body, data);
- *
- * When processing a sub-template, for example while looping through a child array, you can access the parent object's
- * members via the **parent** object:
- *
- *     var tpl = new Ext.XTemplate(
- *         '<p>Name: {name}</p>',
- *         '<p>Kids: ',
- *         '<tpl for="kids">',
- *             '<tpl if="age &gt; 1">',
- *                 '<p>{name}</p>',
- *                 '<p>Dad: {parent.name}</p>',
- *             '</tpl>',
- *         '</tpl></p>'
- *     );
- *     tpl.overwrite(panel.body, data);
- *
- * # Conditional processing with basic comparison operators
- *
- * The **tpl** tag and the **if** operator are used to provide conditional checks for deciding whether or not to render
- * specific parts of the template.
- *
- * Using the sample data above:
- *
- *     var tpl = new Ext.XTemplate(
- *         '<p>Name: {name}</p>',
- *         '<p>Kids: ',
- *         '<tpl for="kids">',
- *             '<tpl if="age &gt; 1">',
- *                 '<p>{name}</p>',
- *             '</tpl>',
- *         '</tpl></p>'
- *     );
- *     tpl.overwrite(panel.body, data);
- *
- * More advanced conditionals are also supported:
- *
- *     var tpl = new Ext.XTemplate(
- *         '<p>Name: {name}</p>',
- *         '<p>Kids: ',
- *         '<tpl for="kids">',
- *             '<p>{name} is a ',
- *             '<tpl if="age &gt;= 13">',
- *                 '<p>teenager</p>',
- *             '<tpl elseif="age &gt;= 2">',
- *                 '<p>kid</p>',
- *             '<tpl else">',
- *                 '<p>baby</p>',
- *             '</tpl>',
- *         '</tpl></p>'
- *     );
- *
- *     var tpl = new Ext.XTemplate(
- *         '<p>Name: {name}</p>',
- *         '<p>Kids: ',
- *         '<tpl for="kids">',
- *             '<p>{name} is a ',
- *             '<tpl switch="name">',
- *                 '<tpl case="Aubrey" case="Nikol">',
- *                     '<p>girl</p>',
- *                 '<tpl default">',
- *                     '<p>boy</p>',
- *             '</tpl>',
- *         '</tpl></p>'
- *     );
- *
- * A `break` is implied between each case and default, however, multiple cases can be listed
- * in a single &lt;tpl&gt; tag.
- *
- * # Using double quotes
- *
- * Examples:
- *
- *     var tpl = new Ext.XTemplate(
- *         "<tpl if='age &gt; 1 && age &lt; 10'>Child</tpl>",
- *         "<tpl if='age &gt;= 10 && age &lt; 18'>Teenager</tpl>",
- *         "<tpl if='this.isGirl(name)'>...</tpl>",
- *         '<tpl if="id == \'download\'">...</tpl>',
- *         "<tpl if='needsIcon'><img src='{icon}' class='{iconCls}'/></tpl>",
- *         "<tpl if='name == \"Don\"'>Hello</tpl>"
- *     );
- *
- * # Basic math support
- *
- * The following basic math operators may be applied directly on numeric data values:
- *
- *     + - * /
- *
- * For example:
- *
- *     var tpl = new Ext.XTemplate(
- *         '<p>Name: {name}</p>',
- *         '<p>Kids: ',
- *         '<tpl for="kids">',
- *             '<tpl if="age &gt; 1">',  // <-- Note that the > is encoded
- *                 '<p>{#}: {name}</p>',  // <-- Auto-number each item
- *                 '<p>In 5 Years: {age+5}</p>',  // <-- Basic math
- *                 '<p>Dad: {parent.name}</p>',
- *             '</tpl>',
- *         '</tpl></p>'
- *     );
- *     tpl.overwrite(panel.body, data);
- *
- * # Execute arbitrary inline code with special built-in template variables
- *
- * Anything between `{[ ... ]}` is considered code to be executed in the scope of the template.
- * The expression is evaluated and the result is included in the generated result. There are
- * some special variables available in that code:
- *
- * - **out**: The output array into which the template is being appended (using `push` to later
- *   `join`).
- * - **values**: The values in the current scope. If you are using scope changing sub-templates,
- *   you can change what values is.
- * - **parent**: The scope (values) of the ancestor template.
- * - **xindex**: If you are in a looping template, the index of the loop you are in (1-based).
- * - **xcount**: If you are in a looping template, the total length of the array you are looping.
- *
- * This example demonstrates basic row striping using an inline code block and the xindex variable:
- *
- *     var tpl = new Ext.XTemplate(
- *         '<p>Name: {name}</p>',
- *         '<p>Company: {[values.company.toUpperCase() + ", " + values.title]}</p>',
- *         '<p>Kids: ',
- *         '<tpl for="kids">',
- *             '<div class="{[xindex % 2 === 0 ? "even" : "odd"]}">',
- *             '{name}',
- *             '</div>',
- *         '</tpl></p>'
- *      );
- *
- * Any code contained in "verbatim" blocks (using "{% ... %}") will be inserted directly in
- * the generated code for the template. These blocks are not included in the output. This
- * can be used for simple things like break/continue in a loop, or control structures or
- * method calls (when they don't produce output). The `this` references the template instance.
- *
- *     var tpl = new Ext.XTemplate(
- *         '<p>Name: {name}</p>',
- *         '<p>Company: {[values.company.toUpperCase() + ", " + values.title]}</p>',
- *         '<p>Kids: ',
- *         '<tpl for="kids">',
- *             '{% if (xindex % 2 === 0) continue; %}',
- *             '{name}',
- *             '{% if (xindex > 100) break; %}',
- *             '</div>',
- *         '</tpl></p>'
- *      );
- *
- * # Template member functions
- *
- * One or more member functions can be specified in a configuration object passed into the XTemplate constructor for
- * more complex processing:
- *
- *     var tpl = new Ext.XTemplate(
- *         '<p>Name: {name}</p>',
- *         '<p>Kids: ',
- *         '<tpl for="kids">',
- *             '<tpl if="this.isGirl(name)">',
- *                 '<p>Girl: {name} - {age}</p>',
- *             '<tpl else>',
- *                 '<p>Boy: {name} - {age}</p>',
- *             '</tpl>',
- *             '<tpl if="this.isBaby(age)">',
- *                 '<p>{name} is a baby!</p>',
- *             '</tpl>',
- *         '</tpl></p>',
- *         {
- *             // XTemplate configuration:
- *             disableFormats: true,
- *             // member functions:
- *             isGirl: function(name){
- *                return name == 'Sara Grace';
- *             },
- *             isBaby: function(age){
- *                return age < 1;
- *             }
- *         }
- *     );
- *     tpl.overwrite(panel.body, data);
- */
-Ext.define('Ext.XTemplate', {
-    extend: 'Ext.Template',
-
-    requires: 'Ext.XTemplateCompiler',
-
-    /**
-     * @cfg {Boolean} compiled
-     * Only applies to {@link Ext.Template}, XTemplates are compiled automatically on the
-     * first call to {@link #apply} or {@link #applyOut}.
-     */
-
-    /**
-     * @cfg {String/Array} definitions
-     * Optional. A statement, or array of statements which set up `var`s which may then
-     * be accessed within the scope of the generated function.
-     */
-
-    apply: function(values) {
-        return this.applyOut(values, []).join('');
-    },
-
-    applyOut: function(values, out) {
-        var me = this,
-            compiler;
-
-        if (!me.fn) {
-            compiler = new Ext.XTemplateCompiler({
-                useFormat: me.disableFormats !== true,
-                definitions: me.definitions
-            });
-
-            me.fn = compiler.compile(me.html);
-        }
-
-        try {
-            me.fn.call(me, out, values, {}, 1, 1);
-        } catch (e) {
-            //<debug>
-            Ext.log('Error: ' + e.message);
-            //</debug>
-        }
-
-        return out;
-    },
-
-    /**
-     * Does nothing. XTemplates are compiled automatically, so this function simply returns this.
-     * @return {Ext.XTemplate} this
-     */
-    compile: function() {
-        return this;
-    },
-
-    statics: {
-        /**
-         * Gets an `XTemplate` from an object (an instance of an {@link Ext#define}'d class).
-         * Many times, templates are configured high in the class hierarchy and are to be
-         * shared by all classes that derive from that base. To further complicate matters,
-         * these templates are seldom actual instances but are rather configurations. For
-         * example:
-         * 
-         *      Ext.define('MyApp.Class', {
-         *          someTpl: [
-         *              'tpl text here'
-         *          ]
-         *      });
-         * 
-         * The goal being to share that template definition with all instances and even
-         * instances of derived classes, until `someTpl` is overridden. This method will
-         * "upgrade" these configurations to be real `XTemplate` instances *in place* (to
-         * avoid creating one instance per object).
-         *
-         * @param {Object} instance The object from which to get the `XTemplate` (must be
-         * an instance of an {@link Ext#define}'d class).
-         * @param {String} name The name of the property by which to get the `XTemplate`.
-         * @return {Ext.XTemplate} The `XTemplate` instance or null if not found.
-         * @protected
-         */
-        getTpl: function (instance, name) {
-            var tpl = instance[name], // go for it! 99% of the time we will get it!
-                proto;
-
-            if (tpl && !tpl.isTemplate) { // tpl is just a configuration (not an instance)
-                // create the template instance from the configuration:
-                tpl = Ext.ClassManager.dynInstantiate('Ext.XTemplate', tpl);
-
-                // and replace the reference with the new instance:
-                if (instance.hasOwnProperty(name)) { // the tpl is on the instance
-                    instance[name] = tpl;
-                } else { // must be somewhere in the prototype chain
-                    for (proto = instance.self.prototype; proto; proto = proto.superclass) {
-                        if (proto.hasOwnProperty(name)) {
-                            proto[name] = tpl;
-                            break;
-                        }
-                    }
-                }
-            }
-            // else !tpl (no such tpl) or the tpl is an instance already... either way, tpl
-            // is ready to return
-
-            return tpl || null;
-        }
-    }
-});