--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.10.3/build/template-micro/template-micro-debug.js Tue Jul 16 14:29:46 2013 +0200
@@ -0,0 +1,256 @@
+/*
+YUI 3.10.3 (build 2fb5187)
+Copyright 2013 Yahoo! Inc. All rights reserved.
+Licensed under the BSD License.
+http://yuilibrary.com/license/
+*/
+
+YUI.add('template-micro', function (Y, NAME) {
+
+/*jshint expr:true */
+
+/**
+Adds the `Y.Template.Micro` template engine, which provides fast, simple
+string-based micro-templating similar to ERB or Underscore templates.
+
+@module template
+@submodule template-micro
+@since 3.8.0
+**/
+
+/**
+Fast, simple string-based micro-templating engine similar to ERB or Underscore
+templates.
+
+@class Template.Micro
+@static
+@since 3.8.0
+**/
+
+// This code was heavily inspired by Underscore.js's _.template() method
+// (written by Jeremy Ashkenas), which was in turn inspired by John Resig's
+// micro-templating implementation.
+
+var Micro = Y.namespace('Template.Micro');
+
+/**
+Default options for `Y.Template.Micro`.
+
+@property {Object} options
+
+ @param {RegExp} [options.code] Regex that matches code blocks like
+ `<% ... %>`.
+ @param {RegExp} [options.escapedOutput] Regex that matches escaped output
+ tags like `<%= ... %>`.
+ @param {RegExp} [options.rawOutput] Regex that matches raw output tags like
+ `<%== ... %>`.
+ @param {RegExp} [options.stringEscape] Regex that matches characters that
+ need to be escaped inside single-quoted JavaScript string literals.
+ @param {Object} [options.stringReplace] Hash that maps characters matched by
+ `stringEscape` to the strings they should be replaced with. If you add
+ a character to the `stringEscape` regex, you need to add it here too or
+ it will be replaced with an empty string.
+
+@static
+@since 3.8.0
+**/
+Micro.options = {
+ code : /<%([\s\S]+?)%>/g,
+ escapedOutput: /<%=([\s\S]+?)%>/g,
+ rawOutput : /<%==([\s\S]+?)%>/g,
+ stringEscape : /\\|'|\r|\n|\t|\u2028|\u2029/g,
+
+ stringReplace: {
+ '\\' : '\\\\',
+ "'" : "\\'",
+ '\r' : '\\r',
+ '\n' : '\\n',
+ '\t' : '\\t',
+ '\u2028': '\\u2028',
+ '\u2029': '\\u2029'
+ }
+};
+
+/**
+Compiles a template string into a JavaScript function. Pass a data object to the
+function to render the template using the given data and get back a rendered
+string.
+
+Within a template, use `<%= ... %>` to output the value of an expression (where
+`...` is the JavaScript expression or data variable to evaluate). The output
+will be HTML-escaped by default. To output a raw value without escaping, use
+`<%== ... %>`, but be careful not to do this with untrusted user input.
+
+To execute arbitrary JavaScript code within the template without rendering its
+output, use `<% ... %>`, where `...` is the code to be executed. This allows the
+use of if/else blocks, loops, function calls, etc., although it's recommended
+that you avoid embedding anything beyond basic flow control logic in your
+templates.
+
+Properties of the data object passed to a template function are made available
+on a `data` variable within the scope of the template. So, if you pass in
+the object `{message: 'hello!'}`, you can print the value of the `message`
+property using `<%= data.message %>`.
+
+@example
+
+ YUI().use('template-micro', function (Y) {
+ var template = '<ul class="<%= data.classNames.list %>">' +
+ '<% Y.Array.each(data.items, function (item) { %>' +
+ '<li><%= item %></li>' +
+ '<% }); %>' +
+ '</ul>';
+
+ // Compile the template into a function.
+ var compiled = Y.Template.Micro.compile(template);
+
+ // Render the template to HTML, passing in the data to use.
+ var html = compiled({
+ classNames: {list: 'demo'},
+ items : ['one', 'two', 'three', 'four']
+ });
+ });
+
+@method compile
+@param {String} text Template text to compile.
+@param {Object} [options] Options. If specified, these options will override the
+ default options defined in `Y.Template.Micro.options`. See the documentation
+ for that property for details on which options are available.
+@return {Function} Compiled template function. Execute this function and pass in
+ a data object to render the template with the given data.
+@static
+@since 3.8.0
+**/
+Micro.compile = function (text, options) {
+ /*jshint evil:true */
+
+ var blocks = [],
+ tokenClose = "\uffff",
+ tokenOpen = "\ufffe",
+ source;
+
+ options = Y.merge(Micro.options, options);
+
+ // Parse the input text into a string of JavaScript code, with placeholders
+ // for code blocks. Text outside of code blocks will be escaped for safe
+ // usage within a double-quoted string literal.
+ //
+ // $b is a blank string, used to avoid creating lots of string objects.
+ //
+ // $v is a function that returns the supplied value if the value is truthy
+ // or the number 0, or returns an empty string if the value is falsy and not
+ // 0.
+ //
+ // $t is the template string.
+ source = "var $b='', $v=function (v){return v || v === 0 ? v : $b;}, $t='" +
+
+ // U+FFFE and U+FFFF are guaranteed to represent non-characters, so no
+ // valid UTF-8 string should ever contain them. That means we can freely
+ // strip them out of the input text (just to be safe) and then use them
+ // for our own nefarious purposes as token placeholders!
+ //
+ // See http://en.wikipedia.org/wiki/Mapping_of_Unicode_characters#Noncharacters
+ text.replace(/\ufffe|\uffff/g, '')
+
+ .replace(options.rawOutput, function (match, code) {
+ return tokenOpen + (blocks.push("'+\n$v(" + code + ")+\n'") - 1) + tokenClose;
+ })
+
+ .replace(options.escapedOutput, function (match, code) {
+ return tokenOpen + (blocks.push("'+\n$e($v(" + code + "))+\n'") - 1) + tokenClose;
+ })
+
+ .replace(options.code, function (match, code) {
+ return tokenOpen + (blocks.push("';\n" + code + "\n$t+='") - 1) + tokenClose;
+ })
+
+ .replace(options.stringEscape, function (match) {
+ return options.stringReplace[match] || '';
+ })
+
+ // Replace the token placeholders with code.
+ .replace(/\ufffe(\d+)\uffff/g, function (match, index) {
+ return blocks[parseInt(index, 10)];
+ })
+
+ // Remove noop string concatenations that have been left behind.
+ .replace(/\n\$t\+='';\n/g, '\n') +
+
+ "';\nreturn $t;";
+
+ // If compile() was called from precompile(), return precompiled source.
+ if (options.precompile) {
+ return "function (Y, $e, data) {\n" + source + "\n}";
+ }
+
+ // Otherwise, return an executable function.
+ return this.revive(new Function('Y', '$e', 'data', source));
+};
+
+/**
+Precompiles the given template text into a string of JavaScript source code that
+can be evaluated later in another context (or on another machine) to render the
+template.
+
+A common use case is to precompile templates at build time or on the server,
+then evaluate the code on the client to render a template. The client only needs
+to revive and render the template, avoiding the work of the compilation step.
+
+@method precompile
+@param {String} text Template text to precompile.
+@param {Object} [options] Options. If specified, these options will override the
+ default options defined in `Y.Template.Micro.options`. See the documentation
+ for that property for details on which options are available.
+@return {String} Source code for the precompiled template.
+@static
+@since 3.8.0
+**/
+Micro.precompile = function (text, options) {
+ options || (options = {});
+ options.precompile = true;
+
+ return this.compile(text, options);
+};
+
+/**
+Compiles and renders the given template text in a single step.
+
+This can be useful for single-use templates, but if you plan to render the same
+template multiple times, it's much better to use `compile()` to compile it once,
+then simply call the compiled function multiple times to avoid recompiling.
+
+@method render
+@param {String} text Template text to render.
+@param {Object} data Data to pass to the template.
+@param {Object} [options] Options. If specified, these options will override the
+ default options defined in `Y.Template.Micro.options`. See the documentation
+ for that property for details on which options are available.
+@return {String} Rendered result.
+@static
+@since 3.8.0
+**/
+Micro.render = function (text, data, options) {
+ return this.compile(text, options)(data);
+};
+
+/**
+Revives a precompiled template function into a normal compiled template function
+that can be called to render the template. The precompiled function must already
+have been evaluated to a function -- you can't pass raw JavaScript code to
+`revive()`.
+
+@method revive
+@param {Function} precompiled Precompiled template function.
+@return {Function} Revived template function, ready to be rendered.
+@static
+@since 3.8.0
+**/
+Micro.revive = function (precompiled) {
+ return function (data) {
+ data || (data = {});
+ return precompiled.call(data, Y, Y.Escape.html, data);
+ };
+};
+
+
+}, '3.10.3', {"requires": ["escape"]});