1 /* AUTO-GENERATED. DO NOT MODIFY. */
6 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
8 Permission is hereby granted, free of charge, to any person
9 obtaining a copy of this software and associated documentation files
10 (the "Software"), to deal in the Software without restriction,
11 including without limitation the rights to use, copy, modify, merge,
12 publish, distribute, sublicense, and/or sell copies of the Software,
13 and to permit persons to whom the Software is furnished to do so,
14 subject to the following conditions:
16 The above copyright notice and this permission notice shall be
17 included in all copies or substantial portions of the Software.
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
23 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
24 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
25 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32 Written by Harutyun Amirjanyan, (amirjanyan@gmail.com)
34 Based on code initially developed by: Einar Lielmanis, <einar@beautifier.io>
35 https://beautifier.io/
38 css_beautify(source_text);
39 css_beautify(source_text, options);
41 The options are (default in brackets):
42 indent_size (4) — indentation size,
43 indent_char (space) — character to indent with,
44 selector_separator_newline (true) - separate selectors with newline or
45 not (e.g. "a,\nbr" or "a, br")
46 end_with_newline (false) - end with a newline
47 newline_between_rules (true) - add a new line after every css rule
48 space_around_selector_separator (false) - ensure space around selector separators:
49 '>', '+', '~' (e.g. "a>b" -> "a > b")
52 css_beautify(css_source_text, {
55 'selector_separator': ' ',
56 'end_with_newline': false,
57 'newline_between_rules': true,
58 'space_around_selector_separator': true
62 // http://www.w3.org/TR/CSS21/syndata.html#tokenization
63 // http://www.w3.org/TR/css3-syntax/
67 /* GENERATED_BUILD_OUTPUT */
68 var legacy_beautify_css;
69 /******/ (function() { // webpackBootstrap
70 /******/ "use strict";
71 /******/ var __webpack_modules__ = ([
75 /***/ (function(module) {
81 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
83 Permission is hereby granted, free of charge, to any person
84 obtaining a copy of this software and associated documentation files
85 (the "Software"), to deal in the Software without restriction,
86 including without limitation the rights to use, copy, modify, merge,
87 publish, distribute, sublicense, and/or sell copies of the Software,
88 and to permit persons to whom the Software is furnished to do so,
89 subject to the following conditions:
91 The above copyright notice and this permission notice shall be
92 included in all copies or substantial portions of the Software.
94 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
95 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
96 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
97 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
98 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
99 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
100 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
106 function OutputLine(parent) {
107 this.__parent = parent;
108 this.__character_count = 0;
109 // use indent_count as a marker for this.__lines that have preserved indentation
110 this.__indent_count = -1;
111 this.__alignment_count = 0;
112 this.__wrap_point_index = 0;
113 this.__wrap_point_character_count = 0;
114 this.__wrap_point_indent_count = -1;
115 this.__wrap_point_alignment_count = 0;
120 OutputLine.prototype.clone_empty = function() {
121 var line = new OutputLine(this.__parent);
122 line.set_indent(this.__indent_count, this.__alignment_count);
126 OutputLine.prototype.item = function(index) {
128 return this.__items[this.__items.length + index];
130 return this.__items[index];
134 OutputLine.prototype.has_match = function(pattern) {
135 for (var lastCheckedOutput = this.__items.length - 1; lastCheckedOutput >= 0; lastCheckedOutput--) {
136 if (this.__items[lastCheckedOutput].match(pattern)) {
143 OutputLine.prototype.set_indent = function(indent, alignment) {
144 if (this.is_empty()) {
145 this.__indent_count = indent || 0;
146 this.__alignment_count = alignment || 0;
147 this.__character_count = this.__parent.get_indent_size(this.__indent_count, this.__alignment_count);
151 OutputLine.prototype._set_wrap_point = function() {
152 if (this.__parent.wrap_line_length) {
153 this.__wrap_point_index = this.__items.length;
154 this.__wrap_point_character_count = this.__character_count;
155 this.__wrap_point_indent_count = this.__parent.next_line.__indent_count;
156 this.__wrap_point_alignment_count = this.__parent.next_line.__alignment_count;
160 OutputLine.prototype._should_wrap = function() {
161 return this.__wrap_point_index &&
162 this.__character_count > this.__parent.wrap_line_length &&
163 this.__wrap_point_character_count > this.__parent.next_line.__character_count;
166 OutputLine.prototype._allow_wrap = function() {
167 if (this._should_wrap()) {
168 this.__parent.add_new_line();
169 var next = this.__parent.current_line;
170 next.set_indent(this.__wrap_point_indent_count, this.__wrap_point_alignment_count);
171 next.__items = this.__items.slice(this.__wrap_point_index);
172 this.__items = this.__items.slice(0, this.__wrap_point_index);
174 next.__character_count += this.__character_count - this.__wrap_point_character_count;
175 this.__character_count = this.__wrap_point_character_count;
177 if (next.__items[0] === " ") {
178 next.__items.splice(0, 1);
179 next.__character_count -= 1;
186 OutputLine.prototype.is_empty = function() {
187 return this.__items.length === 0;
190 OutputLine.prototype.last = function() {
191 if (!this.is_empty()) {
192 return this.__items[this.__items.length - 1];
198 OutputLine.prototype.push = function(item) {
199 this.__items.push(item);
200 var last_newline_index = item.lastIndexOf('\n');
201 if (last_newline_index !== -1) {
202 this.__character_count = item.length - last_newline_index;
204 this.__character_count += item.length;
208 OutputLine.prototype.pop = function() {
210 if (!this.is_empty()) {
211 item = this.__items.pop();
212 this.__character_count -= item.length;
218 OutputLine.prototype._remove_indent = function() {
219 if (this.__indent_count > 0) {
220 this.__indent_count -= 1;
221 this.__character_count -= this.__parent.indent_size;
225 OutputLine.prototype._remove_wrap_indent = function() {
226 if (this.__wrap_point_indent_count > 0) {
227 this.__wrap_point_indent_count -= 1;
230 OutputLine.prototype.trim = function() {
231 while (this.last() === ' ') {
233 this.__character_count -= 1;
237 OutputLine.prototype.toString = function() {
239 if (this.is_empty()) {
240 if (this.__parent.indent_empty_lines) {
241 result = this.__parent.get_indent_string(this.__indent_count);
244 result = this.__parent.get_indent_string(this.__indent_count, this.__alignment_count);
245 result += this.__items.join('');
250 function IndentStringCache(options, baseIndentString) {
252 this.__indent_size = options.indent_size;
253 this.__indent_string = options.indent_char;
254 if (!options.indent_with_tabs) {
255 this.__indent_string = new Array(options.indent_size + 1).join(options.indent_char);
258 // Set to null to continue support for auto detection of base indent
259 baseIndentString = baseIndentString || '';
260 if (options.indent_level > 0) {
261 baseIndentString = new Array(options.indent_level + 1).join(this.__indent_string);
264 this.__base_string = baseIndentString;
265 this.__base_string_length = baseIndentString.length;
268 IndentStringCache.prototype.get_indent_size = function(indent, column) {
269 var result = this.__base_string_length;
270 column = column || 0;
274 result += indent * this.__indent_size;
279 IndentStringCache.prototype.get_indent_string = function(indent_level, column) {
280 var result = this.__base_string;
281 column = column || 0;
282 if (indent_level < 0) {
286 column += indent_level * this.__indent_size;
287 this.__ensure_cache(column);
288 result += this.__cache[column];
292 IndentStringCache.prototype.__ensure_cache = function(column) {
293 while (column >= this.__cache.length) {
298 IndentStringCache.prototype.__add_column = function() {
299 var column = this.__cache.length;
302 if (this.__indent_size && column >= this.__indent_size) {
303 indent = Math.floor(column / this.__indent_size);
304 column -= indent * this.__indent_size;
305 result = new Array(indent + 1).join(this.__indent_string);
308 result += new Array(column + 1).join(' ');
311 this.__cache.push(result);
314 function Output(options, baseIndentString) {
315 this.__indent_cache = new IndentStringCache(options, baseIndentString);
317 this._end_with_newline = options.end_with_newline;
318 this.indent_size = options.indent_size;
319 this.wrap_line_length = options.wrap_line_length;
320 this.indent_empty_lines = options.indent_empty_lines;
322 this.previous_line = null;
323 this.current_line = null;
324 this.next_line = new OutputLine(this);
325 this.space_before_token = false;
326 this.non_breaking_space = false;
327 this.previous_token_wrapped = false;
329 this.__add_outputline();
332 Output.prototype.__add_outputline = function() {
333 this.previous_line = this.current_line;
334 this.current_line = this.next_line.clone_empty();
335 this.__lines.push(this.current_line);
338 Output.prototype.get_line_number = function() {
339 return this.__lines.length;
342 Output.prototype.get_indent_string = function(indent, column) {
343 return this.__indent_cache.get_indent_string(indent, column);
346 Output.prototype.get_indent_size = function(indent, column) {
347 return this.__indent_cache.get_indent_size(indent, column);
350 Output.prototype.is_empty = function() {
351 return !this.previous_line && this.current_line.is_empty();
354 Output.prototype.add_new_line = function(force_newline) {
355 // never newline at the start of file
356 // otherwise, newline only if we didn't just add one or we're forced
357 if (this.is_empty() ||
358 (!force_newline && this.just_added_newline())) {
362 // if raw output is enabled, don't print additional newlines,
363 // but still return True as though you had
365 this.__add_outputline();
370 Output.prototype.get_code = function(eol) {
373 // handle some edge cases where the last tokens
374 // has text that ends with newline(s)
375 var last_item = this.current_line.pop();
377 if (last_item[last_item.length - 1] === '\n') {
378 last_item = last_item.replace(/\n+$/g, '');
380 this.current_line.push(last_item);
383 if (this._end_with_newline) {
384 this.__add_outputline();
387 var sweet_code = this.__lines.join('\n');
390 sweet_code = sweet_code.replace(/[\n]/g, eol);
395 Output.prototype.set_wrap_point = function() {
396 this.current_line._set_wrap_point();
399 Output.prototype.set_indent = function(indent, alignment) {
400 indent = indent || 0;
401 alignment = alignment || 0;
403 // Next line stores alignment values
404 this.next_line.set_indent(indent, alignment);
406 // Never indent your first output indent at the start of the file
407 if (this.__lines.length > 1) {
408 this.current_line.set_indent(indent, alignment);
412 this.current_line.set_indent();
416 Output.prototype.add_raw_token = function(token) {
417 for (var x = 0; x < token.newlines; x++) {
418 this.__add_outputline();
420 this.current_line.set_indent(-1);
421 this.current_line.push(token.whitespace_before);
422 this.current_line.push(token.text);
423 this.space_before_token = false;
424 this.non_breaking_space = false;
425 this.previous_token_wrapped = false;
428 Output.prototype.add_token = function(printable_token) {
429 this.__add_space_before_token();
430 this.current_line.push(printable_token);
431 this.space_before_token = false;
432 this.non_breaking_space = false;
433 this.previous_token_wrapped = this.current_line._allow_wrap();
436 Output.prototype.__add_space_before_token = function() {
437 if (this.space_before_token && !this.just_added_newline()) {
438 if (!this.non_breaking_space) {
439 this.set_wrap_point();
441 this.current_line.push(' ');
445 Output.prototype.remove_indent = function(index) {
446 var output_length = this.__lines.length;
447 while (index < output_length) {
448 this.__lines[index]._remove_indent();
451 this.current_line._remove_wrap_indent();
454 Output.prototype.trim = function(eat_newlines) {
455 eat_newlines = (eat_newlines === undefined) ? false : eat_newlines;
457 this.current_line.trim();
459 while (eat_newlines && this.__lines.length > 1 &&
460 this.current_line.is_empty()) {
462 this.current_line = this.__lines[this.__lines.length - 1];
463 this.current_line.trim();
466 this.previous_line = this.__lines.length > 1 ?
467 this.__lines[this.__lines.length - 2] : null;
470 Output.prototype.just_added_newline = function() {
471 return this.current_line.is_empty();
474 Output.prototype.just_added_blankline = function() {
475 return this.is_empty() ||
476 (this.current_line.is_empty() && this.previous_line.is_empty());
479 Output.prototype.ensure_empty_line_above = function(starts_with, ends_with) {
480 var index = this.__lines.length - 2;
482 var potentialEmptyLine = this.__lines[index];
483 if (potentialEmptyLine.is_empty()) {
485 } else if (potentialEmptyLine.item(0).indexOf(starts_with) !== 0 &&
486 potentialEmptyLine.item(-1) !== ends_with) {
487 this.__lines.splice(index + 1, 0, new OutputLine(this));
488 this.previous_line = this.__lines[this.__lines.length - 2];
495 module.exports.Output = Output;
503 /***/ (function(module) {
505 /*jshint node:true */
508 The MIT License (MIT)
510 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
512 Permission is hereby granted, free of charge, to any person
513 obtaining a copy of this software and associated documentation files
514 (the "Software"), to deal in the Software without restriction,
515 including without limitation the rights to use, copy, modify, merge,
516 publish, distribute, sublicense, and/or sell copies of the Software,
517 and to permit persons to whom the Software is furnished to do so,
518 subject to the following conditions:
520 The above copyright notice and this permission notice shall be
521 included in all copies or substantial portions of the Software.
523 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
524 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
525 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
526 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
527 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
528 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
529 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
535 function Options(options, merge_child_field) {
536 this.raw_options = _mergeOpts(options, merge_child_field);
538 // Support passing the source text back with no change
539 this.disabled = this._get_boolean('disabled');
541 this.eol = this._get_characters('eol', 'auto');
542 this.end_with_newline = this._get_boolean('end_with_newline');
543 this.indent_size = this._get_number('indent_size', 4);
544 this.indent_char = this._get_characters('indent_char', ' ');
545 this.indent_level = this._get_number('indent_level');
547 this.preserve_newlines = this._get_boolean('preserve_newlines', true);
548 this.max_preserve_newlines = this._get_number('max_preserve_newlines', 32786);
549 if (!this.preserve_newlines) {
550 this.max_preserve_newlines = 0;
553 this.indent_with_tabs = this._get_boolean('indent_with_tabs', this.indent_char === '\t');
554 if (this.indent_with_tabs) {
555 this.indent_char = '\t';
557 // indent_size behavior changed after 1.8.6
558 // It used to be that indent_size would be
559 // set to 1 for indent_with_tabs. That is no longer needed and
560 // actually doesn't make sense - why not use spaces? Further,
561 // that might produce unexpected behavior - tabs being used
562 // for single-column alignment. So, when indent_with_tabs is true
563 // and indent_size is 1, reset indent_size to 4.
564 if (this.indent_size === 1) {
565 this.indent_size = 4;
569 // Backwards compat with 1.3.x
570 this.wrap_line_length = this._get_number('wrap_line_length', this._get_number('max_char'));
572 this.indent_empty_lines = this._get_boolean('indent_empty_lines');
574 // valid templating languages ['django', 'erb', 'handlebars', 'php', 'smarty', 'angular']
575 // For now, 'auto' = all off for javascript, all except angular on for html (and inline javascript/css).
576 // other values ignored
577 this.templating = this._get_selection_list('templating', ['auto', 'none', 'angular', 'django', 'erb', 'handlebars', 'php', 'smarty'], ['auto']);
580 Options.prototype._get_array = function(name, default_value) {
581 var option_value = this.raw_options[name];
582 var result = default_value || [];
583 if (typeof option_value === 'object') {
584 if (option_value !== null && typeof option_value.concat === 'function') {
585 result = option_value.concat();
587 } else if (typeof option_value === 'string') {
588 result = option_value.split(/[^a-zA-Z0-9_\/\-]+/);
593 Options.prototype._get_boolean = function(name, default_value) {
594 var option_value = this.raw_options[name];
595 var result = option_value === undefined ? !!default_value : !!option_value;
599 Options.prototype._get_characters = function(name, default_value) {
600 var option_value = this.raw_options[name];
601 var result = default_value || '';
602 if (typeof option_value === 'string') {
603 result = option_value.replace(/\\r/, '\r').replace(/\\n/, '\n').replace(/\\t/, '\t');
608 Options.prototype._get_number = function(name, default_value) {
609 var option_value = this.raw_options[name];
610 default_value = parseInt(default_value, 10);
611 if (isNaN(default_value)) {
614 var result = parseInt(option_value, 10);
616 result = default_value;
621 Options.prototype._get_selection = function(name, selection_list, default_value) {
622 var result = this._get_selection_list(name, selection_list, default_value);
623 if (result.length !== 1) {
625 "Invalid Option Value: The option '" + name + "' can only be one of the following values:\n" +
626 selection_list + "\nYou passed in: '" + this.raw_options[name] + "'");
633 Options.prototype._get_selection_list = function(name, selection_list, default_value) {
634 if (!selection_list || selection_list.length === 0) {
635 throw new Error("Selection list cannot be empty.");
638 default_value = default_value || [selection_list[0]];
639 if (!this._is_valid_selection(default_value, selection_list)) {
640 throw new Error("Invalid Default Value!");
643 var result = this._get_array(name, default_value);
644 if (!this._is_valid_selection(result, selection_list)) {
646 "Invalid Option Value: The option '" + name + "' can contain only the following values:\n" +
647 selection_list + "\nYou passed in: '" + this.raw_options[name] + "'");
653 Options.prototype._is_valid_selection = function(result, selection_list) {
654 return result.length && selection_list.length &&
655 !result.some(function(item) { return selection_list.indexOf(item) === -1; });
659 // merges child options up with the parent options object
660 // Example: obj = {a: 1, b: {a: 2}}
661 // mergeOpts(obj, 'b')
664 function _mergeOpts(allOptions, childFieldName) {
666 allOptions = _normalizeOpts(allOptions);
669 for (name in allOptions) {
670 if (name !== childFieldName) {
671 finalOpts[name] = allOptions[name];
675 //merge in the per type settings for the childFieldName
676 if (childFieldName && allOptions[childFieldName]) {
677 for (name in allOptions[childFieldName]) {
678 finalOpts[name] = allOptions[childFieldName][name];
684 function _normalizeOpts(options) {
685 var convertedOpts = {};
688 for (key in options) {
689 var newKey = key.replace(/-/g, "_");
690 convertedOpts[newKey] = options[key];
692 return convertedOpts;
695 module.exports.Options = Options;
696 module.exports.normalizeOpts = _normalizeOpts;
697 module.exports.mergeOpts = _mergeOpts;
703 /***/ (function(module) {
705 /*jshint node:true */
708 The MIT License (MIT)
710 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
712 Permission is hereby granted, free of charge, to any person
713 obtaining a copy of this software and associated documentation files
714 (the "Software"), to deal in the Software without restriction,
715 including without limitation the rights to use, copy, modify, merge,
716 publish, distribute, sublicense, and/or sell copies of the Software,
717 and to permit persons to whom the Software is furnished to do so,
718 subject to the following conditions:
720 The above copyright notice and this permission notice shall be
721 included in all copies or substantial portions of the Software.
723 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
724 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
725 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
726 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
727 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
728 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
729 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
735 var regexp_has_sticky = RegExp.prototype.hasOwnProperty('sticky');
737 function InputScanner(input_string) {
738 this.__input = input_string || '';
739 this.__input_length = this.__input.length;
743 InputScanner.prototype.restart = function() {
747 InputScanner.prototype.back = function() {
748 if (this.__position > 0) {
749 this.__position -= 1;
753 InputScanner.prototype.hasNext = function() {
754 return this.__position < this.__input_length;
757 InputScanner.prototype.next = function() {
759 if (this.hasNext()) {
760 val = this.__input.charAt(this.__position);
761 this.__position += 1;
766 InputScanner.prototype.peek = function(index) {
769 index += this.__position;
770 if (index >= 0 && index < this.__input_length) {
771 val = this.__input.charAt(index);
776 // This is a JavaScript only helper function (not in python)
777 // Javascript doesn't have a match method
778 // and not all implementation support "sticky" flag.
779 // If they do not support sticky then both this.match() and this.test() method
780 // must get the match and check the index of the match.
781 // If sticky is supported and set, this method will use it.
782 // Otherwise it will check that global is set, and fall back to the slower method.
783 InputScanner.prototype.__match = function(pattern, index) {
784 pattern.lastIndex = index;
785 var pattern_match = pattern.exec(this.__input);
787 if (pattern_match && !(regexp_has_sticky && pattern.sticky)) {
788 if (pattern_match.index !== index) {
789 pattern_match = null;
793 return pattern_match;
796 InputScanner.prototype.test = function(pattern, index) {
798 index += this.__position;
800 if (index >= 0 && index < this.__input_length) {
801 return !!this.__match(pattern, index);
807 InputScanner.prototype.testChar = function(pattern, index) {
808 // test one character regex match
809 var val = this.peek(index);
810 pattern.lastIndex = 0;
811 return val !== null && pattern.test(val);
814 InputScanner.prototype.match = function(pattern) {
815 var pattern_match = this.__match(pattern, this.__position);
817 this.__position += pattern_match[0].length;
819 pattern_match = null;
821 return pattern_match;
824 InputScanner.prototype.read = function(starting_pattern, until_pattern, until_after) {
827 if (starting_pattern) {
828 match = this.match(starting_pattern);
833 if (until_pattern && (match || !starting_pattern)) {
834 val += this.readUntil(until_pattern, until_after);
839 InputScanner.prototype.readUntil = function(pattern, until_after) {
841 var match_index = this.__position;
842 pattern.lastIndex = this.__position;
843 var pattern_match = pattern.exec(this.__input);
845 match_index = pattern_match.index;
847 match_index += pattern_match[0].length;
850 match_index = this.__input_length;
853 val = this.__input.substring(this.__position, match_index);
854 this.__position = match_index;
858 InputScanner.prototype.readUntilAfter = function(pattern) {
859 return this.readUntil(pattern, true);
862 InputScanner.prototype.get_regexp = function(pattern, match_from) {
865 if (match_from && regexp_has_sticky) {
868 // strings are converted to regexp
869 if (typeof pattern === "string" && pattern !== '') {
870 // result = new RegExp(pattern.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), flags);
871 result = new RegExp(pattern, flags);
872 } else if (pattern) {
873 result = new RegExp(pattern.source, flags);
878 InputScanner.prototype.get_literal_regexp = function(literal_string) {
879 return RegExp(literal_string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'));
882 /* css beautifier legacy helpers */
883 InputScanner.prototype.peekUntilAfter = function(pattern) {
884 var start = this.__position;
885 var val = this.readUntilAfter(pattern);
886 this.__position = start;
890 InputScanner.prototype.lookBack = function(testVal) {
891 var start = this.__position - 1;
892 return start >= testVal.length && this.__input.substring(start - testVal.length, start)
893 .toLowerCase() === testVal;
896 module.exports.InputScanner = InputScanner;
905 /***/ (function(module) {
907 /*jshint node:true */
910 The MIT License (MIT)
912 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
914 Permission is hereby granted, free of charge, to any person
915 obtaining a copy of this software and associated documentation files
916 (the "Software"), to deal in the Software without restriction,
917 including without limitation the rights to use, copy, modify, merge,
918 publish, distribute, sublicense, and/or sell copies of the Software,
919 and to permit persons to whom the Software is furnished to do so,
920 subject to the following conditions:
922 The above copyright notice and this permission notice shall be
923 included in all copies or substantial portions of the Software.
925 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
926 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
927 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
928 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
929 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
930 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
931 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
937 function Directives(start_block_pattern, end_block_pattern) {
938 start_block_pattern = typeof start_block_pattern === 'string' ? start_block_pattern : start_block_pattern.source;
939 end_block_pattern = typeof end_block_pattern === 'string' ? end_block_pattern : end_block_pattern.source;
940 this.__directives_block_pattern = new RegExp(start_block_pattern + / beautify( \w+[:]\w+)+ /.source + end_block_pattern, 'g');
941 this.__directive_pattern = / (\w+)[:](\w+)/g;
943 this.__directives_end_ignore_pattern = new RegExp(start_block_pattern + /\sbeautify\signore:end\s/.source + end_block_pattern, 'g');
946 Directives.prototype.get_directives = function(text) {
947 if (!text.match(this.__directives_block_pattern)) {
952 this.__directive_pattern.lastIndex = 0;
953 var directive_match = this.__directive_pattern.exec(text);
955 while (directive_match) {
956 directives[directive_match[1]] = directive_match[2];
957 directive_match = this.__directive_pattern.exec(text);
963 Directives.prototype.readIgnored = function(input) {
964 return input.readUntilAfter(this.__directives_end_ignore_pattern);
968 module.exports.Directives = Directives;
974 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
976 /*jshint node:true */
979 The MIT License (MIT)
981 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
983 Permission is hereby granted, free of charge, to any person
984 obtaining a copy of this software and associated documentation files
985 (the "Software"), to deal in the Software without restriction,
986 including without limitation the rights to use, copy, modify, merge,
987 publish, distribute, sublicense, and/or sell copies of the Software,
988 and to permit persons to whom the Software is furnished to do so,
989 subject to the following conditions:
991 The above copyright notice and this permission notice shall be
992 included in all copies or substantial portions of the Software.
994 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
995 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
996 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
997 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
998 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
999 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
1000 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
1006 var Beautifier = (__webpack_require__(16).Beautifier),
1007 Options = (__webpack_require__(17).Options);
1009 function css_beautify(source_text, options) {
1010 var beautifier = new Beautifier(source_text, options);
1011 return beautifier.beautify();
1014 module.exports = css_beautify;
1015 module.exports.defaultOptions = function() {
1016 return new Options();
1022 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1024 /*jshint node:true */
1027 The MIT License (MIT)
1029 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
1031 Permission is hereby granted, free of charge, to any person
1032 obtaining a copy of this software and associated documentation files
1033 (the "Software"), to deal in the Software without restriction,
1034 including without limitation the rights to use, copy, modify, merge,
1035 publish, distribute, sublicense, and/or sell copies of the Software,
1036 and to permit persons to whom the Software is furnished to do so,
1037 subject to the following conditions:
1039 The above copyright notice and this permission notice shall be
1040 included in all copies or substantial portions of the Software.
1042 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
1043 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
1044 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
1045 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
1046 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
1047 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
1048 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
1054 var Options = (__webpack_require__(17).Options);
1055 var Output = (__webpack_require__(2).Output);
1056 var InputScanner = (__webpack_require__(8).InputScanner);
1057 var Directives = (__webpack_require__(13).Directives);
1059 var directives_core = new Directives(/\/\*/, /\*\//);
1061 var lineBreak = /\r\n|[\r\n]/;
1062 var allLineBreaks = /\r\n|[\r\n]/g;
1065 var whitespaceChar = /\s/;
1066 var whitespacePattern = /(?:\s|\n)+/g;
1067 var block_comment_pattern = /\/\*(?:[\s\S]*?)((?:\*\/)|$)/g;
1068 var comment_pattern = /\/\/(?:[^\n\r\u2028\u2029]*)/g;
1070 function Beautifier(source_text, options) {
1071 this._source_text = source_text || '';
1072 // Allow the setting of language/file-type specific options
1073 // with inheritance of overall settings
1074 this._options = new Options(options);
1078 // https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule
1079 this.NESTED_AT_RULE = {
1083 // also in CONDITIONAL_GROUP_RULE below
1088 this.CONDITIONAL_GROUP_RULE = {
1093 this.NON_SEMICOLON_NEWLINE_PROPERTY = [
1094 "grid-template-areas",
1100 Beautifier.prototype.eatString = function(endChars) {
1102 this._ch = this._input.next();
1105 if (this._ch === "\\") {
1106 result += this._input.next();
1107 } else if (endChars.indexOf(this._ch) !== -1 || this._ch === "\n") {
1110 this._ch = this._input.next();
1115 // Skips any white space in the source text from the current position.
1116 // When allowAtLeastOneNewLine is true, will output new lines for each
1117 // newline character found; if the user has preserve_newlines off, only
1118 // the first newline will be output
1119 Beautifier.prototype.eatWhitespace = function(allowAtLeastOneNewLine) {
1120 var result = whitespaceChar.test(this._input.peek());
1121 var newline_count = 0;
1122 while (whitespaceChar.test(this._input.peek())) {
1123 this._ch = this._input.next();
1124 if (allowAtLeastOneNewLine && this._ch === '\n') {
1125 if (newline_count === 0 || newline_count < this._options.max_preserve_newlines) {
1127 this._output.add_new_line(true);
1134 // Nested pseudo-class if we are insideRule
1135 // and the next special character found opens
1137 Beautifier.prototype.foundNestedPseudoClass = function() {
1140 var ch = this._input.peek(i);
1144 } else if (ch === '(') {
1145 // pseudoclasses can contain ()
1147 } else if (ch === ')') {
1148 if (openParen === 0) {
1152 } else if (ch === ";" || ch === "}") {
1156 ch = this._input.peek(i);
1161 Beautifier.prototype.print_string = function(output_string) {
1162 this._output.set_indent(this._indentLevel);
1163 this._output.non_breaking_space = true;
1164 this._output.add_token(output_string);
1167 Beautifier.prototype.preserveSingleSpace = function(isAfterSpace) {
1169 this._output.space_before_token = true;
1173 Beautifier.prototype.indent = function() {
1174 this._indentLevel++;
1177 Beautifier.prototype.outdent = function() {
1178 if (this._indentLevel > 0) {
1179 this._indentLevel--;
1183 /*_____________________--------------------_____________________*/
1185 Beautifier.prototype.beautify = function() {
1186 if (this._options.disabled) {
1187 return this._source_text;
1190 var source_text = this._source_text;
1191 var eol = this._options.eol;
1192 if (eol === 'auto') {
1194 if (source_text && lineBreak.test(source_text || '')) {
1195 eol = source_text.match(lineBreak)[0];
1200 // HACK: newline parsing inconsistent. This brute force normalizes the this._input.
1201 source_text = source_text.replace(allLineBreaks, '\n');
1204 var baseIndentString = source_text.match(/^[\t ]*/)[0];
1206 this._output = new Output(this._options, baseIndentString);
1207 this._input = new InputScanner(source_text);
1208 this._indentLevel = 0;
1209 this._nestedLevel = 0;
1214 var insideRule = false;
1215 // This is the value side of a property value pair (blue in the following ex)
1216 // label { content: blue }
1217 var insidePropertyValue = false;
1218 var enteringConditionalGroup = false;
1219 var insideNonNestedAtRule = false;
1220 var insideScssMap = false;
1221 var topCharacter = this._ch;
1222 var insideNonSemiColonValues = false;
1228 whitespace = this._input.read(whitespacePattern);
1229 isAfterSpace = whitespace !== '';
1230 previous_ch = topCharacter;
1231 this._ch = this._input.next();
1232 if (this._ch === '\\' && this._input.hasNext()) {
1233 this._ch += this._input.next();
1235 topCharacter = this._ch;
1239 } else if (this._ch === '/' && this._input.peek() === '*') {
1240 // /* css comment */
1241 // Always start block comments on a new line.
1242 // This handles scenarios where a block comment immediately
1243 // follows a property definition on the same line or where
1244 // minified code is being beautified.
1245 this._output.add_new_line();
1248 var comment = this._input.read(block_comment_pattern);
1250 // Handle ignore directive
1251 var directives = directives_core.get_directives(comment);
1252 if (directives && directives.ignore === 'start') {
1253 comment += directives_core.readIgnored(this._input);
1256 this.print_string(comment);
1258 // Ensures any new lines following the comment are preserved
1259 this.eatWhitespace(true);
1261 // Block comments are followed by a new line so they don't
1262 // share a line with other properties
1263 this._output.add_new_line();
1264 } else if (this._ch === '/' && this._input.peek() === '/') {
1265 // // single line comment
1266 // Preserves the space before a comment
1267 // on the same line as a rule
1268 this._output.space_before_token = true;
1270 this.print_string(this._input.read(comment_pattern));
1272 // Ensures any new lines following the comment are preserved
1273 this.eatWhitespace(true);
1274 } else if (this._ch === '$') {
1275 this.preserveSingleSpace(isAfterSpace);
1277 this.print_string(this._ch);
1279 // strip trailing space, if present, for hash property checks
1280 var variable = this._input.peekUntilAfter(/[: ,;{}()[\]\/='"]/g);
1282 if (variable.match(/[ :]$/)) {
1283 // we have a variable or pseudo-class, add it and insert one space before continuing
1284 variable = this.eatString(": ").replace(/\s+$/, '');
1285 this.print_string(variable);
1286 this._output.space_before_token = true;
1289 // might be sass variable
1290 if (parenLevel === 0 && variable.indexOf(':') !== -1) {
1291 insidePropertyValue = true;
1294 } else if (this._ch === '@') {
1295 this.preserveSingleSpace(isAfterSpace);
1297 // deal with less property mixins @{...}
1298 if (this._input.peek() === '{') {
1299 this.print_string(this._ch + this.eatString('}'));
1301 this.print_string(this._ch);
1303 // strip trailing space, if present, for hash property checks
1304 var variableOrRule = this._input.peekUntilAfter(/[: ,;{}()[\]\/='"]/g);
1306 if (variableOrRule.match(/[ :]$/)) {
1307 // we have a variable or pseudo-class, add it and insert one space before continuing
1308 variableOrRule = this.eatString(": ").replace(/\s+$/, '');
1309 this.print_string(variableOrRule);
1310 this._output.space_before_token = true;
1313 // might be less variable
1314 if (parenLevel === 0 && variableOrRule.indexOf(':') !== -1) {
1315 insidePropertyValue = true;
1318 // might be a nesting at-rule
1319 } else if (variableOrRule in this.NESTED_AT_RULE) {
1320 this._nestedLevel += 1;
1321 if (variableOrRule in this.CONDITIONAL_GROUP_RULE) {
1322 enteringConditionalGroup = true;
1325 // might be a non-nested at-rule
1326 } else if (parenLevel === 0 && !insidePropertyValue) {
1327 insideNonNestedAtRule = true;
1330 } else if (this._ch === '#' && this._input.peek() === '{') {
1331 this.preserveSingleSpace(isAfterSpace);
1332 this.print_string(this._ch + this.eatString('}'));
1333 } else if (this._ch === '{') {
1334 if (insidePropertyValue) {
1335 insidePropertyValue = false;
1339 // non nested at rule becomes nested
1340 insideNonNestedAtRule = false;
1342 // when entering conditional groups, only rulesets are allowed
1343 if (enteringConditionalGroup) {
1344 enteringConditionalGroup = false;
1345 insideRule = (this._indentLevel >= this._nestedLevel);
1347 // otherwise, declarations are also allowed
1348 insideRule = (this._indentLevel >= this._nestedLevel - 1);
1350 if (this._options.newline_between_rules && insideRule) {
1351 if (this._output.previous_line && this._output.previous_line.item(-1) !== '{') {
1352 this._output.ensure_empty_line_above('/', ',');
1356 this._output.space_before_token = true;
1358 // The difference in print_string and indent order is necessary to indent the '{' correctly
1359 if (this._options.brace_style === 'expand') {
1360 this._output.add_new_line();
1361 this.print_string(this._ch);
1363 this._output.set_indent(this._indentLevel);
1365 // inside mixin and first param is object
1366 if (previous_ch === '(') {
1367 this._output.space_before_token = false;
1368 } else if (previous_ch !== ',') {
1371 this.print_string(this._ch);
1374 this.eatWhitespace(true);
1375 this._output.add_new_line();
1376 } else if (this._ch === '}') {
1378 this._output.add_new_line();
1379 if (previous_ch === '{') {
1380 this._output.trim(true);
1383 if (insidePropertyValue) {
1385 insidePropertyValue = false;
1387 this.print_string(this._ch);
1389 if (this._nestedLevel) {
1390 this._nestedLevel--;
1393 this.eatWhitespace(true);
1394 this._output.add_new_line();
1396 if (this._options.newline_between_rules && !this._output.just_added_blankline()) {
1397 if (this._input.peek() !== '}') {
1398 this._output.add_new_line(true);
1401 if (this._input.peek() === ')') {
1402 this._output.trim(true);
1403 if (this._options.brace_style === "expand") {
1404 this._output.add_new_line(true);
1407 } else if (this._ch === ":") {
1409 for (var i = 0; i < this.NON_SEMICOLON_NEWLINE_PROPERTY.length; i++) {
1410 if (this._input.lookBack(this.NON_SEMICOLON_NEWLINE_PROPERTY[i])) {
1411 insideNonSemiColonValues = true;
1416 if ((insideRule || enteringConditionalGroup) && !(this._input.lookBack("&") || this.foundNestedPseudoClass()) && !this._input.lookBack("(") && !insideNonNestedAtRule && parenLevel === 0) {
1417 // 'property: value' delimiter
1418 // which could be in a conditional group query
1420 this.print_string(':');
1421 if (!insidePropertyValue) {
1422 insidePropertyValue = true;
1423 this._output.space_before_token = true;
1424 this.eatWhitespace(true);
1428 // sass/less parent reference don't use a space
1429 // sass nested pseudo-class don't use a space
1431 // preserve space before pseudoclasses/pseudoelements, as it means "in any child"
1432 if (this._input.lookBack(" ")) {
1433 this._output.space_before_token = true;
1435 if (this._input.peek() === ":") {
1437 this._ch = this._input.next();
1438 this.print_string("::");
1441 this.print_string(':');
1444 } else if (this._ch === '"' || this._ch === '\'') {
1445 var preserveQuoteSpace = previous_ch === '"' || previous_ch === '\'';
1446 this.preserveSingleSpace(preserveQuoteSpace || isAfterSpace);
1447 this.print_string(this._ch + this.eatString(this._ch));
1448 this.eatWhitespace(true);
1449 } else if (this._ch === ';') {
1450 insideNonSemiColonValues = false;
1451 if (parenLevel === 0) {
1452 if (insidePropertyValue) {
1454 insidePropertyValue = false;
1456 insideNonNestedAtRule = false;
1457 this.print_string(this._ch);
1458 this.eatWhitespace(true);
1460 // This maintains single line comments on the same
1461 // line. Block comments are also affected, but
1462 // a new line is always output before one inside
1464 if (this._input.peek() !== '/') {
1465 this._output.add_new_line();
1468 this.print_string(this._ch);
1469 this.eatWhitespace(true);
1470 this._output.space_before_token = true;
1472 } else if (this._ch === '(') { // may be a url
1473 if (this._input.lookBack("url")) {
1474 this.print_string(this._ch);
1475 this.eatWhitespace();
1478 this._ch = this._input.next();
1479 if (this._ch === ')' || this._ch === '"' || this._ch === '\'') {
1481 } else if (this._ch) {
1482 this.print_string(this._ch + this.eatString(')'));
1489 var space_needed = false;
1490 if (this._input.lookBack("with")) {
1491 // look back is not an accurate solution, we need tokens to confirm without whitespaces
1492 space_needed = true;
1494 this.preserveSingleSpace(isAfterSpace || space_needed);
1495 this.print_string(this._ch);
1497 // handle scss/sass map
1498 if (insidePropertyValue && previous_ch === "$" && this._options.selector_separator_newline) {
1499 this._output.add_new_line();
1500 insideScssMap = true;
1502 this.eatWhitespace();
1507 } else if (this._ch === ')') {
1512 if (insideScssMap && this._input.peek() === ";" && this._options.selector_separator_newline) {
1513 insideScssMap = false;
1515 this._output.add_new_line();
1517 this.print_string(this._ch);
1518 } else if (this._ch === ',') {
1519 this.print_string(this._ch);
1520 this.eatWhitespace(true);
1521 if (this._options.selector_separator_newline && (!insidePropertyValue || insideScssMap) && parenLevel === 0 && !insideNonNestedAtRule) {
1522 this._output.add_new_line();
1524 this._output.space_before_token = true;
1526 } else if ((this._ch === '>' || this._ch === '+' || this._ch === '~') && !insidePropertyValue && parenLevel === 0) {
1527 //handle combinator spacing
1528 if (this._options.space_around_combinator) {
1529 this._output.space_before_token = true;
1530 this.print_string(this._ch);
1531 this._output.space_before_token = true;
1533 this.print_string(this._ch);
1534 this.eatWhitespace();
1535 // squash extra whitespace
1536 if (this._ch && whitespaceChar.test(this._ch)) {
1540 } else if (this._ch === ']') {
1541 this.print_string(this._ch);
1542 } else if (this._ch === '[') {
1543 this.preserveSingleSpace(isAfterSpace);
1544 this.print_string(this._ch);
1545 } else if (this._ch === '=') { // no whitespace before or after
1546 this.eatWhitespace();
1547 this.print_string('=');
1548 if (whitespaceChar.test(this._ch)) {
1551 } else if (this._ch === '!' && !this._input.lookBack("\\")) { // !important
1552 this._output.space_before_token = true;
1553 this.print_string(this._ch);
1555 var preserveAfterSpace = previous_ch === '"' || previous_ch === '\'';
1556 this.preserveSingleSpace(preserveAfterSpace || isAfterSpace);
1557 this.print_string(this._ch);
1559 if (!this._output.just_added_newline() && this._input.peek() === '\n' && insideNonSemiColonValues) {
1560 this._output.add_new_line();
1565 var sweetCode = this._output.get_code(eol);
1570 module.exports.Beautifier = Beautifier;
1575 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1577 /*jshint node:true */
1580 The MIT License (MIT)
1582 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
1584 Permission is hereby granted, free of charge, to any person
1585 obtaining a copy of this software and associated documentation files
1586 (the "Software"), to deal in the Software without restriction,
1587 including without limitation the rights to use, copy, modify, merge,
1588 publish, distribute, sublicense, and/or sell copies of the Software,
1589 and to permit persons to whom the Software is furnished to do so,
1590 subject to the following conditions:
1592 The above copyright notice and this permission notice shall be
1593 included in all copies or substantial portions of the Software.
1595 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
1596 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
1597 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
1598 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
1599 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
1600 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
1601 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
1607 var BaseOptions = (__webpack_require__(6).Options);
1609 function Options(options) {
1610 BaseOptions.call(this, options, 'css');
1612 this.selector_separator_newline = this._get_boolean('selector_separator_newline', true);
1613 this.newline_between_rules = this._get_boolean('newline_between_rules', true);
1614 var space_around_selector_separator = this._get_boolean('space_around_selector_separator');
1615 this.space_around_combinator = this._get_boolean('space_around_combinator') || space_around_selector_separator;
1617 var brace_style_split = this._get_selection_list('brace_style', ['collapse', 'expand', 'end-expand', 'none', 'preserve-inline']);
1618 this.brace_style = 'collapse';
1619 for (var bs = 0; bs < brace_style_split.length; bs++) {
1620 if (brace_style_split[bs] !== 'expand') {
1621 // default to collapse, as only collapse|expand is implemented for now
1622 this.brace_style = 'collapse';
1624 this.brace_style = brace_style_split[bs];
1628 Options.prototype = new BaseOptions();
1632 module.exports.Options = Options;
1637 /************************************************************************/
1638 /******/ // The module cache
1639 /******/ var __webpack_module_cache__ = {};
1641 /******/ // The require function
1642 /******/ function __webpack_require__(moduleId) {
1643 /******/ // Check if module is in cache
1644 /******/ var cachedModule = __webpack_module_cache__[moduleId];
1645 /******/ if (cachedModule !== undefined) {
1646 /******/ return cachedModule.exports;
1648 /******/ // Create a new module (and put it into the cache)
1649 /******/ var module = __webpack_module_cache__[moduleId] = {
1650 /******/ // no module.id needed
1651 /******/ // no module.loaded needed
1652 /******/ exports: {}
1655 /******/ // Execute the module function
1656 /******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
1658 /******/ // Return the exports of the module
1659 /******/ return module.exports;
1662 /************************************************************************/
1665 /******/ // Load entry module and return exports
1666 /******/ // This entry module is referenced by other modules so it can't be inlined
1667 /******/ var __webpack_exports__ = __webpack_require__(15);
1668 /******/ legacy_beautify_css = __webpack_exports__;
1672 var css_beautify = legacy_beautify_css;
1674 if (typeof define === "function" && define.amd) {
1675 // Add support for AMD ( https://github.com/amdjs/amdjs-api/wiki/AMD#defineamd-property- )
1676 define([], function() {
1678 css_beautify: css_beautify
1681 } else if (typeof exports !== "undefined") {
1682 // Add support for CommonJS. Just put this file somewhere on your require.paths
1683 // and you will be able to `var html_beautify = require("beautify").html_beautify`.
1684 exports.css_beautify = css_beautify;
1685 } else if (typeof window !== "undefined") {
1686 // If we're running a web page and don't have either of the above, add our one global
1687 window.css_beautify = css_beautify;
1688 } else if (typeof global !== "undefined") {
1689 // If we don't even have window, try global.
1690 global.css_beautify = css_beautify;