// Non-breaking space is specifically handled inside the replacer function here:

return str && str.replace(/[ \n\r\t\f\xA0]+/g, function(spaces) {

return spaces === '\t' ? '\t' : spaces.replace(/(^|\xA0+)[^\xA0]+/g, '$1 ');

});

var lineBreakBefore = '', lineBreakAfter = '';

if (options.preserveLineBreaks) {

str = str.replace(/^[ \n\r\t\f]*?[\n\r][ \n\r\t\f]*/, function() {

lineBreakBefore = '\n';

return '';

}).replace(/[ \n\r\t\f]*?[\n\r][ \n\r\t\f]*$/, function() {

lineBreakAfter = '\n';

return '';

});

}

if (trimLeft) {

// Non-breaking space is specifically handled inside the replacer function here:

str = str.replace(/^[ \n\r\t\f\xA0]+/, function(spaces) {

var conservative = !lineBreakBefore && options.conservativeCollapse;

if (conservative && spaces === '\t') {

return '\t';

}

return spaces.replace(/^[^\xA0]+/, '').replace(/(\xA0+)[^\xA0]+/g, '$1 ') || (conservative ? ' ' : '');

});

}

if (trimRight) {

// Non-breaking space is specifically handled inside the replacer function here:

str = str.replace(/[ \n\r\t\f\xA0]+$/, function(spaces) {

var conservative = !lineBreakAfter && options.conservativeCollapse;

if (conservative && spaces === '\t') {

return '\t';

}

return spaces.replace(/[^\xA0]+(\xA0+)/g, ' $1').replace(/[^\xA0]+$/, '') || (conservative ? ' ' : '');

});

}

if (collapseAll) {

// strip non space whitespace then compress spaces to one

str = collapseWhitespaceAll(str);

}

return lineBreakBefore + str + lineBreakAfter;

var trimLeft = prevTag && !selfClosingInlineTags(prevTag);

if (trimLeft && !options.collapseInlineTagWhitespace) {

trimLeft = prevTag.charAt(0) === '/' ? !inlineTags(prevTag.slice(1)) : !inlineTextTags(prevTag);

}

var trimRight = nextTag && !selfClosingInlineTags(nextTag);

if (trimRight && !options.collapseInlineTagWhitespace) {

trimRight = nextTag.charAt(0) === '/' ? !inlineTextTags(nextTag.slice(1)) : !inlineTags(nextTag);

}

return collapseWhitespace(str, options, trimLeft, trimRight, prevTag && nextTag);

for (var i = 0, len = options.ignoreCustomComments.length; i < len; i++) {

if (options.ignoreCustomComments[i].test(text)) {

return true;

}

}

return false;

var patterns = options.customEventAttributes;

if (patterns) {

for (var i = patterns.length; i--;) {

if (patterns[i].test(attrName)) {

return true;

}

}

return false;

}

return /^on[a-z]{3,}$/.test(attrName);

// "0.90000" -> "0.9"

// "1.0" -> "1"

// "1.0001" -> "1.0001" (unchanged)

return (+numString).toString();

});

}

else if (options.customAttrCollapse && options.customAttrCollapse.test(attrName)) {

attrValue = attrValue.replace(/\n+|\r+|\s{2,}/g, '');

}

else if (tag === 'script' && attrName === 'type') {

attrValue = trimWhitespace(attrValue.replace(/\s*;\s*/g, ';'));

}

else if (isMediaQuery(tag, attrs, attrName)) {

attrValue = trimWhitespace(attrValue);

return options.minifyCSS(attrValue, 'media');

}

return attrValue;

if (tag !== 'meta') {

return false;

}

for (var i = 0, len = attrs.length; i < len; i++) {

if (attrs[i].name === 'name' && attrs[i].value === 'viewport') {

return true;

}

}

switch (type) {

case 'inline':

return '*{' + text + '}';

case 'media':

return '@media ' + text + '{a{top:0}}';

default:

return text;

}

var matches;

switch (type) {

case 'inline':

matches = text.match(/^\*\{([\s\S]*)\}$/);

break;

case 'media':

matches = text.match(/^@media ([\s\S]*?)\s*{[\s\S]*}$/);

break;

}

return matches ? matches[1] : text;

return options.processConditionalComments ? comment.replace(/^(\[if\s[^\]]+]>)([\s\S]*?)(<!\[endif])$/, function(match, prefix, text, suffix) {

return prefix + minify(text, options, true) + suffix;

}) : comment;

for (var i = 0, len = currentAttrs.length; i < len; i++) {

if (currentAttrs[i].name.toLowerCase() === 'type' &&

options.processScripts.indexOf(currentAttrs[i].value) > -1) {

return minify(text, options);

}

}

return text;

switch (optionalStartTag) {

case 'html':

case 'head':

return true;

case 'body':

return !headerTags(tag);

case 'colgroup':

return tag === 'col';

case 'tbody':

return tag === 'tr';

}

return false;

switch (tag) {

case 'colgroup':

return optionalEndTag === 'colgroup';

case 'tbody':

return tableSectionTags(optionalEndTag);

}

return false;

switch (optionalEndTag) {

case 'html':

case 'head':

case 'body':

case 'colgroup':

case 'caption':

return true;

case 'li':

case 'optgroup':

case 'tr':

return tag === optionalEndTag;

case 'dt':

case 'dd':

return descriptionTags(tag);

case 'p':

return pBlockTags(tag);

case 'rb':

case 'rt':

case 'rp':

return rubyTags(tag);

case 'rtc':

return rtcTag(tag);

case 'option':

return optionTag(tag);

case 'thead':

case 'tbody':

return tableContentTags(tag);

case 'tfoot':

return tag === 'tbody';

case 'td':

case 'th':

return cellTags(tag);

}

return false;

var isValueEmpty = !attrValue || /^\s*$/.test(attrValue);

if (!isValueEmpty) {

return false;

}

if (typeof options.removeEmptyAttributes === 'function') {

return options.removeEmptyAttributes(attrName, tag);

}

return tag === 'input' && attrName === 'value' || reEmptyAttribute.test(attrName);

for (var i = attrs.length - 1; i >= 0; i--) {

if (attrs[i].name === name) {

return true;

}

}

return false;

switch (tag) {

case 'textarea':

return false;

case 'audio':

case 'script':

case 'video':

if (hasAttrName('src', attrs)) {

return false;

}

break;

case 'iframe':

if (hasAttrName('src', attrs) || hasAttrName('srcdoc', attrs)) {

return false;

}

break;

case 'object':

if (hasAttrName('data', attrs)) {

return false;

}

break;

case 'applet':

if (hasAttrName('code', attrs)) {

return false;

}

break;

}

return true;

var attrName = options.name(attr.name),

attrValue = attr.value;

if (options.decodeEntities && attrValue) {

attrValue = decode(attrValue, { isAttributeValue: true });

}

if (options.removeRedundantAttributes &&

isAttributeRedundant(tag, attrName, attrValue, attrs) ||

options.removeScriptTypeAttributes && tag === 'script' &&

attrName === 'type' && isScriptTypeAttribute(attrValue) ||

options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&

attrName === 'type' && isStyleLinkTypeAttribute(attrValue)) {

return;

}

if (attrValue) {

attrValue = cleanAttributeValue(tag, attrName, attrValue, options, attrs);

}

if (options.removeEmptyAttributes &&

canDeleteEmptyAttribute(tag, attrName, attrValue, options)) {

return;

}

if (options.decodeEntities && attrValue) {

attrValue = attrValue.replace(/&(#?[0-9a-zA-Z]+;)/g, '&amp;$1');

}

return {

attr: attr,

name: attrName,

value: attrValue

};

var attrName = normalized.name,

attrValue = normalized.value,

attr = normalized.attr,

attrQuote = attr.quote,

attrFragment,

emittedAttrValue;

if (typeof attrValue !== 'undefined' && (!options.removeAttributeQuotes ||

~attrValue.indexOf(uidAttr) || !canRemoveAttributeQuotes(attrValue))) {

if (!options.preventAttributesEscaping) {

if (typeof options.quoteCharacter === 'undefined') {

var apos = (attrValue.match(/'/g) || []).length;

var quot = (attrValue.match(/"/g) || []).length;

attrQuote = apos < quot ? '\'' : '"';

}

else {

attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';

}

if (attrQuote === '"') {

attrValue = attrValue.replace(/"/g, '&#34;');

text = text.replace(/(url\s*\(\s*)("|'|)(.*?)\2(\s*\))/ig, function(match, prefix, quote, url, suffix) {

return prefix + quote + options.minifyURLs(url) + quote + suffix;

});

var cleanCssOutput = new CleanCSS(value).minify(wrapCSS(text, type));

if (cleanCssOutput.errors.length > 0) {

cleanCssOutput.errors.forEach(options.log);

return text;

}

return unwrapCSS(cleanCssOutput.styles, type);

};

}

else if (key === 'minifyJS' && typeof value !== 'function') {

if (!value) {

return;

}

if (typeof value !== 'object') {

value = {};

}

(value.parse || (value.parse = {})).bare_returns = false;

options.minifyJS = function(text, inline) {

var start = text.match(/^\s*<!--.*/);

var code = start ? text.slice(start[0].length).replace(/\n\s*-->\s*$/, '') : text;

value.parse.bare_returns = inline;

var result = UglifyJS.minify(code, value);

if (result.error) {

options.log(result.error);

return text;

}

return result.code.replace(/;$/, '');

};

}

else if (key === 'minifyURLs' && typeof value !== 'function') {

if (!value) {

return;

}

if (typeof value === 'string') {

value = { site: value };

}

else if (typeof value !== 'object') {

value = {};

}

options.minifyURLs = function(text) {

try {

return RelateUrl.relate(text, value);

}

catch (err) {

options.log(err);

return text;

}

};

}

else {

options[key] = value;

}

});

return options;

var id;

do {

id = Math.random().toString(36).replace(/^0\.[0-9]*/, '');

} while (~value.indexOf(id));

return id;

var attrChains = options.sortAttributes && Object.create(null);

var classChain = options.sortClassName && new TokenChain();

function attrNames(attrs) {

return attrs.map(function(attr) {

return options.name(attr.name);

});

}

function shouldSkipUID(token, uid) {

return !uid || token.indexOf(uid) === -1;

}

function shouldSkipUIDs(token) {

return shouldSkipUID(token, uidIgnore) && shouldSkipUID(token, uidAttr);

}

function scan(input) {

var currentTag, currentType;

new HTMLParser(input, {

start: function(tag, attrs) {

if (attrChains) {

if (!attrChains[tag]) {

attrChains[tag] = new TokenChain();

}

attrChains[tag].add(attrNames(attrs).filter(shouldSkipUIDs));

}

for (var i = 0, len = attrs.length; i < len; i++) {

var attr = attrs[i];

if (classChain && attr.value && options.name(attr.name) === 'class') {

classChain.add(trimWhitespace(attr.value).split(/[ \t\n\f\r]+/).filter(shouldSkipUIDs));

}

else if (options.processScripts && attr.name.toLowerCase() === 'type') {

currentTag = tag;

currentType = attr.value;

}

}

},

end: function() {

currentTag = '';

},

chars: function(text) {

if (options.processScripts && specialContentTags(currentTag) &&

options.processScripts.indexOf(currentType) > -1) {

scan(text);

}

}

});

}

var log = options.log;

options.log = identity;

options.sortAttributes = false;

options.sortClassName = false;

scan(minify(value, options));

options.log = log;

if (attrChains) {

var attrSorters = Object.create(null);

for (var tag in attrChains) {

attrSorters[tag] = attrChains[tag].createSorter();

}

options.sortAttributes = function(tag, attrs) {

var sorter = attrSorters[tag];

if (sorter) {

var attrMap = Object.create(null);

var names = attrNames(attrs);

names.forEach(function(name, index) {

(attrMap[name] || (attrMap[name] = [])).push(attrs[index]);

});

sorter.sort(names).forEach(function(name, index) {

attrs[index] = attrMap[name].shift();

});

}

};

}

if (classChain) {

var sorter = classChain.createSorter();

options.sortClassName = function(value) {

return sorter.sort(value.split(/[ \n\f\r]+/)).join(' ');

};

}

if (options.collapseWhitespace) {

value = collapseWhitespace(value, options, true, true);

}

var buffer = [],

charsPrevTag,

currentChars = '',

hasChars,

currentTag = '',

currentAttrs = [],

stackNoTrimWhitespace = [],

stackNoCollapseWhitespace = [],

optionalStartTag = '',

optionalEndTag = '',

ignoredMarkupChunks = [],

ignoredCustomMarkupChunks = [],

uidIgnore,

uidAttr,

uidPattern;

// temporarily replace ignored chunks with comments,

// so that we don't have to worry what's there.

// for all we care there might be

// completely-horribly-broken-alien-non-html-emoj-cthulhu-filled content

value = value.replace(/<!-- htmlmin:ignore -->([\s\S]*?)<!-- htmlmin:ignore -->/g, function(match, group1) {

if (!uidIgnore) {

uidIgnore = uniqueId(value);

var pattern = new RegExp('^' + uidIgnore + '([0-9]+)$');

if (options.ignoreCustomComments) {

options.ignoreCustomComments = options.ignoreCustomComments.slice();

}

else {

options.ignoreCustomComments = [];

}

options.ignoreCustomComments.push(pattern);

}

var token = '<!--' + uidIgnore + ignoredMarkupChunks.length + '-->';

ignoredMarkupChunks.push(group1);

return token;

});

var customFragments = options.ignoreCustomFragments.map(function(re) {

return re.source;

});

if (customFragments.length) {

var reCustomIgnore = new RegExp('\\s*(?:' + customFragments.join('|') + ')+\\s*', 'g');

// temporarily replace custom ignored fragments with unique attributes

value = value.replace(reCustomIgnore, function(match) {

if (!uidAttr) {

uidAttr = uniqueId(value);

uidPattern = new RegExp('(\\s*)' + uidAttr + '([0-9]+)(\\s*)', 'g');

if (options.minifyCSS) {

options.minifyCSS = (function(fn) {

return function(text, type) {

text = text.replace(uidPattern, function(match, prefix, index) {

var chunks = ignoredCustomMarkupChunks[+index];

return chunks[1] + uidAttr + index + chunks[2];

});

var ids = [];

new CleanCSS().minify(wrapCSS(text, type)).warnings.forEach(function(warning) {

var match = uidPattern.exec(warning);

if (match) {

var id = uidAttr + match[2];

text = text.replace(id, ignoreCSS(id));

ids.push(id);

}

});

text = fn(text, type);

ids.forEach(function(id) {

text = text.replace(ignoreCSS(id), id);

});

return text;

};

})(options.minifyCSS);

}

if (options.minifyJS) {

options.minifyJS = (function(fn) {

return function(text, type) {

return fn(text.replace(uidPattern, function(match, prefix, index) {

var chunks = ignoredCustomMarkupChunks[+index];

return chunks[1] + uidAttr + index + chunks[2];

}), type);

};

})(options.minifyJS);

}

}

var token = uidAttr + ignoredCustomMarkupChunks.length;

ignoredCustomMarkupChunks.push(/^(\s*)[\s\S]*?(\s*)$/.exec(match));

return '\t' + token + '\t';

});

}

if (options.sortAttributes && typeof options.sortAttributes !== 'function' ||

options.sortClassName && typeof options.sortClassName !== 'function') {

createSortFns(value, options, uidIgnore, uidAttr);

}

function _canCollapseWhitespace(tag, attrs) {

return options.canCollapseWhitespace(tag, attrs, canCollapseWhitespace);

}

function _canTrimWhitespace(tag, attrs) {

return options.canTrimWhitespace(tag, attrs, canTrimWhitespace);

}

function removeStartTag() {

var index = buffer.length - 1;

while (index > 0 && !/^<[^/!]/.test(buffer[index])) {

index--;

}

buffer.length = Math.max(0, index);

}

function removeEndTag() {

var index = buffer.length - 1;

while (index > 0 && !/^<\//.test(buffer[index])) {

index--;

}

buffer.length = Math.max(0, index);

}

// look for trailing whitespaces, bypass any inline tags

function trimTrailingWhitespace(index, nextTag) {

for (var endTag = null; index >= 0 && _canTrimWhitespace(endTag); index--) {

var str = buffer[index];

var match = str.match(/^<\/([\w:-]+)>$/);

if (match) {

endTag = match[1];

}

else if (/>$/.test(str) || (buffer[index] = collapseWhitespaceSmart(str, null, nextTag, options))) {

break;

}

}

}

// look for trailing whitespaces from previously processed text

// which may not be trimmed due to a following comment or an empty

// element which has now been removed

function squashTrailingWhitespace(nextTag) {

var charsIndex = buffer.length - 1;

if (buffer.length > 1) {

var item = buffer[buffer.length - 1];

if (/^(?:<!|$)/.test(item) && item.indexOf(uidIgnore) === -1) {

charsIndex--;

}

}

trimTrailingWhitespace(charsIndex, nextTag);

}

new HTMLParser(value, {

partialMarkup: partialMarkup,

html5: options.html5,

start: function(tag, attrs, unary, unarySlash, autoGenerated) {

if (tag.toLowerCase() === 'svg') {

options = Object.create(options);

options.caseSensitive = true;

options.keepClosingSlash = true;

options.name = identity;

}

tag = options.name(tag);

currentTag = tag;

charsPrevTag = tag;

if (!inlineTextTags(tag)) {

currentChars = '';

}

hasChars = false;

currentAttrs = attrs;

var optional = options.removeOptionalTags;

if (optional) {

var htmlTag = htmlTags(tag);

// <html> may be omitted if first thing inside is not comment

// <head> may be omitted if first thing inside is an element

// <body> may be omitted if first thing inside is not space, comment, <meta>, <link>, <script>, <style> or <template>

// <colgroup> may be omitted if first thing inside is <col>

// <tbody> may be omitted if first thing inside is <tr>

if (htmlTag && canRemoveParentTag(optionalStartTag, tag)) {

removeStartTag();

}

optionalStartTag = '';

// end-tag-followed-by-start-tag omission rules

if (htmlTag && canRemovePrecedingTag(optionalEndTag, tag)) {

removeEndTag();