rulemgt/src/main/frontend/src/public/framework/browser/thirdparty/js/mustache.js

   1 /*!
   2  * mustache.js - Logic-less {{mustache}} templates with JavaScript
   3  * http://github.com/janl/mustache.js
   4  */
   5
   6 /*global define: false Mustache: true*/
   7
   8 (function defineMustache (global, factory) {
   9     if (typeof exports === 'object' && exports && typeof exports.nodeName !== 'string') {
  10         factory(exports); // CommonJS
  11     } else if (typeof define === 'function' && define.amd) {
  12         define(['exports'], factory); // AMD
  13     } else {
  14         global.Mustache = {};
  15         factory(global.Mustache); // script, wsh, asp
  16     }
  17 }(this, function mustacheFactory (mustache) {
  18
  19     var objectToString = Object.prototype.toString;
  20     var isArray = Array.isArray || function isArrayPolyfill (object) {
  21             return objectToString.call(object) === '[object Array]';
  22         };
  23
  24     function isFunction (object) {
  25         return typeof object === 'function';
  26     }
  27
  28     /**
  29      * More correct typeof string handling array
  30      * which normally returns typeof 'object'
  31      */
  32     function typeStr (obj) {
  33         return isArray(obj) ? 'array' : typeof obj;
  34     }
  35
  36     function escapeRegExp (string) {
  37         return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, '\\$&');
  38     }
  39
  40     /**
  41      * Null safe way of checking whether or not an object,
  42      * including its prototype, has a given property
  43      */
  44     function hasProperty (obj, propName) {
  45         return obj != null && typeof obj === 'object' && (propName in obj);
  46     }
  47
  48     // Workaround for https://issues.apache.org/jira/browse/COUCHDB-577
  49     // See https://github.com/janl/mustache.js/issues/189
  50     var regExpTest = RegExp.prototype.test;
  51     function testRegExp (re, string) {
  52         return regExpTest.call(re, string);
  53     }
  54
  55     var nonSpaceRe = /\S/;
  56     function isWhitespace (string) {
  57         return !testRegExp(nonSpaceRe, string);
  58     }
  59
  60     var entityMap = {
  61         '&': '&amp;',
  62         '<': '&lt;',
  63         '>': '&gt;',
  64         '"': '&quot;',
  65         "'": '&#39;',
  66         '/': '&#x2F;',
  67         '`': '&#x60;',
  68         '=': '&#x3D;'
  69     };
  70
  71     function escapeHtml (string) {
  72         return String(string).replace(/[&<>"'`=\/]/g, function fromEntityMap (s) {
  73             return entityMap[s];
  74         });
  75     }
  76
  77     var whiteRe = /\s*/;
  78     var spaceRe = /\s+/;
  79     var equalsRe = /\s*=/;
  80     var curlyRe = /\s*\}/;
  81     var tagRe = /#|\^|\/|>|\{|&|=|!/;
  82
  83     /**
  84      * Breaks up the given `template` string into a tree of tokens. If the `tags`
  85      * argument is given here it must be an array with two string values: the
  86      * opening and closing tags used in the template (e.g. [ "<%", "%>" ]). Of
  87      * course, the default is to use mustaches (i.e. mustache.tags).
  88      *
  89      * A token is an array with at least 4 elements. The first element is the
  90      * mustache symbol that was used inside the tag, e.g. "#" or "&". If the tag
  91      * did not contain a symbol (i.e. {{myValue}}) this element is "name". For
  92      * all text that appears outside a symbol this element is "text".
  93      *
  94      * The second element of a token is its "value". For mustache tags this is
  95      * whatever else was inside the tag besides the opening symbol. For text tokens
  96      * this is the text itself.
  97      *
  98      * The third and fourth elements of the token are the start and end indices,
  99      * respectively, of the token in the original template.
 100      *
 101      * Tokens that are the root node of a subtree contain two more elements: 1) an
 102      * array of tokens in the subtree and 2) the index in the original template at
 103      * which the closing tag for that section begins.
 104      */
 105     function parseTemplate (template, tags) {
 106         if (!template)
 107             return [];
 108
 109         var sections = [];     // Stack to hold section tokens
 110         var tokens = [];       // Buffer to hold the tokens
 111         var spaces = [];       // Indices of whitespace tokens on the current line
 112         var hasTag = false;    // Is there a {{tag}} on the current line?
 113         var nonSpace = false;  // Is there a non-space char on the current line?
 114
 115         // Strips all whitespace tokens array for the current line
 116         // if there was a {{#tag}} on it and otherwise only space.
 117         function stripSpace () {
 118             if (hasTag && !nonSpace) {
 119                 while (spaces.length)
 120                     delete tokens[spaces.pop()];
 121             } else {
 122                 spaces = [];
 123             }
 124
 125             hasTag = false;
 126             nonSpace = false;
 127         }
 128
 129         var openingTagRe, closingTagRe, closingCurlyRe;
 130         function compileTags (tagsToCompile) {
 131             if (typeof tagsToCompile === 'string')
 132                 tagsToCompile = tagsToCompile.split(spaceRe, 2);
 133
 134             if (!isArray(tagsToCompile) || tagsToCompile.length !== 2)
 135                 throw new Error('Invalid tags: ' + tagsToCompile);
 136
 137             openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + '\\s*');
 138             closingTagRe = new RegExp('\\s*' + escapeRegExp(tagsToCompile[1]));
 139             closingCurlyRe = new RegExp('\\s*' + escapeRegExp('}' + tagsToCompile[1]));
 140         }
 141
 142         compileTags(tags || mustache.tags);
 143
 144         var scanner = new Scanner(template);
 145
 146         var start, type, value, chr, token, openSection;
 147         while (!scanner.eos()) {
 148             start = scanner.pos;
 149
 150             // Match any text between tags.
 151             value = scanner.scanUntil(openingTagRe);
 152
 153             if (value) {
 154                 for (var i = 0, valueLength = value.length; i < valueLength; ++i) {
 155                     chr = value.charAt(i);
 156
 157                     if (isWhitespace(chr)) {
 158                         spaces.push(tokens.length);
 159                     } else {
 160                         nonSpace = true;
 161                     }
 162
 163                     tokens.push([ 'text', chr, start, start + 1 ]);
 164                     start += 1;
 165
 166                     // Check for whitespace on the current line.
 167                     if (chr === '\n')
 168                         stripSpace();
 169                 }
 170             }
 171
 172             // Match the opening tag.
 173             if (!scanner.scan(openingTagRe))
 174                 break;
 175
 176             hasTag = true;
 177
 178             // Get the tag type.
 179             type = scanner.scan(tagRe) || 'name';
 180             scanner.scan(whiteRe);
 181
 182             // Get the tag value.
 183             if (type === '=') {
 184                 value = scanner.scanUntil(equalsRe);
 185                 scanner.scan(equalsRe);
 186                 scanner.scanUntil(closingTagRe);
 187             } else if (type === '{') {
 188                 value = scanner.scanUntil(closingCurlyRe);
 189                 scanner.scan(curlyRe);
 190                 scanner.scanUntil(closingTagRe);
 191                 type = '&';
 192             } else {
 193                 value = scanner.scanUntil(closingTagRe);
 194             }
 195
 196             // Match the closing tag.
 197             if (!scanner.scan(closingTagRe))
 198                 throw new Error('Unclosed tag at ' + scanner.pos);
 199
 200             token = [ type, value, start, scanner.pos ];
 201             tokens.push(token);
 202
 203             if (type === '#' || type === '^') {
 204                 sections.push(token);
 205             } else if (type === '/') {
 206                 // Check section nesting.
 207                 openSection = sections.pop();
 208
 209                 if (!openSection)
 210                     throw new Error('Unopened section "' + value + '" at ' + start);
 211
 212                 if (openSection[1] !== value)
 213                     throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);
 214             } else if (type === 'name' || type === '{' || type === '&') {
 215                 nonSpace = true;
 216             } else if (type === '=') {
 217                 // Set the tags for the next time around.
 218                 compileTags(value);
 219             }
 220         }
 221
 222         // Make sure there are no open sections when we're done.
 223         openSection = sections.pop();
 224
 225         if (openSection)
 226             throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);
 227
 228         return nestTokens(squashTokens(tokens));
 229     }
 230
 231     /**
 232      * Combines the values of consecutive text tokens in the given `tokens` array
 233      * to a single token.
 234      */
 235     function squashTokens (tokens) {
 236         var squashedTokens = [];
 237
 238         var token, lastToken;
 239         for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
 240             token = tokens[i];
 241
 242             if (token) {
 243                 if (token[0] === 'text' && lastToken && lastToken[0] === 'text') {
 244                     lastToken[1] += token[1];
 245                     lastToken[3] = token[3];
 246                 } else {
 247                     squashedTokens.push(token);
 248                     lastToken = token;
 249                 }
 250             }
 251         }
 252
 253         return squashedTokens;
 254     }
 255
 256     /**
 257      * Forms the given array of `tokens` into a nested tree structure where
 258      * tokens that represent a section have two additional items: 1) an array of
 259      * all tokens that appear in that section and 2) the index in the original
 260      * template that represents the end of that section.
 261      */
 262     function nestTokens (tokens) {
 263         var nestedTokens = [];
 264         var collector = nestedTokens;
 265         var sections = [];
 266
 267         var token, section;
 268         for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
 269             token = tokens[i];
 270
 271             switch (token[0]) {
 272                 case '#':
 273                 case '^':
 274                     collector.push(token);
 275                     sections.push(token);
 276                     collector = token[4] = [];
 277                     break;
 278                 case '/':
 279                     section = sections.pop();
 280                     section[5] = token[2];
 281                     collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
 282                     break;
 283                 default:
 284                     collector.push(token);
 285             }
 286         }
 287
 288         return nestedTokens;
 289     }
 290
 291     /**
 292      * A simple string scanner that is used by the template parser to find
 293      * tokens in template strings.
 294      */
 295     function Scanner (string) {
 296         this.string = string;
 297         this.tail = string;
 298         this.pos = 0;
 299     }
 300
 301     /**
 302      * Returns `true` if the tail is empty (end of string).
 303      */
 304     Scanner.prototype.eos = function eos () {
 305         return this.tail === '';
 306     };
 307
 308     /**
 309      * Tries to match the given regular expression at the current position.
 310      * Returns the matched text if it can match, the empty string otherwise.
 311      */
 312     Scanner.prototype.scan = function scan (re) {
 313         var match = this.tail.match(re);
 314
 315         if (!match || match.index !== 0)
 316             return '';
 317
 318         var string = match[0];
 319
 320         this.tail = this.tail.substring(string.length);
 321         this.pos += string.length;
 322
 323         return string;
 324     };
 325
 326     /**
 327      * Skips all text until the given regular expression can be matched. Returns
 328      * the skipped string, which is the entire tail if no match can be made.
 329      */
 330     Scanner.prototype.scanUntil = function scanUntil (re) {
 331         var index = this.tail.search(re), match;
 332
 333         switch (index) {
 334             case -1:
 335                 match = this.tail;
 336                 this.tail = '';
 337                 break;
 338             case 0:
 339                 match = '';
 340                 break;
 341             default:
 342                 match = this.tail.substring(0, index);
 343                 this.tail = this.tail.substring(index);
 344         }
 345
 346         this.pos += match.length;
 347
 348         return match;
 349     };
 350
 351     /**
 352      * Represents a rendering context by wrapping a view object and
 353      * maintaining a reference to the parent context.
 354      */
 355     function Context (view, parentContext) {
 356         this.view = view;
 357         this.cache = { '.': this.view };
 358         this.parent = parentContext;
 359     }
 360
 361     /**
 362      * Creates a new context using the given view with this context
 363      * as the parent.
 364      */
 365     Context.prototype.push = function push (view) {
 366         return new Context(view, this);
 367     };
 368
 369     /**
 370      * Returns the value of the given name in this context, traversing
 371      * up the context hierarchy if the value is absent in this context's view.
 372      */
 373     Context.prototype.lookup = function lookup (name) {
 374         var cache = this.cache;
 375
 376         var value;
 377         if (cache.hasOwnProperty(name)) {
 378             value = cache[name];
 379         } else {
 380             var context = this, names, index, lookupHit = false;
 381
 382             while (context) {
 383                 if (name.indexOf('.') > 0) {
 384                     value = context.view;
 385                     names = name.split('.');
 386                     index = 0;
 387
 388                     /**
 389                      * Using the dot notion path in `name`, we descend through the
 390                      * nested objects.
 391                      *
 392                      * To be certain that the lookup has been successful, we have to
 393                      * check if the last object in the path actually has the property
 394                      * we are looking for. We store the result in `lookupHit`.
 395                      *
 396                      * This is specially necessary for when the value has been set to
 397                      * `undefined` and we want to avoid looking up parent contexts.
 398                      **/
 399                     while (value != null && index < names.length) {
 400                         if (index === names.length - 1)
 401                             lookupHit = hasProperty(value, names[index]);
 402
 403                         value = value[names[index++]];
 404                     }
 405                 } else {
 406                     value = context.view[name];
 407                     lookupHit = hasProperty(context.view, name);
 408                 }
 409
 410                 if (lookupHit)
 411                     break;
 412
 413                 context = context.parent;
 414             }
 415
 416             cache[name] = value;
 417         }
 418
 419         if (isFunction(value))
 420             value = value.call(this.view);
 421
 422         return value;
 423     };
 424
 425     /**
 426      * A Writer knows how to take a stream of tokens and render them to a
 427      * string, given a context. It also maintains a cache of templates to
 428      * avoid the need to parse the same template twice.
 429      */
 430     function Writer () {
 431         this.cache = {};
 432     }
 433
 434     /**
 435      * Clears all cached templates in this writer.
 436      */
 437     Writer.prototype.clearCache = function clearCache () {
 438         this.cache = {};
 439     };
 440
 441     /**
 442      * Parses and caches the given `template` and returns the array of tokens
 443      * that is generated from the parse.
 444      */
 445     Writer.prototype.parse = function parse (template, tags) {
 446         var cache = this.cache;
 447         var tokens = cache[template];
 448
 449         if (tokens == null)
 450             tokens = cache[template] = parseTemplate(template, tags);
 451
 452         return tokens;
 453     };
 454
 455     /**
 456      * High-level method that is used to render the given `template` with
 457      * the given `view`.
 458      *
 459      * The optional `partials` argument may be an object that contains the
 460      * names and templates of partials that are used in the template. It may
 461      * also be a function that is used to load partial templates on the fly
 462      * that takes a single argument: the name of the partial.
 463      */
 464     Writer.prototype.render = function render (template, view, partials) {
 465         var tokens = this.parse(template);
 466         var context = (view instanceof Context) ? view : new Context(view);
 467         return this.renderTokens(tokens, context, partials, template);
 468     };
 469
 470     /**
 471      * Low-level method that renders the given array of `tokens` using
 472      * the given `context` and `partials`.
 473      *
 474      * Note: The `originalTemplate` is only ever used to extract the portion
 475      * of the original template that was contained in a higher-order section.
 476      * If the template doesn't use higher-order sections, this argument may
 477      * be omitted.
 478      */
 479     Writer.prototype.renderTokens = function renderTokens (tokens, context, partials, originalTemplate) {
 480         var buffer = '';
 481
 482         var token, symbol, value;
 483         for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
 484             value = undefined;
 485             token = tokens[i];
 486             symbol = token[0];
 487
 488             if (symbol === '#') value = this.renderSection(token, context, partials, originalTemplate);
 489             else if (symbol === '^') value = this.renderInverted(token, context, partials, originalTemplate);
 490             else if (symbol === '>') value = this.renderPartial(token, context, partials, originalTemplate);
 491             else if (symbol === '&') value = this.unescapedValue(token, context);
 492             else if (symbol === 'name') value = this.escapedValue(token, context);
 493             else if (symbol === 'text') value = this.rawValue(token);
 494
 495             if (value !== undefined)
 496                 buffer += value;
 497         }
 498
 499         return buffer;
 500     };
 501
 502     Writer.prototype.renderSection = function renderSection (token, context, partials, originalTemplate) {
 503         var self = this;
 504         var buffer = '';
 505         var value = context.lookup(token[1]);
 506
 507         // This function is used to render an arbitrary template
 508         // in the current context by higher-order sections.
 509         function subRender (template) {
 510             return self.render(template, context, partials);
 511         }
 512
 513         if (!value) return;
 514
 515         if (isArray(value)) {
 516             for (var j = 0, valueLength = value.length; j < valueLength; ++j) {
 517                 buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate);
 518             }
 519         } else if (typeof value === 'object' || typeof value === 'string' || typeof value === 'number') {
 520             buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate);
 521         } else if (isFunction(value)) {
 522             if (typeof originalTemplate !== 'string')
 523                 throw new Error('Cannot use higher-order sections without the original template');
 524
 525             // Extract the portion of the original template that the section contains.
 526             value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender);
 527
 528             if (value != null)
 529                 buffer += value;
 530         } else {
 531             buffer += this.renderTokens(token[4], context, partials, originalTemplate);
 532         }
 533         return buffer;
 534     };
 535
 536     Writer.prototype.renderInverted = function renderInverted (token, context, partials, originalTemplate) {
 537         var value = context.lookup(token[1]);
 538
 539         // Use JavaScript's definition of falsy. Include empty arrays.
 540         // See https://github.com/janl/mustache.js/issues/186
 541         if (!value || (isArray(value) && value.length === 0))
 542             return this.renderTokens(token[4], context, partials, originalTemplate);
 543     };
 544
 545     Writer.prototype.renderPartial = function renderPartial (token, context, partials) {
 546         if (!partials) return;
 547
 548         var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];
 549         if (value != null)
 550             return this.renderTokens(this.parse(value), context, partials, value);
 551     };
 552
 553     Writer.prototype.unescapedValue = function unescapedValue (token, context) {
 554         var value = context.lookup(token[1]);
 555         if (value != null)
 556             return value;
 557     };
 558
 559     Writer.prototype.escapedValue = function escapedValue (token, context) {
 560         var value = context.lookup(token[1]);
 561         if (value != null)
 562             return mustache.escape(value);
 563     };
 564
 565     Writer.prototype.rawValue = function rawValue (token) {
 566         return token[1];
 567     };
 568
 569     mustache.name = 'mustache.js';
 570     mustache.version = '2.3.0';
 571     mustache.tags = [ '{{', '}}' ];
 572
 573     // All high-level mustache.* functions use this writer.
 574     var defaultWriter = new Writer();
 575
 576     /**
 577      * Clears all cached templates in the default writer.
 578      */
 579     mustache.clearCache = function clearCache () {
 580         return defaultWriter.clearCache();
 581     };
 582
 583     /**
 584      * Parses and caches the given template in the default writer and returns the
 585      * array of tokens it contains. Doing this ahead of time avoids the need to
 586      * parse templates on the fly as they are rendered.
 587      */
 588     mustache.parse = function parse (template, tags) {
 589         return defaultWriter.parse(template, tags);
 590     };
 591
 592     /**
 593      * Renders the `template` with the given `view` and `partials` using the
 594      * default writer.
 595      */
 596     mustache.render = function render (template, view, partials) {
 597         if (typeof template !== 'string') {
 598             throw new TypeError('Invalid template! Template should be a "string" ' +
 599                 'but "' + typeStr(template) + '" was given as the first ' +
 600                 'argument for mustache#render(template, view, partials)');
 601         }
 602
 603         return defaultWriter.render(template, view, partials);
 604     };
 605
 606     // This is here for backwards compatibility with 0.4.x.,
 607     /*eslint-disable */ // eslint wants camel cased function name
 608     mustache.to_html = function to_html (template, view, partials, send) {
 609         /*eslint-enable*/
 610
 611         var result = mustache.render(template, view, partials);
 612
 613         if (isFunction(send)) {
 614             send(result);
 615         } else {
 616             return result;
 617         }
 618     };
 619
 620     // Export the escaping function so that the user may override it.
 621     // See https://github.com/janl/mustache.js/issues/244
 622     mustache.escape = escapeHtml;
 623
 624     // Export these mainly for testing, but also for advanced usage.
 625     mustache.Scanner = Scanner;
 626     mustache.Context = Context;
 627     mustache.Writer = Writer;
 628
 629     return mustache;
 630 }));