htmlnano 0.2.4 → 0.2.8

package/lib/htmlnano.js

@@ -1,94 +1,54 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
+exports.default = void 0;
 
-var _objectAssign = require('object-assign');
+var _posthtml = _interopRequireDefault(require("posthtml"));
 
-var _objectAssign2 = _interopRequireDefault(_objectAssign);
+var _safe = _interopRequireDefault(require("./presets/safe"));
 
-var _posthtml = require('posthtml');
+var _ampSafe = _interopRequireDefault(require("./presets/ampSafe"));
 
-var _posthtml2 = _interopRequireDefault(_posthtml);
-
-var _safe = require('./presets/safe');
-
-var _safe2 = _interopRequireDefault(_safe);
-
-var _ampSafe = require('./presets/ampSafe');
-
-var _ampSafe2 = _interopRequireDefault(_ampSafe);
-
-var _max = require('./presets/max');
-
-var _max2 = _interopRequireDefault(_max);
+var _max = _interopRequireDefault(require("./presets/max"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function htmlnano() {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var preset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _safe2.default;
-
-    return function minifier(tree) {
-        options = (0, _objectAssign2.default)({}, preset, options);
-        var promise = Promise.resolve(tree);
-
-        var _loop = function _loop(moduleName) {
-            if (!options[moduleName]) {
-                // The module is disabled
-                return 'continue';
-            }
-
-            if (_safe2.default[moduleName] === undefined) {
-                throw new Error('Module "' + moduleName + '" is not defined');
-            }
-
-            var module = require('./modules/' + moduleName);
-            promise = promise.then(function (tree) {
-                return module.default(tree, options, options[moduleName]);
-            });
-        };
+function htmlnano(options = {}, preset = _safe.default) {
+  return function minifier(tree) {
+    options = { ...preset,
+      ...options
+    };
+    let promise = Promise.resolve(tree);
 
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
+    for (const [moduleName, moduleOptions] of Object.entries(options)) {
+      if (!moduleOptions) {
+        // The module is disabled
+        continue;
+      }
 
-        try {
-            for (var _iterator = Object.keys(options)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                var moduleName = _step.value;
+      if (_safe.default[moduleName] === undefined) {
+        throw new Error('Module "' + moduleName + '" is not defined');
+      }
 
-                var _ret = _loop(moduleName);
+      let module = require('./modules/' + moduleName);
 
-                if (_ret === 'continue') continue;
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally {
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return) {
-                    _iterator.return();
-                }
-            } finally {
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
+      promise = promise.then(tree => module.default(tree, options, moduleOptions));
+    }
 
-        return promise;
-    };
+    return promise;
+  };
 }
 
-htmlnano.process = function (html, options, preset) {
-    return (0, _posthtml2.default)([htmlnano(options, preset)]).process(html);
+htmlnano.process = function (html, options, preset, postHtmlOptions) {
+  return (0, _posthtml.default)([htmlnano(options, preset)]).process(html, postHtmlOptions);
 };
 
 htmlnano.presets = {
-    safe: _safe2.default,
-    ampSafe: _ampSafe2.default,
-    max: _max2.default
+  safe: _safe.default,
+  ampSafe: _ampSafe.default,
+  max: _max.default
 };
-
-exports.default = htmlnano;
+var _default = htmlnano;
+exports.default = _default;

package/lib/modules/collapseAttributeWhitespace.js

@@ -1,30 +1,32 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = collapseAttributeWhitespace;
-var attributesWithLists = exports.attributesWithLists = new Set(['class', 'rel', 'ping']);
-
+exports.attributesWithLists = void 0;
+const attributesWithLists = new Set(['class', 'rel', 'ping']);
 /** Collapse whitespaces inside list-like attributes (e.g. class, rel) */
+
+exports.attributesWithLists = attributesWithLists;
+
 function collapseAttributeWhitespace(tree) {
-    tree.walk(function (node) {
-        if (!node.attrs) {
-            return node;
-        }
+  tree.walk(node => {
+    if (!node.attrs) {
+      return node;
+    }
 
-        Object.keys(node.attrs).forEach(function (attrName) {
-            var attrNameLower = attrName.toLowerCase();
-            if (!attributesWithLists.has(attrNameLower)) {
-                return;
-            }
+    Object.entries(node.attrs).forEach(([attrName, attrValue]) => {
+      const attrNameLower = attrName.toLowerCase();
 
-            var attrValue = node.attrs[attrName].replace(/\s+/g, ' ').trim();
-            node.attrs[attrName] = attrValue;
-        });
+      if (!attributesWithLists.has(attrNameLower)) {
+        return;
+      }
 
-        return node;
+      const newAttrValue = attrValue.replace(/\s+/g, ' ').trim();
+      node.attrs[attrName] = newAttrValue;
     });
-
-    return tree;
+    return node;
+  });
+  return tree;
 }

package/lib/modules/collapseBooleanAttributes.js

@@ -1,56 +1,42 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = collapseBooleanAttributes;
 // Source: https://github.com/kangax/html-minifier/issues/63
-var htmlBooleanAttributes = new Set(['allowfullscreen', 'allowpaymentrequest', 'allowtransparency', 'async', 'autofocus', 'autoplay', 'checked', 'compact', 'controls', 'declare', 'default', 'defaultchecked', 'defaultmuted', 'defaultselected', 'defer', 'disabled', 'enabled', 'formnovalidate', 'hidden', 'indeterminate', 'inert', 'ismap', 'itemscope', 'loop', 'multiple', 'muted', 'nohref', 'noresize', 'noshade', 'novalidate', 'nowrap', 'open', 'pauseonexit', 'readonly', 'required', 'reversed', 'scoped', 'seamless', 'selected', 'sortable', 'truespeed', 'typemustmatch', 'visible']);
-
-var amphtmlBooleanAttributes = new Set(['⚡', 'amp', '⚡4ads', 'amp4ads', '⚡4email', 'amp4email', 'amp-custom', 'amp-boilerplate', 'amp4ads-boilerplate', 'amp4email-boilerplate', 'allow-blocked-ranges', 'amp-access-hide', 'amp-access-template', 'amp-keyframes', 'animate', 'arrows', 'data-block-on-consent', 'data-enable-refresh', 'data-multi-size', 'date-template', 'disable-double-tap', 'disable-session-states', 'disableremoteplayback', 'dots', 'expand-single-section', 'expanded', 'fallback', 'first', 'fullscreen', 'inline', 'lightbox', 'noaudio', 'noautoplay', 'noloading', 'once', 'open-after-clear', 'open-after-select', 'open-button', 'placeholder', 'preload', 'reset-on-refresh', 'reset-on-resize', 'resizable', 'rotate-to-fullscreen', 'second', 'standalone', 'stereo', 'submit-error', 'submit-success', 'submitting', 'subscriptions-actions', 'subscriptions-dialog']);
+const htmlBooleanAttributes = new Set(['allowfullscreen', 'allowpaymentrequest', 'allowtransparency', 'async', 'autofocus', 'autoplay', 'checked', 'compact', 'controls', 'declare', 'default', 'defaultchecked', 'defaultmuted', 'defaultselected', 'defer', 'disabled', 'enabled', 'formnovalidate', 'hidden', 'indeterminate', 'inert', 'ismap', 'itemscope', 'loop', 'multiple', 'muted', 'nohref', 'noresize', 'noshade', 'novalidate', 'nowrap', 'open', 'pauseonexit', 'readonly', 'required', 'reversed', 'scoped', 'seamless', 'selected', 'sortable', 'truespeed', 'typemustmatch', 'visible']);
+const amphtmlBooleanAttributes = new Set(['⚡', 'amp', '⚡4ads', 'amp4ads', '⚡4email', 'amp4email', 'amp-custom', 'amp-boilerplate', 'amp4ads-boilerplate', 'amp4email-boilerplate', 'allow-blocked-ranges', 'amp-access-hide', 'amp-access-template', 'amp-keyframes', 'animate', 'arrows', 'data-block-on-consent', 'data-enable-refresh', 'data-multi-size', 'date-template', 'disable-double-tap', 'disable-session-states', 'disableremoteplayback', 'dots', 'expand-single-section', 'expanded', 'fallback', 'first', 'fullscreen', 'inline', 'lightbox', 'noaudio', 'noautoplay', 'noloading', 'once', 'open-after-clear', 'open-after-select', 'open-button', 'placeholder', 'preload', 'reset-on-refresh', 'reset-on-resize', 'resizable', 'rotate-to-fullscreen', 'second', 'standalone', 'stereo', 'submit-error', 'submit-success', 'submitting', 'subscriptions-actions', 'subscriptions-dialog']);
 
 function collapseBooleanAttributes(tree, options, moduleOptions) {
-    tree.match({ attrs: true }, function (node) {
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
-
-        try {
-            for (var _iterator = Object.keys(node.attrs)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                var attrName = _step.value;
-
-                if (!node.tag) {
-                    continue;
-                }
-
-                if (node.tag.search('a-') === 0 && attrName === 'visible') {
-                    continue;
-                }
-
-                if (htmlBooleanAttributes.has(attrName)) {
-                    node.attrs[attrName] = true;
-                }
-                if (moduleOptions.amphtml && node.attrs[attrName] === '' && amphtmlBooleanAttributes.has(attrName)) {
-                    node.attrs[attrName] = true;
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally {
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return) {
-                    _iterator.return();
-                }
-            } finally {
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-
-        return node;
-    });
-
-    return tree;
+  tree.match({
+    attrs: true
+  }, node => {
+    for (const attrName of Object.keys(node.attrs)) {
+      if (!node.tag) {
+        continue;
+      }
+
+      if (node.tag.search('a-') === 0 && attrName === 'visible') {
+        continue;
+      }
+
+      if (htmlBooleanAttributes.has(attrName)) {
+        node.attrs[attrName] = true;
+      }
+
+      if (moduleOptions.amphtml && node.attrs[attrName] === '' && amphtmlBooleanAttributes.has(attrName)) {
+        node.attrs[attrName] = true;
+      } // collapse crossorigin attributes
+      // Specification: https://html.spec.whatwg.org/multipage/urls-and-fetching.html#cors-settings-attributes
+
+
+      if (attrName.toLowerCase() === 'crossorigin' && (node.attrs[attrName] === 'anonymous' || node.attrs[attrName] === '')) {
+        node.attrs[attrName] = true;
+      }
+    }
+
+    return node;
+  });
+  return tree;
 }

package/lib/modules/collapseWhitespace.js

@@ -1,50 +1,84 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = collapseWhitespace;
 
-var _normalizeHtmlWhitespace = require('normalize-html-whitespace');
-
-var _normalizeHtmlWhitespace2 = _interopRequireDefault(_normalizeHtmlWhitespace);
-
-var _helpers = require('../helpers');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var noWhitespaceCollapseElements = new Set(['script', 'style', 'pre', 'textarea']);
+var _helpers = require("../helpers");
 
+const noWhitespaceCollapseElements = new Set(['script', 'style', 'pre', 'textarea']);
+const noTrimWhitespacesArroundElements = new Set([// non-empty tags that will maintain whitespace around them
+'a', 'abbr', 'acronym', 'b', 'bdi', 'bdo', 'big', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'ins', 'kbd', 'label', 'mark', 'math', 'nobr', 'object', 'q', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'time', 'tt', 'u', 'var', // self-closing tags that will maintain whitespace around them
+'comment', 'img', 'input', 'wbr']);
+const noTrimWhitespacesInsideElements = new Set([// non-empty tags that will maintain whitespace within them
+'a', 'abbr', 'acronym', 'b', 'big', 'del', 'em', 'font', 'i', 'ins', 'kbd', 'mark', 'nobr', 'rp', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'time', 'tt', 'u', 'var']);
+const whitespacePattern = /\s{1,}/g;
+const onlyWhitespacePattern = /^\s+$/;
+const NONE = '';
+const SINGLE_SPACE = ' ';
+const validOptions = ['all', 'aggressive', 'conservative'];
 /** Collapses redundant whitespaces */
+
 function collapseWhitespace(tree, options, collapseType, tag) {
-    if (collapseType !== 'all') {
-        collapseType = 'conservative';
+  collapseType = validOptions.includes(collapseType) ? collapseType : 'conservative';
+  tree.forEach((node, index) => {
+    if (typeof node === 'string' && !(0, _helpers.isComment)(node)) {
+      const prevNode = tree[index - 1];
+      const nextNode = tree[index + 1];
+      const prevNodeTag = prevNode && prevNode.tag;
+      const nextNodeTag = nextNode && nextNode.tag;
+      const isTopLevel = !tag || tag === 'html' || tag === 'head';
+      const shouldTrim = collapseType === 'all' || isTopLevel ||
+      /*
+       * When collapseType is set to 'aggressive', and the tag is not inside 'noTrimWhitespacesInsideElements'.
+       * the first & last space inside the tag will be trimmed
+       */
+      collapseType === 'aggressive' && !noTrimWhitespacesInsideElements.has(tag);
+      node = collapseRedundantWhitespaces(node, collapseType, shouldTrim, tag, prevNodeTag, nextNodeTag);
     }
 
-    tree.forEach(function (node, index) {
-        if (typeof node === 'string' && !(0, _helpers.isComment)(node)) {
-            var isTopLevel = !tag || tag === 'html' || tag === 'head';
-            node = collapseRedundantWhitespaces(node, collapseType, isTopLevel);
-        }
-
-        var isAllowCollapseWhitespace = !noWhitespaceCollapseElements.has(node.tag);
-        if (node.content && node.content.length && isAllowCollapseWhitespace) {
-            node.content = collapseWhitespace(node.content, options, collapseType, node.tag);
-        }
+    const isAllowCollapseWhitespace = !noWhitespaceCollapseElements.has(node.tag);
 
-        tree[index] = node;
-    });
+    if (node.content && node.content.length && isAllowCollapseWhitespace) {
+      node.content = collapseWhitespace(node.content, options, collapseType, node.tag);
+    }
 
-    return tree;
+    tree[index] = node;
+  });
+  return tree;
 }
 
-function collapseRedundantWhitespaces(text, collapseType) {
-    var isTopLevel = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+function collapseRedundantWhitespaces(text, collapseType, shouldTrim = false, currentTag, prevNodeTag, nextNodeTag) {
+  if (!text || text.length === 0) {
+    return NONE;
+  }
 
-    text = text && text.length > 0 ? (0, _normalizeHtmlWhitespace2.default)(text) : '';
-    if (collapseType === 'all' || isTopLevel) {
-        text = text.trim();
+  text = text.replace(whitespacePattern, SINGLE_SPACE);
+
+  if (shouldTrim) {
+    if (collapseType === 'aggressive') {
+      if (onlyWhitespacePattern.test(text)) {
+        // "text" only contains whitespaces. Only trim when both prevNodeTag & nextNodeTag are not "noTrimWhitespacesArroundElement"
+        // Otherwise the required ONE whitespace will be trimmed
+        if (!noTrimWhitespacesArroundElements.has(prevNodeTag) || !noTrimWhitespacesArroundElements.has(nextNodeTag)) {
+          text = text.trim();
+        }
+      } else {
+        // text contains whitespaces & non-whitespaces
+        if (!noTrimWhitespacesArroundElements.has(prevNodeTag)) {
+          text = text.trimStart();
+        }
+
+        if (!noTrimWhitespacesArroundElements.has(nextNodeTag)) {
+          text = text.trimEnd();
+        }
+      }
+    } else {
+      // collapseType is 'all', trim spaces
+      text = text.trim();
     }
+  }
 
-    return text;
+  return text;
 }

package/lib/modules/custom.js

@@ -1,22 +1,22 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = custom;
+
 /** Meta-module that runs custom modules  */
 function custom(tree, options, customModules) {
-    if (!customModules) {
-        return tree;
-    }
-
-    if (!Array.isArray(customModules)) {
-        customModules = [customModules];
-    }
+  if (!customModules) {
+    return tree;
+  }
 
-    customModules.forEach(function (customModule) {
-        tree = customModule(tree, options);
-    });
+  if (!Array.isArray(customModules)) {
+    customModules = [customModules];
+  }
 
-    return tree;
+  customModules.forEach(customModule => {
+    tree = customModule(tree, options);
+  });
+  return tree;
 }

package/lib/modules/deduplicateAttributeValues.js

@@ -1,48 +1,46 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = collapseAttributeWhitespace;
 
-var _collapseAttributeWhitespace = require('./collapseAttributeWhitespace');
+var _collapseAttributeWhitespace = require("./collapseAttributeWhitespace");
 
 /** Deduplicate values inside list-like attributes (e.g. class, rel) */
 function collapseAttributeWhitespace(tree) {
-    tree.walk(function (node) {
-        if (!node.attrs) {
-            return node;
+  tree.walk(node => {
+    if (!node.attrs) {
+      return node;
+    }
+
+    Object.keys(node.attrs).forEach(attrName => {
+      const attrNameLower = attrName.toLowerCase();
+
+      if (!_collapseAttributeWhitespace.attributesWithLists.has(attrNameLower)) {
+        return;
+      }
+
+      const attrValues = node.attrs[attrName].split(/\s/);
+      const uniqeAttrValues = new Set();
+      let deduplicatedAttrValues = [];
+      attrValues.forEach(attrValue => {
+        if (!attrValue) {
+          // Keep whitespaces
+          deduplicatedAttrValues.push('');
+          return;
         }
 
-        Object.keys(node.attrs).forEach(function (attrName) {
-            var attrNameLower = attrName.toLowerCase();
-            if (!_collapseAttributeWhitespace.attributesWithLists.has(attrNameLower)) {
-                return;
-            }
-
-            var attrValues = node.attrs[attrName].split(/\s/);
-            var uniqeAttrValues = new Set();
-            var deduplicatedAttrValues = [];
-            attrValues.forEach(function (attrValue) {
-                if (!attrValue) {
-                    // Keep whitespaces
-                    deduplicatedAttrValues.push('');
-                    return;
-                }
-
-                if (uniqeAttrValues.has(attrValue)) {
-                    return;
-                }
-
-                deduplicatedAttrValues.push(attrValue);
-                uniqeAttrValues.add(attrValue);
-            });
-
-            node.attrs[attrName] = deduplicatedAttrValues.join(' ');
-        });
-
-        return node;
-    });
+        if (uniqeAttrValues.has(attrValue)) {
+          return;
+        }
 
-    return tree;
+        deduplicatedAttrValues.push(attrValue);
+        uniqeAttrValues.add(attrValue);
+      });
+      node.attrs[attrName] = deduplicatedAttrValues.join(' ');
+    });
+    return node;
+  });
+  return tree;
 }

package/lib/modules/mergeScripts.js

@@ -1,80 +1,63 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.default = mergeScripts;
+
 /* Merge multiple <script> into one */
 function mergeScripts(tree) {
-    var scriptNodesIndex = {};
-
-    tree.match({ tag: 'script' }, function (node) {
-        var nodeAttrs = node.attrs || {};
-        if (nodeAttrs.src) {
-            return node;
-        }
+  let scriptNodesIndex = {};
+  let scriptSrcIndex = 1;
+  tree.match({
+    tag: 'script'
+  }, node => {
+    const nodeAttrs = node.attrs || {};
+
+    if (nodeAttrs.src) {
+      scriptSrcIndex++;
+      return node;
+    }
 
-        var scriptType = nodeAttrs.type || 'text/javascript';
-        if (scriptType !== 'text/javascript' && scriptType !== 'application/javascript') {
-            return node;
-        }
+    const scriptType = nodeAttrs.type || 'text/javascript';
 
-        var scriptKey = JSON.stringify({
-            id: nodeAttrs.id,
-            class: nodeAttrs.class,
-            type: scriptType,
-            defer: nodeAttrs.defer !== undefined,
-            async: nodeAttrs.async !== undefined
-        });
-        if (!scriptNodesIndex[scriptKey]) {
-            scriptNodesIndex[scriptKey] = [];
-        }
+    if (scriptType !== 'text/javascript' && scriptType !== 'application/javascript') {
+      return node;
+    }
 
-        scriptNodesIndex[scriptKey].push(node);
-        return node;
+    const scriptKey = JSON.stringify({
+      id: nodeAttrs.id,
+      class: nodeAttrs.class,
+      type: scriptType,
+      defer: nodeAttrs.defer !== undefined,
+      async: nodeAttrs.async !== undefined,
+      index: scriptSrcIndex
     });
 
-    var _loop = function _loop(scriptKey) {
-        var scriptNodes = scriptNodesIndex[scriptKey];
-        var lastScriptNode = scriptNodes.pop();
-        scriptNodes.reverse().forEach(function (scriptNode) {
-            var scriptContent = (scriptNode.content || []).join(' ');
-            scriptContent = scriptContent.trim();
-            if (scriptContent.slice(-1) !== ';') {
-                scriptContent += ';';
-            }
-
-            lastScriptNode.content.unshift(scriptContent);
+    if (!scriptNodesIndex[scriptKey]) {
+      scriptNodesIndex[scriptKey] = [];
+    }
 
-            scriptNode.tag = false;
-            scriptNode.content = [];
-        });
-    };
+    scriptNodesIndex[scriptKey].push(node);
+    return node;
+  });
 
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
+  for (const scriptNodes of Object.values(scriptNodesIndex)) {
+    let lastScriptNode = scriptNodes.pop();
+    scriptNodes.reverse().forEach(scriptNode => {
+      let scriptContent = (scriptNode.content || []).join(' ');
+      scriptContent = scriptContent.trim();
 
-    try {
-        for (var _iterator = Object.keys(scriptNodesIndex)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-            var scriptKey = _step.value;
+      if (scriptContent.slice(-1) !== ';') {
+        scriptContent += ';';
+      }
 
-            _loop(scriptKey);
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally {
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return) {
-                _iterator.return();
-            }
-        } finally {
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
+      lastScriptNode.content = lastScriptNode.content || [];
+      lastScriptNode.content.unshift(scriptContent);
+      scriptNode.tag = false;
+      scriptNode.content = [];
+    });
+  }
 
-    return tree;
+  return tree;
 }