| /* |
| |
| The MIT License (MIT) |
| |
| Copyright (c) 2007-2013 Einar Lielmanis and contributors. |
| |
| Permission is hereby granted, free of charge, to any person |
| obtaining a copy of this software and associated documentation files |
| (the "Software"), to deal in the Software without restriction, |
| including without limitation the rights to use, copy, modify, merge, |
| publish, distribute, sublicense, and/or sell copies of the Software, |
| and to permit persons to whom the Software is furnished to do so, |
| subject to the following conditions: |
| |
| The above copyright notice and this permission notice shall be |
| included in all copies or substantial portions of the Software. |
| |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
| BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| SOFTWARE. |
| |
| JS Beautifier |
| --------------- |
| |
| */ |
| |
| function trim(s) { |
| return s.replace(/^\s+|\s+$/g, ''); |
| } |
| |
| function ltrim(s) { |
| return s.replace(/^\s+/g, ''); |
| } |
| |
| function style_html(html_source, options) { |
| //Wrapper function to invoke all the necessary constructors and deal with the output. |
| |
| var multi_parser, |
| indent_inner_html, |
| indent_size, |
| indent_character, |
| wrap_line_length, |
| brace_style, |
| unformatted, |
| preserve_newlines, |
| max_preserve_newlines; |
| |
| options = options || {}; |
| |
| // backwards compatibility to 1.3.4 |
| if ((options.wrap_line_length === undefined || parseInt(options.wrap_line_length, 10) === 0) && |
| (options.max_char === undefined || parseInt(options.max_char, 10) === 0)) { |
| options.wrap_line_length = options.max_char; |
| } |
| |
| indent_inner_html = options.indent_inner_html || false; |
| indent_size = parseInt(options.indent_size || 4, 10); |
| indent_character = options.indent_char || ' '; |
| brace_style = options.brace_style || 'collapse'; |
| wrap_line_length = parseInt(options.wrap_line_length, 10) === 0 ? 32786 : parseInt(options.wrap_line_length || 250, 10); |
| unformatted = options.unformatted || ['a', 'span', 'bdo', 'em', 'strong', 'dfn', 'code', 'samp', 'kbd', 'var', 'cite', 'abbr', 'acronym', 'q', 'sub', 'sup', 'tt', 'i', 'b', 'big', 'small', 'u', 's', 'strike', 'font', 'ins', 'del', 'pre', 'address', 'dt', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6']; |
| preserve_newlines = options.preserve_newlines || true; |
| max_preserve_newlines = preserve_newlines ? parseInt(options.max_preserve_newlines || 32786, 10) : 0; |
| indent_handlebars = options.indent_handlebars || false; |
| |
| function Parser() { |
| |
| this.pos = 0; //Parser position |
| this.token = ''; |
| this.current_mode = 'CONTENT'; //reflects the current Parser mode: TAG/CONTENT |
| this.tags = { //An object to hold tags, their position, and their parent-tags, initiated with default values |
| parent: 'parent1', |
| parentcount: 1, |
| parent1: '' |
| }; |
| this.tag_type = ''; |
| this.token_text = this.last_token = this.last_text = this.token_type = ''; |
| this.newlines = 0; |
| this.indent_content = indent_inner_html; |
| |
| this.Utils = { //Uilities made available to the various functions |
| whitespace: "\n\r\t ".split(''), |
| single_token: 'br,input,link,meta,!doctype,basefont,base,area,hr,wbr,param,img,isindex,?xml,embed,?php,?,?='.split(','), //all the single tags for HTML |
| extra_liners: 'head,body,/html'.split(','), //for tags that need a line of whitespace before them |
| in_array: function(what, arr) { |
| for (var i = 0; i < arr.length; i++) { |
| if (what === arr[i]) { |
| return true; |
| } |
| } |
| return false; |
| } |
| }; |
| |
| this.traverse_whitespace = function() { |
| var input_char = ''; |
| |
| input_char = this.input.charAt(this.pos); |
| if (this.Utils.in_array(input_char, this.Utils.whitespace)) { |
| this.newlines = 0; |
| while (this.Utils.in_array(input_char, this.Utils.whitespace)) { |
| if (preserve_newlines && input_char === '\n' && this.newlines <= max_preserve_newlines) { |
| this.newlines += 1; |
| } |
| |
| this.pos++; |
| input_char = this.input.charAt(this.pos); |
| } |
| return true; |
| } |
| return false; |
| }; |
| |
| this.get_content = function() { //function to capture regular content between tags |
| |
| var input_char = '', |
| content = [], |
| space = false; //if a space is needed |
| |
| while (this.input.charAt(this.pos) !== '<') { |
| if (this.pos >= this.input.length) { |
| return content.length ? content.join('') : ['', 'TK_EOF']; |
| } |
| |
| if (this.traverse_whitespace()) { |
| if (content.length) { |
| space = true; |
| } |
| continue; //don't want to insert unnecessary space |
| } |
| |
| if (indent_handlebars) { |
| // Handlebars parsing is complicated. |
| // {{#foo}} and {{/foo}} are formatted tags. |
| // {{something}} should get treated as content, except: |
| // {{else}} specifically behaves like {{#if}} and {{/if}} |
| var peek3 = this.input.substr(this.pos, 3); |
| if (peek3 === '{{#' || peek3 === '{{/') { |
| // These are tags and not content. |
| break; |
| } else if (this.input.substr(this.pos, 2) === '{{') { |
| if (this.get_tag(true) === '{{else}}') { |
| break; |
| } |
| } |
| } |
| |
| input_char = this.input.charAt(this.pos); |
| this.pos++; |
| |
| if (space) { |
| if (this.line_char_count >= this.wrap_line_length) { //insert a line when the wrap_line_length is reached |
| this.print_newline(false, content); |
| this.print_indentation(content); |
| } else { |
| this.line_char_count++; |
| content.push(' '); |
| } |
| space = false; |
| } |
| this.line_char_count++; |
| content.push(input_char); //letter at-a-time (or string) inserted to an array |
| } |
| return content.length ? content.join('') : ''; |
| }; |
| |
| this.get_contents_to = function(name) { //get the full content of a script or style to pass to js_beautify |
| if (this.pos === this.input.length) { |
| return ['', 'TK_EOF']; |
| } |
| var input_char = ''; |
| var content = ''; |
| var reg_match = new RegExp('</' + name + '\\s*>', 'igm'); |
| reg_match.lastIndex = this.pos; |
| var reg_array = reg_match.exec(this.input); |
| var end_script = reg_array ? reg_array.index : this.input.length; //absolute end of script |
| if (this.pos < end_script) { //get everything in between the script tags |
| content = this.input.substring(this.pos, end_script); |
| this.pos = end_script; |
| } |
| return content; |
| }; |
| |
| this.record_tag = function(tag) { //function to record a tag and its parent in this.tags Object |
| if (this.tags[tag + 'count']) { //check for the existence of this tag type |
| this.tags[tag + 'count']++; |
| this.tags[tag + this.tags[tag + 'count']] = this.indent_level; //and record the present indent level |
| } else { //otherwise initialize this tag type |
| this.tags[tag + 'count'] = 1; |
| this.tags[tag + this.tags[tag + 'count']] = this.indent_level; //and record the present indent level |
| } |
| this.tags[tag + this.tags[tag + 'count'] + 'parent'] = this.tags.parent; //set the parent (i.e. in the case of a div this.tags.div1parent) |
| this.tags.parent = tag + this.tags[tag + 'count']; //and make this the current parent (i.e. in the case of a div 'div1') |
| }; |
| |
| this.retrieve_tag = function(tag) { //function to retrieve the opening tag to the corresponding closer |
| if (this.tags[tag + 'count']) { //if the openener is not in the Object we ignore it |
| var temp_parent = this.tags.parent; //check to see if it's a closable tag. |
| while (temp_parent) { //till we reach '' (the initial value); |
| if (tag + this.tags[tag + 'count'] === temp_parent) { //if this is it use it |
| break; |
| } |
| temp_parent = this.tags[temp_parent + 'parent']; //otherwise keep on climbing up the DOM Tree |
| } |
| if (temp_parent) { //if we caught something |
| this.indent_level = this.tags[tag + this.tags[tag + 'count']]; //set the indent_level accordingly |
| this.tags.parent = this.tags[temp_parent + 'parent']; //and set the current parent |
| } |
| delete this.tags[tag + this.tags[tag + 'count'] + 'parent']; //delete the closed tags parent reference... |
| delete this.tags[tag + this.tags[tag + 'count']]; //...and the tag itself |
| if (this.tags[tag + 'count'] === 1) { |
| delete this.tags[tag + 'count']; |
| } else { |
| this.tags[tag + 'count']--; |
| } |
| } |
| }; |
| |
| this.indent_to_tag = function(tag) { |
| // Match the indentation level to the last use of this tag, but don't remove it. |
| if (!this.tags[tag + 'count']) { |
| return; |
| } |
| var temp_parent = this.tags.parent; |
| while (temp_parent) { |
| if (tag + this.tags[tag + 'count'] === temp_parent) { |
| break; |
| } |
| temp_parent = this.tags[temp_parent + 'parent']; |
| } |
| if (temp_parent) { |
| this.indent_level = this.tags[tag + this.tags[tag + 'count']]; |
| } |
| }; |
| |
| this.get_tag = function(peek) { //function to get a full tag and parse its type |
| var input_char = '', |
| content = [], |
| comment = '', |
| space = false, |
| tag_start, tag_end, |
| tag_start_char, |
| orig_pos = this.pos, |
| orig_line_char_count = this.line_char_count; |
| |
| peek = peek !== undefined ? peek : false; |
| |
| do { |
| if (this.pos >= this.input.length) { |
| if (peek) { |
| this.pos = orig_pos; |
| this.line_char_count = orig_line_char_count; |
| } |
| return content.length ? content.join('') : ['', 'TK_EOF']; |
| } |
| |
| input_char = this.input.charAt(this.pos); |
| this.pos++; |
| |
| if (this.Utils.in_array(input_char, this.Utils.whitespace)) { //don't want to insert unnecessary space |
| space = true; |
| continue; |
| } |
| |
| if (input_char === "'" || input_char === '"') { |
| input_char += this.get_unformatted(input_char); |
| space = true; |
| |
| } |
| |
| if (input_char === '=') { //no space before = |
| space = false; |
| } |
| |
| if (content.length && content[content.length - 1] !== '=' && input_char !== '>' && space) { |
| //no space after = or before > |
| if (this.line_char_count >= this.wrap_line_length) { |
| this.print_newline(false, content); |
| this.print_indentation(content); |
| } else { |
| content.push(' '); |
| this.line_char_count++; |
| } |
| space = false; |
| } |
| |
| if (indent_handlebars && tag_start_char === '<') { |
| // When inside an angle-bracket tag, put spaces around |
| // handlebars not inside of strings. |
| if ((input_char + this.input.charAt(this.pos)) === '{{') { |
| input_char += this.get_unformatted('}}'); |
| if (content.length && content[content.length - 1] !== ' ' && content[content.length - 1] !== '<') { |
| input_char = ' ' + input_char; |
| } |
| space = true; |
| } |
| } |
| |
| if (input_char === '<' && !tag_start_char) { |
| tag_start = this.pos - 1; |
| tag_start_char = '<'; |
| } |
| |
| if (indent_handlebars && !tag_start_char) { |
| if (content.length >= 2 && content[content.length - 1] === '{' && content[content.length - 2] == '{') { |
| if (input_char === '#' || input_char === '/') { |
| tag_start = this.pos - 3; |
| } else { |
| tag_start = this.pos - 2; |
| } |
| tag_start_char = '{'; |
| } |
| } |
| |
| this.line_char_count++; |
| content.push(input_char); //inserts character at-a-time (or string) |
| |
| if (content[1] && content[1] === '!') { //if we're in a comment, do something special |
| // We treat all comments as literals, even more than preformatted tags |
| // we just look for the appropriate close tag |
| content = [this.get_comment(tag_start)]; |
| break; |
| } |
| |
| if (indent_handlebars && tag_start_char === '{' && content.length > 2 && content[content.length - 2] === '}' && content[content.length - 1] === '}') { |
| break; |
| } |
| } while (input_char !== '>'); |
| |
| var tag_complete = content.join(''); |
| var tag_index; |
| var tag_offset; |
| |
| if (tag_complete.indexOf(' ') !== -1) { //if there's whitespace, thats where the tag name ends |
| tag_index = tag_complete.indexOf(' '); |
| } else if (tag_complete[0] === '{') { |
| tag_index = tag_complete.indexOf('}'); |
| } else { //otherwise go with the tag ending |
| tag_index = tag_complete.indexOf('>'); |
| } |
| if (tag_complete[0] === '<' || !indent_handlebars) { |
| tag_offset = 1; |
| } else { |
| tag_offset = tag_complete[2] === '#' ? 3 : 2; |
| } |
| var tag_check = tag_complete.substring(tag_offset, tag_index).toLowerCase(); |
| if (tag_complete.charAt(tag_complete.length - 2) === '/' || |
| this.Utils.in_array(tag_check, this.Utils.single_token)) { //if this tag name is a single tag type (either in the list or has a closing /) |
| if (!peek) { |
| this.tag_type = 'SINGLE'; |
| } |
| } else if (indent_handlebars && tag_complete[0] === '{' && tag_check === 'else') { |
| if (!peek) { |
| this.indent_to_tag('if'); |
| this.tag_type = 'HANDLEBARS_ELSE'; |
| this.indent_content = true; |
| this.traverse_whitespace(); |
| } |
| } else if (tag_check === 'script') { //for later script handling |
| if (!peek) { |
| this.record_tag(tag_check); |
| this.tag_type = 'SCRIPT'; |
| } |
| } else if (tag_check === 'style') { //for future style handling (for now it justs uses get_content) |
| if (!peek) { |
| this.record_tag(tag_check); |
| this.tag_type = 'STYLE'; |
| } |
| } else if (this.is_unformatted(tag_check, unformatted)) { // do not reformat the "unformatted" tags |
| comment = this.get_unformatted('</' + tag_check + '>', tag_complete); //...delegate to get_unformatted function |
| content.push(comment); |
| // Preserve collapsed whitespace either before or after this tag. |
| if (tag_start > 0 && this.Utils.in_array(this.input.charAt(tag_start - 1), this.Utils.whitespace)) { |
| content.splice(0, 0, this.input.charAt(tag_start - 1)); |
| } |
| tag_end = this.pos - 1; |
| if (this.Utils.in_array(this.input.charAt(tag_end + 1), this.Utils.whitespace)) { |
| content.push(this.input.charAt(tag_end + 1)); |
| } |
| this.tag_type = 'SINGLE'; |
| } else if (tag_check.charAt(0) === '!') { //peek for <! comment |
| // for comments content is already correct. |
| if (!peek) { |
| this.tag_type = 'SINGLE'; |
| this.traverse_whitespace(); |
| } |
| } else if (!peek) { |
| if (tag_check.charAt(0) === '/') { //this tag is a double tag so check for tag-ending |
| this.retrieve_tag(tag_check.substring(1)); //remove it and all ancestors |
| this.tag_type = 'END'; |
| this.traverse_whitespace(); |
| } else { //otherwise it's a start-tag |
| this.record_tag(tag_check); //push it on the tag stack |
| if (tag_check.toLowerCase() !== 'html') { |
| this.indent_content = true; |
| } |
| this.tag_type = 'START'; |
| |
| // Allow preserving of newlines after a start tag |
| this.traverse_whitespace(); |
| } |
| if (this.Utils.in_array(tag_check, this.Utils.extra_liners)) { //check if this double needs an extra line |
| this.print_newline(false, this.output); |
| if (this.output.length && this.output[this.output.length - 2] !== '\n') { |
| this.print_newline(true, this.output); |
| } |
| } |
| } |
| |
| if (peek) { |
| this.pos = orig_pos; |
| this.line_char_count = orig_line_char_count; |
| } |
| |
| return content.join(''); //returns fully formatted tag |
| }; |
| |
| this.get_comment = function(start_pos) { //function to return comment content in its entirety |
| // this is will have very poor perf, but will work for now. |
| var comment = '', |
| delimiter = '>', |
| matched = false; |
| |
| this.pos = start_pos; |
| input_char = this.input.charAt(this.pos); |
| this.pos++; |
| |
| while (this.pos <= this.input.length) { |
| comment += input_char; |
| |
| // only need to check for the delimiter if the last chars match |
| if (comment[comment.length - 1] === delimiter[delimiter.length - 1] && |
| comment.indexOf(delimiter) !== -1) { |
| break; |
| } |
| |
| // only need to search for custom delimiter for the first few characters |
| if (!matched && comment.length < 10) { |
| if (comment.indexOf('<![if') === 0) { //peek for <![if conditional comment |
| delimiter = '<![endif]>'; |
| matched = true; |
| } else if (comment.indexOf('<![cdata[') === 0) { //if it's a <[cdata[ comment... |
| delimiter = ']]>'; |
| matched = true; |
| } else if (comment.indexOf('<![') === 0) { // some other ![ comment? ... |
| delimiter = ']>'; |
| matched = true; |
| } else if (comment.indexOf('<!--') === 0) { // <!-- comment ... |
| delimiter = '-->'; |
| matched = true; |
| } |
| } |
| |
| input_char = this.input.charAt(this.pos); |
| this.pos++; |
| } |
| |
| return comment; |
| }; |
| |
| this.get_unformatted = function(delimiter, orig_tag) { //function to return unformatted content in its entirety |
| |
| if (orig_tag && orig_tag.toLowerCase().indexOf(delimiter) !== -1) { |
| return ''; |
| } |
| var input_char = ''; |
| var content = ''; |
| var min_index = 0; |
| var space = true; |
| do { |
| |
| if (this.pos >= this.input.length) { |
| return content; |
| } |
| |
| input_char = this.input.charAt(this.pos); |
| this.pos++; |
| |
| if (this.Utils.in_array(input_char, this.Utils.whitespace)) { |
| if (!space) { |
| this.line_char_count--; |
| continue; |
| } |
| if (input_char === '\n' || input_char === '\r') { |
| content += '\n'; |
| /* Don't change tab indention for unformatted blocks. If using code for html editing, this will greatly affect <pre> tags if they are specified in the 'unformatted array' |
| for (var i=0; i<this.indent_level; i++) { |
| content += this.indent_string; |
| } |
| space = false; //...and make sure other indentation is erased |
| */ |
| this.line_char_count = 0; |
| continue; |
| } |
| } |
| content += input_char; |
| this.line_char_count++; |
| space = true; |
| |
| if (indent_handlebars && input_char === '{' && content.length && content[content.length - 2] === '{') { |
| // Handlebars expressions in strings should also be unformatted. |
| content += this.get_unformatted('}}'); |
| // These expressions are opaque. Ignore delimiters found in them. |
| min_index = content.length; |
| } |
| } while (content.toLowerCase().indexOf(delimiter, min_index) === -1); |
| return content; |
| }; |
| |
| this.get_token = function() { //initial handler for token-retrieval |
| var token; |
| |
| if (this.last_token === 'TK_TAG_SCRIPT' || this.last_token === 'TK_TAG_STYLE') { //check if we need to format javascript |
| var type = this.last_token.substr(7); |
| token = this.get_contents_to(type); |
| if (typeof token !== 'string') { |
| return token; |
| } |
| return [token, 'TK_' + type]; |
| } |
| if (this.current_mode === 'CONTENT') { |
| token = this.get_content(); |
| if (typeof token !== 'string') { |
| return token; |
| } else { |
| return [token, 'TK_CONTENT']; |
| } |
| } |
| |
| if (this.current_mode === 'TAG') { |
| token = this.get_tag(); |
| if (typeof token !== 'string') { |
| return token; |
| } else { |
| var tag_name_type = 'TK_TAG_' + this.tag_type; |
| return [token, tag_name_type]; |
| } |
| } |
| }; |
| |
| this.get_full_indent = function(level) { |
| level = this.indent_level + level || 0; |
| if (level < 1) { |
| return ''; |
| } |
| |
| return Array(level + 1).join(this.indent_string); |
| }; |
| |
| this.is_unformatted = function(tag_check, unformatted) { |
| //is this an HTML5 block-level link? |
| if (!this.Utils.in_array(tag_check, unformatted)) { |
| return false; |
| } |
| |
| if (tag_check.toLowerCase() !== 'a' || !this.Utils.in_array('a', unformatted)) { |
| return true; |
| } |
| |
| //at this point we have an tag; is its first child something we want to remain |
| //unformatted? |
| var next_tag = this.get_tag(true /* peek. */ ); |
| |
| // test next_tag to see if it is just html tag (no external content) |
| var tag = (next_tag || "").match(/^\s*<\s*\/?([a-z]*)\s*[^>]*>\s*$/); |
| |
| // if next_tag comes back but is not an isolated tag, then |
| // let's treat the 'a' tag as having content |
| // and respect the unformatted option |
| if (!tag || this.Utils.in_array(tag, unformatted)) { |
| return true; |
| } else { |
| return false; |
| } |
| }; |
| |
| this.printer = function(js_source, indent_character, indent_size, wrap_line_length, brace_style) { //handles input/output and some other printing functions |
| |
| this.input = js_source || ''; //gets the input for the Parser |
| this.output = []; |
| this.indent_character = indent_character; |
| this.indent_string = ''; |
| this.indent_size = indent_size; |
| this.brace_style = brace_style; |
| this.indent_level = 0; |
| this.wrap_line_length = wrap_line_length; |
| this.line_char_count = 0; //count to see if wrap_line_length was exceeded |
| |
| for (var i = 0; i < this.indent_size; i++) { |
| this.indent_string += this.indent_character; |
| } |
| |
| this.print_newline = function(force, arr) { |
| this.line_char_count = 0; |
| if (!arr || !arr.length) { |
| return; |
| } |
| if (force || (arr[arr.length - 1] !== '\n')) { //we might want the extra line |
| arr.push('\n'); |
| } |
| }; |
| |
| this.print_indentation = function(arr) { |
| for (var i = 0; i < this.indent_level; i++) { |
| arr.push(this.indent_string); |
| this.line_char_count += this.indent_string.length; |
| } |
| }; |
| |
| this.print_token = function(text) { |
| if (text || text !== '') { |
| if (this.output.length && this.output[this.output.length - 1] === '\n') { |
| this.print_indentation(this.output); |
| text = ltrim(text); |
| } |
| } |
| this.print_token_raw(text); |
| }; |
| |
| this.print_token_raw = function(text) { |
| if (text && text !== '') { |
| if (text.length > 1 && text[text.length - 1] === '\n') { |
| // unformatted tags can grab newlines as their last character |
| this.output.push(text.slice(0, -1)); |
| this.print_newline(false, this.output); |
| } else { |
| this.output.push(text); |
| } |
| } |
| |
| for (var n = 0; n < this.newlines; n++) { |
| this.print_newline(n > 0, this.output); |
| } |
| this.newlines = 0; |
| }; |
| |
| this.indent = function() { |
| this.indent_level++; |
| }; |
| |
| this.unindent = function() { |
| if (this.indent_level > 0) { |
| this.indent_level--; |
| } |
| }; |
| }; |
| return this; |
| } |
| |
| /*_____________________--------------------_____________________*/ |
| |
| multi_parser = new Parser(); //wrapping functions Parser |
| multi_parser.printer(html_source, indent_character, indent_size, wrap_line_length, brace_style); //initialize starting values |
| |
| while (true) { |
| var t = multi_parser.get_token(); |
| multi_parser.token_text = t[0]; |
| multi_parser.token_type = t[1]; |
| |
| if (multi_parser.token_type === 'TK_EOF') { |
| break; |
| } |
| |
| switch (multi_parser.token_type) { |
| case 'TK_TAG_START': |
| multi_parser.print_newline(false, multi_parser.output); |
| multi_parser.print_token(multi_parser.token_text); |
| if (multi_parser.indent_content) { |
| multi_parser.indent(); |
| multi_parser.indent_content = false; |
| } |
| multi_parser.current_mode = 'CONTENT'; |
| break; |
| case 'TK_TAG_STYLE': |
| case 'TK_TAG_SCRIPT': |
| multi_parser.print_newline(false, multi_parser.output); |
| multi_parser.print_token(multi_parser.token_text); |
| multi_parser.current_mode = 'CONTENT'; |
| break; |
| case 'TK_TAG_END': |
| //Print new line only if the tag has no content and has child |
| if (multi_parser.last_token === 'TK_CONTENT' && multi_parser.last_text === '') { |
| var tag_name = multi_parser.token_text.match(/\w+/)[0]; |
| var tag_extracted_from_last_output = null; |
| if (multi_parser.output.length) { |
| tag_extracted_from_last_output = multi_parser.output[multi_parser.output.length - 1].match(/(?:<|{{#)\s*(\w+)/); |
| } |
| if (tag_extracted_from_last_output === null || |
| tag_extracted_from_last_output[1] !== tag_name) { |
| multi_parser.print_newline(false, multi_parser.output); |
| } |
| } |
| multi_parser.print_token(multi_parser.token_text); |
| multi_parser.current_mode = 'CONTENT'; |
| break; |
| case 'TK_TAG_SINGLE': |
| // Don't add a newline before elements that should remain unformatted. |
| var tag_check = multi_parser.token_text.match(/^\s*<([a-z]+)/i); |
| if (!tag_check || !multi_parser.Utils.in_array(tag_check[1], unformatted)) { |
| multi_parser.print_newline(false, multi_parser.output); |
| } |
| multi_parser.print_token(multi_parser.token_text); |
| multi_parser.current_mode = 'CONTENT'; |
| break; |
| case 'TK_TAG_HANDLEBARS_ELSE': |
| multi_parser.print_token(multi_parser.token_text); |
| if (multi_parser.indent_content) { |
| multi_parser.indent(); |
| multi_parser.indent_content = false; |
| } |
| multi_parser.current_mode = 'CONTENT'; |
| break; |
| case 'TK_CONTENT': |
| multi_parser.print_token(multi_parser.token_text); |
| multi_parser.current_mode = 'TAG'; |
| break; |
| case 'TK_STYLE': |
| case 'TK_SCRIPT': |
| if (multi_parser.token_text !== '') { |
| multi_parser.print_newline(false, multi_parser.output); |
| var text = multi_parser.token_text, |
| _beautifier, |
| script_indent_level = 1; |
| if (multi_parser.token_type === 'TK_SCRIPT') { |
| _beautifier = typeof js_beautify === 'function' && js_beautify; |
| } else if (multi_parser.token_type === 'TK_STYLE') { |
| _beautifier = typeof css_beautify === 'function' && css_beautify; |
| } |
| |
| if (options.indent_scripts === "keep") { |
| script_indent_level = 0; |
| } else if (options.indent_scripts === "separate") { |
| script_indent_level = -multi_parser.indent_level; |
| } |
| |
| var indentation = multi_parser.get_full_indent(script_indent_level); |
| if (_beautifier) { |
| // call the Beautifier if avaliable |
| text = _beautifier(text.replace(/^\s*/, indentation), options); |
| } else { |
| // simply indent the string otherwise |
| var white = text.match(/^\s*/)[0]; |
| var _level = white.match(/[^\n\r]*$/)[0].split(multi_parser.indent_string).length - 1; |
| var reindent = multi_parser.get_full_indent(script_indent_level - _level); |
| text = text.replace(/^\s*/, indentation) |
| .replace(/\r\n|\r|\n/g, '\n' + reindent) |
| .replace(/\s+$/, ''); |
| } |
| if (text) { |
| multi_parser.print_token_raw(indentation + trim(text)); |
| multi_parser.print_newline(false, multi_parser.output); |
| } |
| } |
| multi_parser.current_mode = 'TAG'; |
| break; |
| } |
| multi_parser.last_token = multi_parser.token_type; |
| multi_parser.last_text = multi_parser.token_text; |
| } |
| return multi_parser.output.join(''); |
| } |
