From a69152f7197b907e39ed663e9ddd5304165eb7a8 Mon Sep 17 00:00:00 2001 From: hyb1996 <946994919@qq.com> Date: Thu, 13 Sep 2018 09:09:28 +0800 Subject: [PATCH] opt(ui): use new js beautifier --- .../assets/js/js-beautify/core/directives.js | 62 + .../js/js-beautify/core/inputscanner.js | 148 ++ .../assets/js/js-beautify/core/options.js | 178 +++ .../main/assets/js/js-beautify/core/output.js | 315 ++++ .../main/assets/js/js-beautify/core/token.js | 54 + .../assets/js/js-beautify/core/tokenizer.js | 152 ++ .../assets/js/js-beautify/core/tokenstream.js | 78 + .../js/js-beautify/core/xml_formatter.js | 43 + app/src/main/assets/js/js-beautify/index.js | 40 + .../assets/js/js-beautify/javascript/acorn.js | 56 + .../js/js-beautify/javascript/beautifier.js | 1402 +++++++++++++++++ .../js/js-beautify/javascript/options.js | 91 ++ .../js/js-beautify/javascript/tokenizer.js | 543 +++++++ .../org/autojs/autojs/tool/ImageSelector.java | 17 +- .../autojs/autojs/ui/edit/EditActivity.java | 12 +- .../autojs/ui/edit/ViewSampleActivity.java | 13 +- .../autojs/ui/edit/editor/CodeEditor.java | 2 +- .../autojs/autojs/ui/main/MainActivity.java | 19 +- .../autojs/autojs/ui/user/WebActivity.java | 12 +- .../org/autojs/autojs/ui/widget/EWebView.java | 18 +- .../main/java/com/stardust/autojs/AutoJs.java | 6 +- .../capture/ScreenCaptureRequestActivity.java | 8 +- .../image/capture/ScreenCaptureRequester.java | 14 +- .../autojs/core/inputevent/RootAutomator.java | 12 +- .../AssetAndUrlModuleSourceProvider.java | 27 +- .../autojs/engine/RhinoJavaScriptEngine.java | 3 +- .../stardust/autojs/script/JsBeautifier.java | 45 +- ...ate.java => OnActivityResultListener.java} | 22 +- 28 files changed, 3284 insertions(+), 108 deletions(-) create mode 100644 app/src/main/assets/js/js-beautify/core/directives.js create mode 100644 app/src/main/assets/js/js-beautify/core/inputscanner.js create mode 100644 app/src/main/assets/js/js-beautify/core/options.js create mode 100644 app/src/main/assets/js/js-beautify/core/output.js create mode 100644 app/src/main/assets/js/js-beautify/core/token.js create mode 100644 app/src/main/assets/js/js-beautify/core/tokenizer.js create mode 100644 app/src/main/assets/js/js-beautify/core/tokenstream.js create mode 100644 app/src/main/assets/js/js-beautify/core/xml_formatter.js create mode 100644 app/src/main/assets/js/js-beautify/index.js create mode 100644 app/src/main/assets/js/js-beautify/javascript/acorn.js create mode 100644 app/src/main/assets/js/js-beautify/javascript/beautifier.js create mode 100644 app/src/main/assets/js/js-beautify/javascript/options.js create mode 100644 app/src/main/assets/js/js-beautify/javascript/tokenizer.js rename common/src/main/java/com/stardust/app/{OnActivityResultDelegate.java => OnActivityResultListener.java} (59%) diff --git a/app/src/main/assets/js/js-beautify/core/directives.js b/app/src/main/assets/js/js-beautify/core/directives.js new file mode 100644 index 00000000..22db1b32 --- /dev/null +++ b/app/src/main/assets/js/js-beautify/core/directives.js @@ -0,0 +1,62 @@ +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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. +*/ + +'use strict'; + +function Directives(start_block_pattern, end_block_pattern) { + start_block_pattern = typeof start_block_pattern === 'string' ? start_block_pattern : start_block_pattern.source; + end_block_pattern = typeof end_block_pattern === 'string' ? end_block_pattern : end_block_pattern.source; + this.__directives_block_pattern = new RegExp(start_block_pattern + / beautify( \w+[:]\w+)+ /.source + end_block_pattern, 'g'); + this.__directive_pattern = / (\w+)[:](\w+)/g; + + this.__directives_end_ignore_pattern = new RegExp('(?:[\\s\\S]*?)((?:' + start_block_pattern + /\sbeautify\signore:end\s/.source + end_block_pattern + ')|$)', 'g'); +} + +Directives.prototype.get_directives = function(text) { + if (!text.match(this.__directives_block_pattern)) { + return null; + } + + var directives = {}; + this.__directive_pattern.lastIndex = 0; + var directive_match = this.__directive_pattern.exec(text); + + while (directive_match) { + directives[directive_match[1]] = directive_match[2]; + directive_match = this.__directive_pattern.exec(text); + } + + return directives; +}; + +Directives.prototype.readIgnored = function(input) { + return input.read(this.__directives_end_ignore_pattern); +}; + + +module.exports.Directives = Directives; \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/core/inputscanner.js b/app/src/main/assets/js/js-beautify/core/inputscanner.js new file mode 100644 index 00000000..500dd9f4 --- /dev/null +++ b/app/src/main/assets/js/js-beautify/core/inputscanner.js @@ -0,0 +1,148 @@ +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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. +*/ + +'use strict'; + +function InputScanner(input_string) { + this.__input = input_string || ''; + this.__input_length = this.__input.length; + this.__position = 0; +} + +InputScanner.prototype.restart = function() { + this.__position = 0; +}; + +InputScanner.prototype.back = function() { + if (this.__position > 0) { + this.__position -= 1; + } +}; + +InputScanner.prototype.hasNext = function() { + return this.__position < this.__input_length; +}; + +InputScanner.prototype.next = function() { + var val = null; + if (this.hasNext()) { + val = this.__input.charAt(this.__position); + this.__position += 1; + } + return val; +}; + +InputScanner.prototype.peek = function(index) { + var val = null; + index = index || 0; + index += this.__position; + if (index >= 0 && index < this.__input_length) { + val = this.__input.charAt(index); + } + return val; +}; + +InputScanner.prototype.test = function(pattern, index) { + index = index || 0; + index += this.__position; + pattern.lastIndex = index; + + if (index >= 0 && index < this.__input_length) { + var pattern_match = pattern.exec(this.__input); + return pattern_match && pattern_match.index === index; + } else { + return false; + } +}; + +InputScanner.prototype.testChar = function(pattern, index) { + // test one character regex match + var val = this.peek(index); + return val !== null && pattern.test(val); +}; + +InputScanner.prototype.match = function(pattern) { + pattern.lastIndex = this.__position; + var pattern_match = pattern.exec(this.__input); + if (pattern_match && pattern_match.index === this.__position) { + this.__position += pattern_match[0].length; + } else { + pattern_match = null; + } + return pattern_match; +}; + +InputScanner.prototype.read = function(pattern) { + var val = ''; + var match = this.match(pattern); + if (match) { + val = match[0]; + } + return val; +}; + +InputScanner.prototype.readUntil = function(pattern, include_match) { + var val = ''; + var match_index = this.__position; + pattern.lastIndex = this.__position; + var pattern_match = pattern.exec(this.__input); + if (pattern_match) { + if (include_match) { + match_index = pattern_match.index + pattern_match[0].length; + } else { + match_index = pattern_match.index; + } + } else { + match_index = this.__input_length; + } + + val = this.__input.substring(this.__position, match_index); + this.__position = match_index; + return val; +}; + +InputScanner.prototype.readUntilAfter = function(pattern) { + return this.readUntil(pattern, true); +}; + +/* css beautifier legacy helpers */ +InputScanner.prototype.peekUntilAfter = function(pattern) { + var start = this.__position; + var val = this.readUntilAfter(pattern); + this.__position = start; + return val; +}; + +InputScanner.prototype.lookBack = function(testVal) { + var start = this.__position - 1; + return start >= testVal.length && this.__input.substring(start - testVal.length, start) + .toLowerCase() === testVal; +}; + + +module.exports.InputScanner = InputScanner; \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/core/options.js b/app/src/main/assets/js/js-beautify/core/options.js new file mode 100644 index 00000000..2bd44ceb --- /dev/null +++ b/app/src/main/assets/js/js-beautify/core/options.js @@ -0,0 +1,178 @@ +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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. +*/ + +'use strict'; + +function Options(options, merge_child_field) { + options = _mergeOpts(options, merge_child_field); + this.raw_options = _normalizeOpts(options); + + // Support passing the source text back with no change + this.disabled = this._get_boolean('disabled'); + + this.eol = this._get_characters('eol', 'auto'); + this.end_with_newline = this._get_boolean('end_with_newline'); + this.indent_size = this._get_number('indent_size', 4); + this.indent_char = this._get_characters('indent_char', ' '); + this.indent_level = this._get_number('indent_level'); + + this.preserve_newlines = this._get_boolean('preserve_newlines', true); + this.max_preserve_newlines = this._get_number('max_preserve_newlines', 32786); + if (!this.preserve_newlines) { + this.max_preserve_newlines = 0; + } + + this.indent_with_tabs = this._get_boolean('indent_with_tabs'); + if (this.indent_with_tabs) { + this.indent_char = '\t'; + this.indent_size = 1; + } + + // Backwards compat with 1.3.x + this.wrap_line_length = this._get_number('wrap_line_length', this._get_number('max_char')); + +} + +Options.prototype._get_array = function(name, default_value) { + var option_value = this.raw_options[name]; + var result = default_value || []; + if (typeof option_value === 'object') { + if (option_value !== null && typeof option_value.concat === 'function') { + result = option_value.concat(); + } + } else if (typeof option_value === 'string') { + result = option_value.split(/[^a-zA-Z0-9_\/\-]+/); + } + return result; +}; + +Options.prototype._get_boolean = function(name, default_value) { + var option_value = this.raw_options[name]; + var result = option_value === undefined ? !!default_value : !!option_value; + return result; +}; + +Options.prototype._get_characters = function(name, default_value) { + var option_value = this.raw_options[name]; + var result = default_value || ''; + if (typeof option_value === 'string') { + result = option_value.replace(/\\r/, '\r').replace(/\\n/, '\n').replace(/\\t/, '\t'); + } + return result; +}; + +Options.prototype._get_number = function(name, default_value) { + var option_value = this.raw_options[name]; + default_value = parseInt(default_value, 10); + if (isNaN(default_value)) { + default_value = 0; + } + var result = parseInt(option_value, 10); + if (isNaN(result)) { + result = default_value; + } + return result; +}; + +Options.prototype._get_selection = function(name, selection_list, default_value) { + var result = this._get_selection_list(name, selection_list, default_value); + if (result.length !== 1) { + throw new Error( + "Invalid Option Value: The option '" + name + "' can only be one of the following values:\n" + + selection_list + "\nYou passed in: '" + this.raw_options[name] + "'"); + } + + return result[0]; +}; + + +Options.prototype._get_selection_list = function(name, selection_list, default_value) { + if (!selection_list || selection_list.length === 0) { + throw new Error("Selection list cannot be empty."); + } + + default_value = default_value || [selection_list[0]]; + if (!this._is_valid_selection(default_value, selection_list)) { + throw new Error("Invalid Default Value!"); + } + + var result = this._get_array(name, default_value); + if (!this._is_valid_selection(result, selection_list)) { + throw new Error( + "Invalid Option Value: The option '" + name + "' can contain only the following values:\n" + + selection_list + "\nYou passed in: '" + this.raw_options[name] + "'"); + } + + return result; +}; + +Options.prototype._is_valid_selection = function(result, selection_list) { + return result.length && selection_list.length && + !result.some(function(item) { return selection_list.indexOf(item) === -1; }); +}; + + +// merges child options up with the parent options object +// Example: obj = {a: 1, b: {a: 2}} +// mergeOpts(obj, 'b') +// +// Returns: {a: 2, b: {a: 2}} +function _mergeOpts(allOptions, childFieldName) { + var finalOpts = {}; + allOptions = allOptions || {}; + var name; + + for (name in allOptions) { + if (name !== childFieldName) { + finalOpts[name] = allOptions[name]; + } + } + + //merge in the per type settings for the childFieldName + if (childFieldName && allOptions[childFieldName]) { + for (name in allOptions[childFieldName]) { + finalOpts[name] = allOptions[childFieldName][name]; + } + } + return finalOpts; +} + +function _normalizeOpts(options) { + var convertedOpts = {}; + var key; + + for (key in options) { + var newKey = key.replace(/-/g, "_"); + convertedOpts[newKey] = options[key]; + } + return convertedOpts; +} + +module.exports.Options = Options; +module.exports.normalizeOpts = _normalizeOpts; +module.exports.mergeOpts = _mergeOpts; \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/core/output.js b/app/src/main/assets/js/js-beautify/core/output.js new file mode 100644 index 00000000..428f4a46 --- /dev/null +++ b/app/src/main/assets/js/js-beautify/core/output.js @@ -0,0 +1,315 @@ +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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. +*/ + +'use strict'; +var TOKEN = require('javascript/tokenizer').TOKEN; + + +function OutputLine(parent) { + this.__parent = parent; + this.__character_count = 0; + // use indent_count as a marker for this.__lines that have preserved indentation + this.__indent_count = -1; + this.__alignment_count = 0; + + this.__items = []; +} + +OutputLine.prototype.item = function(index) { + if (index < 0) { + return this.__items[this.__items.length + index]; + } else { + return this.__items[index]; + } +}; + +OutputLine.prototype.has_match = function(pattern) { + for (var lastCheckedOutput = this.__items.length - 1; lastCheckedOutput >= 0; lastCheckedOutput--) { + if (this.__items[lastCheckedOutput].match(pattern)) { + return true; + } + } + return false; +}; + +OutputLine.prototype.set_indent = function(indent, alignment) { + this.__indent_count = indent || 0; + this.__alignment_count = alignment || 0; + this.__character_count = this.__parent.baseIndentLength + this.__alignment_count + this.__indent_count * this.__parent.indent_length; +}; + +OutputLine.prototype.get_character_count = function() { + return this.__character_count; +}; + +OutputLine.prototype.is_empty = function() { + return this.__items.length === 0; +}; + +OutputLine.prototype.last = function() { + if (!this.is_empty()) { + return this.__items[this.__items.length - 1]; + } else { + return null; + } +}; + +OutputLine.prototype.push = function(item) { + this.__items.push(item); + this.__character_count += item.length; +}; + +OutputLine.prototype.push_raw = function(item) { + this.push(item); + var last_newline_index = item.lastIndexOf('\n'); + if (last_newline_index !== -1) { + this.__character_count = item.length - last_newline_index; + } +}; + +OutputLine.prototype.pop = function() { + var item = null; + if (!this.is_empty()) { + item = this.__items.pop(); + this.__character_count -= item.length; + } + return item; +}; + +OutputLine.prototype.remove_indent = function() { + if (this.__indent_count > 0) { + this.__indent_count -= 1; + this.__character_count -= this.__parent.indent_length; + } +}; + +OutputLine.prototype.trim = function() { + while (this.last() === ' ') { + this.__items.pop(); + this.__character_count -= 1; + } +}; + +OutputLine.prototype.toString = function() { + var result = ''; + if (!this.is_empty()) { + if (this.__indent_count >= 0) { + result = this.__parent.get_indent_string(this.__indent_count); + } + if (this.__alignment_count >= 0) { + result += this.__parent.get_alignment_string(this.__alignment_count); + } + result += this.__items.join(''); + } + return result; +}; + +function IndentCache(base_string, level_string) { + this.__cache = [base_string]; + this.__level_string = level_string; +} + +IndentCache.prototype.__ensure_cache = function(level) { + while (level >= this.__cache.length) { + this.__cache.push(this.__cache[this.__cache.length - 1] + this.__level_string); + } +}; + +IndentCache.prototype.get_level_string = function(level) { + this.__ensure_cache(level); + return this.__cache[level]; +}; + + +function Output(options, baseIndentString) { + var indent_string = options.indent_char; + if (options.indent_size > 1) { + indent_string = new Array(options.indent_size + 1).join(options.indent_char); + } + + // Set to null to continue support for auto detection of base indent level. + baseIndentString = baseIndentString || ''; + if (options.indent_level > 0) { + baseIndentString = new Array(options.indent_level + 1).join(indent_string); + } + + this.__indent_cache = new IndentCache(baseIndentString, indent_string); + this.__alignment_cache = new IndentCache('', ' '); + this.baseIndentLength = baseIndentString.length; + this.indent_length = indent_string.length; + this.raw = false; + this._end_with_newline = options.end_with_newline; + + this.__lines = []; + this.previous_line = null; + this.current_line = null; + this.space_before_token = false; + // initialize + this.__add_outputline(); +} + +Output.prototype.__add_outputline = function() { + this.previous_line = this.current_line; + this.current_line = new OutputLine(this); + this.__lines.push(this.current_line); +}; + +Output.prototype.get_line_number = function() { + return this.__lines.length; +}; + +Output.prototype.get_indent_string = function(level) { + return this.__indent_cache.get_level_string(level); +}; + +Output.prototype.get_alignment_string = function(level) { + return this.__alignment_cache.get_level_string(level); +}; + +Output.prototype.is_empty = function() { + return !this.previous_line && this.current_line.is_empty(); +}; + +Output.prototype.add_new_line = function(force_newline) { + // never newline at the start of file + // otherwise, newline only if we didn't just add one or we're forced + if (this.is_empty() || + (!force_newline && this.just_added_newline())) { + return false; + } + + // if raw output is enabled, don't print additional newlines, + // but still return True as though you had + if (!this.raw) { + this.__add_outputline(); + } + return true; +}; + +Output.prototype.get_code = function(eol) { + var sweet_code = this.__lines.join('\n').replace(/[\r\n\t ]+$/, ''); + + if (this._end_with_newline) { + sweet_code += '\n'; + } + + if (eol !== '\n') { + sweet_code = sweet_code.replace(/[\n]/g, eol); + } + + return sweet_code; +}; + +Output.prototype.set_indent = function(indent, alignment) { + indent = indent || 0; + alignment = alignment || 0; + + // Never indent your first output indent at the start of the file + if (this.__lines.length > 1) { + this.current_line.set_indent(indent, alignment); + return true; + } + this.current_line.set_indent(); + return false; +}; + +Output.prototype.add_raw_token = function(token) { + for (var x = 0; x < token.newlines; x++) { + this.__add_outputline(); + } + this.current_line.push(token.whitespace_before); + this.current_line.push_raw(token.text); + this.space_before_token = false; +}; + +Output.prototype.add_token = function(printable_token) { + this.add_space_before_token(); + if(printable_token.type == TOKEN.XML){ + var indent = this.get_indent_string(this.current_line.__indent_count); + printable_token.text = printable_token.text.replace('\n', '\n' + indent); + } + this.current_line.push(printable_token); +}; + +Output.prototype.add_space_before_token = function() { + if (this.space_before_token && !this.just_added_newline()) { + this.current_line.push(' '); + } + this.space_before_token = false; +}; + +Output.prototype.remove_indent = function(index) { + var output_length = this.__lines.length; + while (index < output_length) { + this.__lines[index].remove_indent(); + index++; + } +}; + +Output.prototype.trim = function(eat_newlines) { + eat_newlines = (eat_newlines === undefined) ? false : eat_newlines; + + this.current_line.trim(this.indent_string, this.baseIndentString); + + while (eat_newlines && this.__lines.length > 1 && + this.current_line.is_empty()) { + this.__lines.pop(); + this.current_line = this.__lines[this.__lines.length - 1]; + this.current_line.trim(); + } + + this.previous_line = this.__lines.length > 1 ? + this.__lines[this.__lines.length - 2] : null; +}; + +Output.prototype.just_added_newline = function() { + return this.current_line.is_empty(); +}; + +Output.prototype.just_added_blankline = function() { + return this.is_empty() || + (this.current_line.is_empty() && this.previous_line.is_empty()); +}; + +Output.prototype.ensure_empty_line_above = function(starts_with, ends_with) { + var index = this.__lines.length - 2; + while (index >= 0) { + var potentialEmptyLine = this.__lines[index]; + if (potentialEmptyLine.is_empty()) { + break; + } else if (potentialEmptyLine.item(0).indexOf(starts_with) !== 0 && + potentialEmptyLine.item(-1) !== ends_with) { + this.__lines.splice(index + 1, 0, new OutputLine(this)); + this.previous_line = this.__lines[this.__lines.length - 2]; + break; + } + index--; + } +}; + +module.exports.Output = Output; \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/core/token.js b/app/src/main/assets/js/js-beautify/core/token.js new file mode 100644 index 00000000..3ccd0c33 --- /dev/null +++ b/app/src/main/assets/js/js-beautify/core/token.js @@ -0,0 +1,54 @@ +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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. +*/ + +'use strict'; + +function Token(type, text, newlines, whitespace_before) { + this.type = type; + this.text = text; + + // comments_before are + // comments that have a new line before them + // and may or may not have a newline after + // this is a set of comments before + this.comments_before = null; /* inline comment*/ + + + // this.comments_after = new TokenStream(); // no new line before and newline after + this.newlines = newlines || 0; + this.whitespace_before = whitespace_before || ''; + this.parent = null; + this.next = null; + this.previous = null; + this.opened = null; + this.closed = null; + this.directives = null; +} + + +module.exports.Token = Token; \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/core/tokenizer.js b/app/src/main/assets/js/js-beautify/core/tokenizer.js new file mode 100644 index 00000000..52f51458 --- /dev/null +++ b/app/src/main/assets/js/js-beautify/core/tokenizer.js @@ -0,0 +1,152 @@ +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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. +*/ + +'use strict'; + +var InputScanner = require('core/inputscanner').InputScanner; +var Token = require('core/token').Token; +var TokenStream = require('core/tokenstream').TokenStream; + +var TOKEN = { + START: 'TK_START', + RAW: 'TK_RAW', + EOF: 'TK_EOF' +}; + +var Tokenizer = function(input_string, options) { + this._input = new InputScanner(input_string); + this._options = options || {}; + this.__tokens = null; + this.__newline_count = 0; + this.__whitespace_before_token = ''; + + this._whitespace_pattern = /[\n\r\t ]+/g; + this._newline_pattern = /([^\n\r]*)(\r\n|[\n\r])?/g; +}; + +Tokenizer.prototype.tokenize = function() { + this._input.restart(); + this.__tokens = new TokenStream(); + + this._reset(); + + var current; + var previous = new Token(TOKEN.START, ''); + var open_token = null; + var open_stack = []; + var comments = new TokenStream(); + + while (previous.type !== TOKEN.EOF) { + current = this._get_next_token(previous, open_token); + while (this._is_comment(current)) { + comments.add(current); + current = this._get_next_token(previous, open_token); + } + + if (!comments.isEmpty()) { + current.comments_before = comments; + comments = new TokenStream(); + } + + current.parent = open_token; + + if (this._is_opening(current)) { + open_stack.push(open_token); + open_token = current; + } else if (open_token && this._is_closing(current, open_token)) { + current.opened = open_token; + open_token.closed = current; + open_token = open_stack.pop(); + current.parent = open_token; + } + + current.previous = previous; + previous.next = current; + + this.__tokens.add(current); + previous = current; + } + + return this.__tokens; +}; + + +Tokenizer.prototype._is_first_token = function() { + return this.__tokens.isEmpty(); +}; + +Tokenizer.prototype._reset = function() {}; + +Tokenizer.prototype._get_next_token = function(previous_token, open_token) { // jshint unused:false + this._readWhitespace(); + var resulting_string = this._input.read(/.+/g); + if (resulting_string) { + return this._create_token(TOKEN.RAW, resulting_string); + } else { + return this._create_token(TOKEN.EOF, ''); + } +}; + +Tokenizer.prototype._is_comment = function(current_token) { // jshint unused:false + return false; +}; + +Tokenizer.prototype._is_opening = function(current_token) { // jshint unused:false + return false; +}; + +Tokenizer.prototype._is_closing = function(current_token, open_token) { // jshint unused:false + return false; +}; + +Tokenizer.prototype._create_token = function(type, text) { + var token = new Token(type, text, this.__newline_count, this.__whitespace_before_token); + this.__newline_count = 0; + this.__whitespace_before_token = ''; + return token; +}; + +Tokenizer.prototype._readWhitespace = function() { + var resulting_string = this._input.read(this._whitespace_pattern); + if (resulting_string === ' ') { + this.__whitespace_before_token = resulting_string; + } else if (resulting_string !== '') { + this._newline_pattern.lastIndex = 0; + var nextMatch = this._newline_pattern.exec(resulting_string); + while (nextMatch[2]) { + this.__newline_count += 1; + nextMatch = this._newline_pattern.exec(resulting_string); + } + this.__whitespace_before_token = nextMatch[1]; + } +}; + + + +module.exports.Tokenizer = Tokenizer; +module.exports.TOKEN = TOKEN; \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/core/tokenstream.js b/app/src/main/assets/js/js-beautify/core/tokenstream.js new file mode 100644 index 00000000..4ec3df6d --- /dev/null +++ b/app/src/main/assets/js/js-beautify/core/tokenstream.js @@ -0,0 +1,78 @@ +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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. +*/ + +'use strict'; + +function TokenStream(parent_token) { + // private + this.__tokens = []; + this.__tokens_length = this.__tokens.length; + this.__position = 0; + this.__parent_token = parent_token; +} + +TokenStream.prototype.restart = function() { + this.__position = 0; +}; + +TokenStream.prototype.isEmpty = function() { + return this.__tokens_length === 0; +}; + +TokenStream.prototype.hasNext = function() { + return this.__position < this.__tokens_length; +}; + +TokenStream.prototype.next = function() { + var val = null; + if (this.hasNext()) { + val = this.__tokens[this.__position]; + this.__position += 1; + } + return val; +}; + +TokenStream.prototype.peek = function(index) { + var val = null; + index = index || 0; + index += this.__position; + if (index >= 0 && index < this.__tokens_length) { + val = this.__tokens[index]; + } + return val; +}; + +TokenStream.prototype.add = function(token) { + if (this.__parent_token) { + token.parent = this.__parent_token; + } + this.__tokens.push(token); + this.__tokens_length += 1; +}; + +module.exports.TokenStream = TokenStream; \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/core/xml_formatter.js b/app/src/main/assets/js/js-beautify/core/xml_formatter.js new file mode 100644 index 00000000..38400df0 --- /dev/null +++ b/app/src/main/assets/js/js-beautify/core/xml_formatter.js @@ -0,0 +1,43 @@ + +const stringTimesN = (n, char) => Array(n + 1).join(char) + +// Adapted from https://gist.github.com/sente/1083506 +function prettifyXml(xmlInput, options) { + options = options || {}; + let newlineOption = options.newline || '\n'; + let indentOption = options.indent || 2; + let margin = options.margin || ''; + const indentString = stringTimesN(indentOption, ' ') + + let formatted = ''; + const regex = /(>)(<)(\/*)/g; + const xml = xmlInput.replace(regex, '$1' + newlineOption + '$2$3'); + let pad = 0; + xml.split(/\r?\n/).forEach(l => { + const line = l.trim(); + + let indent = 0; + if (line.match(/.+<\/\w[^>]*>$/)) { + indent = 0; + } else if (line.match(/^<\/\w/)) { + // Somehow istanbul doesn't see the else case as covered, although it is. Skip it. + /* istanbul ignore else */ + if (pad !== 0) { + pad -= 1 + } + } else if (line.match(/^<\w([^>]*[^\/])?>.*$/)) { + indent = 1 + } else { + indent = 0 + } + + const padding = stringTimesN(pad, indentString) + formatted += margin + padding + line + newlineOption // eslint-disable-line prefer-template + pad += indent + }) + + return formatted.trim() +} + +// For non-es2015 usage +module.exports = prettifyXml \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/index.js b/app/src/main/assets/js/js-beautify/index.js new file mode 100644 index 00000000..e7c0898a --- /dev/null +++ b/app/src/main/assets/js/js-beautify/index.js @@ -0,0 +1,40 @@ +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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. +*/ + +'use strict'; + +var Beautifier = require('javascript/beautifier').Beautifier; + +function js_beautify(js_source_text) { + var beautifier = new Beautifier(js_source_text, { + e4x: true + }); + return beautifier.beautify(); +} + +//module.exports = js_beautify; \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/javascript/acorn.js b/app/src/main/assets/js/js-beautify/javascript/acorn.js new file mode 100644 index 00000000..e8b158fc --- /dev/null +++ b/app/src/main/assets/js/js-beautify/javascript/acorn.js @@ -0,0 +1,56 @@ +/* jshint node: true, curly: false */ +// Parts of this section of code is taken from acorn. +// +// Acorn was written by Marijn Haverbeke and released under an MIT +// license. The Unicode regexps (for identifiers and whitespace) were +// taken from [Esprima](http://esprima.org) by Ariya Hidayat. +// +// Git repositories for Acorn are available at +// +// http://marijnhaverbeke.nl/git/acorn +// https://github.com/marijnh/acorn.git + +// ## Character categories + + +'use strict'; + +// acorn used char codes to squeeze the last bit of performance out +// Beautifier is okay without that, so we're using regex +// permit $ (36) and @ (64). @ is used in ES7 decorators. +// 65 through 91 are uppercase letters. +// permit _ (95). +// 97 through 123 are lowercase letters. +var baseASCIIidentifierStartChars = "\x24\x40\x41-\x5a\x5f\x61-\x7a"; + +// inside an identifier @ is not allowed but 0-9 are. +var baseASCIIidentifierChars = "\x24\x30-\x39\x41-\x5a\x5f\x61-\x7a"; + +// Big ugly regular expressions that match characters in the +// whitespace, identifier, and identifier-start categories. These +// are only applied when a character is found to actually have a +// code point above 128. +var nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc"; +var nonASCIIidentifierChars = "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f"; +//var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]"); +//var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]"); + +var identifierStart = "[" + baseASCIIidentifierStartChars + nonASCIIidentifierStartChars + "]"; +var identifierChars = "[" + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]*"; + +exports.identifier = new RegExp(identifierStart + identifierChars, 'g'); + + +var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/; // jshint ignore:line + +// Whether a single character denotes a newline. + +exports.newline = /[\n\r\u2028\u2029]/; + +// Matches a whole line break (where CRLF is considered a single +// line break). Used to count lines. + +// in javascript, these two differ +// in python they are the same, different methods are called on them +exports.lineBreak = new RegExp('\r\n|' + exports.newline.source); +exports.allLineBreaks = new RegExp(exports.lineBreak.source, 'g'); \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/javascript/beautifier.js b/app/src/main/assets/js/js-beautify/javascript/beautifier.js new file mode 100644 index 00000000..ee628646 --- /dev/null +++ b/app/src/main/assets/js/js-beautify/javascript/beautifier.js @@ -0,0 +1,1402 @@ +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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. +*/ + +'use strict'; + +var Output = require('core/output').Output; +var Token = require('core/token').Token; +var acorn = require('javascript/acorn'); +var Options = require('javascript/options').Options; +var Tokenizer = require('javascript/tokenizer').Tokenizer; +var line_starters = require('javascript/tokenizer').line_starters; +var positionable_operators = require('javascript/tokenizer').positionable_operators; +var TOKEN = require('javascript/tokenizer').TOKEN; + +function remove_redundant_indentation(output, frame) { + // This implementation is effective but has some issues: + // - can cause line wrap to happen too soon due to indent removal + // after wrap points are calculated + // These issues are minor compared to ugly indentation. + + if (frame.multiline_frame || + frame.mode === MODE.ForInitializer || + frame.mode === MODE.Conditional) { + return; + } + + // remove one indent from each line inside this section + output.remove_indent(frame.start_line_index); +} + +function in_array(what, arr) { + return arr.indexOf(what) !== -1; +} + +function ltrim(s) { + return s.replace(/^\s+/g, ''); +} + +function generateMapFromStrings(list) { + var result = {}; + for (var x = 0; x < list.length; x++) { + // make the mapped names underscored instead of dash + result[list[x].replace(/-/g, '_')] = list[x]; + } + return result; +} + +function reserved_word(token, word) { + return token && token.type === TOKEN.RESERVED && token.text === word; +} + +function reserved_array(token, words) { + return token && token.type === TOKEN.RESERVED && in_array(token.text, words); +} +// Unsure of what they mean, but they work. Worth cleaning up in future. +var special_words = ['case', 'return', 'do', 'if', 'throw', 'else', 'await', 'break', 'continue', 'async']; + +var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline']; + +// Generate map from array +var OPERATOR_POSITION = generateMapFromStrings(validPositionValues); + +var OPERATOR_POSITION_BEFORE_OR_PRESERVE = [OPERATOR_POSITION.before_newline, OPERATOR_POSITION.preserve_newline]; + +var MODE = { + BlockStatement: 'BlockStatement', // 'BLOCK' + Statement: 'Statement', // 'STATEMENT' + ObjectLiteral: 'ObjectLiteral', // 'OBJECT', + ArrayLiteral: 'ArrayLiteral', //'[EXPRESSION]', + ForInitializer: 'ForInitializer', //'(FOR-EXPRESSION)', + Conditional: 'Conditional', //'(COND-EXPRESSION)', + Expression: 'Expression' //'(EXPRESSION)' +}; + +// we could use just string.split, but +// IE doesn't like returning empty strings +function split_linebreaks(s) { + //return s.split(/\x0d\x0a|\x0a/); + + s = s.replace(acorn.allLineBreaks, '\n'); + var out = [], + idx = s.indexOf("\n"); + while (idx !== -1) { + out.push(s.substring(0, idx)); + s = s.substring(idx + 1); + idx = s.indexOf("\n"); + } + if (s.length) { + out.push(s); + } + return out; +} + +function is_array(mode) { + return mode === MODE.ArrayLiteral; +} + +function is_expression(mode) { + return in_array(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]); +} + +function all_lines_start_with(lines, c) { + for (var i = 0; i < lines.length; i++) { + var line = lines[i].trim(); + if (line.charAt(0) !== c) { + return false; + } + } + return true; +} + +function each_line_matches_indent(lines, indent) { + var i = 0, + len = lines.length, + line; + for (; i < len; i++) { + line = lines[i]; + // allow empty lines to pass through + if (line && line.indexOf(indent) !== 0) { + return false; + } + } + return true; +} + + +function Beautifier(source_text, options) { + options = options || {}; + this._source_text = source_text || ''; + + this._output = null; + this._tokens = null; + this._last_last_text = null; + this._flags = null; + this._previous_flags = null; + + this._flag_store = null; + this._options = new Options(options); +} + +Beautifier.prototype.create_flags = function(flags_base, mode) { + var next_indent_level = 0; + if (flags_base) { + next_indent_level = flags_base.indentation_level; + if (!this._output.just_added_newline() && + flags_base.line_indent_level > next_indent_level) { + next_indent_level = flags_base.line_indent_level; + } + } + + var next_flags = { + mode: mode, + parent: flags_base, + last_token: flags_base ? flags_base.last_token : new Token(TOKEN.START_BLOCK, ''), // last token text + last_word: flags_base ? flags_base.last_word : '', // last TOKEN.WORD passed + declaration_statement: false, + declaration_assignment: false, + multiline_frame: false, + inline_frame: false, + if_block: false, + else_block: false, + do_block: false, + do_while: false, + import_block: false, + in_case_statement: false, // switch(..){ INSIDE HERE } + in_case: false, // we're on the exact line with "case 0:" + case_body: false, // the indented case-action block + indentation_level: next_indent_level, + line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level, + start_line_index: this._output.get_line_number(), + ternary_depth: 0 + }; + return next_flags; +}; + +Beautifier.prototype._reset = function(source_text) { + var baseIndentString = source_text.match(/^[\t ]*/)[0]; + + this._last_last_text = ''; // pre-last token text + this._output = new Output(this._options, baseIndentString); + + // If testing the ignore directive, start with output disable set to true + this._output.raw = this._options.test_output_raw; + + + // Stack of parsing/formatting states, including MODE. + // We tokenize, parse, and output in an almost purely a forward-only stream of token input + // and formatted output. This makes the beautifier less accurate than full parsers + // but also far more tolerant of syntax errors. + // + // For example, the default mode is MODE.BlockStatement. If we see a '{' we push a new frame of type + // MODE.BlockStatement on the the stack, even though it could be object literal. If we later + // encounter a ":", we'll switch to to MODE.ObjectLiteral. If we then see a ";", + // most full parsers would die, but the beautifier gracefully falls back to + // MODE.BlockStatement and continues on. + this._flag_store = []; + this.set_mode(MODE.BlockStatement); + var tokenizer = new Tokenizer(source_text, this._options); + this._tokens = tokenizer.tokenize(); + return source_text; +}; + +Beautifier.prototype.beautify = function() { + // if disabled, return the input unchanged. + if (this._options.disabled) { + return this._source_text; + } + + var sweet_code; + var source_text = this._reset(this._source_text); + + var eol = this._options.eol; + if (this._options.eol === 'auto') { + eol = '\n'; + if (source_text && acorn.lineBreak.test(source_text || '')) { + eol = source_text.match(acorn.lineBreak)[0]; + } + } + + var current_token = this._tokens.next(); + while (current_token) { + this.handle_token(current_token); + + this._last_last_text = this._flags.last_token.text; + this._flags.last_token = current_token; + + current_token = this._tokens.next(); + } + + sweet_code = this._output.get_code(eol); + + return sweet_code; +}; + +Beautifier.prototype.handle_token = function(current_token, preserve_statement_flags) { + if (current_token.type === TOKEN.START_EXPR) { + this.handle_start_expr(current_token); + } else if (current_token.type === TOKEN.END_EXPR) { + this.handle_end_expr(current_token); + } else if (current_token.type === TOKEN.START_BLOCK) { + this.handle_start_block(current_token); + } else if (current_token.type === TOKEN.END_BLOCK) { + this.handle_end_block(current_token); + } else if (current_token.type === TOKEN.WORD) { + this.handle_word(current_token); + } else if (current_token.type === TOKEN.RESERVED) { + this.handle_word(current_token); + } else if (current_token.type === TOKEN.SEMICOLON) { + this.handle_semicolon(current_token); + } else if (current_token.type === TOKEN.STRING) { + this.handle_string(current_token); + } else if (current_token.type === TOKEN.XML) { + this.handle_xml(current_token); + } else if (current_token.type === TOKEN.EQUALS) { + this.handle_equals(current_token); + } else if (current_token.type === TOKEN.OPERATOR) { + this.handle_operator(current_token); + } else if (current_token.type === TOKEN.COMMA) { + this.handle_comma(current_token); + } else if (current_token.type === TOKEN.BLOCK_COMMENT) { + this.handle_block_comment(current_token, preserve_statement_flags); + } else if (current_token.type === TOKEN.COMMENT) { + this.handle_comment(current_token, preserve_statement_flags); + } else if (current_token.type === TOKEN.DOT) { + this.handle_dot(current_token); + } else if (current_token.type === TOKEN.EOF) { + this.handle_eof(current_token); + } else if (current_token.type === TOKEN.UNKNOWN) { + this.handle_unknown(current_token, preserve_statement_flags); + } else { + this.handle_unknown(current_token, preserve_statement_flags); + } +}; + +Beautifier.prototype.handle_whitespace_and_comments = function(current_token, preserve_statement_flags) { + var newlines = current_token.newlines; + var keep_whitespace = this._options.keep_array_indentation && is_array(this._flags.mode); + + if (current_token.comments_before) { + var comment_token = current_token.comments_before.next(); + while (comment_token) { + // The cleanest handling of inline comments is to treat them as though they aren't there. + // Just continue formatting and the behavior should be logical. + // Also ignore unknown tokens. Again, this should result in better behavior. + this.handle_whitespace_and_comments(comment_token, preserve_statement_flags); + this.handle_token(comment_token, preserve_statement_flags); + comment_token = current_token.comments_before.next(); + } + } + + if (keep_whitespace) { + for (var i = 0; i < newlines; i += 1) { + this.print_newline(i > 0, preserve_statement_flags); + } + } else { + if (this._options.max_preserve_newlines && newlines > this._options.max_preserve_newlines) { + newlines = this._options.max_preserve_newlines; + } + + if (this._options.preserve_newlines) { + if (newlines > 1) { + this.print_newline(false, preserve_statement_flags); + for (var j = 1; j < newlines; j += 1) { + this.print_newline(true, preserve_statement_flags); + } + } + } + } + +}; + +var newline_restricted_tokens = ['async', 'break', 'continue', 'return', 'throw', 'yield']; + +Beautifier.prototype.allow_wrap_or_preserved_newline = function(current_token, force_linewrap) { + force_linewrap = (force_linewrap === undefined) ? false : force_linewrap; + + // Never wrap the first token on a line + if (this._output.just_added_newline()) { + return; + } + + var shouldPreserveOrForce = (this._options.preserve_newlines && current_token.newlines) || force_linewrap; + var operatorLogicApplies = in_array(this._flags.last_token.text, positionable_operators) || + in_array(current_token.text, positionable_operators); + + if (operatorLogicApplies) { + var shouldPrintOperatorNewline = ( + in_array(this._flags.last_token.text, positionable_operators) && + in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE) + ) || + in_array(current_token.text, positionable_operators); + shouldPreserveOrForce = shouldPreserveOrForce && shouldPrintOperatorNewline; + } + + if (shouldPreserveOrForce) { + this.print_newline(false, true); + } else if (this._options.wrap_line_length) { + if (reserved_array(this._flags.last_token, newline_restricted_tokens)) { + // These tokens should never have a newline inserted + // between them and the following expression. + return; + } + var proposed_line_length = this._output.current_line.get_character_count() + current_token.text.length + + (this._output.space_before_token ? 1 : 0); + if (proposed_line_length >= this._options.wrap_line_length) { + this.print_newline(false, true); + } + } +}; + +Beautifier.prototype.print_newline = function(force_newline, preserve_statement_flags) { + if (!preserve_statement_flags) { + if (this._flags.last_token.text !== ';' && this._flags.last_token.text !== ',' && this._flags.last_token.text !== '=' && (this._flags.last_token.type !== TOKEN.OPERATOR || this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) { + var next_token = this._tokens.peek(); + while (this._flags.mode === MODE.Statement && + !(this._flags.if_block && reserved_word(next_token, 'else')) && + !this._flags.do_block) { + this.restore_mode(); + } + } + } + + if (this._output.add_new_line(force_newline)) { + this._flags.multiline_frame = true; + } +}; + +Beautifier.prototype.print_token_line_indentation = function(current_token) { + if (this._output.just_added_newline()) { + if (this._options.keep_array_indentation && is_array(this._flags.mode) && current_token.newlines) { + this._output.current_line.push(current_token.whitespace_before); + this._output.space_before_token = false; + } else if (this._output.set_indent(this._flags.indentation_level)) { + this._flags.line_indent_level = this._flags.indentation_level; + } + } +}; + +Beautifier.prototype.print_token = function(current_token, printable_token) { + if (this._output.raw) { + this._output.add_raw_token(current_token); + return; + } + + if (this._options.comma_first && current_token.previous && current_token.previous.type === TOKEN.COMMA && + this._output.just_added_newline()) { + if (this._output.previous_line.last() === ',') { + var popped = this._output.previous_line.pop(); + // if the comma was already at the start of the line, + // pull back onto that line and reprint the indentation + if (this._output.previous_line.is_empty()) { + this._output.previous_line.push(popped); + this._output.trim(true); + this._output.current_line.pop(); + this._output.trim(); + } + + // add the comma in front of the next token + this.print_token_line_indentation(current_token); + this._output.add_token(','); + this._output.space_before_token = true; + } + } + + printable_token = printable_token || current_token.text; + this.print_token_line_indentation(current_token); + this._output.add_token(printable_token); +}; + +Beautifier.prototype.indent = function() { + this._flags.indentation_level += 1; +}; + +Beautifier.prototype.deindent = function() { + if (this._flags.indentation_level > 0 && + ((!this._flags.parent) || this._flags.indentation_level > this._flags.parent.indentation_level)) { + this._flags.indentation_level -= 1; + + } +}; + +Beautifier.prototype.set_mode = function(mode) { + if (this._flags) { + this._flag_store.push(this._flags); + this._previous_flags = this._flags; + } else { + this._previous_flags = this.create_flags(null, mode); + } + + this._flags = this.create_flags(this._previous_flags, mode); +}; + + +Beautifier.prototype.restore_mode = function() { + if (this._flag_store.length > 0) { + this._previous_flags = this._flags; + this._flags = this._flag_store.pop(); + if (this._previous_flags.mode === MODE.Statement) { + remove_redundant_indentation(this._output, this._previous_flags); + } + } +}; + +Beautifier.prototype.start_of_object_property = function() { + return this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement && ( + (this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || (reserved_array(this._flags.last_token, ['get', 'set']))); +}; + +Beautifier.prototype.start_of_statement = function(current_token) { + var start = false; + start = start || reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN.WORD; + start = start || reserved_word(this._flags.last_token, 'do'); + start = start || (reserved_array(this._flags.last_token, newline_restricted_tokens) && !current_token.newlines); + start = start || reserved_word(this._flags.last_token, 'else') && + !(reserved_word(current_token, 'if') && !current_token.comments_before); + start = start || (this._flags.last_token.type === TOKEN.END_EXPR && (this._previous_flags.mode === MODE.ForInitializer || this._previous_flags.mode === MODE.Conditional)); + start = start || (this._flags.last_token.type === TOKEN.WORD && this._flags.mode === MODE.BlockStatement && + !this._flags.in_case && + !(current_token.text === '--' || current_token.text === '++') && + this._last_last_text !== 'function' && + current_token.type !== TOKEN.WORD && current_token.type !== TOKEN.RESERVED); + start = start || (this._flags.mode === MODE.ObjectLiteral && ( + (this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || reserved_array(this._flags.last_token, ['get', 'set']))); + + if (start) { + this.set_mode(MODE.Statement); + this.indent(); + + this.handle_whitespace_and_comments(current_token, true); + + // Issue #276: + // If starting a new statement with [if, for, while, do], push to a new line. + // if (a) if (b) if(c) d(); else e(); else f(); + if (!this.start_of_object_property()) { + this.allow_wrap_or_preserved_newline(current_token, + reserved_array(current_token, ['do', 'for', 'if', 'while'])); + } + return true; + } + return false; +}; + +Beautifier.prototype.handle_start_expr = function(current_token) { + // The conditional starts the statement if appropriate. + if (!this.start_of_statement(current_token)) { + this.handle_whitespace_and_comments(current_token); + } + + var next_mode = MODE.Expression; + if (current_token.text === '[') { + + if (this._flags.last_token.type === TOKEN.WORD || this._flags.last_token.text === ')') { + // this is array index specifier, break immediately + // a[x], fn()[x] + if (reserved_array(this._flags.last_token, line_starters)) { + this._output.space_before_token = true; + } + this.set_mode(next_mode); + this.print_token(current_token); + this.indent(); + if (this._options.space_in_paren) { + this._output.space_before_token = true; + } + return; + } + + next_mode = MODE.ArrayLiteral; + if (is_array(this._flags.mode)) { + if (this._flags.last_token.text === '[' || + (this._flags.last_token.text === ',' && (this._last_last_text === ']' || this._last_last_text === '}'))) { + // ], [ goes to new line + // }, [ goes to new line + if (!this._options.keep_array_indentation) { + this.print_newline(); + } + } + } + + if (!in_array(this._flags.last_token.type, [TOKEN.START_EXPR, TOKEN.END_EXPR, TOKEN.WORD, TOKEN.OPERATOR])) { + this._output.space_before_token = true; + } + } else { + if (this._flags.last_token.type === TOKEN.RESERVED) { + if (this._flags.last_token.text === 'for') { + this._output.space_before_token = this._options.space_before_conditional; + next_mode = MODE.ForInitializer; + } else if (in_array(this._flags.last_token.text, ['if', 'while'])) { + this._output.space_before_token = this._options.space_before_conditional; + next_mode = MODE.Conditional; + } else if (in_array(this._flags.last_word, ['await', 'async'])) { + // Should be a space between await and an IIFE, or async and an arrow function + this._output.space_before_token = true; + } else if (this._flags.last_token.text === 'import' && current_token.whitespace_before === '') { + this._output.space_before_token = false; + } else if (in_array(this._flags.last_token.text, line_starters) || this._flags.last_token.text === 'catch') { + this._output.space_before_token = true; + } + } else if (this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) { + // Support of this kind of newline preservation. + // a = (b && + // (c || d)); + if (!this.start_of_object_property()) { + this.allow_wrap_or_preserved_newline(current_token); + } + } else if (this._flags.last_token.type === TOKEN.WORD) { + this._output.space_before_token = false; + } else { + // Support preserving wrapped arrow function expressions + // a.b('c', + // () => d.e + // ) + this.allow_wrap_or_preserved_newline(current_token); + } + + // function() vs function () + // yield*() vs yield* () + // function*() vs function* () + if ((this._flags.last_token.type === TOKEN.RESERVED && (this._flags.last_word === 'function' || this._flags.last_word === 'typeof')) || + (this._flags.last_token.text === '*' && + (in_array(this._last_last_text, ['function', 'yield']) || + (this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) { + + this._output.space_before_token = this._options.space_after_anon_function; + } + + } + + if (this._flags.last_token.text === ';' || this._flags.last_token.type === TOKEN.START_BLOCK) { + this.print_newline(); + } else if (this._flags.last_token.type === TOKEN.END_EXPR || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.END_BLOCK || this._flags.last_token.text === '.' || this._flags.last_token.type === TOKEN.COMMA) { + // do nothing on (( and )( and ][ and ]( and .( + // TODO: Consider whether forcing this is required. Review failing tests when removed. + this.allow_wrap_or_preserved_newline(current_token, current_token.newlines); + } + + this.set_mode(next_mode); + this.print_token(current_token); + if (this._options.space_in_paren) { + this._output.space_before_token = true; + } + + // In all cases, if we newline while inside an expression it should be indented. + this.indent(); +}; + +Beautifier.prototype.handle_end_expr = function(current_token) { + // statements inside expressions are not valid syntax, but... + // statements must all be closed when their container closes + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + + this.handle_whitespace_and_comments(current_token); + + if (this._flags.multiline_frame) { + this.allow_wrap_or_preserved_newline(current_token, + current_token.text === ']' && is_array(this._flags.mode) && !this._options.keep_array_indentation); + } + + if (this._options.space_in_paren) { + if (this._flags.last_token.type === TOKEN.START_EXPR && !this._options.space_in_empty_paren) { + // () [] no inner space in empty parens like these, ever, ref #320 + this._output.trim(); + this._output.space_before_token = false; + } else { + this._output.space_before_token = true; + } + } + if (current_token.text === ']' && this._options.keep_array_indentation) { + this.print_token(current_token); + this.restore_mode(); + } else { + this.restore_mode(); + this.print_token(current_token); + } + remove_redundant_indentation(this._output, this._previous_flags); + + // do {} while () // no statement required after + if (this._flags.do_while && this._previous_flags.mode === MODE.Conditional) { + this._previous_flags.mode = MODE.Expression; + this._flags.do_block = false; + this._flags.do_while = false; + + } +}; + +Beautifier.prototype.handle_start_block = function(current_token) { + this.handle_whitespace_and_comments(current_token); + + // Check if this is should be treated as a ObjectLiteral + var next_token = this._tokens.peek(); + var second_token = this._tokens.peek(1); + if (this._flags.last_word === 'switch' && this._flags.last_token.type === TOKEN.END_EXPR) { + this.set_mode(MODE.BlockStatement); + this._flags.in_case_statement = true; + } else if (second_token && ( + (in_array(second_token.text, [':', ',']) && in_array(next_token.type, [TOKEN.STRING, TOKEN.WORD, TOKEN.RESERVED])) || + (in_array(next_token.text, ['get', 'set', '...']) && in_array(second_token.type, [TOKEN.WORD, TOKEN.RESERVED])) + )) { + // We don't support TypeScript,but we didn't break it for a very long time. + // We'll try to keep not breaking it. + if (!in_array(this._last_last_text, ['class', 'interface'])) { + this.set_mode(MODE.ObjectLiteral); + } else { + this.set_mode(MODE.BlockStatement); + } + } else if (this._flags.last_token.type === TOKEN.OPERATOR && this._flags.last_token.text === '=>') { + // arrow function: (param1, paramN) => { statements } + this.set_mode(MODE.BlockStatement); + } else if (in_array(this._flags.last_token.type, [TOKEN.EQUALS, TOKEN.START_EXPR, TOKEN.COMMA, TOKEN.OPERATOR]) || + reserved_array(this._flags.last_token, ['return', 'throw', 'import', 'default']) + ) { + // Detecting shorthand function syntax is difficult by scanning forward, + // so check the surrounding context. + // If the block is being returned, imported, export default, passed as arg, + // assigned with = or assigned in a nested object, treat as an ObjectLiteral. + this.set_mode(MODE.ObjectLiteral); + } else { + this.set_mode(MODE.BlockStatement); + } + + var empty_braces = !next_token.comments_before && next_token.text === '}'; + var empty_anonymous_function = empty_braces && this._flags.last_word === 'function' && + this._flags.last_token.type === TOKEN.END_EXPR; + + if (this._options.brace_preserve_inline) // check for inline, set inline_frame if so + { + // search forward for a newline wanted inside this block + var index = 0; + var check_token = null; + this._flags.inline_frame = true; + do { + index += 1; + check_token = this._tokens.peek(index - 1); + if (check_token.newlines) { + this._flags.inline_frame = false; + break; + } + } while (check_token.type !== TOKEN.EOF && + !(check_token.type === TOKEN.END_BLOCK && check_token.opened === current_token)); + } + + if ((this._options.brace_style === "expand" || + (this._options.brace_style === "none" && current_token.newlines)) && + !this._flags.inline_frame) { + if (this._flags.last_token.type !== TOKEN.OPERATOR && + (empty_anonymous_function || + this._flags.last_token.type === TOKEN.EQUALS || + (reserved_array(this._flags.last_token, special_words) && this._flags.last_token.text !== 'else'))) { + this._output.space_before_token = true; + } else { + this.print_newline(false, true); + } + } else { // collapse || inline_frame + if (is_array(this._previous_flags.mode) && (this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.COMMA)) { + if (this._flags.last_token.type === TOKEN.COMMA || this._options.space_in_paren) { + this._output.space_before_token = true; + } + + if (this._flags.last_token.type === TOKEN.COMMA || (this._flags.last_token.type === TOKEN.START_EXPR && this._flags.inline_frame)) { + this.allow_wrap_or_preserved_newline(current_token); + this._previous_flags.multiline_frame = this._previous_flags.multiline_frame || this._flags.multiline_frame; + this._flags.multiline_frame = false; + } + } + if (this._flags.last_token.type !== TOKEN.OPERATOR && this._flags.last_token.type !== TOKEN.START_EXPR) { + if (this._flags.last_token.type === TOKEN.START_BLOCK && !this._flags.inline_frame) { + this.print_newline(); + } else { + this._output.space_before_token = true; + } + } + } + this.print_token(current_token); + this.indent(); +}; + +Beautifier.prototype.handle_end_block = function(current_token) { + // statements must all be closed when their container closes + this.handle_whitespace_and_comments(current_token); + + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + + var empty_braces = this._flags.last_token.type === TOKEN.START_BLOCK; + + if (this._flags.inline_frame && !empty_braces) { // try inline_frame (only set if this._options.braces-preserve-inline) first + this._output.space_before_token = true; + } else if (this._options.brace_style === "expand") { + if (!empty_braces) { + this.print_newline(); + } + } else { + // skip {} + if (!empty_braces) { + if (is_array(this._flags.mode) && this._options.keep_array_indentation) { + // we REALLY need a newline here, but newliner would skip that + this._options.keep_array_indentation = false; + this.print_newline(); + this._options.keep_array_indentation = true; + + } else { + this.print_newline(); + } + } + } + this.restore_mode(); + this.print_token(current_token); +}; + +Beautifier.prototype.handle_word = function(current_token) { + if (current_token.type === TOKEN.RESERVED) { + if (in_array(current_token.text, ['set', 'get']) && this._flags.mode !== MODE.ObjectLiteral) { + current_token.type = TOKEN.WORD; + } else if (in_array(current_token.text, ['as', 'from']) && !this._flags.import_block) { + current_token.type = TOKEN.WORD; + } else if (this._flags.mode === MODE.ObjectLiteral) { + var next_token = this._tokens.peek(); + if (next_token.text === ':') { + current_token.type = TOKEN.WORD; + } + } + } + + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + if (reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN.WORD) { + this._flags.declaration_statement = true; + } + } else if (current_token.newlines && !is_expression(this._flags.mode) && + (this._flags.last_token.type !== TOKEN.OPERATOR || (this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) && + this._flags.last_token.type !== TOKEN.EQUALS && + (this._options.preserve_newlines || !reserved_array(this._flags.last_token, ['var', 'let', 'const', 'set', 'get']))) { + this.handle_whitespace_and_comments(current_token); + this.print_newline(); + } else { + this.handle_whitespace_and_comments(current_token); + } + + if (this._flags.do_block && !this._flags.do_while) { + if (reserved_word(current_token, 'while')) { + // do {} ## while () + this._output.space_before_token = true; + this.print_token(current_token); + this._output.space_before_token = true; + this._flags.do_while = true; + return; + } else { + // do {} should always have while as the next word. + // if we don't see the expected while, recover + this.print_newline(); + this._flags.do_block = false; + } + } + + // if may be followed by else, or not + // Bare/inline ifs are tricky + // Need to unwind the modes correctly: if (a) if (b) c(); else d(); else e(); + if (this._flags.if_block) { + if (!this._flags.else_block && reserved_word(current_token, 'else')) { + this._flags.else_block = true; + } else { + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + this._flags.if_block = false; + this._flags.else_block = false; + } + } + + if (this._flags.in_case_statement && reserved_array(current_token, ['case', 'default'])) { + this.print_newline(); + if (this._flags.case_body || this._options.jslint_happy) { + // switch cases following one another + this.deindent(); + this._flags.case_body = false; + } + this.print_token(current_token); + this._flags.in_case = true; + return; + } + + if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) { + if (!this.start_of_object_property()) { + this.allow_wrap_or_preserved_newline(current_token); + } + } + + if (reserved_word(current_token, 'function')) { + if (in_array(this._flags.last_token.text, ['}', ';']) || + (this._output.just_added_newline() && !(in_array(this._flags.last_token.text, ['(', '[', '{', ':', '=', ',']) || this._flags.last_token.type === TOKEN.OPERATOR))) { + // make sure there is a nice clean space of at least one blank line + // before a new function definition + if (!this._output.just_added_blankline() && !current_token.comments_before) { + this.print_newline(); + this.print_newline(true); + } + } + if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD) { + if (reserved_array(this._flags.last_token, ['get', 'set', 'new', 'export']) || + reserved_array(this._flags.last_token, newline_restricted_tokens)) { + this._output.space_before_token = true; + } else if (reserved_word(this._flags.last_token, 'default') && this._last_last_text === 'export') { + this._output.space_before_token = true; + } else if (this._flags.last_token.text === 'declare') { + // accomodates Typescript declare function formatting + this._output.space_before_token = true; + } else { + this.print_newline(); + } + } else if (this._flags.last_token.type === TOKEN.OPERATOR || this._flags.last_token.text === '=') { + // foo = function + this._output.space_before_token = true; + } else if (!this._flags.multiline_frame && (is_expression(this._flags.mode) || is_array(this._flags.mode))) { + // (function + } else { + this.print_newline(); + } + + this.print_token(current_token); + this._flags.last_word = current_token.text; + return; + } + + var prefix = 'NONE'; + + if (this._flags.last_token.type === TOKEN.END_BLOCK) { + + if (this._previous_flags.inline_frame) { + prefix = 'SPACE'; + } else if (!reserved_array(current_token, ['else', 'catch', 'finally', 'from'])) { + prefix = 'NEWLINE'; + } else { + if (this._options.brace_style === "expand" || + this._options.brace_style === "end-expand" || + (this._options.brace_style === "none" && current_token.newlines)) { + prefix = 'NEWLINE'; + } else { + prefix = 'SPACE'; + this._output.space_before_token = true; + } + } + } else if (this._flags.last_token.type === TOKEN.SEMICOLON && this._flags.mode === MODE.BlockStatement) { + // TODO: Should this be for STATEMENT as well? + prefix = 'NEWLINE'; + } else if (this._flags.last_token.type === TOKEN.SEMICOLON && is_expression(this._flags.mode)) { + prefix = 'SPACE'; + } else if (this._flags.last_token.type === TOKEN.STRING) { + prefix = 'NEWLINE'; + } else if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD || + (this._flags.last_token.text === '*' && + (in_array(this._last_last_text, ['function', 'yield']) || + (this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) { + prefix = 'SPACE'; + } else if (this._flags.last_token.type === TOKEN.START_BLOCK) { + if (this._flags.inline_frame) { + prefix = 'SPACE'; + } else { + prefix = 'NEWLINE'; + } + } else if (this._flags.last_token.type === TOKEN.END_EXPR) { + this._output.space_before_token = true; + prefix = 'NEWLINE'; + } + + if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') { + if (this._flags.inline_frame || this._flags.last_token.text === 'else' || this._flags.last_token.text === 'export') { + prefix = 'SPACE'; + } else { + prefix = 'NEWLINE'; + } + + } + + if (reserved_array(current_token, ['else', 'catch', 'finally'])) { + if ((!(this._flags.last_token.type === TOKEN.END_BLOCK && this._previous_flags.mode === MODE.BlockStatement) || + this._options.brace_style === "expand" || + this._options.brace_style === "end-expand" || + (this._options.brace_style === "none" && current_token.newlines)) && + !this._flags.inline_frame) { + this.print_newline(); + } else { + this._output.trim(true); + var line = this._output.current_line; + // If we trimmed and there's something other than a close block before us + // put a newline back in. Handles '} // comment' scenario. + if (line.last() !== '}') { + this.print_newline(); + } + this._output.space_before_token = true; + } + } else if (prefix === 'NEWLINE') { + if (reserved_array(this._flags.last_token, special_words)) { + // no newline between 'return nnn' + this._output.space_before_token = true; + } else if (this._flags.last_token.text === 'declare' && reserved_array(current_token, ['var', 'let', 'const'])) { + // accomodates Typescript declare formatting + this._output.space_before_token = true; + } else if (this._flags.last_token.type !== TOKEN.END_EXPR) { + if ((this._flags.last_token.type !== TOKEN.START_EXPR || !reserved_array(current_token, ['var', 'let', 'const'])) && this._flags.last_token.text !== ':') { + // no need to force newline on 'var': for (var x = 0...) + if (reserved_word(current_token, 'if') && reserved_word(current_token.previous, 'else')) { + // no newline for } else if { + this._output.space_before_token = true; + } else { + this.print_newline(); + } + } + } else if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') { + this.print_newline(); + } + } else if (this._flags.multiline_frame && is_array(this._flags.mode) && this._flags.last_token.text === ',' && this._last_last_text === '}') { + this.print_newline(); // }, in lists get a newline treatment + } else if (prefix === 'SPACE') { + this._output.space_before_token = true; + } + if (current_token.previous && (current_token.previous.type === TOKEN.WORD || current_token.previous.type === TOKEN.RESERVED)) { + this._output.space_before_token = true; + } + this.print_token(current_token); + this._flags.last_word = current_token.text; + + if (current_token.type === TOKEN.RESERVED) { + if (current_token.text === 'do') { + this._flags.do_block = true; + } else if (current_token.text === 'if') { + this._flags.if_block = true; + } else if (current_token.text === 'import') { + this._flags.import_block = true; + } else if (this._flags.import_block && reserved_word(current_token, 'from')) { + this._flags.import_block = false; + } + } +}; + +Beautifier.prototype.handle_semicolon = function(current_token) { + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + // Semicolon can be the start (and end) of a statement + this._output.space_before_token = false; + } else { + this.handle_whitespace_and_comments(current_token); + } + + var next_token = this._tokens.peek(); + while (this._flags.mode === MODE.Statement && + !(this._flags.if_block && reserved_word(next_token, 'else')) && + !this._flags.do_block) { + this.restore_mode(); + } + + // hacky but effective for the moment + if (this._flags.import_block) { + this._flags.import_block = false; + } + this.print_token(current_token); +}; + +Beautifier.prototype.handle_string = function(current_token) { + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + // One difference - strings want at least a space before + this._output.space_before_token = true; + } else { + this.handle_whitespace_and_comments(current_token); + if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD || this._flags.inline_frame) { + this._output.space_before_token = true; + } else if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) { + if (!this.start_of_object_property()) { + this.allow_wrap_or_preserved_newline(current_token); + } + } else { + this.print_newline(); + } + } + this.print_token(current_token); +}; + +Beautifier.prototype.handle_xml = function(current_token) { + this._output.space_before_token = true; + this.print_token(current_token); +}; + +Beautifier.prototype.handle_equals = function(current_token) { + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + } else { + this.handle_whitespace_and_comments(current_token); + } + + if (this._flags.declaration_statement) { + // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done + this._flags.declaration_assignment = true; + } + this._output.space_before_token = true; + this.print_token(current_token); + this._output.space_before_token = true; +}; + +Beautifier.prototype.handle_comma = function(current_token) { + this.handle_whitespace_and_comments(current_token, true); + + this.print_token(current_token); + this._output.space_before_token = true; + if (this._flags.declaration_statement) { + if (is_expression(this._flags.parent.mode)) { + // do not break on comma, for(var a = 1, b = 2) + this._flags.declaration_assignment = false; + } + + if (this._flags.declaration_assignment) { + this._flags.declaration_assignment = false; + this.print_newline(false, true); + } else if (this._options.comma_first) { + // for comma-first, we want to allow a newline before the comma + // to turn into a newline after the comma, which we will fixup later + this.allow_wrap_or_preserved_newline(current_token); + } + } else if (this._flags.mode === MODE.ObjectLiteral || + (this._flags.mode === MODE.Statement && this._flags.parent.mode === MODE.ObjectLiteral)) { + if (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + + if (!this._flags.inline_frame) { + this.print_newline(); + } + } else if (this._options.comma_first) { + // EXPR or DO_BLOCK + // for comma-first, we want to allow a newline before the comma + // to turn into a newline after the comma, which we will fixup later + this.allow_wrap_or_preserved_newline(current_token); + } +}; + +Beautifier.prototype.handle_operator = function(current_token) { + var isGeneratorAsterisk = current_token.text === '*' && + (reserved_array(this._flags.last_token, ['function', 'yield']) || + (in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.COMMA, TOKEN.END_BLOCK, TOKEN.SEMICOLON])) + ); + var isUnary = in_array(current_token.text, ['-', '+']) && ( + in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.START_EXPR, TOKEN.EQUALS, TOKEN.OPERATOR]) || + in_array(this._flags.last_token.text, line_starters) || + this._flags.last_token.text === ',' + ); + + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + } else { + var preserve_statement_flags = !isGeneratorAsterisk; + this.handle_whitespace_and_comments(current_token, preserve_statement_flags); + } + + if (reserved_array(this._flags.last_token, special_words)) { + // "return" had a special handling in TK_WORD. Now we need to return the favor + this._output.space_before_token = true; + this.print_token(current_token); + return; + } + + // hack for actionscript's import .*; + if (current_token.text === '*' && this._flags.last_token.type === TOKEN.DOT) { + this.print_token(current_token); + return; + } + + if (current_token.text === '::') { + // no spaces around exotic namespacing syntax operator + this.print_token(current_token); + return; + } + + // Allow line wrapping between operators when operator_position is + // set to before or preserve + if (this._flags.last_token.type === TOKEN.OPERATOR && in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) { + this.allow_wrap_or_preserved_newline(current_token); + } + + if (current_token.text === ':' && this._flags.in_case) { + this._flags.case_body = true; + this.indent(); + this.print_token(current_token); + this.print_newline(); + this._flags.in_case = false; + return; + } + + var space_before = true; + var space_after = true; + var in_ternary = false; + if (current_token.text === ':') { + if (this._flags.ternary_depth === 0) { + // Colon is invalid javascript outside of ternary and object, but do our best to guess what was meant. + space_before = false; + } else { + this._flags.ternary_depth -= 1; + in_ternary = true; + } + } else if (current_token.text === '?') { + this._flags.ternary_depth += 1; + } + + // let's handle the operator_position option prior to any conflicting logic + if (!isUnary && !isGeneratorAsterisk && this._options.preserve_newlines && in_array(current_token.text, positionable_operators)) { + var isColon = current_token.text === ':'; + var isTernaryColon = (isColon && in_ternary); + var isOtherColon = (isColon && !in_ternary); + + switch (this._options.operator_position) { + case OPERATOR_POSITION.before_newline: + // if the current token is : and it's not a ternary statement then we set space_before to false + this._output.space_before_token = !isOtherColon; + + this.print_token(current_token); + + if (!isColon || isTernaryColon) { + this.allow_wrap_or_preserved_newline(current_token); + } + + this._output.space_before_token = true; + return; + + case OPERATOR_POSITION.after_newline: + // if the current token is anything but colon, or (via deduction) it's a colon and in a ternary statement, + // then print a newline. + + this._output.space_before_token = true; + + if (!isColon || isTernaryColon) { + if (this._tokens.peek().newlines) { + this.print_newline(false, true); + } else { + this.allow_wrap_or_preserved_newline(current_token); + } + } else { + this._output.space_before_token = false; + } + + this.print_token(current_token); + + this._output.space_before_token = true; + return; + + case OPERATOR_POSITION.preserve_newline: + if (!isOtherColon) { + this.allow_wrap_or_preserved_newline(current_token); + } + + // if we just added a newline, or the current token is : and it's not a ternary statement, + // then we set space_before to false + space_before = !(this._output.just_added_newline() || isOtherColon); + + this._output.space_before_token = space_before; + this.print_token(current_token); + this._output.space_before_token = true; + return; + } + } + + if (isGeneratorAsterisk) { + this.allow_wrap_or_preserved_newline(current_token); + space_before = false; + var next_token = this._tokens.peek(); + space_after = next_token && in_array(next_token.type, [TOKEN.WORD, TOKEN.RESERVED]); + } else if (current_token.text === '...') { + this.allow_wrap_or_preserved_newline(current_token); + space_before = this._flags.last_token.type === TOKEN.START_BLOCK; + space_after = false; + } else if (in_array(current_token.text, ['--', '++', '!', '~']) || isUnary) { + // unary operators (and binary +/- pretending to be unary) special cases + if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR) { + this.allow_wrap_or_preserved_newline(current_token); + } + + space_before = false; + space_after = false; + + // http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1 + // if there is a newline between -- or ++ and anything else we should preserve it. + if (current_token.newlines && (current_token.text === '--' || current_token.text === '++')) { + this.print_newline(false, true); + } + + if (this._flags.last_token.text === ';' && is_expression(this._flags.mode)) { + // for (;; ++i) + // ^^^ + space_before = true; + } + + if (this._flags.last_token.type === TOKEN.RESERVED) { + space_before = true; + } else if (this._flags.last_token.type === TOKEN.END_EXPR) { + space_before = !(this._flags.last_token.text === ']' && (current_token.text === '--' || current_token.text === '++')); + } else if (this._flags.last_token.type === TOKEN.OPERATOR) { + // a++ + ++b; + // a - -b + space_before = in_array(current_token.text, ['--', '-', '++', '+']) && in_array(this._flags.last_token.text, ['--', '-', '++', '+']); + // + and - are not unary when preceeded by -- or ++ operator + // a-- + b + // a * +b + // a - -b + if (in_array(current_token.text, ['+', '-']) && in_array(this._flags.last_token.text, ['--', '++'])) { + space_after = true; + } + } + + + if (((this._flags.mode === MODE.BlockStatement && !this._flags.inline_frame) || this._flags.mode === MODE.Statement) && + (this._flags.last_token.text === '{' || this._flags.last_token.text === ';')) { + // { foo; --i } + // foo(); --bar; + this.print_newline(); + } + } + + this._output.space_before_token = this._output.space_before_token || space_before; + this.print_token(current_token); + this._output.space_before_token = space_after; +}; + +Beautifier.prototype.handle_block_comment = function(current_token, preserve_statement_flags) { + if (this._output.raw) { + this._output.add_raw_token(current_token); + if (current_token.directives && current_token.directives.preserve === 'end') { + // If we're testing the raw output behavior, do not allow a directive to turn it off. + this._output.raw = this._options.test_output_raw; + } + return; + } + + if (current_token.directives) { + this.print_newline(false, preserve_statement_flags); + this.print_token(current_token); + if (current_token.directives.preserve === 'start') { + this._output.raw = true; + } + this.print_newline(false, true); + return; + } + + // inline block + if (!acorn.newline.test(current_token.text) && !current_token.newlines) { + this._output.space_before_token = true; + this.print_token(current_token); + this._output.space_before_token = true; + return; + } + + var lines = split_linebreaks(current_token.text); + var j; // iterator for this case + var javadoc = false; + var starless = false; + var lastIndent = current_token.whitespace_before; + var lastIndentLength = lastIndent.length; + + // block comment starts with a new line + this.print_newline(false, preserve_statement_flags); + if (lines.length > 1) { + javadoc = all_lines_start_with(lines.slice(1), '*'); + starless = each_line_matches_indent(lines.slice(1), lastIndent); + } + + // first line always indented + this.print_token(current_token, lines[0]); + for (j = 1; j < lines.length; j++) { + this.print_newline(false, true); + if (javadoc) { + // javadoc: reformat and re-indent + this.print_token(current_token, ' ' + ltrim(lines[j])); + } else if (starless && lines[j].length > lastIndentLength) { + // starless: re-indent non-empty content, avoiding trim + this.print_token(current_token, lines[j].substring(lastIndentLength)); + } else { + // normal comments output raw + this._output.add_token(lines[j]); + } + } + + // for comments of more than one line, make sure there's a new line after + this.print_newline(false, preserve_statement_flags); +}; + +Beautifier.prototype.handle_comment = function(current_token, preserve_statement_flags) { + if (current_token.newlines) { + this.print_newline(false, preserve_statement_flags); + } else { + this._output.trim(true); + } + + this._output.space_before_token = true; + this.print_token(current_token); + this.print_newline(false, preserve_statement_flags); +}; + +Beautifier.prototype.handle_dot = function(current_token) { + if (this.start_of_statement(current_token)) { + // The conditional starts the statement if appropriate. + } else { + this.handle_whitespace_and_comments(current_token, true); + } + + if (reserved_array(this._flags.last_token, special_words)) { + this._output.space_before_token = false; + } else { + // allow preserved newlines before dots in general + // force newlines on dots after close paren when break_chained - for bar().baz() + this.allow_wrap_or_preserved_newline(current_token, + this._flags.last_token.text === ')' && this._options.break_chained_methods); + } + + // Only unindent chained method dot if this dot starts a new line. + // Otherwise the automatic extra indentation removal will handle the over indent + if (this._options.unindent_chained_methods && this._output.just_added_newline()) { + this.deindent(); + } + + this.print_token(current_token); +}; + +Beautifier.prototype.handle_unknown = function(current_token, preserve_statement_flags) { + this.print_token(current_token); + + if (current_token.text[current_token.text.length - 1] === '\n') { + this.print_newline(false, preserve_statement_flags); + } +}; + +Beautifier.prototype.handle_eof = function(current_token) { + // Unwind any open statements + while (this._flags.mode === MODE.Statement) { + this.restore_mode(); + } + this.handle_whitespace_and_comments(current_token); +}; + +module.exports.Beautifier = Beautifier; \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/javascript/options.js b/app/src/main/assets/js/js-beautify/javascript/options.js new file mode 100644 index 00000000..7667d8da --- /dev/null +++ b/app/src/main/assets/js/js-beautify/javascript/options.js @@ -0,0 +1,91 @@ +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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. +*/ + +'use strict'; + +var BaseOptions = require('core/options').Options; + +var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline']; + +function Options(options) { + BaseOptions.call(this, options, 'js'); + + // compatibility, re + var raw_brace_style = this.raw_options.brace_style || null; + if (raw_brace_style === "expand-strict") { //graceful handling of deprecated option + this.raw_options.brace_style = "expand"; + } else if (raw_brace_style === "collapse-preserve-inline") { //graceful handling of deprecated option + this.raw_options.brace_style = "collapse,preserve-inline"; + } else if (this.raw_options.braces_on_own_line !== undefined) { //graceful handling of deprecated option + this.raw_options.brace_style = this.raw_options.braces_on_own_line ? "expand" : "collapse"; + // } else if (!raw_brace_style) { //Nothing exists to set it + // raw_brace_style = "collapse"; + } + + //preserve-inline in delimited string will trigger brace_preserve_inline, everything + //else is considered a brace_style and the last one only will have an effect + + var brace_style_split = this._get_selection_list('brace_style', ['collapse', 'expand', 'end-expand', 'none', 'preserve-inline']); + + this.brace_preserve_inline = false; //Defaults in case one or other was not specified in meta-option + this.brace_style = "collapse"; + + for (var bs = 0; bs < brace_style_split.length; bs++) { + if (brace_style_split[bs] === "preserve-inline") { + this.brace_preserve_inline = true; + } else { + this.brace_style = brace_style_split[bs]; + } + } + + this.unindent_chained_methods = this._get_boolean('unindent_chained_methods'); + this.break_chained_methods = this._get_boolean('break_chained_methods'); + this.space_in_paren = this._get_boolean('space_in_paren'); + this.space_in_empty_paren = this._get_boolean('space_in_empty_paren'); + this.jslint_happy = this._get_boolean('jslint_happy'); + this.space_after_anon_function = this._get_boolean('space_after_anon_function'); + this.keep_array_indentation = this._get_boolean('keep_array_indentation'); + this.space_before_conditional = this._get_boolean('space_before_conditional', true); + this.unescape_strings = this._get_boolean('unescape_strings'); + this.e4x = this._get_boolean('e4x'); + this.comma_first = this._get_boolean('comma_first'); + this.operator_position = this._get_selection('operator_position', validPositionValues); + + // For testing of beautify preserve:start directive + this.test_output_raw = this._get_boolean('test_output_raw'); + + // force this._options.space_after_anon_function to true if this._options.jslint_happy + if (this.jslint_happy) { + this.space_after_anon_function = true; + } +} +Options.prototype = new BaseOptions(); + + + +module.exports.Options = Options; \ No newline at end of file diff --git a/app/src/main/assets/js/js-beautify/javascript/tokenizer.js b/app/src/main/assets/js/js-beautify/javascript/tokenizer.js new file mode 100644 index 00000000..35d66879 --- /dev/null +++ b/app/src/main/assets/js/js-beautify/javascript/tokenizer.js @@ -0,0 +1,543 @@ +/*jshint node:true */ +/* + + The MIT License (MIT) + + Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, 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. +*/ + +'use strict'; + +var InputScanner = require('core/inputscanner').InputScanner; +var BaseTokenizer = require('core/tokenizer').Tokenizer; +var BASETOKEN = require('core/tokenizer').TOKEN; +var Directives = require('core/directives').Directives; +var acorn = require('javascript/acorn'); +var prettifyXml = require('core/xml_formatter.js'); + +function in_array(what, arr) { + return arr.indexOf(what) !== -1; +} + + +var TOKEN = { + START_EXPR: 'TK_START_EXPR', + END_EXPR: 'TK_END_EXPR', + START_BLOCK: 'TK_START_BLOCK', + END_BLOCK: 'TK_END_BLOCK', + WORD: 'TK_WORD', + RESERVED: 'TK_RESERVED', + SEMICOLON: 'TK_SEMICOLON', + STRING: 'TK_STRING', + XML: 'TK_XML', + EQUALS: 'TK_EQUALS', + OPERATOR: 'TK_OPERATOR', + COMMA: 'TK_COMMA', + BLOCK_COMMENT: 'TK_BLOCK_COMMENT', + COMMENT: 'TK_COMMENT', + DOT: 'TK_DOT', + UNKNOWN: 'TK_UNKNOWN', + START: BASETOKEN.START, + RAW: BASETOKEN.RAW, + EOF: BASETOKEN.EOF +}; + + +var directives_core = new Directives(/\/\*/, /\*\//); + +var number_pattern = /0[xX][0123456789abcdefABCDEF]*|0[oO][01234567]*|0[bB][01]*|\d+n|(?:\.\d+|\d+\.?\d*)(?:[eE][+-]?\d+)?/g; + +var digit = /[0-9]/; + +// Dot "." must be distinguished from "..." and decimal +var dot_pattern = /[^\d\.]/; + +var positionable_operators = ( + ">>> === !== " + + "<< && >= ** != == <= >> || " + + "< / - + > : & % ? ^ | *").split(' '); + +// IMPORTANT: this must be sorted longest to shortest or tokenizing many not work. +// Also, you must update possitionable operators separately from punct +var punct = + ">>>= " + + "... >>= <<= === >>> !== **= " + + "=> ^= :: /= << <= == && -= >= >> != -- += ** || ++ %= &= *= |= " + + "= ! ? > < : / ^ - + * & % ~ |"; + +punct = punct.replace(/[-[\]{}()*+?.,\\^$|#]/g, "\\$&"); +punct = punct.replace(/ /g, '|'); + +var punct_pattern = new RegExp(punct, 'g'); + +// words which should always start on new line. +var line_starters = 'continue,try,throw,return,var,let,const,if,switch,case,default,for,while,break,function,import,export'.split(','); +var reserved_words = line_starters.concat(['do', 'in', 'of', 'else', 'get', 'set', 'new', 'catch', 'finally', 'typeof', 'yield', 'async', 'await', 'from', 'as']); +var reserved_word_pattern = new RegExp('^(?:' + reserved_words.join('|') + ')$'); + +// /* ... */ comment ends with nearest */ or end of file +var block_comment_pattern = /\/\*(?:[\s\S]*?)((?:\*\/)|$)/g; + +// comment ends just before nearest linefeed or end of file +var comment_pattern = /\/\/(?:[^\n\r\u2028\u2029]*)/g; + +var template_pattern = /(?:(?:<\?php|<\?=)[\s\S]*?\?>)|(?:<%[\s\S]*?%>)/g; + +var in_html_comment; + +var Tokenizer = function(input_string, options) { + BaseTokenizer.call(this, input_string, options); + + this._whitespace_pattern = /[\n\r\u2028\u2029\t\u000B\u00A0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff ]+/g; + this._newline_pattern = /([^\n\r\u2028\u2029]*)(\r\n|[\n\r\u2028\u2029])?/g; +}; +Tokenizer.prototype = new BaseTokenizer(); + +Tokenizer.prototype._is_comment = function(current_token) { + return current_token.type === TOKEN.COMMENT || current_token.type === TOKEN.BLOCK_COMMENT || current_token.type === TOKEN.UNKNOWN; +}; + +Tokenizer.prototype._is_opening = function(current_token) { + return current_token.type === TOKEN.START_BLOCK || current_token.type === TOKEN.START_EXPR; +}; + +Tokenizer.prototype._is_closing = function(current_token, open_token) { + return (current_token.type === TOKEN.END_BLOCK || current_token.type === TOKEN.END_EXPR) && + (open_token && ( + (current_token.text === ']' && open_token.text === '[') || + (current_token.text === ')' && open_token.text === '(') || + (current_token.text === '}' && open_token.text === '{'))); +}; + +Tokenizer.prototype._reset = function() { + in_html_comment = false; +}; + +Tokenizer.prototype._get_next_token = function(previous_token, open_token) { // jshint unused:false + this._readWhitespace(); + var token = null; + var c = this._input.peek(); + + token = token || this._read_singles(c); + token = token || this._read_word(previous_token); + token = token || this._read_comment(c); + token = token || this._read_string(c); + token = token || this._read_regexp(c, previous_token); + token = token || this._read_xml(c, previous_token); + token = token || this._read_non_javascript(c); + token = token || this._read_punctuation(); + token = token || this._create_token(TOKEN.UNKNOWN, this._input.next()); + + return token; +}; + +Tokenizer.prototype._read_word = function(previous_token) { + var resulting_string; + resulting_string = this._input.read(acorn.identifier); + if (resulting_string !== '') { + if (!(previous_token.type === TOKEN.DOT || + (previous_token.type === TOKEN.RESERVED && (previous_token.text === 'set' || previous_token.text === 'get'))) && + reserved_word_pattern.test(resulting_string)) { + if (resulting_string === 'in' || resulting_string === 'of') { // hack for 'in' and 'of' operators + return this._create_token(TOKEN.OPERATOR, resulting_string); + } + return this._create_token(TOKEN.RESERVED, resulting_string); + } + + return this._create_token(TOKEN.WORD, resulting_string); + } + + resulting_string = this._input.read(number_pattern); + if (resulting_string !== '') { + return this._create_token(TOKEN.WORD, resulting_string); + } +}; + +Tokenizer.prototype._read_singles = function(c) { + var token = null; + if (c === null) { + token = this._create_token(TOKEN.EOF, ''); + } else if (c === '(' || c === '[') { + token = this._create_token(TOKEN.START_EXPR, c); + } else if (c === ')' || c === ']') { + token = this._create_token(TOKEN.END_EXPR, c); + } else if (c === '{') { + token = this._create_token(TOKEN.START_BLOCK, c); + } else if (c === '}') { + token = this._create_token(TOKEN.END_BLOCK, c); + } else if (c === ';') { + token = this._create_token(TOKEN.SEMICOLON, c); + } else if (c === '.' && dot_pattern.test(this._input.peek(1))) { + token = this._create_token(TOKEN.DOT, c); + } else if (c === ',') { + token = this._create_token(TOKEN.COMMA, c); + } + + if (token) { + this._input.next(); + } + return token; +}; + +Tokenizer.prototype._read_punctuation = function() { + var resulting_string = this._input.read(punct_pattern); + + if (resulting_string !== '') { + if (resulting_string === '=') { + return this._create_token(TOKEN.EQUALS, resulting_string); + } else { + return this._create_token(TOKEN.OPERATOR, resulting_string); + } + } +}; + +Tokenizer.prototype._read_non_javascript = function(c) { + var resulting_string = ''; + + if (c === '#') { + c = this._input.next(); + + if (this._is_first_token() && this._input.peek() === '!') { + // shebang + resulting_string = c; + while (this._input.hasNext() && c !== '\n') { + c = this._input.next(); + resulting_string += c; + } + return this._create_token(TOKEN.UNKNOWN, resulting_string.trim() + '\n'); + } + + // Spidermonkey-specific sharp variables for circular references. Considered obsolete. + var sharp = '#'; + if (this._input.hasNext() && this._input.testChar(digit)) { + do { + c = this._input.next(); + sharp += c; + } while (this._input.hasNext() && c !== '#' && c !== '='); + if (c === '#') { + // + } else if (this._input.peek() === '[' && this._input.peek(1) === ']') { + sharp += '[]'; + this._input.next(); + this._input.next(); + } else if (this._input.peek() === '{' && this._input.peek(1) === '}') { + sharp += '{}'; + this._input.next(); + this._input.next(); + } + return this._create_token(TOKEN.WORD, sharp); + } + + this._input.back(); + + } else if (c === '<') { + if (this._input.peek(1) === '?' || this._input.peek(1) === '%') { + resulting_string = this._input.read(template_pattern); + if (resulting_string) { + resulting_string = resulting_string.replace(acorn.allLineBreaks, '\n'); + return this._create_token(TOKEN.STRING, resulting_string); + } + } else if (this._input.match(/<\!--/g)) { + c = '/g)) { + in_html_comment = false; + return this._create_token(TOKEN.COMMENT, '-->'); + } + + return null; +}; + +Tokenizer.prototype._read_comment = function(c) { + var token = null; + if (c === '/') { + var comment = ''; + if (this._input.peek(1) === '*') { + // peek for comment /* ... */ + comment = this._input.read(block_comment_pattern); + var directives = directives_core.get_directives(comment); + if (directives && directives.ignore === 'start') { + comment += directives_core.readIgnored(this._input); + } + comment = comment.replace(acorn.allLineBreaks, '\n'); + token = this._create_token(TOKEN.BLOCK_COMMENT, comment); + token.directives = directives; + } else if (this._input.peek(1) === '/') { + // peek for comment // ... + comment = this._input.read(comment_pattern); + token = this._create_token(TOKEN.COMMENT, comment); + } + } + return token; +}; + +Tokenizer.prototype._read_string = function(c) { + if (c === '`' || c === "'" || c === '"') { + var resulting_string = this._input.next(); + this.has_char_escapes = false; + + if (c === '`') { + resulting_string += this._read_string_recursive('`', true, '${'); + } else { + resulting_string += this._read_string_recursive(c); + } + + if (this.has_char_escapes && this._options.unescape_strings) { + resulting_string = unescape_string(resulting_string); + } + if (this._input.peek() === c) { + resulting_string += this._input.next(); + } + + return this._create_token(TOKEN.STRING, resulting_string); + } + + return null; +}; + +Tokenizer.prototype._allow_regexp_or_xml = function(previous_token) { + // regex and xml can only appear in specific locations during parsing + return (previous_token.type === TOKEN.RESERVED && in_array(previous_token.text, ['return', 'case', 'throw', 'else', 'do', 'typeof', 'yield'])) || + (previous_token.type === TOKEN.END_EXPR && previous_token.text === ')' && + previous_token.opened.previous.type === TOKEN.RESERVED && in_array(previous_token.opened.previous.text, ['if', 'while', 'for'])) || + (in_array(previous_token.type, [TOKEN.COMMENT, TOKEN.START_EXPR, TOKEN.START_BLOCK, TOKEN.START, + TOKEN.END_BLOCK, TOKEN.OPERATOR, TOKEN.EQUALS, TOKEN.EOF, TOKEN.SEMICOLON, TOKEN.COMMA + ])); +}; + +Tokenizer.prototype._read_regexp = function(c, previous_token) { + + if (c === '/' && this._allow_regexp_or_xml(previous_token)) { + // handle regexp + // + var resulting_string = this._input.next(); + var esc = false; + + var in_char_class = false; + while (this._input.hasNext() && + ((esc || in_char_class || this._input.peek() !== c) && + !this._input.testChar(acorn.newline))) { + resulting_string += this._input.peek(); + if (!esc) { + esc = this._input.peek() === '\\'; + if (this._input.peek() === '[') { + in_char_class = true; + } else if (this._input.peek() === ']') { + in_char_class = false; + } + } else { + esc = false; + } + this._input.next(); + } + + if (this._input.peek() === c) { + resulting_string += this._input.next(); + + // regexps may have modifiers /regexp/MOD , so fetch those, too + // Only [gim] are valid, but if the user puts in garbage, do what we can to take it. + resulting_string += this._input.read(acorn.identifier); + } + return this._create_token(TOKEN.STRING, resulting_string); + } + return null; +}; + + +var startXmlRegExp = /<()([-a-zA-Z:0-9_.]+|{[\s\S]+?}|!\[CDATA\[[\s\S]*?\]\])(\s+{[\s\S]+?}|\s+[-a-zA-Z:0-9_.]+|\s+[-a-zA-Z:0-9_.]+\s*=\s*('[^']*'|"[^"]*"|{[\s\S]+?}))*\s*(\/?)\s*>/g; +var xmlRegExp = /[\s\S]*?<(\/?)([-a-zA-Z:0-9_.]+|{[\s\S]+?}|!\[CDATA\[[\s\S]*?\]\])(\s+{[\s\S]+?}|\s+[-a-zA-Z:0-9_.]+|\s+[-a-zA-Z:0-9_.]+\s*=\s*('[^']*'|"[^"]*"|{[\s\S]+?}))*\s*(\/?)\s*>/g; + +Tokenizer.prototype._read_xml = function(c, previous_token) { + + if (this._options.e4x && c === "<" && this._input.test(startXmlRegExp) && this._allow_regexp_or_xml(previous_token)) { + // handle e4x xml literals + // + var xmlStr = ''; + var match = this._input.match(startXmlRegExp); + if (match) { + // Trim root tag to attempt to + var trimIndentStr = match[2].replace(/^{\s+/, '{'); + var indent = match[2].length - trimIndentStr.length; + var rootTag = trimIndentStr.replace(/\s+}$/, '}'); + var isCurlyRoot = rootTag.indexOf('{') === 0; + var depth = 0; + while (match) { + var isEndTag = !!match[1]; + var tagName = match[2]; + var isSingletonTag = (!!match[match.length - 1]) || (tagName.slice(0, 8) === "![CDATA["); + if (!isSingletonTag && + (tagName === rootTag || (isCurlyRoot && tagName.replace(/^{\s+/, '{').replace(/\s+}$/, '}')))) { + if (isEndTag) { + --depth; + } else { + ++depth; + } + } + xmlStr += match[0]; + if (depth <= 0) { + break; + } + match = this._input.match(xmlRegExp); + } + // if we didn't close correctly, keep unformatted. + if (!match) { + xmlStr += this._input.match(/[\s\S]*/g)[0]; + }else{ + xmlStr = prettifyXml(xmlStr,{ + margin: ' ' + }); + java.lang.System.out.println(" match: " + match[2] + ", xml = " + xmlStr); + } + xmlStr = xmlStr.replace(acorn.allLineBreaks, '\n'); + return this._create_token(TOKEN.XML, xmlStr); + } + } + + return null; +}; + +function unescape_string(s) { + // You think that a regex would work for this + // return s.replace(/\\x([0-9a-f]{2})/gi, function(match, val) { + // return String.fromCharCode(parseInt(val, 16)); + // }) + // However, dealing with '\xff', '\\xff', '\\\xff' makes this more fun. + var out = '', + escaped = 0; + + var input_scan = new InputScanner(s); + var matched = null; + + while (input_scan.hasNext()) { + // Keep any whitespace, non-slash characters + // also keep slash pairs. + matched = input_scan.match(/([\s]|[^\\]|\\\\)+/g); + + if (matched) { + out += matched[0]; + } + + if (input_scan.peek() === '\\') { + input_scan.next(); + if (input_scan.peek() === 'x') { + matched = input_scan.match(/x([0-9A-Fa-f]{2})/g); + } else if (input_scan.peek() === 'u') { + matched = input_scan.match(/u([0-9A-Fa-f]{4})/g); + } else { + out += '\\'; + if (input_scan.hasNext()) { + out += input_scan.next(); + } + continue; + } + + // If there's some error decoding, return the original string + if (!matched) { + return s; + } + + escaped = parseInt(matched[1], 16); + + if (escaped > 0x7e && escaped <= 0xff && matched[0].indexOf('x') === 0) { + // we bail out on \x7f..\xff, + // leaving whole string escaped, + // as it's probably completely binary + return s; + } else if (escaped >= 0x00 && escaped < 0x20) { + // leave 0x00...0x1f escaped + out += '\\' + matched[0]; + continue; + } else if (escaped === 0x22 || escaped === 0x27 || escaped === 0x5c) { + // single-quote, apostrophe, backslash - escape these + out += '\\' + String.fromCharCode(escaped); + } else { + out += String.fromCharCode(escaped); + } + } + } + + return out; +} + +// handle string +// +Tokenizer.prototype._read_string_recursive = function(delimiter, allow_unescaped_newlines, start_sub) { + // Template strings can travers lines without escape characters. + // Other strings cannot + var current_char; + var resulting_string = ''; + var esc = false; + while (this._input.hasNext()) { + current_char = this._input.peek(); + if (!(esc || (current_char !== delimiter && + (allow_unescaped_newlines || !acorn.newline.test(current_char))))) { + break; + } + + // Handle \r\n linebreaks after escapes or in template strings + if ((esc || allow_unescaped_newlines) && acorn.newline.test(current_char)) { + if (current_char === '\r' && this._input.peek(1) === '\n') { + this._input.next(); + current_char = this._input.peek(); + } + resulting_string += '\n'; + } else { + resulting_string += current_char; + } + + if (esc) { + if (current_char === 'x' || current_char === 'u') { + this.has_char_escapes = true; + } + esc = false; + } else { + esc = current_char === '\\'; + } + + this._input.next(); + + if (start_sub && resulting_string.indexOf(start_sub, resulting_string.length - start_sub.length) !== -1) { + if (delimiter === '`') { + resulting_string += this._read_string_recursive('}', allow_unescaped_newlines, '`'); + } else { + resulting_string += this._read_string_recursive('`', allow_unescaped_newlines, '${'); + } + + if (this._input.hasNext()) { + resulting_string += this._input.next(); + } + } + } + + return resulting_string; +}; + +module.exports.Tokenizer = Tokenizer; +module.exports.TOKEN = TOKEN; +module.exports.positionable_operators = positionable_operators.slice(); +module.exports.line_starters = line_starters.slice(); \ No newline at end of file diff --git a/app/src/main/java/org/autojs/autojs/tool/ImageSelector.java b/app/src/main/java/org/autojs/autojs/tool/ImageSelector.java index 63439ea4..cb99bb9c 100644 --- a/app/src/main/java/org/autojs/autojs/tool/ImageSelector.java +++ b/app/src/main/java/org/autojs/autojs/tool/ImageSelector.java @@ -4,17 +4,14 @@ import android.app.Activity; import android.content.Intent; import android.net.Uri; -import com.stardust.app.OnActivityResultDelegate; +import com.stardust.app.OnActivityResultListener; import org.autojs.autojs.R; -import java.io.FileNotFoundException; -import java.io.InputStream; - /** * Created by Stardust on 2017/3/5. */ -public class ImageSelector implements OnActivityResultDelegate { +public class ImageSelector implements OnActivityResultListener { public interface ImageSelectorCallback { void onImageSelected(ImageSelector selector, Uri uri); @@ -26,13 +23,13 @@ public class ImageSelector implements OnActivityResultDelegate { private Activity mActivity; private ImageSelectorCallback mCallback; private boolean mDisposable; - private Mediator mMediator; + private ActivityResultObserver mActivityResultObserver; - public ImageSelector(Activity activity, OnActivityResultDelegate.Mediator mediator, ImageSelectorCallback callback) { - mediator.addDelegate(REQUEST_CODE, this); + public ImageSelector(Activity activity, ActivityResultObserver activityResultObserver, ImageSelectorCallback callback) { + activityResultObserver.addListener(REQUEST_CODE, this); mActivity = activity; mCallback = callback; - mMediator = mediator; + mActivityResultObserver = activityResultObserver; } public void select() { @@ -49,7 +46,7 @@ public class ImageSelector implements OnActivityResultDelegate { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (mDisposable) { - mMediator.removeDelegate(this); + mActivityResultObserver.removeListener(this); } if (data == null) { mCallback.onImageSelected(this, null); diff --git a/app/src/main/java/org/autojs/autojs/ui/edit/EditActivity.java b/app/src/main/java/org/autojs/autojs/ui/edit/EditActivity.java index e751d2ab..736aebe4 100644 --- a/app/src/main/java/org/autojs/autojs/ui/edit/EditActivity.java +++ b/app/src/main/java/org/autojs/autojs/ui/edit/EditActivity.java @@ -8,7 +8,7 @@ import android.view.ActionMode; import android.view.Menu; import android.view.MenuItem; -import com.stardust.app.OnActivityResultDelegate; +import com.stardust.app.OnActivityResultListener; import com.stardust.autojs.core.permission.OnRequestPermissionsResultCallback; import com.stardust.autojs.core.permission.PermissionRequestProxyActivity; import com.stardust.autojs.core.permission.RequestPermissionCallbacks; @@ -40,9 +40,9 @@ import static org.autojs.autojs.ui.edit.EditorView.EXTRA_READ_ONLY; * Created by Stardust on 2017/1/29. */ @EActivity(R.layout.activity_edit) -public class EditActivity extends BaseActivity implements OnActivityResultDelegate.DelegateHost, PermissionRequestProxyActivity { +public class EditActivity extends BaseActivity implements OnActivityResultListener.ObservableActivity, PermissionRequestProxyActivity { - private OnActivityResultDelegate.Mediator mMediator = new OnActivityResultDelegate.Mediator(); + private OnActivityResultListener.ActivityResultObserver mActivityResultObserver = new OnActivityResultListener.ActivityResultObserver(); @ViewById(R.id.editor_view) EditorView mEditorView; @@ -147,13 +147,13 @@ public class EditActivity extends BaseActivity implements OnActivityResultDelega @NonNull @Override - public OnActivityResultDelegate.Mediator getOnActivityResultDelegateMediator() { - return mMediator; + public OnActivityResultListener.ActivityResultObserver getActivityResultObserver() { + return mActivityResultObserver; } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { - mMediator.onActivityResult(requestCode, resultCode, data); + mActivityResultObserver.onActivityResult(requestCode, resultCode, data); } @Override diff --git a/app/src/main/java/org/autojs/autojs/ui/edit/ViewSampleActivity.java b/app/src/main/java/org/autojs/autojs/ui/edit/ViewSampleActivity.java index e553e15c..e15fe551 100644 --- a/app/src/main/java/org/autojs/autojs/ui/edit/ViewSampleActivity.java +++ b/app/src/main/java/org/autojs/autojs/ui/edit/ViewSampleActivity.java @@ -12,7 +12,7 @@ import android.view.Menu; import android.view.MenuItem; import android.view.View; -import com.stardust.app.OnActivityResultDelegate; +import com.stardust.app.OnActivityResultListener; import com.stardust.autojs.engine.JavaScriptEngine; import com.stardust.autojs.execution.ScriptExecution; import org.autojs.autojs.R; @@ -21,7 +21,6 @@ import org.autojs.autojs.model.sample.SampleFile; import org.autojs.autojs.ui.BaseActivity; import org.autojs.autojs.ui.common.ScriptOperations; import com.stardust.theme.ThemeColorManager; -import com.stardust.util.AssetsCache; import com.stardust.util.SparseArrayEntries; import org.autojs.autojs.ui.widget.ToolbarMenuItem; @@ -38,7 +37,7 @@ import static org.autojs.autojs.model.script.Scripts.EXTRA_EXCEPTION_MESSAGE; /** * Created by Stardust on 2017/4/29. */ -public class ViewSampleActivity extends AppCompatActivity implements OnActivityResultDelegate.DelegateHost { +public class ViewSampleActivity extends AppCompatActivity implements OnActivityResultListener.ObservableActivity { public static void view(Context context, SampleFile sample) { @@ -51,7 +50,7 @@ public class ViewSampleActivity extends AppCompatActivity implements OnActivityR private SampleFile mSample; private ScriptExecution mScriptExecution; private SparseArray mMenuMap; - private OnActivityResultDelegate.Mediator mMediator = new OnActivityResultDelegate.Mediator(); + private OnActivityResultListener.ActivityResultObserver mActivityResultObserver = new OnActivityResultListener.ActivityResultObserver(); private BroadcastReceiver mOnRunFinishedReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { @@ -182,12 +181,12 @@ public class ViewSampleActivity extends AppCompatActivity implements OnActivityR } @Override - public OnActivityResultDelegate.Mediator getOnActivityResultDelegateMediator() { - return mMediator; + public OnActivityResultListener.ActivityResultObserver getActivityResultObserver() { + return mActivityResultObserver; } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { - mMediator.onActivityResult(requestCode, resultCode, data); + mActivityResultObserver.onActivityResult(requestCode, resultCode, data); } } diff --git a/app/src/main/java/org/autojs/autojs/ui/edit/editor/CodeEditor.java b/app/src/main/java/org/autojs/autojs/ui/edit/editor/CodeEditor.java index c0dccbbd..89aa5571 100644 --- a/app/src/main/java/org/autojs/autojs/ui/edit/editor/CodeEditor.java +++ b/app/src/main/java/org/autojs/autojs/ui/edit/editor/CodeEditor.java @@ -80,7 +80,7 @@ public class CodeEditor extends HVScrollView { mTextViewRedoUndo = new TextViewUndoRedo(mCodeEditText); mJavaScriptHighlighter = new JavaScriptHighlighter(mTheme, mCodeEditText); setTheme(Theme.getDefault(getContext())); - mJsBeautifier = new JsBeautifier(this, "js/beautify.js"); + mJsBeautifier = new JsBeautifier(this, "js/js-beautify"); } diff --git a/app/src/main/java/org/autojs/autojs/ui/main/MainActivity.java b/app/src/main/java/org/autojs/autojs/ui/main/MainActivity.java index aee04a89..604a4aeb 100644 --- a/app/src/main/java/org/autojs/autojs/ui/main/MainActivity.java +++ b/app/src/main/java/org/autojs/autojs/ui/main/MainActivity.java @@ -3,12 +3,10 @@ package org.autojs.autojs.ui.main; import android.Manifest; import android.content.Intent; import android.content.pm.PackageManager; -import android.os.Build; import android.os.Bundle; import android.support.annotation.NonNull; import android.support.design.widget.FloatingActionButton; import android.support.design.widget.TabLayout; -import android.support.v4.app.ActivityCompat; import android.support.v4.app.Fragment; import android.support.v4.view.ViewPager; import android.support.v4.widget.DrawerLayout; @@ -20,8 +18,7 @@ import android.view.MenuItem; import android.view.View; import com.stardust.app.FragmentPagerAdapterBuilder; -import com.stardust.app.OnActivityResultDelegate; -import com.stardust.autojs.core.image.OpenCVHelper; +import com.stardust.app.OnActivityResultListener; import com.stardust.autojs.core.permission.OnRequestPermissionsResultCallback; import com.stardust.autojs.core.permission.PermissionRequestProxyActivity; import com.stardust.autojs.core.permission.RequestPermissionCallbacks; @@ -33,7 +30,6 @@ import org.autojs.autojs.Pref; import org.autojs.autojs.R; import org.autojs.autojs.autojs.AutoJs; import org.autojs.autojs.storage.file.StorageFileProvider; -import org.autojs.autojs.timing.TimedTaskManager; import org.autojs.autojs.tool.AccessibilityServiceTool; import org.autojs.autojs.ui.BaseActivity; import org.autojs.autojs.ui.common.NotAskAgainDialog; @@ -52,8 +48,6 @@ import org.autojs.autojs.ui.widget.SearchViewItem; import com.stardust.theme.ThemeColorManager; -import org.autojs.autojs.theme.dialog.ThemeColorMaterialDialogBuilder; - import com.stardust.util.BackPressedHandler; import com.stardust.util.DeveloperUtils; import com.stardust.util.DrawerAutoClose; @@ -64,12 +58,11 @@ import org.androidannotations.annotations.EActivity; import org.androidannotations.annotations.ViewById; import org.greenrobot.eventbus.EventBus; import org.greenrobot.eventbus.Subscribe; -import org.opencv.core.Core; import java.util.Arrays; @EActivity(R.layout.activity_main) -public class MainActivity extends BaseActivity implements OnActivityResultDelegate.DelegateHost, BackPressedHandler.HostActivity, PermissionRequestProxyActivity { +public class MainActivity extends BaseActivity implements OnActivityResultListener.ObservableActivity, BackPressedHandler.HostActivity, PermissionRequestProxyActivity { public static class DrawerOpenEvent { @@ -88,7 +81,7 @@ public class MainActivity extends BaseActivity implements OnActivityResultDelega FloatingActionButton mFab; private FragmentPagerAdapterBuilder.StoredFragmentPagerAdapter mPagerAdapter; - private OnActivityResultDelegate.Mediator mActivityResultMediator = new OnActivityResultDelegate.Mediator(); + private OnActivityResultListener.ActivityResultObserver mActivityResultActivityResultObserver = new OnActivityResultListener.ActivityResultObserver(); private RequestPermissionCallbacks mRequestPermissionCallbacks = new RequestPermissionCallbacks(); private VersionGuard mVersionGuard; private BackPressedHandler.Observer mBackPressObserver = new BackPressedHandler.Observer(); @@ -235,7 +228,7 @@ public class MainActivity extends BaseActivity implements OnActivityResultDelega @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { - mActivityResultMediator.onActivityResult(requestCode, resultCode, data); + mActivityResultActivityResultObserver.onActivityResult(requestCode, resultCode, data); } @Override @@ -268,8 +261,8 @@ public class MainActivity extends BaseActivity implements OnActivityResultDelega @NonNull @Override - public OnActivityResultDelegate.Mediator getOnActivityResultDelegateMediator() { - return mActivityResultMediator; + public OnActivityResultListener.ActivityResultObserver getActivityResultObserver() { + return mActivityResultActivityResultObserver; } @Override diff --git a/app/src/main/java/org/autojs/autojs/ui/user/WebActivity.java b/app/src/main/java/org/autojs/autojs/ui/user/WebActivity.java index 4cd4d720..a9e2e053 100644 --- a/app/src/main/java/org/autojs/autojs/ui/user/WebActivity.java +++ b/app/src/main/java/org/autojs/autojs/ui/user/WebActivity.java @@ -3,7 +3,7 @@ package org.autojs.autojs.ui.user; import android.content.Intent; import android.support.annotation.NonNull; -import com.stardust.app.OnActivityResultDelegate; +import com.stardust.app.OnActivityResultListener; import org.autojs.autojs.R; import org.autojs.autojs.ui.BaseActivity; import org.autojs.autojs.ui.widget.EWebView; @@ -16,11 +16,11 @@ import org.androidannotations.annotations.ViewById; * Created by Stardust on 2017/10/26. */ @EActivity(R.layout.activity_web) -public class WebActivity extends BaseActivity implements OnActivityResultDelegate.DelegateHost { +public class WebActivity extends BaseActivity implements OnActivityResultListener.ObservableActivity { public static final String EXTRA_URL = "url"; - private OnActivityResultDelegate.Mediator mMediator = new OnActivityResultDelegate.Mediator(); + private OnActivityResultListener.ActivityResultObserver mActivityResultObserver = new OnActivityResultListener.ActivityResultObserver(); @ViewById(R.id.eweb_view) EWebView mEWebView; @@ -33,12 +33,12 @@ public class WebActivity extends BaseActivity implements OnActivityResultDelegat @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { - mMediator.onActivityResult(requestCode, resultCode, data); + mActivityResultObserver.onActivityResult(requestCode, resultCode, data); } @NonNull @Override - public OnActivityResultDelegate.Mediator getOnActivityResultDelegateMediator() { - return mMediator; + public OnActivityResultListener.ActivityResultObserver getActivityResultObserver() { + return mActivityResultObserver; } } diff --git a/app/src/main/java/org/autojs/autojs/ui/widget/EWebView.java b/app/src/main/java/org/autojs/autojs/ui/widget/EWebView.java index 7340072c..36c18b8f 100644 --- a/app/src/main/java/org/autojs/autojs/ui/widget/EWebView.java +++ b/app/src/main/java/org/autojs/autojs/ui/widget/EWebView.java @@ -20,16 +20,10 @@ import android.webkit.WebViewClient; import android.widget.FrameLayout; import android.widget.ProgressBar; -import com.stardust.app.OnActivityResultDelegate; +import com.stardust.app.OnActivityResultListener; import org.autojs.autojs.R; import org.autojs.autojs.tool.ImageSelector; -import com.stardust.util.IntentUtil; -import org.androidannotations.annotations.OnActivityResult; -import org.androidannotations.annotations.ViewById; - -import java.io.File; -import java.io.InputStream; import java.util.Arrays; import java.util.List; import java.util.concurrent.TimeUnit; @@ -41,7 +35,7 @@ import io.reactivex.android.schedulers.AndroidSchedulers; * Created by Stardust on 2017/8/22. */ -public class EWebView extends FrameLayout implements SwipeRefreshLayout.OnRefreshListener, OnActivityResultDelegate { +public class EWebView extends FrameLayout implements SwipeRefreshLayout.OnRefreshListener, OnActivityResultListener { private static final List IMAGE_TYPES = Arrays.asList("png", "jpg", "bmp"); private static final int CHOOSE_IMAGE = 42222; @@ -133,7 +127,7 @@ public class EWebView extends FrameLayout implements SwipeRefreshLayout.OnRefres public boolean openFileChooser(ValueCallback valueCallback, String[] acceptType) { - if (getContext() instanceof OnActivityResultDelegate.DelegateHost && + if (getContext() instanceof ObservableActivity && getContext() instanceof Activity && isImageType(acceptType)) { chooseImage(valueCallback); return true; @@ -161,10 +155,10 @@ public class EWebView extends FrameLayout implements SwipeRefreshLayout.OnRefres } private void chooseImage(ValueCallback valueCallback) { - DelegateHost delegateHost = ((OnActivityResultDelegate.DelegateHost) getContext()); - Mediator mediator = delegateHost.getOnActivityResultDelegateMediator(); + ObservableActivity observableActivity = ((ObservableActivity) getContext()); + ActivityResultObserver activityResultObserver = observableActivity.getActivityResultObserver(); Activity activity = (Activity) getContext(); - new ImageSelector(activity, mediator, (selector, uri) -> valueCallback.onReceiveValue(uri)) + new ImageSelector(activity, activityResultObserver, (selector, uri) -> valueCallback.onReceiveValue(uri)) .disposable() .select(); } diff --git a/autojs/src/main/java/com/stardust/autojs/AutoJs.java b/autojs/src/main/java/com/stardust/autojs/AutoJs.java index 2f95ba50..8e545659 100644 --- a/autojs/src/main/java/com/stardust/autojs/AutoJs.java +++ b/autojs/src/main/java/com/stardust/autojs/AutoJs.java @@ -8,7 +8,7 @@ import android.os.Bundle; import android.support.annotation.Nullable; import android.support.annotation.RequiresApi; -import com.stardust.app.OnActivityResultDelegate; +import com.stardust.app.OnActivityResultListener; import com.stardust.app.SimpleActivityLifecycleCallbacks; import com.stardust.autojs.core.accessibility.AccessibilityBridge; import com.stardust.autojs.core.console.GlobalStardustConsole; @@ -228,9 +228,9 @@ public abstract class AutoJs { @Override public void request() { Activity activity = mAppUtils.getCurrentActivity(); - if (activity instanceof OnActivityResultDelegate.DelegateHost) { + if (activity instanceof OnActivityResultListener.ObservableActivity) { ScreenCaptureRequester requester = new ActivityScreenCaptureRequester( - ((OnActivityResultDelegate.DelegateHost) activity).getOnActivityResultDelegateMediator(), activity); + ((OnActivityResultListener.ObservableActivity) activity).getActivityResultObserver(), activity); requester.setOnActivityResultCallback(mCallback); requester.request(); } else { diff --git a/autojs/src/main/java/com/stardust/autojs/core/image/capture/ScreenCaptureRequestActivity.java b/autojs/src/main/java/com/stardust/autojs/core/image/capture/ScreenCaptureRequestActivity.java index 103039bd..2fbd9997 100644 --- a/autojs/src/main/java/com/stardust/autojs/core/image/capture/ScreenCaptureRequestActivity.java +++ b/autojs/src/main/java/com/stardust/autojs/core/image/capture/ScreenCaptureRequestActivity.java @@ -8,7 +8,7 @@ import android.os.Bundle; import android.support.annotation.Nullable; import android.support.annotation.RequiresApi; -import com.stardust.app.OnActivityResultDelegate; +import com.stardust.app.OnActivityResultListener; import com.stardust.util.IntentExtras; /** @@ -18,7 +18,7 @@ import com.stardust.util.IntentExtras; @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) public class ScreenCaptureRequestActivity extends Activity { - private OnActivityResultDelegate.Mediator mOnActivityResultDelegateMediator = new OnActivityResultDelegate.Mediator(); + private OnActivityResultListener.ActivityResultObserver mOnActivityResultDelegateActivityResultObserver = new OnActivityResultListener.ActivityResultObserver(); private ScreenCaptureRequester mScreenCaptureRequester; private ScreenCaptureRequester.Callback mCallback; @@ -44,7 +44,7 @@ public class ScreenCaptureRequestActivity extends Activity { finish(); return; } - mScreenCaptureRequester = new ScreenCaptureRequester.ActivityScreenCaptureRequester(mOnActivityResultDelegateMediator, this); + mScreenCaptureRequester = new ScreenCaptureRequester.ActivityScreenCaptureRequester(mOnActivityResultDelegateActivityResultObserver, this); mScreenCaptureRequester.setOnActivityResultCallback(mCallback); mScreenCaptureRequester.request(); } @@ -61,7 +61,7 @@ public class ScreenCaptureRequestActivity extends Activity { @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { - mOnActivityResultDelegateMediator.onActivityResult(requestCode, resultCode, data); + mOnActivityResultDelegateActivityResultObserver.onActivityResult(requestCode, resultCode, data); finish(); } diff --git a/autojs/src/main/java/com/stardust/autojs/core/image/capture/ScreenCaptureRequester.java b/autojs/src/main/java/com/stardust/autojs/core/image/capture/ScreenCaptureRequester.java index d88d5fd9..1d17d795 100644 --- a/autojs/src/main/java/com/stardust/autojs/core/image/capture/ScreenCaptureRequester.java +++ b/autojs/src/main/java/com/stardust/autojs/core/image/capture/ScreenCaptureRequester.java @@ -7,7 +7,7 @@ import android.media.projection.MediaProjectionManager; import android.os.Build; import android.support.annotation.RequiresApi; -import com.stardust.app.OnActivityResultDelegate; +import com.stardust.app.OnActivityResultListener; /** * Created by Stardust on 2017/5/17. @@ -53,16 +53,16 @@ public interface ScreenCaptureRequester { } @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) - class ActivityScreenCaptureRequester extends AbstractScreenCaptureRequester implements ScreenCaptureRequester, OnActivityResultDelegate { + class ActivityScreenCaptureRequester extends AbstractScreenCaptureRequester implements ScreenCaptureRequester, OnActivityResultListener { private static final int REQUEST_CODE_MEDIA_PROJECTION = 17777; - private OnActivityResultDelegate.Mediator mMediator; + private ActivityResultObserver mActivityResultObserver; private Activity mActivity; - public ActivityScreenCaptureRequester(Mediator mediator, Activity activity) { - mMediator = mediator; + public ActivityScreenCaptureRequester(ActivityResultObserver activityResultObserver, Activity activity) { + mActivityResultObserver = activityResultObserver; mActivity = activity; - mMediator.addDelegate(REQUEST_CODE_MEDIA_PROJECTION, this); + mActivityResultObserver.addListener(REQUEST_CODE_MEDIA_PROJECTION, this); } @@ -74,7 +74,7 @@ public interface ScreenCaptureRequester { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { mResult = data; - mMediator.removeDelegate(this); + mActivityResultObserver.removeListener(this); onResult(resultCode, data); } } diff --git a/autojs/src/main/java/com/stardust/autojs/core/inputevent/RootAutomator.java b/autojs/src/main/java/com/stardust/autojs/core/inputevent/RootAutomator.java index 852b811e..2c815c79 100644 --- a/autojs/src/main/java/com/stardust/autojs/core/inputevent/RootAutomator.java +++ b/autojs/src/main/java/com/stardust/autojs/core/inputevent/RootAutomator.java @@ -44,7 +44,7 @@ public class RootAutomator { @Nullable private ScreenMetrics mScreenMetrics; private AbstractShell mShell; - private int mDefaultId = 1; + private int mDefaultId = 10000; public RootAutomator(Context context) { mShell = new ProcessShell(true); @@ -151,11 +151,11 @@ public class RootAutomator { public void touchDown(int x, int y, int id) throws IOException { sendEvent(EV_ABS, ABS_MT_TRACKING_ID, id); - sendEvent(EV_KEY, BTN_TOUCH, 0x00000001); - sendEvent(EV_KEY, BTN_TOOL_FINGER, 0x00000001); + //sendEvent(EV_KEY, BTN_TOOL_FINGER, 0x00000001); sendEvent(EV_ABS, ABS_MT_POSITION_X, scaleX(x)); sendEvent(EV_ABS, ABS_MT_POSITION_Y, scaleY(y)); - sendEvent(EV_ABS, ABS_MT_TOUCH_MAJOR, 5); + sendEvent(EV_KEY, BTN_TOUCH, 0x00000001); + // sendEvent(EV_ABS, ABS_MT_TOUCH_MAJOR, 5); sendEvent(EV_SYN, SYN_REPORT, 0x00000000); } @@ -164,9 +164,9 @@ public class RootAutomator { } public void touchUp(int id) throws IOException { - sendEvent(EV_ABS, ABS_MT_TRACKING_ID, id); + sendEvent(EV_ABS, ABS_MT_TRACKING_ID, 0xffffffff); sendEvent(EV_KEY, BTN_TOUCH, 0x00000000); - sendEvent(EV_KEY, BTN_TOOL_FINGER, 0x00000000); + //sendEvent(EV_KEY, BTN_TOOL_FINGER, 0x00000000); sendEvent(EV_SYN, SYN_REPORT, 0x00000000); } diff --git a/autojs/src/main/java/com/stardust/autojs/engine/AssetAndUrlModuleSourceProvider.java b/autojs/src/main/java/com/stardust/autojs/engine/AssetAndUrlModuleSourceProvider.java index 6cb6e0d9..85ab1bfd 100644 --- a/autojs/src/main/java/com/stardust/autojs/engine/AssetAndUrlModuleSourceProvider.java +++ b/autojs/src/main/java/com/stardust/autojs/engine/AssetAndUrlModuleSourceProvider.java @@ -1,5 +1,6 @@ package com.stardust.autojs.engine; +import android.content.res.AssetManager; import android.net.Uri; import org.mozilla.javascript.Scriptable; @@ -7,6 +8,7 @@ import org.mozilla.javascript.commonjs.module.provider.ModuleSource; import org.mozilla.javascript.commonjs.module.provider.UrlModuleSourceProvider; import java.io.File; +import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStreamReader; import java.net.URI; @@ -21,19 +23,17 @@ import java.util.List; public class AssetAndUrlModuleSourceProvider extends UrlModuleSourceProvider { - private static final String MODULES_PATH = "modules"; private android.content.Context mContext; - private List mModules; - private final URI mBaseURI = URI.create("file:///android_asset/modules"); + private final URI mBaseURI; + private final String mAssetDirPath; + private final AssetManager mAssetManager; - public AssetAndUrlModuleSourceProvider(android.content.Context context, List list) { + public AssetAndUrlModuleSourceProvider(android.content.Context context, String assetDirPath, List list) { super(list, null); mContext = context; - try { - mModules = Arrays.asList(mContext.getAssets().list(MODULES_PATH)); - } catch (IOException e) { - throw new RuntimeException(e); - } + mAssetDirPath = assetDirPath; + mBaseURI = URI.create("file:///android_asset/" + assetDirPath); + mAssetManager = mContext.getAssets(); } @Override @@ -42,10 +42,11 @@ public class AssetAndUrlModuleSourceProvider extends UrlModuleSourceProvider { if (!moduleIdWithExtension.endsWith(".js")) { moduleIdWithExtension += ".js"; } - if (mModules.contains(moduleIdWithExtension)) { - return new ModuleSource(new InputStreamReader(mContext.getAssets().open(MODULES_PATH + "/" + moduleIdWithExtension)), null, - URI.create(moduleIdWithExtension), mBaseURI, validator); + try { + return new ModuleSource(new InputStreamReader(mAssetManager.open(mAssetDirPath + "/" + moduleIdWithExtension)), null, + new URI(mBaseURI.toString() + "/" + moduleIdWithExtension), mBaseURI, validator); + } catch (FileNotFoundException e) { + return super.loadFromPrivilegedLocations(moduleId, validator); } - return super.loadFromPrivilegedLocations(moduleId, validator); } } \ No newline at end of file diff --git a/autojs/src/main/java/com/stardust/autojs/engine/RhinoJavaScriptEngine.java b/autojs/src/main/java/com/stardust/autojs/engine/RhinoJavaScriptEngine.java index dfd1b86b..f5543bc4 100644 --- a/autojs/src/main/java/com/stardust/autojs/engine/RhinoJavaScriptEngine.java +++ b/autojs/src/main/java/com/stardust/autojs/engine/RhinoJavaScriptEngine.java @@ -47,6 +47,7 @@ public class RhinoJavaScriptEngine extends JavaScriptEngine { public static final String SOURCE_NAME_INIT = ""; + private static final String MODULES_PATH = "modules"; private static final String LOG_TAG = "RhinoJavaScriptEngine"; private static int contextCount = 0; @@ -129,7 +130,7 @@ public class RhinoJavaScriptEngine extends JavaScriptEngine { } void initRequireBuilder(Context context, Scriptable scope) { - AssetAndUrlModuleSourceProvider provider = new AssetAndUrlModuleSourceProvider(mAndroidContext, + AssetAndUrlModuleSourceProvider provider = new AssetAndUrlModuleSourceProvider(mAndroidContext, MODULES_PATH, Collections.singletonList(new File("/").toURI())); new RequireBuilder() .setModuleScriptProvider(new SoftCachingModuleScriptProvider(provider)) diff --git a/autojs/src/main/java/com/stardust/autojs/script/JsBeautifier.java b/autojs/src/main/java/com/stardust/autojs/script/JsBeautifier.java index 0006f6b9..845d293f 100644 --- a/autojs/src/main/java/com/stardust/autojs/script/JsBeautifier.java +++ b/autojs/src/main/java/com/stardust/autojs/script/JsBeautifier.java @@ -4,14 +4,20 @@ import android.content.Context; import android.util.Log; import android.view.View; +import com.stardust.autojs.engine.AssetAndUrlModuleSourceProvider; import com.stardust.pio.PFiles; import com.stardust.pio.UncheckedIOException; import org.mozilla.javascript.Function; +import org.mozilla.javascript.ImporterTopLevel; import org.mozilla.javascript.Scriptable; +import org.mozilla.javascript.commonjs.module.RequireBuilder; +import org.mozilla.javascript.commonjs.module.provider.SoftCachingModuleScriptProvider; +import java.io.File; import java.io.IOException; import java.io.InputStream; +import java.util.Collections; import java.util.concurrent.Executor; import java.util.concurrent.Executors; @@ -28,18 +34,30 @@ public class JsBeautifier { void onException(Exception e); } + private static final String LOG_TAG = "JsBeautifier"; + private Executor mExecutor = Executors.newSingleThreadExecutor(); private Context mContext; private Function mJsBeautifyFunction; private org.mozilla.javascript.Context mScriptContext; private Scriptable mScriptable; private final String mBeautifyJsPath; + private final String mBeautifyJsDir; private View mView; + private File mJsDir; - public JsBeautifier(View view, String beautifyJsPath) { + public JsBeautifier(View view, String beautifyJsDirPath) { mContext = view.getContext(); mView = view; - mBeautifyJsPath = beautifyJsPath; + mBeautifyJsDir = beautifyJsDirPath; + mBeautifyJsPath = PFiles.join(beautifyJsDirPath, "index.js"); + mExecutor.execute(this::copyJsFiles); + } + + private void copyJsFiles() { + mJsDir = new File(mContext.getFilesDir(), "js-beautify/"); + boolean result = PFiles.copyAssetDir(mContext, mBeautifyJsDir, mJsDir.getPath()); + Log.d(LOG_TAG, "copyJsFiles: " + result); } public void beautify(final String code, final Callback callback) { @@ -65,11 +83,24 @@ public class JsBeautifier { } private void enterContext() { - if (mScriptContext == null) { - mScriptContext = org.mozilla.javascript.Context.enter(); - mScriptContext.setLanguageVersion(org.mozilla.javascript.Context.VERSION_1_8); - mScriptContext.setOptimizationLevel(-1); + if (mScriptContext != null) { + return; } + mScriptContext = org.mozilla.javascript.Context.enter(); + mScriptContext.setLanguageVersion(org.mozilla.javascript.Context.VERSION_1_8); + mScriptContext.setOptimizationLevel(-1); + if (mScriptable == null){ + ImporterTopLevel importerTopLevel = new ImporterTopLevel(); + importerTopLevel.initStandardObjects(mScriptContext, false); + mScriptable = importerTopLevel; + } + AssetAndUrlModuleSourceProvider provider = new AssetAndUrlModuleSourceProvider(mContext, mBeautifyJsDir, + Collections.singletonList(new File("/").toURI())); + new RequireBuilder() + .setModuleScriptProvider(new SoftCachingModuleScriptProvider(provider)) + .setSandboxed(false) + .createRequire(mScriptContext, mScriptable) + .install(mScriptable); } public void prepare() { @@ -93,8 +124,6 @@ public class JsBeautifier { try { enterContext(); InputStream is = mContext.getAssets().open(mBeautifyJsPath); - if (mScriptable == null) - mScriptable = mScriptContext.initSafeStandardObjects(); mJsBeautifyFunction = (Function) mScriptContext.evaluateString(mScriptable, PFiles.read(is), "", 1, null); } catch (IOException e) { exitContext(); diff --git a/common/src/main/java/com/stardust/app/OnActivityResultDelegate.java b/common/src/main/java/com/stardust/app/OnActivityResultListener.java similarity index 59% rename from common/src/main/java/com/stardust/app/OnActivityResultDelegate.java rename to common/src/main/java/com/stardust/app/OnActivityResultListener.java index 03f49ee1..82413e36 100644 --- a/common/src/main/java/com/stardust/app/OnActivityResultDelegate.java +++ b/common/src/main/java/com/stardust/app/OnActivityResultListener.java @@ -11,39 +11,39 @@ import java.util.List; * Created by Stardust on 2017/3/5. */ -public interface OnActivityResultDelegate { +public interface OnActivityResultListener { void onActivityResult(int requestCode, int resultCode, Intent data); - interface DelegateHost { + interface ObservableActivity { @NonNull - Mediator getOnActivityResultDelegateMediator(); + ActivityResultObserver getActivityResultObserver(); } - class Mediator implements OnActivityResultDelegate { + class ActivityResultObserver implements OnActivityResultListener { - private SparseArray mSpecialDelegate = new SparseArray<>(); - private List mDelegates = new ArrayList<>(); + private SparseArray mSpecialDelegate = new SparseArray<>(); + private List mDelegates = new ArrayList<>(); public void onActivityResult(int requestCode, int resultCode, Intent data) { - OnActivityResultDelegate delegate = mSpecialDelegate.get(requestCode); + OnActivityResultListener delegate = mSpecialDelegate.get(requestCode); if (delegate != null) { delegate.onActivityResult(requestCode, resultCode, data); } - for (OnActivityResultDelegate d : mDelegates) { + for (OnActivityResultListener d : mDelegates) { d.onActivityResult(requestCode, resultCode, data); } } - public void addDelegate(OnActivityResultDelegate delegate) { + public void addListener(OnActivityResultListener delegate) { mDelegates.add(delegate); } - public void addDelegate(int requestCode, OnActivityResultDelegate delegate) { + public void addListener(int requestCode, OnActivityResultListener delegate) { mSpecialDelegate.put(requestCode, delegate); } - public void removeDelegate(OnActivityResultDelegate delegate) { + public void removeListener(OnActivityResultListener delegate) { if (mDelegates.remove(delegate)) { mSpecialDelegate.removeAt(mSpecialDelegate.indexOfValue(delegate)); }