Proyectos de Subversion Moodle

YUI.add('handlebars-base', function (Y, NAME) {

/*!

Handlebars.js - Copyright (C) 2011 Yehuda Katz

https://raw.github.com/wycats/handlebars.js/master/LICENSE

*/

// This file contains YUI-specific wrapper code and overrides for the

// handlebars-base module.

/**

Handlebars is a simple template language inspired by Mustache.

This is a YUI port of the original Handlebars project, which can be found at

<https://github.com/wycats/handlebars.js>.

@module handlebars

@main handlebars

@since 3.5.0

*/

/**

Provides basic Handlebars template rendering functionality. Use this module when

you only need to render pre-compiled templates.

@module handlebars

@submodule handlebars-base

*/

/**

Handlebars is a simple template language inspired by Mustache.

This is a YUI port of the original Handlebars project, which can be found at

<https://github.com/wycats/handlebars.js>.

@class Handlebars

@since 3.5.0

*/

var Handlebars = Y.namespace('Handlebars');

/* THIS FILE IS GENERATED BY A BUILD SCRIPT - DO NOT EDIT! */

Handlebars.SafeString = {};

(function (exports) {

"use strict";

// Build out our basic SafeString type

function SafeString(string) {

  this.string = string;

}

SafeString.prototype.toString = function() {

  return "" + this.string;

};

exports["default"] = SafeString;

}(Handlebars.SafeString));

Handlebars.SafeString = Handlebars.SafeString['default'];

/* THIS FILE IS GENERATED BY A BUILD SCRIPT - DO NOT EDIT! */

Handlebars.Utils = {};

(function (exports, SafeString) {

"use strict";

/*jshint -W004 */

var escape = {

  "&": "&",

  "<": "&lt;",

  ">": ">",

  '"': """,

  "'": "'",

  "`": "`"

};

var badChars = /[&<>"'`]/g;

var possible = /[&<>"'`]/;

function escapeChar(chr) {

  return escape[chr];

}

function extend(obj /* , ...source */) {

  for (var i = 1; i < arguments.length; i++) {

    for (var key in arguments[i]) {

      if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {

        obj[key] = arguments[i][key];

      }

    }

  }

  return obj;

}

exports.extend = extend;var toString = Object.prototype.toString;

exports.toString = toString;

// Sourced from lodash

// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt

var isFunction = function(value) {

  return typeof value === 'function';

};

// fallback for older versions of Chrome and Safari

/* istanbul ignore next */

if (isFunction(/x/)) {

  isFunction = function(value) {

    return typeof value === 'function' && toString.call(value) === '[object Function]';

  };

}

var isFunction;

exports.isFunction = isFunction;

/* istanbul ignore next */

var isArray = Array.isArray || function(value) {

  return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;

};

exports.isArray = isArray;

function escapeExpression(string) {

  // don't escape SafeStrings, since they're already safe

  if (string instanceof SafeString) {

    return string.toString();

  } else if (string == null) {

    return "";

  } else if (!string) {

    return string + '';

  }

  // Force a string conversion as this will be done by the append regardless and

  // the regex test will do this transparently behind the scenes, causing issues if

  // an object's to string has escaped characters in it.

  string = "" + string;

  if(!possible.test(string)) { return string; }

  return string.replace(badChars, escapeChar);

}

exports.escapeExpression = escapeExpression;function isEmpty(value) {

  if (!value && value !== 0) {

    return true;

  } else if (isArray(value) && value.length === 0) {

    return true;

  } else {

    return false;

  }

}

exports.isEmpty = isEmpty;function appendContextPath(contextPath, id) {

  return (contextPath ? contextPath + '.' : '') + id;

}

exports.appendContextPath = appendContextPath;

}(Handlebars.Utils, Handlebars.SafeString));

/* THIS FILE IS GENERATED BY A BUILD SCRIPT - DO NOT EDIT! */

Handlebars.Exception = {};

(function (exports) {

"use strict";

var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];

function Exception(message, node) {

  var line;

  if (node && node.firstLine) {

    line = node.firstLine;

    message += ' - ' + line + ':' + node.firstColumn;

  }

  var tmp = Error.prototype.constructor.call(this, message);

  // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.

  for (var idx = 0; idx < errorProps.length; idx++) {

    this[errorProps[idx]] = tmp[errorProps[idx]];

  }

  if (line) {

    this.lineNumber = line;

    this.column = node.firstColumn;

  }

}

Exception.prototype = new Error();

exports["default"] = Exception;

}(Handlebars.Exception));

Handlebars.Exception = Handlebars.Exception['default'];

/* THIS FILE IS GENERATED BY A BUILD SCRIPT - DO NOT EDIT! */

(function (exports, Utils, Exception) {

"use strict";

var VERSION = "2.0.0";

exports.VERSION = VERSION;var COMPILER_REVISION = 6;

exports.COMPILER_REVISION = COMPILER_REVISION;

var REVISION_CHANGES = {

  1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it

  2: '== 1.0.0-rc.3',

  3: '== 1.0.0-rc.4',

  4: '== 1.x.x',

  5: '== 2.0.0-alpha.x',

  6: '>= 2.0.0-beta.1'

};

exports.REVISION_CHANGES = REVISION_CHANGES;

var isArray = Utils.isArray,

    isFunction = Utils.isFunction,

    toString = Utils.toString,

    objectType = '[object Object]';

function HandlebarsEnvironment(helpers, partials) {

  this.helpers = helpers || {};

  this.partials = partials || {};

  registerDefaultHelpers(this);

}

exports.HandlebarsEnvironment = HandlebarsEnvironment;HandlebarsEnvironment.prototype = {

  constructor: HandlebarsEnvironment,

  logger: logger,

  log: log,

  registerHelper: function(name, fn) {

    if (toString.call(name) === objectType) {

      if (fn) { throw new Exception('Arg not supported with multiple helpers'); }

      Utils.extend(this.helpers, name);

    } else {

      this.helpers[name] = fn;

    }

  },

  unregisterHelper: function(name) {

    delete this.helpers[name];

  },

  registerPartial: function(name, partial) {

    if (toString.call(name) === objectType) {

      Utils.extend(this.partials,  name);

    } else {

      this.partials[name] = partial;

    }

  },

  unregisterPartial: function(name) {

    delete this.partials[name];

  }

};

function registerDefaultHelpers(instance) {

  instance.registerHelper('helperMissing', function(/* [args, ]options */) {

    if(arguments.length === 1) {

      // A missing field in a {{foo}} constuct.

      return undefined;

    } else {

      // Someone is actually trying to call something, blow up.

      throw new Exception("Missing helper: '" + arguments[arguments.length-1].name + "'");

    }

  });

  instance.registerHelper('blockHelperMissing', function(context, options) {

    var inverse = options.inverse,

        fn = options.fn;

    if(context === true) {

      return fn(this);

    } else if(context === false || context == null) {

      return inverse(this);

    } else if (isArray(context)) {

      if(context.length > 0) {

        if (options.ids) {

          options.ids = [options.name];

        }

        return instance.helpers.each(context, options);

      } else {

        return inverse(this);

      }

    } else {

      if (options.data && options.ids) {

        var data = createFrame(options.data);

        data.contextPath = Utils.appendContextPath(options.data.contextPath, options.name);

        options = {data: data};

      }

      return fn(context, options);

    }

  });

  instance.registerHelper('each', function(context, options) {

    if (!options) {

      throw new Exception('Must pass iterator to #each');

    }

    var fn = options.fn, inverse = options.inverse;

    var i = 0, ret = "", data;

    var contextPath;

    if (options.data && options.ids) {

      contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';

    }

    if (isFunction(context)) { context = context.call(this); }

    if (options.data) {

      data = createFrame(options.data);

    }

    if(context && typeof context === 'object') {

      if (isArray(context)) {

        for(var j = context.length; i<j; i++) {

          if (data) {

            data.index = i;

            data.first = (i === 0);

            data.last  = (i === (context.length-1));

            if (contextPath) {

              data.contextPath = contextPath + i;

            }

          }

          ret = ret + fn(context[i], { data: data });

        }

      } else {

        for(var key in context) {

          if(context.hasOwnProperty(key)) {

            if(data) {

              data.key = key;

              data.index = i;

              data.first = (i === 0);

              if (contextPath) {

                data.contextPath = contextPath + key;

              }

            }

            ret = ret + fn(context[key], {data: data});

            i++;

          }

        }

      }

    }

    if(i === 0){

      ret = inverse(this);

    }

    return ret;

  });

  instance.registerHelper('if', function(conditional, options) {

    if (isFunction(conditional)) { conditional = conditional.call(this); }

    // Default behavior is to render the positive path if the value is truthy and not empty.

    // The `includeZero` option may be set to treat the condtional as purely not empty based on the

    // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.

    if ((!options.hash.includeZero && !conditional) || Utils.isEmpty(conditional)) {

      return options.inverse(this);

    } else {

      return options.fn(this);

    }

  });

  instance.registerHelper('unless', function(conditional, options) {

    return instance.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn, hash: options.hash});

  });

  instance.registerHelper('with', function(context, options) {

    if (isFunction(context)) { context = context.call(this); }

    var fn = options.fn;

    if (!Utils.isEmpty(context)) {

      if (options.data && options.ids) {

        var data = createFrame(options.data);

        data.contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]);

        options = {data:data};

      }

      return fn(context, options);

    } else {

      return options.inverse(this);

    }

  });

  instance.registerHelper('log', function(message, options) {

    var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;

    instance.log(level, message);

  });

  instance.registerHelper('lookup', function(obj, field) {

    return obj && obj[field];

  });

}

var logger = {

  methodMap: { 0: 'debug', 1: 'info', 2: 'warn', 3: 'error' },

  // State enum

  DEBUG: 0,

  INFO: 1,

  WARN: 2,

  ERROR: 3,

  level: 3,

  // can be overridden in the host environment

  log: function(level, message) {

    if (logger.level <= level) {

      var method = logger.methodMap[level];

      if (typeof console !== 'undefined' && console[method]) {

        console[method].call(console, message);

      }

    }

  }

};

exports.logger = logger;

var log = logger.log;

exports.log = log;

var createFrame = function(object) {

  var frame = Utils.extend({}, object);

  frame._parent = object;

  return frame;

};

exports.createFrame = createFrame;

}(Handlebars, Handlebars.Utils, Handlebars.Exception));

/* THIS FILE IS GENERATED BY A BUILD SCRIPT - DO NOT EDIT! */

Handlebars.VM = {};

(function (exports, Utils, Exception, createFrame, COMPILER_REVISION, REVISION_CHANGES) {

"use strict";

function checkRevision(compilerInfo) {

  var compilerRevision = compilerInfo && compilerInfo[0] || 1,

      currentRevision = COMPILER_REVISION;

  if (compilerRevision !== currentRevision) {

    if (compilerRevision < currentRevision) {

      var runtimeVersions = REVISION_CHANGES[currentRevision],

          compilerVersions = REVISION_CHANGES[compilerRevision];

      throw new Exception("Template was precompiled with an older version of Handlebars than the current runtime. "+

            "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").");

    } else {

      // Use the embedded version info since the runtime doesn't know about this revision yet

      throw new Exception("Template was precompiled with a newer version of Handlebars than the current runtime. "+

            "Please update your runtime to a newer version ("+compilerInfo[1]+").");

    }

  }

}

exports.checkRevision = checkRevision;// TODO: Remove this line and break up compilePartial

function template(templateSpec, env) {

  /* istanbul ignore next */

  if (!env) {

    throw new Exception("No environment passed to template");

  }

  if (!templateSpec || !templateSpec.main) {

    throw new Exception('Unknown template object: ' + typeof templateSpec);

  }

  // Note: Using env.VM references rather than local var references throughout this section to allow

  // for external users to override these as psuedo-supported APIs.

  env.VM.checkRevision(templateSpec.compiler);

  var invokePartialWrapper = function(partial, indent, name, context, hash, helpers, partials, data, depths) {

    if (hash) {

      context = Utils.extend({}, context, hash);

    }

    var result = env.VM.invokePartial.call(this, partial, name, context, helpers, partials, data, depths);

    if (result == null && env.compile) {

      var options = { helpers: helpers, partials: partials, data: data, depths: depths };

      partials[name] = env.compile(partial, { data: data !== undefined, compat: templateSpec.compat }, env);

      result = partials[name](context, options);

    }

    if (result != null) {

      if (indent) {

        var lines = result.split('\n');

        for (var i = 0, l = lines.length; i < l; i++) {

          if (!lines[i] && i + 1 === l) {

            break;

          }

          lines[i] = indent + lines[i];

        }

        result = lines.join('\n');

      }

      return result;

    } else {

      throw new Exception("The partial " + name + " could not be compiled when running in runtime-only mode");

    }

  };

  // Just add water

  var container = {

    lookup: function(depths, name) {

      var len = depths.length;

      for (var i = 0; i < len; i++) {

        if (depths[i] && depths[i][name] != null) {

          return depths[i][name];

        }

      }

    },

    lambda: function(current, context) {

      return typeof current === 'function' ? current.call(context) : current;

    },

    escapeExpression: Utils.escapeExpression,

    invokePartial: invokePartialWrapper,

    fn: function(i) {

      return templateSpec[i];

    },

    programs: [],

    program: function(i, data, depths) {

      var programWrapper = this.programs[i],

          fn = this.fn(i);

      if (data || depths) {

        programWrapper = program(this, i, fn, data, depths);

      } else if (!programWrapper) {

        programWrapper = this.programs[i] = program(this, i, fn);

      }

      return programWrapper;

    },

    data: function(data, depth) {

      while (data && depth--) {

        data = data._parent;

      }

      return data;

    },

    merge: function(param, common) {

      var ret = param || common;

      if (param && common && (param !== common)) {

        ret = Utils.extend({}, common, param);

      }

      return ret;

    },

    noop: env.VM.noop,

    compilerInfo: templateSpec.compiler

  };

  var ret = function(context, options) {

    options = options || {};

    var data = options.data;

    ret._setup(options);

    if (!options.partial && templateSpec.useData) {

      data = initData(context, data);

    }

    var depths;

    if (templateSpec.useDepths) {

      depths = options.depths ? [context].concat(options.depths) : [context];

    }

    return templateSpec.main.call(container, context, container.helpers, container.partials, data, depths);

  };

  ret.isTop = true;

  ret._setup = function(options) {

    if (!options.partial) {

      container.helpers = container.merge(options.helpers, env.helpers);

      if (templateSpec.usePartial) {

        container.partials = container.merge(options.partials, env.partials);

      }

    } else {

      container.helpers = options.helpers;

      container.partials = options.partials;

    }

  };

  ret._child = function(i, data, depths) {

    if (templateSpec.useDepths && !depths) {

      throw new Exception('must pass parent depths');

    }

    return program(container, i, templateSpec[i], data, depths);

  };

  return ret;

}

exports.template = template;function program(container, i, fn, data, depths) {

  var prog = function(context, options) {

    options = options || {};

    return fn.call(container, context, container.helpers, container.partials, options.data || data, depths && [context].concat(depths));

  };

  prog.program = i;

  prog.depth = depths ? depths.length : 0;

  return prog;

}

exports.program = program;function invokePartial(partial, name, context, helpers, partials, data, depths) {

  var options = { partial: true, helpers: helpers, partials: partials, data: data, depths: depths };

  if(partial === undefined) {

    throw new Exception("The partial " + name + " could not be found");

  } else if(partial instanceof Function) {

    return partial(context, options);

  }

}

exports.invokePartial = invokePartial;function noop() { return ""; }

exports.noop = noop;function initData(context, data) {

    if(!data || (typeof data !== "object")) {

        data = {root: context};

    } else if(!('root' in data)) {

        data = createFrame(data);

        data.root = context;

    }

    return data;

}

}(Handlebars.VM, Handlebars.Utils, Handlebars.Exception, Handlebars.createFrame, Handlebars.COMPILER_REVISION, Handlebars.REVISION_CHANGES));

Handlebars.template = Handlebars.VM.template;

// This file contains YUI-specific wrapper code and overrides for the

// handlebars-base module.

Handlebars.VERSION += '-yui';

/**

Registers a helper function that will be made available to all templates.

Helper functions receive the current template context as the `this` object, and

can also receive arguments passed by the template.

@example

    Y.Handlebars.registerHelper('linkify', function () {

        return '<a href="' + Y.Escape.html(this.url) + '">' +

            Y.Escape.html(this.text) + '</a>';

    });

    var source = '<ul>{{#links}}<li>{{{linkify}}}</li>{{/links}}</ul>';

    Y.Handlebars.render(source, {

        links: [

            {url: '/foo', text: 'Foo'},

            {url: '/bar', text: 'Bar'},

            {url: '/baz', text: 'Baz'}

        ]

    });

@method registerHelper

@param {String} name Name of this helper.

@param {Function} fn Helper function.

@param {Boolean} [inverse=false] If `true`, this helper will be considered an

    "inverse" helper, like "unless". This means it will only be called if the

    expression given in the template evaluates to a false or empty value.

*/

/**

Registers a partial that will be made available to all templates.

A partial is another template that can be used to render part of a larger

template. For example, a website with a common header and footer across all its

pages might use a template for each page, which would call shared partials to

render the headers and footers.

Partials may be specified as uncompiled template strings or as compiled template

functions.

@example

    Y.Handlebars.registerPartial('header', '<h1>{{title}}</h1>');

    Y.Handlebars.registerPartial('footer', 'Copyright (c) 2011 by Me.');

    var source = '{{> header}} <p>Mustaches are awesome!</p> {{> footer}}';

    Y.Handlebars.render(source, {title: 'My Page About Mustaches'});

@method registerPartial

@param {String} name Name of this partial.

@param {Function|String} partial Template string or compiled template function.

*/

/**

Converts a precompiled template into a renderable template function.

@example

    <script src="precompiled-template.js"></script>

    <script>

    YUI().use('handlebars-base', function (Y) {

        // Convert the precompiled template function into a renderable template

        // function.

        var template = Y.Handlebars.template(precompiledTemplate);

        // Render it.

        template({pie: 'Pumpkin'});

    });

    </script>

@method template

@param {Function} template Precompiled Handlebars template function.

@return {Function} Compiled template function.

*/

// Alias for Y.Handlebars.template(), used by Y.Template.

Handlebars.revive = Handlebars.template;

// Make Y.Template.Handlebars an alias for Y.Handlebars.

Y.namespace('Template').Handlebars = Handlebars;

}, '3.18.1', {"requires": []});