vendor: 54,387 bytes, lines 1-1693
1/* AUTO-GENERATED. DO NOT MODIFY. */ 2/* 3 4 The MIT License (MIT) 5 6 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. 7 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: 15 16 The above copyright notice and this permission notice shall be 17 included in all copies or substantial portions of the Software. 18 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 26 SOFTWARE. 27 28 29 CSS Beautifier 30--------------- 31 32 Written by Harutyun Amirjanyan, ([email protected]) 33 34 Based on code initially developed by: Einar Lielmanis, <[email protected]> 35 https://beautifier.io/ 36 37 Usage: 38 css_beautify(source_text); 39 css_beautify(source_text, options); 40 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") 50 e.g 51 52 css_beautify(css_source_text, { 53 'indent_size': 1, 54 'indent_char': '\t', 55 'selector_separator': ' ', 56 'end_with_newline': false, 57 'newline_between_rules': true, 58 'space_around_selector_separator': true 59 }); 60*/ 61 62// http://www.w3.org/TR/CSS21/syndata.html#tokenization 63// http://www.w3.org/TR/css3-syntax/ 64 65(function() { 66 67/* GENERATED_BUILD_OUTPUT */ 68var legacy_beautify_css; 69/******/ (function() { // webpackBootstrap 70/******/ "use strict"; 71/******/ var __webpack_modules__ = ([ 72/* 0 */, 73/* 1 */, 74/* 2 */ 75/***/ (function(module) { 76 77/*jshint node:true */ 78/* 79 The MIT License (MIT) 80 81 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. 82 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: 90 91 The above copyright notice and this permission notice shall be 92 included in all copies or substantial portions of the Software. 93 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 101 SOFTWARE. 102*/ 103 104 105 106function 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; 116 117 this.__items = []; 118} 119 120OutputLine.prototype.clone_empty = function() { 121 var line = new OutputLine(this.__parent); 122 line.set_indent(this.__indent_count, this.__alignment_count); 123 return line; 124}; 125 126OutputLine.prototype.item = function(index) { 127 if (index < 0) { 128 return this.__items[this.__items.length + index]; 129 } else { 130 return this.__items[index]; 131 } 132}; 133 134OutputLine.prototype.has_match = function(pattern) { 135 for (var lastCheckedOutput = this.__items.length - 1; lastCheckedOutput >= 0; lastCheckedOutput--) { 136 if (this.__items[lastCheckedOutput].match(pattern)) { 137 return true; 138 } 139 } 140 return false; 141}; 142 143OutputLine.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); 148 } 149}; 150 151OutputLine.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; 157 } 158}; 159 160OutputLine.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; 164}; 165 166OutputLine.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); 173 174 next.__character_count += this.__character_count - this.__wrap_point_character_count; 175 this.__character_count = this.__wrap_point_character_count; 176 177 if (next.__items[0] === " ") { 178 next.__items.splice(0, 1); 179 next.__character_count -= 1; 180 } 181 return true; 182 } 183 return false; 184}; 185 186OutputLine.prototype.is_empty = function() { 187 return this.__items.length === 0; 188}; 189 190OutputLine.prototype.last = function() { 191 if (!this.is_empty()) { 192 return this.__items[this.__items.length - 1]; 193 } else { 194 return null; 195 } 196}; 197 198OutputLine.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; 203 } else { 204 this.__character_count += item.length; 205 } 206}; 207 208OutputLine.prototype.pop = function() { 209 var item = null; 210 if (!this.is_empty()) { 211 item = this.__items.pop(); 212 this.__character_count -= item.length; 213 } 214 return item; 215}; 216 217 218OutputLine.prototype._remove_indent = function() { 219 if (this.__indent_count > 0) { 220 this.__indent_count -= 1; 221 this.__character_count -= this.__parent.indent_size; 222 } 223}; 224 225OutputLine.prototype._remove_wrap_indent = function() { 226 if (this.__wrap_point_indent_count > 0) { 227 this.__wrap_point_indent_count -= 1; 228 } 229}; 230OutputLine.prototype.trim = function() { 231 while (this.last() === ' ') { 232 this.__items.pop(); 233 this.__character_count -= 1; 234 } 235}; 236 237OutputLine.prototype.toString = function() { 238 var result = ''; 239 if (this.is_empty()) { 240 if (this.__parent.indent_empty_lines) { 241 result = this.__parent.get_indent_string(this.__indent_count); 242 } 243 } else { 244 result = this.__parent.get_indent_string(this.__indent_count, this.__alignment_count); 245 result += this.__items.join(''); 246 } 247 return result; 248}; 249 250function IndentStringCache(options, baseIndentString) { 251 this.__cache = ['']; 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); 256 } 257 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); 262 } 263 264 this.__base_string = baseIndentString; 265 this.__base_string_length = baseIndentString.length; 266} 267 268IndentStringCache.prototype.get_indent_size = function(indent, column) { 269 var result = this.__base_string_length; 270 column = column || 0; 271 if (indent < 0) { 272 result = 0; 273 } 274 result += indent * this.__indent_size; 275 result += column; 276 return result; 277}; 278 279IndentStringCache.prototype.get_indent_string = function(indent_level, column) { 280 var result = this.__base_string; 281 column = column || 0; 282 if (indent_level < 0) { 283 indent_level = 0; 284 result = ''; 285 } 286 column += indent_level * this.__indent_size; 287 this.__ensure_cache(column); 288 result += this.__cache[column]; 289 return result; 290}; 291 292IndentStringCache.prototype.__ensure_cache = function(column) { 293 while (column >= this.__cache.length) { 294 this.__add_column(); 295 } 296}; 297 298IndentStringCache.prototype.__add_column = function() { 299 var column = this.__cache.length; 300 var indent = 0; 301 var result = ''; 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); 306 } 307 if (column) { 308 result += new Array(column + 1).join(' '); 309 } 310 311 this.__cache.push(result); 312}; 313 314function Output(options, baseIndentString) { 315 this.__indent_cache = new IndentStringCache(options, baseIndentString); 316 this.raw = false; 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; 321 this.__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; 328 // initialize 329 this.__add_outputline(); 330} 331 332Output.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); 336}; 337 338Output.prototype.get_line_number = function() { 339 return this.__lines.length; 340}; 341 342Output.prototype.get_indent_string = function(indent, column) { 343 return this.__indent_cache.get_indent_string(indent, column); 344}; 345 346Output.prototype.get_indent_size = function(indent, column) { 347 return this.__indent_cache.get_indent_size(indent, column); 348}; 349 350Output.prototype.is_empty = function() { 351 return !this.previous_line && this.current_line.is_empty(); 352}; 353 354Output.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())) { 359 return false; 360 } 361 362 // if raw output is enabled, don't print additional newlines, 363 // but still return True as though you had 364 if (!this.raw) { 365 this.__add_outputline(); 366 } 367 return true; 368}; 369 370Output.prototype.get_code = function(eol) { 371 this.trim(true); 372 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(); 376 if (last_item) { 377 if (last_item[last_item.length - 1] === '\n') { 378 last_item = last_item.replace(/\n+$/g, ''); 379 } 380 this.current_line.push(last_item); 381 } 382 383 if (this._end_with_newline) { 384 this.__add_outputline(); 385 } 386 387 var sweet_code = this.__lines.join('\n'); 388 389 if (eol !== '\n') { 390 sweet_code = sweet_code.replace(/[\n]/g, eol); 391 } 392 return sweet_code; 393}; 394 395Output.prototype.set_wrap_point = function() { 396 this.current_line._set_wrap_point(); 397}; 398 399Output.prototype.set_indent = function(indent, alignment) { 400 indent = indent || 0; 401 alignment = alignment || 0; 402 403 // Next line stores alignment values 404 this.next_line.set_indent(indent, alignment); 405 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); 409 return true; 410 } 411 412 this.current_line.set_indent(); 413 return false; 414}; 415 416Output.prototype.add_raw_token = function(token) { 417 for (var x = 0; x < token.newlines; x++) { 418 this.__add_outputline(); 419 } 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; 426}; 427 428Output.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(); 434}; 435 436Output.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(); 440 } 441 this.current_line.push(' '); 442 } 443}; 444 445Output.prototype.remove_indent = function(index) { 446 var output_length = this.__lines.length; 447 while (index < output_length) { 448 this.__lines[index]._remove_indent(); 449 index++; 450 } 451 this.current_line._remove_wrap_indent(); 452}; 453 454Output.prototype.trim = function(eat_newlines) { 455 eat_newlines = (eat_newlines === undefined) ? false : eat_newlines; 456 457 this.current_line.trim(); 458 459 while (eat_newlines && this.__lines.length > 1 && 460 this.current_line.is_empty()) { 461 this.__lines.pop(); 462 this.current_line = this.__lines[this.__lines.length - 1]; 463 this.current_line.trim(); 464 } 465 466 this.previous_line = this.__lines.length > 1 ? 467 this.__lines[this.__lines.length - 2] : null; 468}; 469 470Output.prototype.just_added_newline = function() { 471 return this.current_line.is_empty(); 472}; 473 474Output.prototype.just_added_blankline = function() { 475 return this.is_empty() || 476 (this.current_line.is_empty() && this.previous_line.is_empty()); 477}; 478 479Output.prototype.ensure_empty_line_above = function(starts_with, ends_with) { 480 var index = this.__lines.length - 2; 481 while (index >= 0) { 482 var potentialEmptyLine = this.__lines[index]; 483 if (potentialEmptyLine.is_empty()) { 484 break; 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]; 489 break; 490 } 491 index--; 492 } 493}; 494 495module.exports.Output = Output; 496 497 498/***/ }), 499/* 3 */, 500/* 4 */, 501/* 5 */, 502/* 6 */ 503/***/ (function(module) { 504 505/*jshint node:true */ 506/* 507 508 The MIT License (MIT) 509 510 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. 511 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: 519 520 The above copyright notice and this permission notice shall be 521 included in all copies or substantial portions of the Software. 522 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 530 SOFTWARE. 531*/ 532 533 534 535function Options(options, merge_child_field) { 536 this.raw_options = _mergeOpts(options, merge_child_field); 537 538 // Support passing the source text back with no change 539 this.disabled = this._get_boolean('disabled'); 540 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'); 546 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; 551 } 552 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'; 556 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; 566 } 567 } 568 569 // Backwards compat with 1.3.x 570 this.wrap_line_length = this._get_number('wrap_line_length', this._get_number('max_char')); 571 572 this.indent_empty_lines = this._get_boolean('indent_empty_lines'); 573 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']); 578} 579 580Options.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(); 586 } 587 } else if (typeof option_value === 'string') { 588 result = option_value.split(/[^a-zA-Z0-9_\/\-]+/); 589 } 590 return result; 591}; 592 593Options.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; 596 return result; 597}; 598 599Options.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'); 604 } 605 return result; 606}; 607 608Options.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)) { 612 default_value = 0; 613 } 614 var result = parseInt(option_value, 10); 615 if (isNaN(result)) { 616 result = default_value; 617 } 618 return result; 619}; 620 621Options.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) { 624 throw new Error( 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] + "'"); 627 } 628 629 return result[0]; 630}; 631 632 633Options.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."); 636 } 637 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!"); 641 } 642 643 var result = this._get_array(name, default_value); 644 if (!this._is_valid_selection(result, selection_list)) { 645 throw new Error( 646 "Invalid Option Value: The option '" + name + "' can contain only the following values:\n" + 647 selection_list + "\nYou passed in: '" + this.raw_options[name] + "'"); 648 } 649 650 return result; 651}; 652 653Options.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; }); 656}; 657 658 659// merges child options up with the parent options object 660// Example: obj = {a: 1, b: {a: 2}} 661// mergeOpts(obj, 'b') 662// 663// Returns: {a: 2} 664function _mergeOpts(allOptions, childFieldName) { 665 var finalOpts = {}; 666 allOptions = _normalizeOpts(allOptions); 667 var name; 668 669 for (name in allOptions) { 670 if (name !== childFieldName) { 671 finalOpts[name] = allOptions[name]; 672 } 673 } 674 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]; 679 } 680 } 681 return finalOpts; 682} 683 684function _normalizeOpts(options) { 685 var convertedOpts = {}; 686 var key; 687 688 for (key in options) { 689 var newKey = key.replace(/-/g, "_"); 690 convertedOpts[newKey] = options[key]; 691 } 692 return convertedOpts; 693} 694 695module.exports.Options = Options; 696module.exports.normalizeOpts = _normalizeOpts; 697module.exports.mergeOpts = _mergeOpts; 698 699 700/***/ }), 701/* 7 */, 702/* 8 */ 703/***/ (function(module) { 704 705/*jshint node:true */ 706/* 707 708 The MIT License (MIT) 709 710 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. 711 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: 719 720 The above copyright notice and this permission notice shall be 721 included in all copies or substantial portions of the Software. 722 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 730 SOFTWARE. 731*/ 732 733 734 735var regexp_has_sticky = RegExp.prototype.hasOwnProperty('sticky'); 736 737function InputScanner(input_string) { 738 this.__input = input_string || ''; 739 this.__input_length = this.__input.length; 740 this.__position = 0; 741} 742 743InputScanner.prototype.restart = function() { 744 this.__position = 0; 745}; 746 747InputScanner.prototype.back = function() { 748 if (this.__position > 0) { 749 this.__position -= 1; 750 } 751}; 752 753InputScanner.prototype.hasNext = function() { 754 return this.__position < this.__input_length; 755}; 756 757InputScanner.prototype.next = function() { 758 var val = null; 759 if (this.hasNext()) { 760 val = this.__input.charAt(this.__position); 761 this.__position += 1; 762 } 763 return val; 764}; 765 766InputScanner.prototype.peek = function(index) { 767 var val = null; 768 index = index || 0; 769 index += this.__position; 770 if (index >= 0 && index < this.__input_length) { 771 val = this.__input.charAt(index); 772 } 773 return val; 774}; 775 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. 783InputScanner.prototype.__match = function(pattern, index) { 784 pattern.lastIndex = index; 785 var pattern_match = pattern.exec(this.__input); 786 787 if (pattern_match && !(regexp_has_sticky && pattern.sticky)) { 788 if (pattern_match.index !== index) { 789 pattern_match = null; 790 } 791 } 792 793 return pattern_match; 794}; 795 796InputScanner.prototype.test = function(pattern, index) { 797 index = index || 0; 798 index += this.__position; 799 800 if (index >= 0 && index < this.__input_length) { 801 return !!this.__match(pattern, index); 802 } else { 803 return false; 804 } 805}; 806 807InputScanner.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); 812}; 813 814InputScanner.prototype.match = function(pattern) { 815 var pattern_match = this.__match(pattern, this.__position); 816 if (pattern_match) { 817 this.__position += pattern_match[0].length; 818 } else { 819 pattern_match = null; 820 } 821 return pattern_match; 822}; 823 824InputScanner.prototype.read = function(starting_pattern, until_pattern, until_after) { 825 var val = ''; 826 var match; 827 if (starting_pattern) { 828 match = this.match(starting_pattern); 829 if (match) { 830 val += match[0]; 831 } 832 } 833 if (until_pattern && (match || !starting_pattern)) { 834 val += this.readUntil(until_pattern, until_after); 835 } 836 return val; 837}; 838 839InputScanner.prototype.readUntil = function(pattern, until_after) { 840 var val = ''; 841 var match_index = this.__position; 842 pattern.lastIndex = this.__position; 843 var pattern_match = pattern.exec(this.__input); 844 if (pattern_match) { 845 match_index = pattern_match.index; 846 if (until_after) { 847 match_index += pattern_match[0].length; 848 } 849 } else { 850 match_index = this.__input_length; 851 } 852 853 val = this.__input.substring(this.__position, match_index); 854 this.__position = match_index; 855 return val; 856}; 857 858InputScanner.prototype.readUntilAfter = function(pattern) { 859 return this.readUntil(pattern, true); 860}; 861 862InputScanner.prototype.get_regexp = function(pattern, match_from) { 863 var result = null; 864 var flags = 'g'; 865 if (match_from && regexp_has_sticky) { 866 flags = 'y'; 867 } 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); 874 } 875 return result; 876}; 877 878InputScanner.prototype.get_literal_regexp = function(literal_string) { 879 return RegExp(literal_string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')); 880}; 881 882/* css beautifier legacy helpers */ 883InputScanner.prototype.peekUntilAfter = function(pattern) { 884 var start = this.__position; 885 var val = this.readUntilAfter(pattern); 886 this.__position = start; 887 return val; 888}; 889 890InputScanner.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; 894}; 895 896module.exports.InputScanner = InputScanner; 897 898 899/***/ }), 900/* 9 */, 901/* 10 */, 902/* 11 */, 903/* 12 */, 904/* 13 */ 905/***/ (function(module) { 906 907/*jshint node:true */ 908/* 909 910 The MIT License (MIT) 911 912 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. 913 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: 921 922 The above copyright notice and this permission notice shall be 923 included in all copies or substantial portions of the Software. 924 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 932 SOFTWARE. 933*/ 934 935 936 937function 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; 942 943 this.__directives_end_ignore_pattern = new RegExp(start_block_pattern + /\sbeautify\signore:end\s/.source + end_block_pattern, 'g'); 944} 945 946Directives.prototype.get_directives = function(text) { 947 if (!text.match(this.__directives_block_pattern)) { 948 return null; 949 } 950 951 var directives = {}; 952 this.__directive_pattern.lastIndex = 0; 953 var directive_match = this.__directive_pattern.exec(text); 954 955 while (directive_match) { 956 directives[directive_match[1]] = directive_match[2]; 957 directive_match = this.__directive_pattern.exec(text); 958 } 959 960 return directives; 961}; 962 963Directives.prototype.readIgnored = function(input) { 964 return input.readUntilAfter(this.__directives_end_ignore_pattern); 965}; 966 967 968module.exports.Directives = Directives; 969 970 971/***/ }), 972/* 14 */, 973/* 15 */ 974/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 975 976/*jshint node:true */ 977/* 978 979 The MIT License (MIT) 980 981 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. 982 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: 990 991 The above copyright notice and this permission notice shall be 992 included in all copies or substantial portions of the Software. 993 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 1001 SOFTWARE. 1002*/ 1003 1004 1005 1006var Beautifier = (__webpack_require__(16).Beautifier), 1007 Options = (__webpack_require__(17).Options); 1008 1009function css_beautify(source_text, options) { 1010 var beautifier = new Beautifier(source_text, options); 1011 return beautifier.beautify(); 1012} 1013 1014module.exports = css_beautify; 1015module.exports.defaultOptions = function() { 1016 return new Options(); 1017}; 1018 1019 1020/***/ }), 1021/* 16 */ 1022/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 1023 1024/*jshint node:true */ 1025/* 1026 1027 The MIT License (MIT) 1028 1029 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. 1030 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: 1038 1039 The above copyright notice and this permission notice shall be 1040 included in all copies or substantial portions of the Software. 1041 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 1049 SOFTWARE. 1050*/ 1051 1052 1053 1054var Options = (__webpack_require__(17).Options); 1055var Output = (__webpack_require__(2).Output); 1056var InputScanner = (__webpack_require__(8).InputScanner); 1057var Directives = (__webpack_require__(13).Directives); 1058 1059var directives_core = new Directives(/\/\*/, /\*\//); 1060 1061var lineBreak = /\r\n|[\r\n]/; 1062var allLineBreaks = /\r\n|[\r\n]/g; 1063 1064// tokenizer 1065var whitespaceChar = /\s/; 1066var whitespacePattern = /(?:\s|\n)+/g; 1067var block_comment_pattern = /\/\*(?:[\s\S]*?)((?:\*\/)|$)/g; 1068var comment_pattern = /\/\/(?:[^\n\r\u2028\u2029]*)/g; 1069 1070function 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); 1075 this._ch = null; 1076 this._input = null; 1077 1078 // https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule 1079 this.NESTED_AT_RULE = { 1080 "page": true, 1081 "font-face": true, 1082 "keyframes": true, 1083 // also in CONDITIONAL_GROUP_RULE below 1084 "media": true, 1085 "supports": true, 1086 "document": true 1087 }; 1088 this.CONDITIONAL_GROUP_RULE = { 1089 "media": true, 1090 "supports": true, 1091 "document": true 1092 }; 1093 this.NON_SEMICOLON_NEWLINE_PROPERTY = [ 1094 "grid-template-areas", 1095 "grid-template" 1096 ]; 1097 1098} 1099 1100Beautifier.prototype.eatString = function(endChars) { 1101 var result = ''; 1102 this._ch = this._input.next(); 1103 while (this._ch) { 1104 result += this._ch; 1105 if (this._ch === "\\") { 1106 result += this._input.next(); 1107 } else if (endChars.indexOf(this._ch) !== -1 || this._ch === "\n") { 1108 break; 1109 } 1110 this._ch = this._input.next(); 1111 } 1112 return result; 1113}; 1114 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 1119Beautifier.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) { 1126 newline_count++; 1127 this._output.add_new_line(true); 1128 } 1129 } 1130 } 1131 return result; 1132}; 1133 1134// Nested pseudo-class if we are insideRule 1135// and the next special character found opens 1136// a new block 1137Beautifier.prototype.foundNestedPseudoClass = function() { 1138 var openParen = 0; 1139 var i = 1; 1140 var ch = this._input.peek(i); 1141 while (ch) { 1142 if (ch === "{") { 1143 return true; 1144 } else if (ch === '(') { 1145 // pseudoclasses can contain () 1146 openParen += 1; 1147 } else if (ch === ')') { 1148 if (openParen === 0) { 1149 return false; 1150 } 1151 openParen -= 1; 1152 } else if (ch === ";" || ch === "}") { 1153 return false; 1154 } 1155 i++; 1156 ch = this._input.peek(i); 1157 } 1158 return false; 1159}; 1160 1161Beautifier.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); 1165}; 1166 1167Beautifier.prototype.preserveSingleSpace = function(isAfterSpace) { 1168 if (isAfterSpace) { 1169 this._output.space_before_token = true; 1170 } 1171}; 1172 1173Beautifier.prototype.indent = function() { 1174 this._indentLevel++; 1175}; 1176 1177Beautifier.prototype.outdent = function() { 1178 if (this._indentLevel > 0) { 1179 this._indentLevel--; 1180 } 1181}; 1182 1183/*_____________________--------------------_____________________*/ 1184 1185Beautifier.prototype.beautify = function() { 1186 if (this._options.disabled) { 1187 return this._source_text; 1188 } 1189 1190 var source_text = this._source_text; 1191 var eol = this._options.eol; 1192 if (eol === 'auto') { 1193 eol = '\n'; 1194 if (source_text && lineBreak.test(source_text || '')) { 1195 eol = source_text.match(lineBreak)[0]; 1196 } 1197 } 1198 1199 1200 // HACK: newline parsing inconsistent. This brute force normalizes the this._input. 1201 source_text = source_text.replace(allLineBreaks, '\n'); 1202 1203 // reset 1204 var baseIndentString = source_text.match(/^[\t ]*/)[0]; 1205 1206 this._output = new Output(this._options, baseIndentString); 1207 this._input = new InputScanner(source_text); 1208 this._indentLevel = 0; 1209 this._nestedLevel = 0; 1210 1211 this._ch = null; 1212 var parenLevel = 0; 1213 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; 1223 var whitespace; 1224 var isAfterSpace; 1225 var previous_ch; 1226 1227 while (true) { 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(); 1234 } 1235 topCharacter = this._ch; 1236 1237 if (!this._ch) { 1238 break; 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(); 1246 this._input.back(); 1247 1248 var comment = this._input.read(block_comment_pattern); 1249 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); 1254 } 1255 1256 this.print_string(comment); 1257 1258 // Ensures any new lines following the comment are preserved 1259 this.eatWhitespace(true); 1260 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; 1269 this._input.back(); 1270 this.print_string(this._input.read(comment_pattern)); 1271 1272 // Ensures any new lines following the comment are preserved 1273 this.eatWhitespace(true); 1274 } else if (this._ch === '$') { 1275 this.preserveSingleSpace(isAfterSpace); 1276 1277 this.print_string(this._ch); 1278 1279 // strip trailing space, if present, for hash property checks 1280 var variable = this._input.peekUntilAfter(/[: ,;{}()[\]\/='"]/g); 1281 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; 1287 } 1288 1289 // might be sass variable 1290 if (parenLevel === 0 && variable.indexOf(':') !== -1) { 1291 insidePropertyValue = true; 1292 this.indent(); 1293 } 1294 } else if (this._ch === '@') { 1295 this.preserveSingleSpace(isAfterSpace); 1296 1297 // deal with less property mixins @{...} 1298 if (this._input.peek() === '{') { 1299 this.print_string(this._ch + this.eatString('}')); 1300 } else { 1301 this.print_string(this._ch); 1302 1303 // strip trailing space, if present, for hash property checks 1304 var variableOrRule = this._input.peekUntilAfter(/[: ,;{}()[\]\/='"]/g); 1305 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; 1311 } 1312 1313 // might be less variable 1314 if (parenLevel === 0 && variableOrRule.indexOf(':') !== -1) { 1315 insidePropertyValue = true; 1316 this.indent(); 1317 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; 1323 } 1324 1325 // might be a non-nested at-rule 1326 } else if (parenLevel === 0 && !insidePropertyValue) { 1327 insideNonNestedAtRule = true; 1328 } 1329 } 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; 1336 this.outdent(); 1337 } 1338 1339 // non nested at rule becomes nested 1340 insideNonNestedAtRule = false; 1341 1342 // when entering conditional groups, only rulesets are allowed 1343 if (enteringConditionalGroup) { 1344 enteringConditionalGroup = false; 1345 insideRule = (this._indentLevel >= this._nestedLevel); 1346 } else { 1347 // otherwise, declarations are also allowed 1348 insideRule = (this._indentLevel >= this._nestedLevel - 1); 1349 } 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('/', ','); 1353 } 1354 } 1355 1356 this._output.space_before_token = true; 1357 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); 1362 this.indent(); 1363 this._output.set_indent(this._indentLevel); 1364 } else { 1365 // inside mixin and first param is object 1366 if (previous_ch === '(') { 1367 this._output.space_before_token = false; 1368 } else if (previous_ch !== ',') { 1369 this.indent(); 1370 } 1371 this.print_string(this._ch); 1372 } 1373 1374 this.eatWhitespace(true); 1375 this._output.add_new_line(); 1376 } else if (this._ch === '}') { 1377 this.outdent(); 1378 this._output.add_new_line(); 1379 if (previous_ch === '{') { 1380 this._output.trim(true); 1381 } 1382 1383 if (insidePropertyValue) { 1384 this.outdent(); 1385 insidePropertyValue = false; 1386 } 1387 this.print_string(this._ch); 1388 insideRule = false; 1389 if (this._nestedLevel) { 1390 this._nestedLevel--; 1391 } 1392 1393 this.eatWhitespace(true); 1394 this._output.add_new_line(); 1395 1396 if (this._options.newline_between_rules && !this._output.just_added_blankline()) { 1397 if (this._input.peek() !== '}') { 1398 this._output.add_new_line(true); 1399 } 1400 } 1401 if (this._input.peek() === ')') { 1402 this._output.trim(true); 1403 if (this._options.brace_style === "expand") { 1404 this._output.add_new_line(true); 1405 } 1406 } 1407 } else if (this._ch === ":") { 1408 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; 1412 break; 1413 } 1414 } 1415 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 1419 1420 this.print_string(':'); 1421 if (!insidePropertyValue) { 1422 insidePropertyValue = true; 1423 this._output.space_before_token = true; 1424 this.eatWhitespace(true); 1425 this.indent(); 1426 } 1427 } else { 1428 // sass/less parent reference don't use a space 1429 // sass nested pseudo-class don't use a space 1430 1431 // preserve space before pseudoclasses/pseudoelements, as it means "in any child" 1432 if (this._input.lookBack(" ")) { 1433 this._output.space_before_token = true; 1434 } 1435 if (this._input.peek() === ":") { 1436 // pseudo-element 1437 this._ch = this._input.next(); 1438 this.print_string("::"); 1439 } else { 1440 // pseudo-class 1441 this.print_string(':'); 1442 } 1443 } 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) { 1453 this.outdent(); 1454 insidePropertyValue = false; 1455 } 1456 insideNonNestedAtRule = false; 1457 this.print_string(this._ch); 1458 this.eatWhitespace(true); 1459 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 1463 // that section 1464 if (this._input.peek() !== '/') { 1465 this._output.add_new_line(); 1466 } 1467 } else { 1468 this.print_string(this._ch); 1469 this.eatWhitespace(true); 1470 this._output.space_before_token = true; 1471 } 1472 } else if (this._ch === '(') { // may be a url 1473 if (this._input.lookBack("url")) { 1474 this.print_string(this._ch); 1475 this.eatWhitespace(); 1476 parenLevel++; 1477 this.indent(); 1478 this._ch = this._input.next(); 1479 if (this._ch === ')' || this._ch === '"' || this._ch === '\'') { 1480 this._input.back(); 1481 } else if (this._ch) { 1482 this.print_string(this._ch + this.eatString(')')); 1483 if (parenLevel) { 1484 parenLevel--; 1485 this.outdent(); 1486 } 1487 } 1488 } else { 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; 1493 } 1494 this.preserveSingleSpace(isAfterSpace || space_needed); 1495 this.print_string(this._ch); 1496 1497 // handle scss/sass map 1498 if (insidePropertyValue && previous_ch === "$" && this._options.selector_separator_newline) { 1499 this._output.add_new_line(); 1500 insideScssMap = true; 1501 } else { 1502 this.eatWhitespace(); 1503 parenLevel++; 1504 this.indent(); 1505 } 1506 } 1507 } else if (this._ch === ')') { 1508 if (parenLevel) { 1509 parenLevel--; 1510 this.outdent(); 1511 } 1512 if (insideScssMap && this._input.peek() === ";" && this._options.selector_separator_newline) { 1513 insideScssMap = false; 1514 this.outdent(); 1515 this._output.add_new_line(); 1516 } 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(); 1523 } else { 1524 this._output.space_before_token = true; 1525 } 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; 1532 } else { 1533 this.print_string(this._ch); 1534 this.eatWhitespace(); 1535 // squash extra whitespace 1536 if (this._ch && whitespaceChar.test(this._ch)) { 1537 this._ch = ''; 1538 } 1539 } 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)) { 1549 this._ch = ''; 1550 } 1551 } else if (this._ch === '!' && !this._input.lookBack("\\")) { // !important 1552 this._output.space_before_token = true; 1553 this.print_string(this._ch); 1554 } else { 1555 var preserveAfterSpace = previous_ch === '"' || previous_ch === '\''; 1556 this.preserveSingleSpace(preserveAfterSpace || isAfterSpace); 1557 this.print_string(this._ch); 1558 1559 if (!this._output.just_added_newline() && this._input.peek() === '\n' && insideNonSemiColonValues) { 1560 this._output.add_new_line(); 1561 } 1562 } 1563 } 1564 1565 var sweetCode = this._output.get_code(eol); 1566 1567 return sweetCode; 1568}; 1569 1570module.exports.Beautifier = Beautifier; 1571 1572 1573/***/ }), 1574/* 17 */ 1575/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 1576 1577/*jshint node:true */ 1578/* 1579 1580 The MIT License (MIT) 1581 1582 Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors. 1583 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: 1591 1592 The above copyright notice and this permission notice shall be 1593 included in all copies or substantial portions of the Software. 1594 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 1602 SOFTWARE. 1603*/ 1604 1605 1606 1607var BaseOptions = (__webpack_require__(6).Options); 1608 1609function Options(options) { 1610 BaseOptions.call(this, options, 'css'); 1611 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; 1616 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'; 1623 } else { 1624 this.brace_style = brace_style_split[bs]; 1625 } 1626 } 1627} 1628Options.prototype = new BaseOptions(); 1629 1630 1631 1632module.exports.Options = Options; 1633 1634 1635/***/ }) 1636/******/ ]); 1637/************************************************************************/ 1638/******/ // The module cache 1639/******/ var __webpack_module_cache__ = {}; 1640/******/ 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; 1647/******/ } 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: {} 1653/******/ }; 1654/******/ 1655/******/ // Execute the module function 1656/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); 1657/******/ 1658/******/ // Return the exports of the module 1659/******/ return module.exports; 1660/******/ } 1661/******/ 1662/************************************************************************/ 1663/******/ 1664/******/ // startup 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__; 1669/******/ 1670/******/ })() 1671; 1672var css_beautify = legacy_beautify_css; 1673/* Footer */ 1674if (typeof define === "function" && define.amd) { 1675 // Add support for AMD ( https://github.com/amdjs/amdjs-api/wiki/AMD#defineamd-property- ) 1676 define([], function() { 1677 return { 1678 css_beautify: css_beautify 1679 }; 1680 }); 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; 1691} 1692 1693}());
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.