diff options
Diffstat (limited to 'devtools/shared/jsbeautify/src/beautify-css.js')
| -rw-r--r-- | devtools/shared/jsbeautify/src/beautify-css.js | 1683 |
1 files changed, 1683 insertions, 0 deletions
diff --git a/devtools/shared/jsbeautify/src/beautify-css.js b/devtools/shared/jsbeautify/src/beautify-css.js new file mode 100644 index 0000000000..42cf64a856 --- /dev/null +++ b/devtools/shared/jsbeautify/src/beautify-css.js @@ -0,0 +1,1683 @@ +/* AUTO-GENERATED. DO NOT MODIFY. */ +/* + + 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. + + + CSS Beautifier +--------------- + + Written by Harutyun Amirjanyan, (amirjanyan@gmail.com) + + Based on code initially developed by: Einar Lielmanis, <einar@beautifier.io> + https://beautifier.io/ + + Usage: + css_beautify(source_text); + css_beautify(source_text, options); + + The options are (default in brackets): + indent_size (4) — indentation size, + indent_char (space) — character to indent with, + selector_separator_newline (true) - separate selectors with newline or + not (e.g. "a,\nbr" or "a, br") + end_with_newline (false) - end with a newline + newline_between_rules (true) - add a new line after every css rule + space_around_selector_separator (false) - ensure space around selector separators: + '>', '+', '~' (e.g. "a>b" -> "a > b") + e.g + + css_beautify(css_source_text, { + 'indent_size': 1, + 'indent_char': '\t', + 'selector_separator': ' ', + 'end_with_newline': false, + 'newline_between_rules': true, + 'space_around_selector_separator': true + }); +*/ + +// http://www.w3.org/TR/CSS21/syndata.html#tokenization +// http://www.w3.org/TR/css3-syntax/ + +(function() { + +/* GENERATED_BUILD_OUTPUT */ +var legacy_beautify_css = +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 15); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */, +/* 1 */, +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/*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. +*/ + + + +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.__wrap_point_index = 0; + this.__wrap_point_character_count = 0; + this.__wrap_point_indent_count = -1; + this.__wrap_point_alignment_count = 0; + + this.__items = []; +} + +OutputLine.prototype.clone_empty = function() { + var line = new OutputLine(this.__parent); + line.set_indent(this.__indent_count, this.__alignment_count); + return line; +}; + +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) { + if (this.is_empty()) { + this.__indent_count = indent || 0; + this.__alignment_count = alignment || 0; + this.__character_count = this.__parent.get_indent_size(this.__indent_count, this.__alignment_count); + } +}; + +OutputLine.prototype._set_wrap_point = function() { + if (this.__parent.wrap_line_length) { + this.__wrap_point_index = this.__items.length; + this.__wrap_point_character_count = this.__character_count; + this.__wrap_point_indent_count = this.__parent.next_line.__indent_count; + this.__wrap_point_alignment_count = this.__parent.next_line.__alignment_count; + } +}; + +OutputLine.prototype._should_wrap = function() { + return this.__wrap_point_index && + this.__character_count > this.__parent.wrap_line_length && + this.__wrap_point_character_count > this.__parent.next_line.__character_count; +}; + +OutputLine.prototype._allow_wrap = function() { + if (this._should_wrap()) { + this.__parent.add_new_line(); + var next = this.__parent.current_line; + next.set_indent(this.__wrap_point_indent_count, this.__wrap_point_alignment_count); + next.__items = this.__items.slice(this.__wrap_point_index); + this.__items = this.__items.slice(0, this.__wrap_point_index); + + next.__character_count += this.__character_count - this.__wrap_point_character_count; + this.__character_count = this.__wrap_point_character_count; + + if (next.__items[0] === " ") { + next.__items.splice(0, 1); + next.__character_count -= 1; + } + return true; + } + return false; +}; + +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); + var last_newline_index = item.lastIndexOf('\n'); + if (last_newline_index !== -1) { + this.__character_count = item.length - last_newline_index; + } else { + this.__character_count += item.length; + } +}; + +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_size; + } +}; + +OutputLine.prototype._remove_wrap_indent = function() { + if (this.__wrap_point_indent_count > 0) { + this.__wrap_point_indent_count -= 1; + } +}; +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.__parent.indent_empty_lines) { + result = this.__parent.get_indent_string(this.__indent_count); + } + } else { + result = this.__parent.get_indent_string(this.__indent_count, this.__alignment_count); + result += this.__items.join(''); + } + return result; +}; + +function IndentStringCache(options, baseIndentString) { + this.__cache = ['']; + this.__indent_size = options.indent_size; + this.__indent_string = options.indent_char; + if (!options.indent_with_tabs) { + this.__indent_string = new Array(options.indent_size + 1).join(options.indent_char); + } + + // Set to null to continue support for auto detection of base indent + baseIndentString = baseIndentString || ''; + if (options.indent_level > 0) { + baseIndentString = new Array(options.indent_level + 1).join(this.__indent_string); + } + + this.__base_string = baseIndentString; + this.__base_string_length = baseIndentString.length; +} + +IndentStringCache.prototype.get_indent_size = function(indent, column) { + var result = this.__base_string_length; + column = column || 0; + if (indent < 0) { + result = 0; + } + result += indent * this.__indent_size; + result += column; + return result; +}; + +IndentStringCache.prototype.get_indent_string = function(indent_level, column) { + var result = this.__base_string; + column = column || 0; + if (indent_level < 0) { + indent_level = 0; + result = ''; + } + column += indent_level * this.__indent_size; + this.__ensure_cache(column); + result += this.__cache[column]; + return result; +}; + +IndentStringCache.prototype.__ensure_cache = function(column) { + while (column >= this.__cache.length) { + this.__add_column(); + } +}; + +IndentStringCache.prototype.__add_column = function() { + var column = this.__cache.length; + var indent = 0; + var result = ''; + if (this.__indent_size && column >= this.__indent_size) { + indent = Math.floor(column / this.__indent_size); + column -= indent * this.__indent_size; + result = new Array(indent + 1).join(this.__indent_string); + } + if (column) { + result += new Array(column + 1).join(' '); + } + + this.__cache.push(result); +}; + +function Output(options, baseIndentString) { + this.__indent_cache = new IndentStringCache(options, baseIndentString); + this.raw = false; + this._end_with_newline = options.end_with_newline; + this.indent_size = options.indent_size; + this.wrap_line_length = options.wrap_line_length; + this.indent_empty_lines = options.indent_empty_lines; + this.__lines = []; + this.previous_line = null; + this.current_line = null; + this.next_line = new OutputLine(this); + this.space_before_token = false; + this.non_breaking_space = false; + this.previous_token_wrapped = false; + // initialize + this.__add_outputline(); +} + +Output.prototype.__add_outputline = function() { + this.previous_line = this.current_line; + this.current_line = this.next_line.clone_empty(); + this.__lines.push(this.current_line); +}; + +Output.prototype.get_line_number = function() { + return this.__lines.length; +}; + +Output.prototype.get_indent_string = function(indent, column) { + return this.__indent_cache.get_indent_string(indent, column); +}; + +Output.prototype.get_indent_size = function(indent, column) { + return this.__indent_cache.get_indent_size(indent, column); +}; + +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) { + this.trim(true); + + // handle some edge cases where the last tokens + // has text that ends with newline(s) + var last_item = this.current_line.pop(); + if (last_item) { + if (last_item[last_item.length - 1] === '\n') { + last_item = last_item.replace(/\n+$/g, ''); + } + this.current_line.push(last_item); + } + + if (this._end_with_newline) { + this.__add_outputline(); + } + + var sweet_code = this.__lines.join('\n'); + + if (eol !== '\n') { + sweet_code = sweet_code.replace(/[\n]/g, eol); + } + return sweet_code; +}; + +Output.prototype.set_wrap_point = function() { + this.current_line._set_wrap_point(); +}; + +Output.prototype.set_indent = function(indent, alignment) { + indent = indent || 0; + alignment = alignment || 0; + + // Next line stores alignment values + this.next_line.set_indent(indent, alignment); + + // 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.set_indent(-1); + this.current_line.push(token.whitespace_before); + this.current_line.push(token.text); + this.space_before_token = false; + this.non_breaking_space = false; + this.previous_token_wrapped = false; +}; + +Output.prototype.add_token = function(printable_token) { + this.__add_space_before_token(); + this.current_line.push(printable_token); + this.space_before_token = false; + this.non_breaking_space = false; + this.previous_token_wrapped = this.current_line._allow_wrap(); +}; + +Output.prototype.__add_space_before_token = function() { + if (this.space_before_token && !this.just_added_newline()) { + if (!this.non_breaking_space) { + this.set_wrap_point(); + } + this.current_line.push(' '); + } +}; + +Output.prototype.remove_indent = function(index) { + var output_length = this.__lines.length; + while (index < output_length) { + this.__lines[index]._remove_indent(); + index++; + } + this.current_line._remove_wrap_indent(); +}; + +Output.prototype.trim = function(eat_newlines) { + eat_newlines = (eat_newlines === undefined) ? false : eat_newlines; + + this.current_line.trim(); + + 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; + + +/***/ }), +/* 3 */, +/* 4 */, +/* 5 */, +/* 6 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/*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. +*/ + + + +function Options(options, merge_child_field) { + this.raw_options = _mergeOpts(options, merge_child_field); + + // 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', this.indent_char === '\t'); + if (this.indent_with_tabs) { + this.indent_char = '\t'; + + // indent_size behavior changed after 1.8.6 + // It used to be that indent_size would be + // set to 1 for indent_with_tabs. That is no longer needed and + // actually doesn't make sense - why not use spaces? Further, + // that might produce unexpected behavior - tabs being used + // for single-column alignment. So, when indent_with_tabs is true + // and indent_size is 1, reset indent_size to 4. + if (this.indent_size === 1) { + this.indent_size = 4; + } + } + + // Backwards compat with 1.3.x + this.wrap_line_length = this._get_number('wrap_line_length', this._get_number('max_char')); + + this.indent_empty_lines = this._get_boolean('indent_empty_lines'); + + // valid templating languages ['django', 'erb', 'handlebars', 'php'] + // For now, 'auto' = all off for javascript, all on for html (and inline javascript). + // other values ignored + this.templating = this._get_selection_list('templating', ['auto', 'none', 'django', 'erb', 'handlebars', 'php'], ['auto']); +} + +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} +function _mergeOpts(allOptions, childFieldName) { + var finalOpts = {}; + allOptions = _normalizeOpts(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; + + +/***/ }), +/* 7 */, +/* 8 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/*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. +*/ + + + +var regexp_has_sticky = RegExp.prototype.hasOwnProperty('sticky'); + +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; +}; + +// This is a JavaScript only helper function (not in python) +// Javascript doesn't have a match method +// and not all implementation support "sticky" flag. +// If they do not support sticky then both this.match() and this.test() method +// must get the match and check the index of the match. +// If sticky is supported and set, this method will use it. +// Otherwise it will check that global is set, and fall back to the slower method. +InputScanner.prototype.__match = function(pattern, index) { + pattern.lastIndex = index; + var pattern_match = pattern.exec(this.__input); + + if (pattern_match && !(regexp_has_sticky && pattern.sticky)) { + if (pattern_match.index !== index) { + pattern_match = null; + } + } + + return pattern_match; +}; + +InputScanner.prototype.test = function(pattern, index) { + index = index || 0; + index += this.__position; + + if (index >= 0 && index < this.__input_length) { + return !!this.__match(pattern, index); + } else { + return false; + } +}; + +InputScanner.prototype.testChar = function(pattern, index) { + // test one character regex match + var val = this.peek(index); + pattern.lastIndex = 0; + return val !== null && pattern.test(val); +}; + +InputScanner.prototype.match = function(pattern) { + var pattern_match = this.__match(pattern, this.__position); + if (pattern_match) { + this.__position += pattern_match[0].length; + } else { + pattern_match = null; + } + return pattern_match; +}; + +InputScanner.prototype.read = function(starting_pattern, until_pattern, until_after) { + var val = ''; + var match; + if (starting_pattern) { + match = this.match(starting_pattern); + if (match) { + val += match[0]; + } + } + if (until_pattern && (match || !starting_pattern)) { + val += this.readUntil(until_pattern, until_after); + } + return val; +}; + +InputScanner.prototype.readUntil = function(pattern, until_after) { + var val = ''; + var match_index = this.__position; + pattern.lastIndex = this.__position; + var pattern_match = pattern.exec(this.__input); + if (pattern_match) { + match_index = pattern_match.index; + if (until_after) { + match_index += pattern_match[0].length; + } + } 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); +}; + +InputScanner.prototype.get_regexp = function(pattern, match_from) { + var result = null; + var flags = 'g'; + if (match_from && regexp_has_sticky) { + flags = 'y'; + } + // strings are converted to regexp + if (typeof pattern === "string" && pattern !== '') { + // result = new RegExp(pattern.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), flags); + result = new RegExp(pattern, flags); + } else if (pattern) { + result = new RegExp(pattern.source, flags); + } + return result; +}; + +InputScanner.prototype.get_literal_regexp = function(literal_string) { + return RegExp(literal_string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')); +}; + +/* 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; + + +/***/ }), +/* 9 */, +/* 10 */, +/* 11 */, +/* 12 */, +/* 13 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/*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. +*/ + + + +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(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.readUntilAfter(this.__directives_end_ignore_pattern); +}; + + +module.exports.Directives = Directives; + + +/***/ }), +/* 14 */, +/* 15 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/*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. +*/ + + + +var Beautifier = __webpack_require__(16).Beautifier, + Options = __webpack_require__(17).Options; + +function css_beautify(source_text, options) { + var beautifier = new Beautifier(source_text, options); + return beautifier.beautify(); +} + +module.exports = css_beautify; +module.exports.defaultOptions = function() { + return new Options(); +}; + + +/***/ }), +/* 16 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/*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. +*/ + + + +var Options = __webpack_require__(17).Options; +var Output = __webpack_require__(2).Output; +var InputScanner = __webpack_require__(8).InputScanner; +var Directives = __webpack_require__(13).Directives; + +var directives_core = new Directives(/\/\*/, /\*\//); + +var lineBreak = /\r\n|[\r\n]/; +var allLineBreaks = /\r\n|[\r\n]/g; + +// tokenizer +var whitespaceChar = /\s/; +var whitespacePattern = /(?:\s|\n)+/g; +var block_comment_pattern = /\/\*(?:[\s\S]*?)((?:\*\/)|$)/g; +var comment_pattern = /\/\/(?:[^\n\r\u2028\u2029]*)/g; + +function Beautifier(source_text, options) { + this._source_text = source_text || ''; + // Allow the setting of language/file-type specific options + // with inheritance of overall settings + this._options = new Options(options); + this._ch = null; + this._input = null; + + // https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule + this.NESTED_AT_RULE = { + "@page": true, + "@font-face": true, + "@keyframes": true, + // also in CONDITIONAL_GROUP_RULE below + "@media": true, + "@supports": true, + "@document": true + }; + this.CONDITIONAL_GROUP_RULE = { + "@media": true, + "@supports": true, + "@document": true + }; + +} + +Beautifier.prototype.eatString = function(endChars) { + var result = ''; + this._ch = this._input.next(); + while (this._ch) { + result += this._ch; + if (this._ch === "\\") { + result += this._input.next(); + } else if (endChars.indexOf(this._ch) !== -1 || this._ch === "\n") { + break; + } + this._ch = this._input.next(); + } + return result; +}; + +// Skips any white space in the source text from the current position. +// When allowAtLeastOneNewLine is true, will output new lines for each +// newline character found; if the user has preserve_newlines off, only +// the first newline will be output +Beautifier.prototype.eatWhitespace = function(allowAtLeastOneNewLine) { + var result = whitespaceChar.test(this._input.peek()); + var isFirstNewLine = true; + + while (whitespaceChar.test(this._input.peek())) { + this._ch = this._input.next(); + if (allowAtLeastOneNewLine && this._ch === '\n') { + if (this._options.preserve_newlines || isFirstNewLine) { + isFirstNewLine = false; + this._output.add_new_line(true); + } + } + } + return result; +}; + +// Nested pseudo-class if we are insideRule +// and the next special character found opens +// a new block +Beautifier.prototype.foundNestedPseudoClass = function() { + var openParen = 0; + var i = 1; + var ch = this._input.peek(i); + while (ch) { + if (ch === "{") { + return true; + } else if (ch === '(') { + // pseudoclasses can contain () + openParen += 1; + } else if (ch === ')') { + if (openParen === 0) { + return false; + } + openParen -= 1; + } else if (ch === ";" || ch === "}") { + return false; + } + i++; + ch = this._input.peek(i); + } + return false; +}; + +Beautifier.prototype.print_string = function(output_string) { + this._output.set_indent(this._indentLevel); + this._output.non_breaking_space = true; + this._output.add_token(output_string); +}; + +Beautifier.prototype.preserveSingleSpace = function(isAfterSpace) { + if (isAfterSpace) { + this._output.space_before_token = true; + } +}; + +Beautifier.prototype.indent = function() { + this._indentLevel++; +}; + +Beautifier.prototype.outdent = function() { + if (this._indentLevel > 0) { + this._indentLevel--; + } +}; + +/*_____________________--------------------_____________________*/ + +Beautifier.prototype.beautify = function() { + if (this._options.disabled) { + return this._source_text; + } + + var source_text = this._source_text; + var eol = this._options.eol; + if (eol === 'auto') { + eol = '\n'; + if (source_text && lineBreak.test(source_text || '')) { + eol = source_text.match(lineBreak)[0]; + } + } + + + // HACK: newline parsing inconsistent. This brute force normalizes the this._input. + source_text = source_text.replace(allLineBreaks, '\n'); + + // reset + var baseIndentString = source_text.match(/^[\t ]*/)[0]; + + this._output = new Output(this._options, baseIndentString); + this._input = new InputScanner(source_text); + this._indentLevel = 0; + this._nestedLevel = 0; + + this._ch = null; + var parenLevel = 0; + + var insideRule = false; + // This is the value side of a property value pair (blue in the following ex) + // label { content: blue } + var insidePropertyValue = false; + var enteringConditionalGroup = false; + var insideAtExtend = false; + var insideAtImport = false; + var topCharacter = this._ch; + var whitespace; + var isAfterSpace; + var previous_ch; + + while (true) { + whitespace = this._input.read(whitespacePattern); + isAfterSpace = whitespace !== ''; + previous_ch = topCharacter; + this._ch = this._input.next(); + if (this._ch === '\\' && this._input.hasNext()) { + this._ch += this._input.next(); + } + topCharacter = this._ch; + + if (!this._ch) { + break; + } else if (this._ch === '/' && this._input.peek() === '*') { + // /* css comment */ + // Always start block comments on a new line. + // This handles scenarios where a block comment immediately + // follows a property definition on the same line or where + // minified code is being beautified. + this._output.add_new_line(); + this._input.back(); + + var comment = this._input.read(block_comment_pattern); + + // Handle ignore directive + var directives = directives_core.get_directives(comment); + if (directives && directives.ignore === 'start') { + comment += directives_core.readIgnored(this._input); + } + + this.print_string(comment); + + // Ensures any new lines following the comment are preserved + this.eatWhitespace(true); + + // Block comments are followed by a new line so they don't + // share a line with other properties + this._output.add_new_line(); + } else if (this._ch === '/' && this._input.peek() === '/') { + // // single line comment + // Preserves the space before a comment + // on the same line as a rule + this._output.space_before_token = true; + this._input.back(); + this.print_string(this._input.read(comment_pattern)); + + // Ensures any new lines following the comment are preserved + this.eatWhitespace(true); + } else if (this._ch === '@') { + this.preserveSingleSpace(isAfterSpace); + + // deal with less propery mixins @{...} + if (this._input.peek() === '{') { + this.print_string(this._ch + this.eatString('}')); + } else { + this.print_string(this._ch); + + // strip trailing space, if present, for hash property checks + var variableOrRule = this._input.peekUntilAfter(/[: ,;{}()[\]\/='"]/g); + + if (variableOrRule.match(/[ :]$/)) { + // we have a variable or pseudo-class, add it and insert one space before continuing + variableOrRule = this.eatString(": ").replace(/\s$/, ''); + this.print_string(variableOrRule); + this._output.space_before_token = true; + } + + variableOrRule = variableOrRule.replace(/\s$/, ''); + + if (variableOrRule === 'extend') { + insideAtExtend = true; + } else if (variableOrRule === 'import') { + insideAtImport = true; + } + + // might be a nesting at-rule + if (variableOrRule in this.NESTED_AT_RULE) { + this._nestedLevel += 1; + if (variableOrRule in this.CONDITIONAL_GROUP_RULE) { + enteringConditionalGroup = true; + } + // might be less variable + } else if (!insideRule && parenLevel === 0 && variableOrRule.indexOf(':') !== -1) { + insidePropertyValue = true; + this.indent(); + } + } + } else if (this._ch === '#' && this._input.peek() === '{') { + this.preserveSingleSpace(isAfterSpace); + this.print_string(this._ch + this.eatString('}')); + } else if (this._ch === '{') { + if (insidePropertyValue) { + insidePropertyValue = false; + this.outdent(); + } + + // when entering conditional groups, only rulesets are allowed + if (enteringConditionalGroup) { + enteringConditionalGroup = false; + insideRule = (this._indentLevel >= this._nestedLevel); + } else { + // otherwise, declarations are also allowed + insideRule = (this._indentLevel >= this._nestedLevel - 1); + } + if (this._options.newline_between_rules && insideRule) { + if (this._output.previous_line && this._output.previous_line.item(-1) !== '{') { + this._output.ensure_empty_line_above('/', ','); + } + } + + this._output.space_before_token = true; + + // The difference in print_string and indent order is necessary to indent the '{' correctly + if (this._options.brace_style === 'expand') { + this._output.add_new_line(); + this.print_string(this._ch); + this.indent(); + this._output.set_indent(this._indentLevel); + } else { + this.indent(); + this.print_string(this._ch); + } + + this.eatWhitespace(true); + this._output.add_new_line(); + } else if (this._ch === '}') { + this.outdent(); + this._output.add_new_line(); + if (previous_ch === '{') { + this._output.trim(true); + } + insideAtImport = false; + insideAtExtend = false; + if (insidePropertyValue) { + this.outdent(); + insidePropertyValue = false; + } + this.print_string(this._ch); + insideRule = false; + if (this._nestedLevel) { + this._nestedLevel--; + } + + this.eatWhitespace(true); + this._output.add_new_line(); + + if (this._options.newline_between_rules && !this._output.just_added_blankline()) { + if (this._input.peek() !== '}') { + this._output.add_new_line(true); + } + } + } else if (this._ch === ":") { + if ((insideRule || enteringConditionalGroup) && !(this._input.lookBack("&") || this.foundNestedPseudoClass()) && !this._input.lookBack("(") && !insideAtExtend && parenLevel === 0) { + // 'property: value' delimiter + // which could be in a conditional group query + this.print_string(':'); + if (!insidePropertyValue) { + insidePropertyValue = true; + this._output.space_before_token = true; + this.eatWhitespace(true); + this.indent(); + } + } else { + // sass/less parent reference don't use a space + // sass nested pseudo-class don't use a space + + // preserve space before pseudoclasses/pseudoelements, as it means "in any child" + if (this._input.lookBack(" ")) { + this._output.space_before_token = true; + } + if (this._input.peek() === ":") { + // pseudo-element + this._ch = this._input.next(); + this.print_string("::"); + } else { + // pseudo-class + this.print_string(':'); + } + } + } else if (this._ch === '"' || this._ch === '\'') { + this.preserveSingleSpace(isAfterSpace); + this.print_string(this._ch + this.eatString(this._ch)); + this.eatWhitespace(true); + } else if (this._ch === ';') { + if (parenLevel === 0) { + if (insidePropertyValue) { + this.outdent(); + insidePropertyValue = false; + } + insideAtExtend = false; + insideAtImport = false; + this.print_string(this._ch); + this.eatWhitespace(true); + + // This maintains single line comments on the same + // line. Block comments are also affected, but + // a new line is always output before one inside + // that section + if (this._input.peek() !== '/') { + this._output.add_new_line(); + } + } else { + this.print_string(this._ch); + this.eatWhitespace(true); + this._output.space_before_token = true; + } + } else if (this._ch === '(') { // may be a url + if (this._input.lookBack("url")) { + this.print_string(this._ch); + this.eatWhitespace(); + parenLevel++; + this.indent(); + this._ch = this._input.next(); + if (this._ch === ')' || this._ch === '"' || this._ch === '\'') { + this._input.back(); + } else if (this._ch) { + this.print_string(this._ch + this.eatString(')')); + if (parenLevel) { + parenLevel--; + this.outdent(); + } + } + } else { + this.preserveSingleSpace(isAfterSpace); + this.print_string(this._ch); + this.eatWhitespace(); + parenLevel++; + this.indent(); + } + } else if (this._ch === ')') { + if (parenLevel) { + parenLevel--; + this.outdent(); + } + this.print_string(this._ch); + } else if (this._ch === ',') { + this.print_string(this._ch); + this.eatWhitespace(true); + if (this._options.selector_separator_newline && !insidePropertyValue && parenLevel === 0 && !insideAtImport) { + this._output.add_new_line(); + } else { + this._output.space_before_token = true; + } + } else if ((this._ch === '>' || this._ch === '+' || this._ch === '~') && !insidePropertyValue && parenLevel === 0) { + //handle combinator spacing + if (this._options.space_around_combinator) { + this._output.space_before_token = true; + this.print_string(this._ch); + this._output.space_before_token = true; + } else { + this.print_string(this._ch); + this.eatWhitespace(); + // squash extra whitespace + if (this._ch && whitespaceChar.test(this._ch)) { + this._ch = ''; + } + } + } else if (this._ch === ']') { + this.print_string(this._ch); + } else if (this._ch === '[') { + this.preserveSingleSpace(isAfterSpace); + this.print_string(this._ch); + } else if (this._ch === '=') { // no whitespace before or after + this.eatWhitespace(); + this.print_string('='); + if (whitespaceChar.test(this._ch)) { + this._ch = ''; + } + } else if (this._ch === '!' && !this._input.lookBack("\\")) { // !important + this.print_string(' '); + this.print_string(this._ch); + } else { + this.preserveSingleSpace(isAfterSpace); + this.print_string(this._ch); + } + } + + var sweetCode = this._output.get_code(eol); + + return sweetCode; +}; + +module.exports.Beautifier = Beautifier; + + +/***/ }), +/* 17 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/*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. +*/ + + + +var BaseOptions = __webpack_require__(6).Options; + +function Options(options) { + BaseOptions.call(this, options, 'css'); + + this.selector_separator_newline = this._get_boolean('selector_separator_newline', true); + this.newline_between_rules = this._get_boolean('newline_between_rules', true); + var space_around_selector_separator = this._get_boolean('space_around_selector_separator'); + this.space_around_combinator = this._get_boolean('space_around_combinator') || space_around_selector_separator; + + var brace_style_split = this._get_selection_list('brace_style', ['collapse', 'expand', 'end-expand', 'none', 'preserve-inline']); + this.brace_style = 'collapse'; + for (var bs = 0; bs < brace_style_split.length; bs++) { + if (brace_style_split[bs] !== 'expand') { + // default to collapse, as only collapse|expand is implemented for now + this.brace_style = 'collapse'; + } else { + this.brace_style = brace_style_split[bs]; + } + } +} +Options.prototype = new BaseOptions(); + + + +module.exports.Options = Options; + + +/***/ }) +/******/ ]); +var css_beautify = legacy_beautify_css; +/* Footer */ +if (typeof define === "function" && define.amd) { + // Add support for AMD ( https://github.com/amdjs/amdjs-api/wiki/AMD#defineamd-property- ) + define([], function() { + return { + css_beautify: css_beautify + }; + }); +} else if (typeof exports !== "undefined") { + // Add support for CommonJS. Just put this file somewhere on your require.paths + // and you will be able to `var html_beautify = require("beautify").html_beautify`. + exports.css_beautify = css_beautify; +} else if (typeof window !== "undefined") { + // If we're running a web page and don't have either of the above, add our one global + window.css_beautify = css_beautify; +} else if (typeof global !== "undefined") { + // If we don't even have window, try global. + global.css_beautify = css_beautify; +} + +}()); |