phtml/index.mjs

import HTMLParser from 'parse5/lib/parser';
import defaultTreeAdapter from 'parse5/lib/tree-adapters/default';
import Tokenizer from 'parse5/lib/tokenizer';

/**
* @name AttributeList
* @class
* @extends Array
* @classdesc Return a new list of {@link Element} attributes.
* @param {...Array|AttributeList|Object} attrs - An array or object of attributes.
* @returns {AttributeList}
* @example
* new AttributeList([{ name: 'class', value: 'foo' }, { name: 'id', value: 'bar' }])
* @example
* new AttributeList({ class: 'foo', id: 'bar' })
*/
class AttributeList extends Array {
  constructor(attrs) {
    super();

    if (attrs === Object(attrs)) {
      this.push(...getAttributeListArray(attrs));
    }
  }
  /**
  * Add an attribute or attributes to the current {@link AttributeList}.
  * @param {Array|Object|RegExp|String} name - The attribute to remove.
  * @param {String} [value] - The value of the attribute being added.
  * @returns {Boolean} - Whether the attribute or attributes were added to the current {@link AttributeList}.
  * @example <caption>Add an empty "id" attribute.</caption>
  * attrs.add('id')
  * @example <caption>Add an "id" attribute with a value of "bar".</caption>
  * attrs.add({ id: 'bar' })
  * @example
  * attrs.add([{ name: 'id', value: 'bar' }])
  */


  add(name, ...args) {
    return toggle(this, getAttributeListArray(name, ...args), true).attributeAdded;
  }
  /**
  * Return a new clone of the current {@link AttributeList} while conditionally applying additional attributes.
  * @param {...Array|AttributeList|Object} attrs - Additional attributes to be added to the new {@link AttributeList}.
  * @returns {Element} - The cloned Element.
  * @example
  * attrs.clone()
  * @example <caption>Clone the current attribute and add an "id" attribute with a value of "bar".</caption>
  * attrs.clone({ name: 'id', value: 'bar' })
  */


  clone(...attrs) {
    return new AttributeList(Array.from(this).concat(getAttributeListArray(attrs)));
  }
  /**
  * Return whether an attribute or attributes exists in the current {@link AttributeList}.
  * @param {String} name - The name or attribute object being accessed.
  * @returns {Boolean} - Whether the attribute exists.
  * @example <caption>Return whether there is an "id" attribute.</caption>
  * attrs.contains('id')
  * @example
  * attrs.contains({ id: 'bar' })
  * @example <caption>Return whether there is an "id" attribute with a value of "bar".</caption>
  * attrs.contains([{ name: 'id': value: 'bar' }])
  */


  contains(name) {
    return this.indexOf(name) !== -1;
  }
  /**
  * Return an attribute value by name from the current {@link AttributeList}.
  * @description If the attribute exists with a value then a String is returned. If the attribute exists with no value then `null` is returned. If the attribute does not exist then `false` is returned.
  * @param {RegExp|String} name - The name of the attribute being accessed.
  * @returns {Boolean|Null|String} - The value of the attribute (a string or null) or false (if the attribute does not exist).
  * @example <caption>Return the value of "id" or `false`.</caption>
  * // <div>this element has no "id" attribute</div>
  * attrs.get('id') // returns false
  * // <div id>this element has an "id" attribute with no value</div>
  * attrs.get('id') // returns null
  * // <div id="">this element has an "id" attribute with a value</div>
  * attrs.get('id') // returns ''
  */


  get(name) {
    const index = this.indexOf(name);
    return index === -1 ? false : this[index].value;
  }
  /**
  * Return the position of an attribute by name or attribute object in the current {@link AttributeList}.
  * @param {Array|Object|RegExp|String} name - The attribute to locate.
  * @returns {Number} - The index of the attribute or -1.
  * @example <caption>Return the index of "id".</caption>
  * attrs.indexOf('id')
  * @example <caption>Return the index of /d$/.</caption>
  * attrs.indexOf(/d$/i)
  * @example <caption>Return the index of "foo" with a value of "bar".</caption>
  * attrs.indexOf({ foo: 'bar' })
  * @example <caption>Return the index of "ariaLabel" or "aria-label" matching /^open/.</caption>
  * attrs.indexOf({ ariaLabel: /^open/ })
  * @example <caption>Return the index of an attribute whose name matches `/^foo/`.</caption>
  * attrs.indexOf([{ name: /^foo/ })
  */


  indexOf(name, ...args) {
    return this.findIndex(Array.isArray(name) ? findIndexByArray : isRegExp(name) ? findIndexByRegExp : name === Object(name) ? findIndexByObject : findIndexByString);

    function findIndexByArray(attr) {
      return name.some(innerAttr => ('name' in Object(innerAttr) ? isRegExp(innerAttr.name) ? innerAttr.name.test(attr.name) : String(innerAttr.name) === attr.name : true) && ('value' in Object(innerAttr) ? isRegExp(innerAttr.value) ? innerAttr.value.test(attr.value) : getAttributeValue(innerAttr.value) === attr.value : true));
    }

    function findIndexByObject(attr) {
      const innerAttr = name[attr.name] || name[toCamelCaseString(attr.name)];
      return innerAttr ? isRegExp(innerAttr) ? innerAttr.test(attr.value) : attr.value === innerAttr : false;
    }

    function findIndexByRegExp(attr) {
      return name.test(attr.name) && (args.length ? isRegExp(args[0]) ? args[0].test(attr.value) : attr.value === getAttributeValue(args[0]) : true);
    }

    function findIndexByString(attr) {
      return (attr.name === String(name) || attr.name === toKebabCaseString(name)) && (args.length ? isRegExp(args[0]) ? args[0].test(attr.value) : attr.value === getAttributeValue(args[0]) : true);
    }
  }
  /**
  * Remove an attribute or attributes from the current {@link AttributeList}.
  * @param {Array|Object|RegExp|String} name - The attribute to remove.
  * @param {String} [value] - The value of the attribute being removed.
  * @returns {Boolean} - Whether the attribute or attributes were removed from the {@link AttributeList}.
  * @example <caption>Remove the "id" attribute.</caption>
  * attrs.remove('id')
  * @example <caption>Remove the "id" attribute when it has a value of "bar".</caption>
  * attrs.remove('id', 'bar')
  * @example
  * attrs.remove({ id: 'bar' })
  * @example
  * attrs.remove([{ name: 'id', value: 'bar' }])
  * @example <caption>Remove the "id" and "class" attributes.</caption>
  * attrs.remove(['id', 'class'])
  */


  remove(name, ...args) {
    return toggle(this, getAttributeListArray(name, ...args), false).attributeRemoved;
  }
  /**
  * Toggle an attribute or attributes from the current {@link AttributeList}.
  * @param {String|Object} name_or_attrs - The name of the attribute being toggled, or an object of attributes being toggled.
  * @param {String|Boolean} [value_or_force] - The value of the attribute being toggled when the first argument is not an object, or attributes should be exclusively added (true) or removed (false).
  * @param {Boolean} [force] - Whether attributes should be exclusively added (true) or removed (false).
  * @returns {Boolean} - Whether any attribute was added to the current {@link AttributeList}.
  * @example <caption>Toggle the "id" attribute.</caption>
  * attrs.toggle('id')
  * @example <caption>Toggle the "id" attribute with a value of "bar".</caption>
  * attrs.toggle('id', 'bar')
  * @example
  * attrs.toggle({ id: 'bar' })
  * @example
  * attrs.toggle([{ name: 'id', value: 'bar' }])
  */


  toggle(name, ...args) {
    const attrs = getAttributeListArray(name, ...args);
    const force = name === Object(name) ? args[0] == null ? null : Boolean(args[0]) : args[1] == null ? null : Boolean(args[1]);
    const result = toggle(this, attrs, force);
    return result.attributeAdded || result.atttributeModified;
  }
  /**
  * Return the current {@link AttributeList} as a String.
  * @returns {String} A string version of the current {@link AttributeList}
  * @example
  * attrs.toString() // returns 'class="foo" data-foo="bar"'
  */


  toString() {
    return this.length ? `${this.map(attr => `${Object(attr.source).before || ' '}${attr.name}${attr.value === null ? '' : `=${Object(attr.source).quote || '"'}${attr.value}${Object(attr.source).quote || '"'}`}`).join('')}` : '';
  }
  /**
  * Return the current {@link AttributeList} as an Object.
  * @returns {Object} point - An object version of the current {@link AttributeList}
  * @example
  * attrs.toJSON() // returns { class: 'foo', dataFoo: 'bar' } when <x class="foo" data-foo: "bar" />
  */


  toJSON() {
    return this.reduce((object, attr) => Object.assign(object, {
      [toCamelCaseString(attr.name)]: attr.value
    }), {});
  }
  /**
  * Return a new {@link AttributeList} from an array or object.
  * @param {Array|AttributeList|Object} nodes - An array or object of attributes.
  * @returns {AttributeList} A new {@link AttributeList}
  * @example <caption>Return an array of attributes from a regular object.</caption>
  * AttributeList.from({ dataFoo: 'bar' }) // returns AttributeList [{ name: 'data-foo', value: 'bar' }]
  * @example <caption>Return a normalized array of attributes from an impure array of attributes.</caption>
  * AttributeList.from([{ name: 'data-foo', value: true, foo: 'bar' }]) // returns AttributeList [{ name: 'data-foo', value: 'true' }]
  */


  static from(attrs) {
    return new AttributeList(getAttributeListArray(attrs));
  }

}
/**
* Toggle an attribute or attributes from an {@link AttributeList}.
* @param {AttributeList} attrs - The {@link AttributeList} being modified.
* @param {String|Object} toggles - The attributes being toggled.
* @param {Boolean} [force] - Whether attributes should be exclusively added (true) or removed (false)
* @returns {Object} An object specifying whether any attributes were added, removed, and/or modified.
* @private
*/


function toggle(attrs, toggles, force) {
  let attributeAdded = false;
  let attributeRemoved = false;
  let atttributeModified = false;
  toggles.forEach(toggleAttr => {
    const index = attrs.indexOf(toggleAttr.name);

    if (index === -1) {
      if (force !== false) {
        // add the attribute (if not exclusively removing attributes)
        attrs.push(toggleAttr);
        attributeAdded = true;
      }
    } else if (force !== true) {
      // remove the attribute (if not exclusively adding attributes)
      attrs.splice(index, 1);
      attributeRemoved = true;
    } else if (toggleAttr.value !== undefined && attrs[index].value !== toggleAttr.value) {
      // change the value of the attribute (if exclusively adding attributes)
      attrs[index].value = toggleAttr.value;
      atttributeModified = true;
    }
  });
  return {
    attributeAdded,
    attributeRemoved,
    atttributeModified
  };
}
/**
* Return an AttributeList-compatible array from an array or object.
* @private
*/


function getAttributeListArray(attrs, value) {
  return attrs === null || attrs === undefined // void values are omitted
  ? [] : Array.isArray(attrs) // arrays are sanitized as a name or value, and then optionally a source
  ? attrs.reduce((attrs, rawattr) => {
    const attr = {};

    if ('name' in Object(rawattr)) {
      attr.name = String(rawattr.name);
    }

    if ('value' in Object(rawattr)) {
      attr.value = getAttributeValue(rawattr.value);
    }

    if ('source' in Object(rawattr)) {
      attr.source = rawattr.source;
    }

    if ('name' in attr || 'value' in attr) {
      attrs.push(attr);
    }

    return attrs;
  }, []) : attrs === Object(attrs) // objects are sanitized as a name and value
  ? Object.keys(attrs).map(name => ({
    name: toKebabCaseString(name),
    value: getAttributeValue(attrs[name])
  })) : 1 in arguments // both name and value arguments are sanitized as a name and value
  ? [{
    name: attrs,
    value: getAttributeValue(value)
  }] // one name argument is sanitized as a name
  : [{
    name: attrs
  }];
}
/**
* Return a value transformed into an attribute value.
* @description Expected values are strings. Unexpected values are null, objects, and undefined. Nulls returns null, Objects with the default toString return their JSON.stringify’d value otherwise toString’d, and Undefineds return an empty string.
* @example <caption>Expected values.</caption>
* getAttributeValue('foo') // returns 'foo'
* getAttributeValue('') // returns ''
* @example <caption>Unexpected values.</caption>
* getAttributeValue(null) // returns null
* getAttributeValue(undefined) // returns ''
* getAttributeValue(['foo']) // returns '["foo"]'
* getAttributeValue({ toString() { return 'bar' }}) // returns 'bar'
* getAttributeValue({ toString: 'bar' }) // returns '{"toString":"bar"}'
* @private
*/


function getAttributeValue(value) {
  return value === null ? null : value === undefined ? '' : value === Object(value) ? value.toString === Object.prototype.toString ? JSON.stringify(value) : String(value) : String(value);
}
/**
* Return a string formatted using camelCasing.
* @param {String} value - The value being formatted.
* @example
* toCamelCaseString('hello-world') // returns 'helloWorld'
* @private
*/


function toCamelCaseString(value) {
  return isKebabCase(value) ? String(value).replace(/-[a-z]/g, $0 => $0.slice(1).toUpperCase()) : String(value);
}
/**
* Return a string formatted using kebab-casing.
* @param {String} value - The value being formatted.
* @description Expected values do not already contain dashes.
* @example <caption>Expected values.</caption>
* toKebabCaseString('helloWorld') // returns 'hello-world'
* toKebabCaseString('helloworld') // returns 'helloworld'
* @example <caption>Unexpected values.</caption>
* toKebabCaseString('hello-World') // returns 'hello-World'
* @private
*/


function toKebabCaseString(value) {
  return isCamelCase(value) ? String(value).replace(/[A-Z]/g, $0 => `-${$0.toLowerCase()}`) : String(value);
}
/**
* Return whether a value is formatted camelCase.
* @example
* isCamelCase('helloWorld')  // returns true
* isCamelCase('hello-world') // returns false
* isCamelCase('helloworld')  // returns false
* @private
*/


function isCamelCase(value) {
  return /^\w+[A-Z]\w*$/.test(value);
}
/**
* Return whether a value is formatted kebab-case.
* @example
* isKebabCase('hello-world') // returns true
* isKebabCase('helloworld')  // returns false
* isKebabCase('helloWorld')  // returns false
* @private
*/


function isKebabCase(value) {
  return /^\w+[-]\w+$/.test(value);
}
/**
* Return whether a value is a Regular Expression.
* @example
* isRegExp(/hello-world/) // returns true
* isRegExp('/hello-world/')  // returns false
* isRegExp(new RegExp('hello-world')) // returns true
* @private
*/


function isRegExp(value) {
  return Object.prototype.toString.call(value) === '[object RegExp]';
}

/**
* Transform a {@link Node} and any descendants using visitors.
* @param {Node} node - The {@link Node} to be visited.
* @param {Result} result - The {@link Result} to be used by visitors.
* @param {Object} [overrideVisitors] - Alternative visitors to be used in place of {@link Result} visitors.
* @returns {ResultPromise}
* @private
*/
function visit(node, result, overrideVisitors) {
  // get visitors as an object
  const visitors = Object(overrideVisitors || Object(result).visitors); // get node types

  const beforeType = getTypeFromNode(node);
  const beforeSubType = getSubTypeFromNode(node);
  const beforeNodeType = 'Node';
  const beforeRootType = 'Root';
  const afterType = `after${beforeType}`;
  const afterSubType = `after${beforeSubType}`;
  const afterNodeType = 'afterNode';
  const afterRootType = 'afterRoot';
  let promise = Promise.resolve(); // fire "before" visitors

  if (visitors[beforeNodeType]) {
    promise = promise.then(() => runAll(visitors[beforeNodeType], node, result));
  }

  if (visitors[beforeType]) {
    promise = promise.then(() => runAll(visitors[beforeType], node, result));
  }

  if (beforeSubType !== beforeType && visitors[beforeSubType]) {
    promise = promise.then(() => runAll(visitors[beforeSubType], node, result));
  } // dispatch before root event


  if (visitors[beforeRootType] && node === result.root) {
    promise = promise.then(() => runAll(visitors[beforeRootType], node, result));
  } // walk children


  if (Array.isArray(node.nodes)) {
    node.nodes.slice(0).forEach(childNode => {
      promise = promise.then(() => childNode.parent === node && visit(childNode, result, overrideVisitors));
    });
  } // fire "after" visitors


  if (visitors[afterNodeType]) {
    promise = promise.then(() => runAll(visitors[afterNodeType], node, result));
  }

  if (visitors[afterType]) {
    promise = promise.then(() => runAll(visitors[afterType], node, result));
  }

  if (afterType !== afterSubType && visitors[afterSubType]) {
    promise = promise.then(() => runAll(visitors[afterSubType], node, result));
  } // dispatch root event


  if (visitors[afterRootType] && node === result.root) {
    promise = promise.then(() => runAll(visitors[afterRootType], node, result));
  }

  return promise.then(() => result);
}

function runAll(plugins, node, result) {
  let promise = Promise.resolve();
  [].concat(plugins || []).forEach(plugin => {
    // run the current plugin
    promise = promise.then(() => {
      // update the current plugin
      result.currentPlugin = plugin;
      return plugin(node, result);
    }).then(() => {
      // clear the current plugin
      result.currentPlugin = null;
    });
  });
  return promise;
} // return normalized plugins and visitors

function getVisitors(rawplugins) {
  const visitors = {}; // initialize plugins and visitors

  [].concat(rawplugins || []).forEach(plugin => {
    const initializedPlugin = Object(plugin).type === 'plugin' ? plugin() : plugin;

    if (initializedPlugin instanceof Function) {
      if (!visitors.afterRoot) {
        visitors.afterRoot = [];
      }

      visitors.afterRoot.push(initializedPlugin);
    } else if (Object(initializedPlugin) === initializedPlugin && Object.keys(initializedPlugin).length) {
      Object.keys(initializedPlugin).forEach(key => {
        const fn = initializedPlugin[key];

        if (fn instanceof Function) {
          if (!visitors[key]) {
            visitors[key] = [];
          }

          visitors[key].push(initializedPlugin[key]);
        }
      });
    }
  });
  return visitors;
}

function getTypeFromNode(node) {
  return {
    'comment': 'Comment',
    'text': 'Text',
    'doctype': 'Doctype',
    'fragment': 'Fragment'
  }[node.type] || 'Element';
}

function getSubTypeFromNode(node) {
  return {
    'comment': 'Comment',
    'text': 'Text',
    'doctype': 'Doctype',
    'fragment': 'Fragment'
  }[node.type] || (!node.name ? 'FragmentElement' : `${node.name[0].toUpperCase()}${node.name.slice(1)}Element`);
}

/**
* @name Node
* @class
* @extends Node
* @classdesc Create a new {@link Node}.
* @returns {Node}
*/

class Node {
  /**
  * The position of the current {@link Node} from its parent.
  * @returns {Number}
  * @example
  * node.index // returns the index of the node or -1
  */
  get index() {
    if (this.parent === Object(this.parent) && this.parent.nodes && this.parent.nodes.length) {
      return this.parent.nodes.indexOf(this);
    }

    return -1;
  }
  /**
  * The next {@link Node} after the current {@link Node}, or `null` if there is none.
  * @returns {Node|Null} - The next Node or null.
  * @example
  * node.next // returns null
  */


  get next() {
    const index = this.index;

    if (index !== -1) {
      return this.parent.nodes[index + 1] || null;
    }

    return null;
  }
  /**
  * The next {@link Element} after the current {@link Node}, or `null` if there is none.
  * @returns {Element|Null}
  * @example
  * node.nextElement // returns an element or null
  */


  get nextElement() {
    const index = this.index;

    if (index !== -1) {
      return this.parent.nodes.slice(index).find(hasNodes);
    }

    return null;
  }
  /**
  * The previous {@link Node} before the current {@link Node}, or `null` if there is none.
  * @returns {Node|Null}
  * @example
  * node.previous // returns a node or null
  */


  get previous() {
    const index = this.index;

    if (index !== -1) {
      return this.parent.nodes[index - 1] || null;
    }

    return null;
  }
  /**
  * The previous {@link Element} before the current {@link Node}, or `null` if there is none.
  * @returns {Element|Null}
  * @example
  * node.previousElement // returns an element or null
  */


  get previousElement() {
    const index = this.index;

    if (index !== -1) {
      return this.parent.nodes.slice(0, index).reverse().find(hasNodes);
    }

    return null;
  }
  /**
  * The top-most ancestor from the current {@link Node}.
  * @returns {Node}
  * @example
  * node.root // returns the top-most node or the current node itself
  */


  get root() {
    let parent = this;

    while (parent.parent) {
      parent = parent.parent;
    }

    return parent;
  }
  /**
  * Insert one ore more {@link Node}s after the current {@link Node}.
  * @param {...Node|String} nodes - Any nodes to be inserted after the current {@link Node}.
  * @returns {Node} - The current {@link Node}.
  * @example
  * node.after(new Text({ data: 'Hello World' }))
  */


  after(...nodes) {
    if (nodes.length) {
      const index = this.index;

      if (index !== -1) {
        this.parent.nodes.splice(index + 1, 0, ...nodes);
      }
    }

    return this;
  }
  /**
  * Append Nodes or new Text Nodes to the current {@link Node}.
  * @param {...Node|String} nodes - Any nodes to be inserted after the last child of the current {@link Node}.
  * @returns {Node} - The current {@link Node}.
  * @example
  * node.append(someOtherNode)
  */


  append(...nodes) {
    if (this.nodes) {
      this.nodes.splice(this.nodes.length, 0, ...nodes);
    }

    return this;
  }
  /**
  * Append the current {@link Node} to another Node.
  * @param {Container} parent - The {@link Container} for the current {@link Node}.
  * @returns {Node} - The current {@link Node}.
  */


  appendTo(parent) {
    if (parent && parent.nodes) {
      parent.nodes.splice(parent.nodes.length, 0, this);
    }

    return this;
  }
  /**
  * Insert Nodes or new Text Nodes before the Node if it has a parent.
  * @param {...Node|String} nodes - Any nodes to be inserted before the current {@link Node}.
  * @returns {Node}
  * @example
  * node.before(new Text({ data: 'Hello World' })) // returns the current node
  */


  before(...nodes) {
    if (nodes.length) {
      const index = this.index;

      if (index !== -1) {
        this.parent.nodes.splice(index, 0, ...nodes);
      }
    }

    return this;
  }
  /**
  * Prepend Nodes or new Text Nodes to the current {@link Node}.
  * @param {...Node|String} nodes - Any nodes inserted before the first child of the current {@link Node}.
  * @returns {Node} - The current {@link Node}.
  * @example
  * node.prepend(someOtherNode)
  */


  prepend(...nodes) {
    if (this.nodes) {
      this.nodes.splice(0, 0, ...nodes);
    }

    return this;
  }
  /**
  * Remove the current {@link Node} from its parent.
  * @returns {Node}
  * @example
  * node.remove() // returns the current node
  */


  remove() {
    const index = this.index;

    if (index !== -1) {
      this.parent.nodes.splice(index, 1);
    }

    return this;
  }
  /**
  * Replace the current {@link Node} with another Node or Nodes.
  * @param {...Node} nodes - Any nodes replacing the current {@link Node}.
  * @returns {Node} - The current {@link Node}
  * @example
  * node.replaceWith(someOtherNode) // returns the current node
  */


  replaceWith(...nodes) {
    const index = this.index;

    if (index !== -1) {
      this.parent.nodes.splice(index, 1, ...nodes);
    }

    return this;
  }
  /**
  * Transform the current {@link Node} and any descendants using visitors.
  * @param {Result} result - The {@link Result} to be used by visitors.
  * @param {Object} [overrideVisitors] - Alternative visitors to be used in place of {@link Result} visitors.
  * @returns {ResultPromise}
  * @example
  * await node.visit(result)
  * @example
  * await node.visit() // visit using the result of the current node
  * @example
  * await node.visit(result, {
  *   Element () {
  *     // do something to an element
  *   }
  * })
  */


  visit(result, overrideVisitors) {
    const resultToUse = 0 in arguments ? result : this.result;
    return visit(this, resultToUse, overrideVisitors);
  }
  /**
  * Add a warning from the current {@link Node}.
  * @param {Result} result - The {@link Result} the warning is being added to.
  * @param {String} text - The message being sent as the warning.
  * @param {Object} [opts] - Additional information about the warning.
  * @example
  * node.warn(result, 'Something went wrong')
  * @example
  * node.warn(result, 'Something went wrong', {
  *   node: someOtherNode,
  *   plugin: someOtherPlugin
  * })
  */


  warn(result, text, opts) {
    const data = Object.assign({
      node: this
    }, opts);
    return result.warn(text, data);
  }

}

function hasNodes(node) {
  return node.nodes;
}

/**
* @name Comment
* @class
* @extends Node
* @classdesc Return a new {@link Comment} {@link Node}.
* @param {Object|String} settings - Custom settings applied to the Comment, or the content of the {@link Comment}.
* @param {String} settings.comment - Content of the Comment.
* @param {Object} settings.source - Source mapping of the Comment.
* @returns {Comment}
* @example
* new Comment({ comment: ' Hello World ' })
*/

class Comment extends Node {
  constructor(settings) {
    super();

    if (typeof settings === 'string') {
      settings = {
        comment: settings
      };
    }

    Object.assign(this, {
      type: 'comment',
      name: '#comment',
      comment: String(Object(settings).comment || ''),
      source: Object(Object(settings).source)
    });
  }
  /**
  * Return the stringified innerHTML of the current {@link Comment}.
  * @returns {String}
  * @example
  * attrs.innerHTML // returns ' Hello World '
  */


  get innerHTML() {
    return String(this.comment);
  }
  /**
  * Return the stringified outerHTML of the current {@link Comment}.
  * @returns {String}
  * @example
  * attrs.outerHTML // returns '<!-- Hello World -->'
  */


  get outerHTML() {
    return String(this);
  }
  /**
  * Return the stringified innerHTML from the source input.
  * @returns {String}
  * @example
  * attrs.sourceInnerHTML // returns ' Hello World '
  */


  get sourceInnerHTML() {
    return typeof Object(this.source.input).html !== 'string' ? '' : this.source.input.html.slice(this.source.startOffset + 4, this.source.endOffset - 3);
  }
  /**
  * Return the stringified outerHTML from the source input.
  * @returns {String}
  * @example
  * attrs.sourceOuterHTML // returns '<!-- Hello World -->'
  */


  get sourceOuterHTML() {
    return typeof Object(this.source.input).html !== 'string' ? '' : this.source.input.html.slice(this.source.startOffset, this.source.endOffset);
  }
  /**
  * Return a clone of the current {@link Comment}.
  * @param {Object} settings - Custom settings applied to the cloned {@link Comment}.
  * @returns {Comment} - The cloned {@link Comment}
  * @example
  * comment.clone()
  * @example <caption>Clone the current text with new source.</caption>
  * comment.clone({ source: { input: 'modified source' } })
  */


  clone(settings) {
    return new this.constructor(Object.assign({}, this, settings, {
      source: Object.assign({}, this.source, Object(settings).source)
    }));
  }
  /**
  * Return the current {@link Comment} as a String.
  * @returns {String} A string version of the current {@link Comment}
  * @example
  * attrs.toJSON() // returns '<!-- Hello World -->'
  */


  toString() {
    return `<!--${this.comment}-->`;
  }
  /**
  * Return the current {@link Comment} as a Object.
  * @returns {Object} An object version of the current {@link Comment}
  * @example
  * attrs.toJSON() // returns { comment: ' Hello World ' }
  */


  toJSON() {
    return {
      comment: this.comment
    };
  }

}

/**
* @name Container
* @class
* @extends Node
* @classdesc Return a new {@link Container} {@link Node}.
* @returns {Container}
*/

class Container extends Node {
  /**
  * Return the first child {@link Node} of the current {@link Container}, or `null` if there is none.
  * @returns {Node|Null}
  * @example
  * container.first // returns a Node or null
  */
  get first() {
    return this.nodes[0] || null;
  }
  /**
  * Return the first child {@link Element} of the current {@link Container}, or `null` if there is none.
  * @returns {Node|Null}
  * @example
  * container.firstElement // returns an Element or null
  */


  get firstElement() {
    return this.nodes.find(hasNodes$1) || null;
  }
  /**
  * Return the last child {@link Node} of the current {@link Container}, or `null` if there is none.
  * @returns {Node|Null}
  * @example
  * container.last // returns a Node or null
  */


  get last() {
    return this.nodes[this.nodes.length - 1] || null;
  }
  /**
  * Return the last child {@link Element} of the current {@link Container}, or `null` if there is none.
  * @returns {Node|Null}
  * @example
  * container.lastElement // returns an Element or null
  */


  get lastElement() {
    return this.nodes.slice().reverse().find(hasNodes$1) || null;
  }
  /**
  * Return a child {@link Element} {@link NodeList} of the current {@link Container}.
  * @returns {Array}
  * @example
  * container.elements // returns an array of Elements
  */


  get elements() {
    return this.nodes.filter(hasNodes$1) || [];
  }
  /**
  * Return the innerHTML of the current {@link Container} as a String.
  * @returns {String}
  * @example
  * container.innerHTML // returns a string of innerHTML
  */


  get innerHTML() {
    return this.nodes.innerHTML;
  }
  /**
  * Define the nodes of the current {@link Container} from a String.
  * @param {String} innerHTML - Source being processed.
  * @returns {Void}
  * @example
  * container.innerHTML = 'Hello <strong>world</strong>';
  * container.nodes.length; // 2
  */


  set innerHTML(innerHTML) {
    this.nodes.innerHTML = innerHTML;
  }
  /**
  * Return the outerHTML of the current {@link Container} as a String.
  * @returns {String}
  * @example
  * container.outerHTML // returns a string of outerHTML
  */


  get outerHTML() {
    return this.nodes.innerHTML;
  }
  /**
  * Replace the current {@link Container} from a String.
  * @param {String} input - Source being processed.
  * @returns {Void}
  * @example
  * container.outerHTML = 'Hello <strong>world</strong>';
  */


  set outerHTML(outerHTML) {
    const Result = Object(this.result).constructor;

    if (Result) {
      const childNodes = new Result(outerHTML).root.nodes;
      this.replaceWith(...childNodes);
    }
  }
  /**
  * Return the stringified innerHTML from the source input.
  * @returns {String}
  */


  get sourceInnerHTML() {
    return this.isSelfClosing || this.isVoid || typeof Object(this.source.input).html !== 'string' ? '' : 'startInnerOffset' in this.source && 'endInnerOffset' in this.source ? this.source.input.html.slice(this.source.startInnerOffset, this.source.endInnerOffset) : this.sourceOuterHTML;
  }
  /**
  * Return the stringified outerHTML from the source input.
  * @returns {String}
  */


  get sourceOuterHTML() {
    return typeof Object(this.source.input).html !== 'string' ? '' : this.source.input.html.slice(this.source.startOffset, this.source.endOffset);
  }
  /**
  * Return the text content of the current {@link Container} as a String.
  * @returns {String}
  */


  get textContent() {
    return this.nodes.textContent;
  }
  /**
  * Define the content of the current {@link Container} as a new {@link Text} {@link Node}.
  * @returns {String}
  */


  set textContent(textContent) {
    this.nodes.textContent = textContent;
  }
  /**
  * Return a child {@link Node} of the current {@link Container} by last index, or `null` if there is none.
  * @returns {Node|Null}
  * @example
  * container.lastNth(0) // returns a Node or null
  */


  lastNth(index) {
    return this.nodes.slice().reverse()[index] || null;
  }
  /**
  * Return a child {@link Element} of the current {@link Container} by last index, or `null` if there is none.
  * @returns {Element|Null}
  * @example
  * container.lastNthElement(0) // returns an Element or null
  */


  lastNthElement(index) {
    return this.elements.reverse()[index] || null;
  }
  /**
  * Return a child {@link Node} of the current {@link Container} by index, or `null` if there is none.
  * @returns {Node|Null}
  * @example
  * container.nth(0) // returns a Node or null
  */


  nth(index) {
    return this.nodes[index] || null;
  }
  /**
  * Return an {@link Element} child of the current Container by index, or `null` if there is none.
  * @returns {Element|Null}
  * @example
  * container.nthElement(0) // returns an Element or null
  */


  nthElement(index) {
    return this.elements[index] || null;
  }
  /**
  * Replace all of the children of the current {@link Container}.
  * @param {...Node} nodes - Any nodes replacing the current children of the {@link Container}.
  * @returns {Container} - The current {@link Container}.
  * @example
  * container.replaceAll(new Text({ data: 'Hello World' }))
  */


  replaceAll(...nodes) {
    if (this.nodes) {
      this.nodes.splice(0, this.nodes.length, ...nodes);
    }

    return this;
  }
  /**
  * Traverse the descendant {@link Node}s of the current {@link Container} with a callback function.
  * @param {Function|String|RegExp} callback_or_filter - A callback function, or a filter to reduce {@link Node}s the callback is applied to.
  * @param {Function|String|RegExp} callback - A callback function when a filter is also specified.
  * @returns {Container} - The current {@link Container}.
  * @example
  * container.walk(node => {
  *   console.log(node);
  * })
  * @example
  * container.walk('*', node => {
  *   console.log(node);
  * })
  * @example <caption>Walk only "section" {@link Element}s.</caption>
  * container.walk('section', node => {
  *   console.log(node); // logs only Section Elements
  * })
  * @example
  * container.walk(/^section$/, node => {
  *   console.log(node); // logs only Section Elements
  * })
  * @example
  * container.walk(
  *   node => node.name.toLowerCase() === 'section',
  *   node => {
  *   console.log(node); // logs only Section Elements
  * })
  * @example <caption>Walk only {@link Text}.</caption>
  * container.walk('#text', node => {
  *   console.log(node); // logs only Text Nodes
  * })
  */


  walk() {
    const [cb, filter] = getCbAndFilterFromArgs(arguments);
    walk(this, cb, filter);
    return this;
  }

}

function walk(node, cb, filter) {
  if (typeof cb === 'function' && node.nodes) {
    node.nodes.slice(0).forEach(child => {
      if (Object(child).parent === node) {
        if (testWithFilter(child, filter)) {
          cb(child); // eslint-disable-line callback-return
        }

        if (child.nodes) {
          walk(child, cb, filter);
        }
      }
    });
  }
}

function getCbAndFilterFromArgs(args) {
  const [cbOrFilter, onlyCb] = args;
  const cb = onlyCb || cbOrFilter;
  const filter = onlyCb ? cbOrFilter : undefined;
  return [cb, filter];
}

function testWithFilter(node, filter) {
  if (!filter) {
    return true;
  } else if (filter === '*') {
    return Object(node).constructor.name === 'Element';
  } else if (typeof filter === 'string') {
    return node.name === filter;
  } else if (filter instanceof RegExp) {
    return filter.test(node.name);
  } else if (filter instanceof Function) {
    return filter(node);
  } else {
    return false;
  }
}

function hasNodes$1(node) {
  return node.nodes;
}

/**
* @name Doctype
* @class
* @extends Node
* @classdesc Create a new {@link Doctype} {@link Node}.
* @param {Object|String} settings - Custom settings applied to the {@link Doctype}, or the name of the {@link Doctype}.
* @param {String} settings.name - Name of the {@link Doctype}.
* @param {String} settings.publicId - Public identifier portion of the {@link Doctype}.
* @param {String} settings.systemId - System identifier portion of the {@link Doctype}.
* @param {Object} settings.source - Source mapping of the {@link Doctype}.
* @returns {Doctype}
* @example
* new Doctype({ name: 'html' }) // <!doctype html>
*/

class Doctype extends Node {
  constructor(settings) {
    super();

    if (typeof settings === 'string') {
      settings = {
        name: settings
      };
    }

    Object.assign(this, {
      type: 'doctype',
      doctype: String(Object(settings).doctype || 'doctype'),
      name: String(Object(settings).name || 'html'),
      publicId: Object(settings).publicId || null,
      systemId: Object(settings).systemId || null,
      source: Object.assign({
        before: Object(Object(settings).source).before || ' ',
        after: Object(Object(settings).source).after || '',
        beforePublicId: Object(Object(settings).source).beforePublicId || null,
        beforeSystemId: Object(Object(settings).source).beforeSystemId || null
      }, Object(settings).source)
    });
  }
  /**
  * Return a clone of the current {@link Doctype}.
  * @param {Object} settings - Custom settings applied to the cloned {@link Doctype}.
  * @returns {Doctype} - The cloned {@link Doctype}
  * @example
  * doctype.clone()
  * @example <caption>Clone the current text with new source.</caption>
  * doctype.clone({ source: { input: 'modified source' } })
  */


  clone(settings) {
    return new this.constructor(Object.assign({}, this, settings, {
      source: Object.assign({}, this.source, Object(settings).source)
    }));
  }
  /**
  * Return the current {@link Doctype} as a String.
  * @returns {String}
  */


  toString() {
    const publicId = this.publicId ? `${this.source.beforePublicId || ' '}${this.publicId}` : '';
    const systemId = this.systemId ? `${this.source.beforeSystemId || ' '}${this.systemId}` : '';
    return `<!${this.doctype}${this.source.before}${this.name}${this.source.after}${publicId}${systemId}>`;
  }
  /**
  * Return the current {@link Doctype} as an Object.
  * @returns {Object}
  */


  toJSON() {
    return {
      name: this.name,
      publicId: this.publicId,
      systemId: this.systemId
    };
  }

}

/**
* @name Fragment
* @class
* @extends Container
* @classdesc Create a new {@link Fragment} {@Link Node}.
* @param {Object} settings - Custom settings applied to the {@link Fragment}.
* @param {Array|NodeList} settings.nodes - Nodes appended to the {@link Fragment}.
* @param {Object} settings.source - Source mapping of the {@link Fragment}.
* @returns {Fragment}
* @example
* new Fragment() // returns an empty fragment
*
* new Fragment({ nodes: [ new Element('span') ] }) // returns a fragment with a <span>
*/

class Fragment extends Container {
  constructor(settings) {
    super();
    Object.assign(this, settings, {
      type: 'fragment',
      name: '#document-fragment',
      nodes: Array.isArray(Object(settings).nodes) ? new NodeList(this, ...Array.from(settings.nodes)) : Object(settings).nodes !== null && Object(settings).nodes !== undefined ? new NodeList(this, settings.nodes) : new NodeList(this),
      source: Object(Object(settings).source)
    });
  }
  /**
  * Return a clone of the current {@link Fragment}.
  * @param {Boolean} isDeep - Whether the descendants of the current Fragment should also be cloned.
  * @returns {Fragment} - The cloned Fragment
  */


  clone(isDeep) {
    const clone = new Fragment(Object.assign({}, this, {
      nodes: []
    }));

    if (isDeep) {
      clone.nodes = this.nodes.clone(clone);
    }

    return clone;
  }
  /**
  * Return the current {@link Fragment} as an Array.
  * @returns {Array}
  * @example
  * fragment.toJSON() // returns []
  */


  toJSON() {
    return this.nodes.toJSON();
  }
  /**
  * Return the current {@link Fragment} as a String.
  * @returns {String}
  * @example
  * fragment.toJSON() // returns ''
  */


  toString() {
    return String(this.nodes);
  }

}

/**
* @name Text
* @class
* @extends Node
* @classdesc Create a new {@link Text} {@link Node}.
* @param {Object|String} settings - Custom settings applied to the {@link Text}, or the content of the {@link Text}.
* @param {String} settings.data - Content of the {@link Text}.
* @param {Object} settings.source - Source mapping of the {@link Text}.
* @returns {Text}
* @example
* new Text({ data: 'Hello World' })
*/

class Text extends Node {
  constructor(settings) {
    super();

    if (typeof settings === 'string') {
      settings = {
        data: settings
      };
    }

    Object.assign(this, {
      type: 'text',
      name: '#text',
      data: String(Object(settings).data || ''),
      source: Object(Object(settings).source)
    });
  }
  /**
  * Return the stringified innerHTML from the source input.
  * @returns {String}
  */


  get sourceInnerHTML() {
    return typeof Object(this.source.input).html !== 'string' ? '' : this.source.input.html.slice(this.source.startOffset, this.source.endOffset);
  }
  /**
  * Return the stringified outerHTML from the source input.
  * @returns {String}
  */


  get sourceOuterHTML() {
    return typeof Object(this.source.input).html !== 'string' ? '' : this.source.input.html.slice(this.source.startOffset, this.source.endOffset);
  }
  /**
  * Return the current {@link Text} as a String.
  * @returns {String}
  * @example
  * text.textContent // returns ''
  */


  get textContent() {
    return String(this.data);
  }
  /**
  * Define the current {@link Text} from a String.
  * @returns {Void}
  * @example
  * text.textContent = 'Hello World'
  * text.textContent // 'Hello World'
  */


  set textContent(textContent) {
    this.data = String(textContent);
  }
  /**
  * Return a clone of the current {@link Text}.
  * @param {Object} settings - Custom settings applied to the cloned {@link Text}.
  * @returns {Text} - The cloned {@link Text}
  * @example
  * text.clone()
  * @example <caption>Clone the current text with new source.</caption>
  * text.clone({ source: { input: 'modified source' } })
  */


  clone(settings) {
    return new Text(Object.assign({}, this, settings, {
      source: Object.assign({}, this.source, Object(settings).source)
    }));
  }
  /**
  * Return the current {@link Text} as a String.
  * @returns {String}
  * @example
  * text.toString() // returns ''
  */


  toString() {
    return String(this.data);
  }
  /**
  * Return the current {@link Text} as a String.
  * @returns {String}
  * @example
  * text.toJSON() // returns ''
  */


  toJSON() {
    return String(this.data);
  }

}

function normalize(node) {
  const nodeTypes = {
    comment: Comment,
    doctype: Doctype,
    element: Element,
    fragment: Fragment,
    text: Text
  };
  return node instanceof Node // Nodes are unchanged
  ? node : node.type in nodeTypes // Strings are converted into Text nodes
  ? new nodeTypes[node.type](node) // Node-like Objects with recognized types are normalized
  : new Text({
    data: String(node)
  });
}

const parents = new WeakMap();
/**
* @name NodeList
* @class
* @extends Array
* @classdesc Create a new {@link NodeList}.
* @param {Container} parent - Parent containing the current {@link NodeList}.
* @param {...Node} nodes - {@link Node}s belonging to the current {@link NodeList}.
* @returns {NodeList}
*/

class NodeList extends Array {
  constructor(parent, ...nodes) {
    super();
    parents.set(this, parent);

    if (nodes.length) {
      this.push(...nodes);
    }
  }
  /**
  * Return the innerHTML of the current {@link Container} as a String.
  * @returns {String}
  * @example
  * container.innerHTML // returns a string of innerHTML
  */


  get innerHTML() {
    return this.map(node => node.type === 'text' ? getInnerHtmlEncodedString(node.data) : 'outerHTML' in node ? node.outerHTML : String(node)).join('');
  }
  /**
  * Define the nodes of the current {@link NodeList} from a String.
  * @param {String} innerHTML - Source being processed.
  * @returns {Void}
  * @example
  * nodeList.innerHTML = 'Hello <strong>world</strong>';
  * nodeList.length; // 2
  */


  set innerHTML(innerHTML) {
    const parent = this.parent;
    const Result = Object(parent.result).constructor;

    if (Result) {
      const nodes = new Result(innerHTML).root.nodes;
      this.splice(0, this.length, ...nodes);
    }
  }
  /**
  * Return the parent of the current {@link NodeList}.
  * @returns {Container}
  */


  get parent() {
    return parents.get(this);
  }
  /**
  * Return the text content of the current {@link NodeList} as a String.
  * @returns {String}
  */


  get textContent() {
    return this.map(node => Object(node).textContent || '').join('');
  }
  /**
  * Define the content of the current {@link NodeList} as a new {@link Text} {@link Node}.
  * @returns {String}
  */


  set textContent(textContent) {
    this.splice(0, this.length, new Text({
      data: textContent
    }));
  }
  /**
  * Return a clone of the current {@link NodeList}.
  * @param {Object} parent - New parent containing the cloned {@link NodeList}.
  * @returns {NodeList} - The cloned NodeList
  */


  clone(parent) {
    return new NodeList(parent, ...this.map(node => node.clone({}, true)));
  }
  /**
  * Remove and return the last {@link Node} in the {@link NodeList}.
  * @returns {Node}
  */


  pop() {
    const [remove] = this.splice(this.length - 1, 1);
    return remove;
  }
  /**
  * Add {@link Node}s to the end of the {@link NodeList} and return the new length of the {@link NodeList}.
  * @returns {Number}
  */


  push(...nodes) {
    const parent = this.parent;
    const inserts = nodes.filter(node => node !== parent);
    this.splice(this.length, 0, ...inserts);
    return this.length;
  }
  /**
  * Remove and return the first {@link Node} in the {@link NodeList}.
  * @returns {Node}
  */


  shift() {
    const [remove] = this.splice(0, 1);
    return remove;
  }
  /**
  * Add and remove {@link Node}s to and from the {@link NodeList}.
  * @returns {Array}
  */


  splice(start, ...args) {
    const {
      length,
      parent
    } = this;
    const startIndex = start > length ? length : start < 0 ? Math.max(length + start, 0) : Number(start) || 0;
    const deleteCount = 0 in args ? Number(args[0]) || 0 : length;
    const inserts = getNodeListArray(args.slice(1).filter(node => node !== parent));

    for (let _i = 0, _length = inserts == null ? 0 : inserts.length; _i < _length; _i++) {
      let insert = inserts[_i];
      insert.remove();
      insert.parent = parent;
    }

    const removes = Array.prototype.splice.call(this, startIndex, deleteCount, ...inserts);

    for (let _i2 = 0, _length2 = removes == null ? 0 : removes.length; _i2 < _length2; _i2++) {
      let remove = removes[_i2];
      delete remove.parent;
    }

    return removes;
  }
  /**
  * Add {@link Node}s to the beginning of the {@link NodeList} and return the new length of the {@link NodeList}.
  * @returns {Number}
  */


  unshift(...nodes) {
    const parent = this.parent;
    const inserts = nodes.filter(node => node !== parent);
    this.splice(0, 0, ...inserts);
    return this.length;
  }
  /**
  * Return the current {@link NodeList} as a String.
  * @returns {String}
  * @example
  * nodeList.toString() // returns ''
  */


  toString() {
    return this.join('');
  }
  /**
  * Return the current {@link NodeList} as an Array.
  * @returns {Array}
  * @example
  * nodeList.toJSON() // returns []
  */


  toJSON() {
    return Array.from(this).map(node => node.toJSON());
  }
  /**
  * Return a new {@link NodeList} from an object.
  * @param {Array|Node} nodes - An array or object of nodes.
  * @returns {NodeList} A new {@link NodeList}
  * @example <caption>Return a NodeList from an array of text.</caption>
  * NodeList.from([ 'test' ]) // returns NodeList [ Text { data: 'test' } ]
  */


  static from(nodes) {
    return new NodeList(new Fragment(), ...getNodeListArray(nodes));
  }

}
/**
* Return an NodeList-compatible array from an array.
* @private
*/

function getNodeListArray(nodes) {
  // coerce nodes into an array
  return Object(nodes).length ? Array.from(nodes).filter(node => node != null).map(normalize) : [];
}
/**
* Return an innerHTML-encoded string.
* @private
*/


function getInnerHtmlEncodedString(string) {
  return string.replace(/&|<|>/g, match => match === '&' ? '&amp;' : match === '<' ? '&lt;' : '&gt;');
}

defaultTreeAdapter.isElementNode = node => 'tagName' in node; // patch defaultTreeAdapter.createCommentNode to support doctype nodes


defaultTreeAdapter.createCommentNode = function createCommentNode(data) {
  return typeof data === 'string' ? {
    nodeName: '#comment',
    data,
    parentNode: null
  } : Object.assign({
    nodeName: '#documentType',
    name: data
  }, data);
};

Tokenizer.prototype._createDoctypeToken = function _createDoctypeToken() {
  const doctypeRegExp = /^(doctype)(\s+)(html)(?:(\s+)(public\s+(["']).*?\6))?(?:(\s+)((["']).*\9))?(\s*)/i;
  const doctypeStartRegExp = /doctype\s*$/i;
  const offset = this.preprocessor.html.slice(0, this.preprocessor.pos).match(doctypeStartRegExp, '')[0].length;
  const innerHTML = this.preprocessor.html.slice(this.preprocessor.pos - offset);
  const [, doctype, before, name, beforePublicId, publicId,, beforeSystemId, systemId,, after] = Object(innerHTML.match(doctypeRegExp));
  this.currentToken = {
    type: Tokenizer.COMMENT_TOKEN,
    data: {
      doctype,
      name,
      publicId,
      systemId,
      source: {
        before,
        beforePublicId,
        beforeSystemId,
        after
      }
    },
    forceQuirks: false,
    publicId: null,
    systemId: null
  };
}; // patch _createAttr to include the start offset position for name


Tokenizer.prototype._createAttr = function _createAttr(attrNameFirstCh) {
  this.currentAttr = {
    name: attrNameFirstCh,
    value: '',
    startName: this.preprocessor.pos
  };
}; // patch _leaveAttrName to support duplicate attributes


Tokenizer.prototype._leaveAttrName = function _leaveAttrName(toState) {
  const startName = this.currentAttr.startName;
  const endName = this.currentAttr.endName = this.preprocessor.pos;
  this.currentToken.attrs.push(this.currentAttr);
  const before = this.preprocessor.html.slice(0, startName).match(/\s*$/)[0];
  this.currentAttr.raw = {
    name: this.preprocessor.html.slice(startName, endName),
    value: null,
    source: {
      startName,
      endName,
      startValue: null,
      endValue: null,
      before,
      quote: ''
    }
  };
  this.state = toState;
}; // patch _leaveAttrValue to include the offset end position for value


Tokenizer.prototype._leaveAttrValue = function _leaveAttrValue(toState) {
  const startValue = this.currentAttr.endName + 1;
  const endValue = this.preprocessor.pos;
  const quote = endValue - this.currentAttr.value.length === startValue ? '' : this.preprocessor.html[startValue];
  const currentAttrValue = this.preprocessor.html.slice(startValue + quote.length, endValue - quote.length);
  this.currentAttr.raw.value = currentAttrValue;
  this.currentAttr.raw.source.startValue = startValue;
  this.currentAttr.raw.source.endValue = endValue;
  this.currentAttr.raw.source.quote = quote;
  this.state = toState;
}; // patch TAG_OPEN_STATE to support jsx-style fragments


const originalTAG_OPEN_STATE = Tokenizer.prototype.TAG_OPEN_STATE;

Tokenizer.prototype.TAG_OPEN_STATE = function TAG_OPEN_STATE(cp) {
  const isReactOpeningElement = this.preprocessor.html.slice(this.preprocessor.pos - 1, this.preprocessor.pos + 1) === '<>';
  const isReactClosingElement = this.preprocessor.html.slice(this.preprocessor.pos - 1, this.preprocessor.pos + 2) === '</>';

  if (isReactOpeningElement) {
    this._createStartTagToken();

    this._reconsumeInState('TAG_NAME_STATE');
  } else if (isReactClosingElement) {
    this._createEndTagToken();

    this._reconsumeInState('TAG_NAME_STATE');
  } else {
    originalTAG_OPEN_STATE.call(this, cp);
  }
};

function parseLoose(html, parseOpts) {
  this.tokenizer = new Tokenizer(this.options);
  const document = defaultTreeAdapter.createDocumentFragment();
  const template = defaultTreeAdapter.createDocumentFragment();

  this._bootstrap(document, template);

  this._pushTmplInsertionMode('IN_TEMPLATE_MODE');

  this._initTokenizerForFragmentParsing();

  this._insertFakeRootElement();

  this.tokenizer.write(html, true);

  this._runParsingLoop(null);

  document.childNodes = filter(document.childNodes, parseOpts);
  return document;
}

function parseHTML(input, parseOpts) {
  const htmlParser = new HTMLParser({
    treeAdapter: defaultTreeAdapter,
    sourceCodeLocationInfo: true
  });
  return parseLoose.call(htmlParser, input, parseOpts);
} // filter out generated elements

function filter(childNodes, parseOpts) {
  return childNodes.reduce((nodes, childNode) => {
    const isVoidElement = parseOpts.voidElements.includes(childNode.nodeName);
    const grandChildNodes = childNode.childNodes ? filter(childNode.childNodes, parseOpts) : []; // filter child nodes

    if (isVoidElement) {
      delete childNode.childNodes;
    } else {
      childNode.childNodes = grandChildNodes;
    } // push nodes with source


    if (childNode.sourceCodeLocation) {
      nodes.push(childNode);
    }

    if (!childNode.sourceCodeLocation || !childNode.childNodes) {
      nodes.push(...grandChildNodes);
    }

    return nodes;
  }, []);
}

/**
* @name Result
* @class
* @classdesc Create a new syntax tree {@link Result} from a processed input.
* @param {Object} processOptions - Custom settings applied to the {@link Result}.
* @param {String} processOptions.from - Source input location.
* @param {String} processOptions.to - Destination output location.
* @param {Array} processOptions.voidElements - Void elements.
* @returns {Result}
* @property {Result} result - Result of pHTML transformations.
* @property {String} result.from - Path to the HTML source file. You should always set from, because it is used in source map generation and syntax error messages.
* @property {String} result.to - Path to the HTML output file.
* @property {Fragment} result.root - Object representing the parsed nodes of the HTML file.
* @property {Array} result.messages - List of the messages gathered during transformations.
* @property {Array} result.voidElements - List of the elements that only have a start tag, as they cannot have any content.
*/

class Result {
  constructor(html, processOptions) {
    // the "to" and "from" locations are always string values
    const from = 'from' in Object(processOptions) && processOptions.from !== undefined && processOptions.from !== null ? String(processOptions.from) : '';
    const to = 'to' in Object(processOptions) && processOptions.to !== undefined && processOptions.to !== null ? String(processOptions.to) : from;
    const voidElements = 'voidElements' in Object(processOptions) ? [].concat(Object(processOptions).voidElements || []) : Result.voidElements; // prepare visitors (which may be functions or visitors)

    const visitors = getVisitors(Object(processOptions).visitors); // prepare the result object

    Object.assign(this, {
      type: 'result',
      from,
      to,
      input: {
        html,
        from,
        to
      },
      root: null,
      voidElements,
      visitors,
      messages: []
    }); // parse the html and transform it into nodes

    const documentFragment = parseHTML(html, {
      voidElements
    });
    this.root = transform(documentFragment, this);
  }
  /**
  * Current {@link Root} as a String.
  * @returns {String}
  */


  get html() {
    return String(this.root);
  }
  /**
  * Messages that are warnings.
  * @returns {String}
  */


  get warnings() {
    return this.messages.filter(message => Object(message).type === 'warning');
  }
  /**
  * Return a normalized node whose instances match the current {@link Result}.
  * @param {Node} [node] - the node to be normalized.
  * @returns {Node}
  * @example
  * result.normalize(someNode)
  */


  normalize(node) {
    return normalize(node);
  }
  /**
  * The current {@link Root} as an Object.
  * @returns {Object}
  */


  toJSON() {
    return this.root.toJSON();
  }
  /**
  * Transform the current {@link Node} and any descendants using visitors.
  * @param {Node} node - The {@link Node} to be visited.
  * @param {Object} [overrideVisitors] - Alternative visitors to be used in place of {@link Result} visitors.
  * @returns {ResultPromise}
  * @example
  * await result.visit(someNode)
  * @example
  * await result.visit() // visit using the root of the current result
  * @example
  * await result.visit(root, {
  *   Element () {
  *     // do something to an element
  *   }
  * })
  */


  visit(node, overrideVisitors) {
    const nodeToUse = 0 in arguments ? node : this.root;
    return visit(nodeToUse, this, overrideVisitors);
  }
  /**
  * Add a warning to the current {@link Root}.
  * @param {String} text - The message being sent as the warning.
  * @param {Object} [opts] - Additional information about the warning.
  * @example
  * result.warn('Something went wrong')
  * @example
  * result.warn('Something went wrong', {
  *   node: someNode,
  *   plugin: somePlugin
  * })
  */


  warn(text, rawopts) {
    const opts = Object(rawopts);

    if (!opts.plugin) {
      if (Object(this.currentPlugin).name) {
        opts.plugin = this.currentPlugin.name;
      }
    }

    this.messages.push({
      type: 'warning',
      text,
      opts
    });
  }

}

Result.voidElements = ['area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];

function transform(node, result) {
  const hasSource = node.sourceCodeLocation === Object(node.sourceCodeLocation);
  const source = hasSource ? {
    startOffset: node.sourceCodeLocation.startOffset,
    endOffset: node.sourceCodeLocation.endOffset,
    startInnerOffset: Object(node.sourceCodeLocation.startTag).endOffset || node.sourceCodeLocation.startOffset,
    endInnerOffset: Object(node.sourceCodeLocation.endTag).startOffset || node.sourceCodeLocation.endOffset,
    input: result.input
  } : {
    startOffset: 0,
    startInnerOffset: 0,
    endInnerOffset: result.input.html.length,
    endOffset: result.input.html.length,
    input: result.input
  };

  if (Object(node.sourceCodeLocation).startTag) {
    source.before = result.input.html.slice(source.startOffset, source.startInnerOffset - 1).match(/\s*\/?$/)[0];
  }

  if (Object(node.sourceCodeLocation).endTag) {
    source.after = result.input.html.slice(source.endInnerOffset + 2 + node.nodeName.length, source.endOffset - 1);
  }

  const $node = defaultTreeAdapter.isCommentNode(node) ? new Comment({
    comment: node.data,
    source,
    result
  }) : defaultTreeAdapter.isDocumentTypeNode(node) ? new Doctype(Object.assign(node, {
    result,
    source: Object.assign({}, node.source, source)
  })) : defaultTreeAdapter.isElementNode(node) ? new Element({
    name: result.input.html.slice(source.startOffset + 1, source.startOffset + 1 + node.nodeName.length),
    attrs: node.attrs.map(attr => attr.raw),
    nodes: node.childNodes instanceof Array ? node.childNodes.map(child => transform(child, result)) : null,
    isSelfClosing: /\//.test(source.before),
    isWithoutEndTag: !Object(node.sourceCodeLocation).endTag,
    isVoid: result.voidElements.includes(node.tagName),
    result,
    source
  }) : defaultTreeAdapter.isTextNode(node) ? new Text({
    data: hasSource ? source.input.html.slice(source.startInnerOffset, source.endInnerOffset) : node.value,
    result,
    source
  }) : new Fragment({
    nodes: node.childNodes instanceof Array ? node.childNodes.map(child => transform(child, result)) : null,
    result,
    source
  });
  return $node;
}
/**
* A promise to return a syntax tree.
* @typedef {Promise} ResultPromise
* @example
* resultPromise.then(result => {
*  // do something with the result
* })
*/

/**
* A promise to return a syntax tree.
* @typedef {Object} ProcessOptions
* @property {Object} ProcessOptions - Custom settings applied to the {@link Result}.
* @property {String} ProcessOptions.from - Source input location.
* @property {String} ProcessOptions.to - Destination output location.
* @property {Array} ProcessOptions.voidElements - Void elements.
*/

/**
* @name Element
* @class
* @extends Container
* @classdesc Create a new {@link Element} {@Link Node}.
* @param {Object|String} settings - Custom settings applied to the {@link Element} or its tag name.
* @param {String} settings.name - Tag name of the {@link Element}.
* @param {Boolean} settings.isSelfClosing - Whether the {@link Element} is self-closing.
* @param {Boolean} settings.isVoid - Whether the {@link Element} is void.
* @param {Boolean} settings.isWithoutEndTag - Whether the {@link Element} uses a closing tag.
* @param {Array|AttributeList|Object} settings.attrs - Attributes applied to the {@link Element}.
* @param {Array|NodeList} settings.nodes - Nodes appended to the {@link Element}.
* @param {Object} settings.source - Source mapping of the {@link Element}.
* @param {Array|AttributeList|Object} [attrs] - Conditional override attributes applied to the {@link Element}.
* @param {Array|NodeList} [nodes] - Conditional override nodes appended to the {@link Element}.
* @returns {Element} A new {@link Element} {@Link Node}
* @example
* new Element({ name: 'p' }) // returns an element representing <p></p>
*
* new Element({
*   name: 'input',
*   attrs: [{ name: 'type', value: 'search' }],
*   isVoid: true
* }) // returns an element representing <input type="search">
* @example
* new Element('p') // returns an element representing <p></p>
*
* new Element('p', null,
*   new Element(
*     'input',
*     [{ name: 'type', value: 'search' }]
*   )
* ) // returns an element representing <p><input type="search"></p>
*/

class Element extends Container {
  constructor(settings, ...args) {
    super();

    if (settings !== Object(settings)) {
      settings = {
        name: String(settings == null ? 'span' : settings)
      };
    }

    if (args[0] === Object(args[0])) {
      settings.attrs = args[0];
    }

    if (args.length > 1) {
      settings.nodes = args.slice(1);
    }

    Object.assign(this, settings, {
      type: 'element',
      name: settings.name,
      isSelfClosing: Boolean(settings.isSelfClosing),
      isVoid: 'isVoid' in settings ? Boolean(settings.isVoid) : Result.voidElements.includes(settings.name),
      isWithoutEndTag: Boolean(settings.isWithoutEndTag),
      attrs: AttributeList.from(settings.attrs),
      nodes: Array.isArray(settings.nodes) ? new NodeList(this, ...Array.from(settings.nodes)) : settings.nodes !== null && settings.nodes !== undefined ? new NodeList(this, settings.nodes) : new NodeList(this),
      source: Object(settings.source)
    });
  }
  /**
  * Return the outerHTML of the current {@link Element} as a String.
  * @returns {String}
  * @example
  * element.outerHTML // returns a string of outerHTML
  */


  get outerHTML() {
    return `${getOpeningTagString(this)}${this.nodes.innerHTML}${getClosingTagString(this)}`;
  }
  /**
  * Replace the current {@link Element} from a String.
  * @param {String} input - Source being processed.
  * @returns {Void}
  * @example
  * element.outerHTML = 'Hello <strong>world</strong>';
  */


  set outerHTML(outerHTML) {
    Object.getOwnPropertyDescriptor(Container.prototype, 'outerHTML').set.call(this, outerHTML);
  }
  /**
  * Return a clone of the current {@link Element}.
  * @param {Object} settings - Custom settings applied to the cloned {@link Element}.
  * @param {Boolean} isDeep - Whether the descendants of the current {@link Element} should also be cloned.
  * @returns {Element} - The cloned Element
  */


  clone(settings, isDeep) {
    const clone = new Element(Object.assign({}, this, {
      nodes: []
    }, Object(settings)));
    const didSetNodes = 'nodes' in Object(settings);

    if (isDeep && !didSetNodes) {
      clone.nodes = this.nodes.clone(clone);
    }

    return clone;
  }
  /**
  * Return the Element as a unique Object.
  * @returns {Object}
  */


  toJSON() {
    const object = {
      name: this.name
    }; // conditionally disclose whether the Element is self-closing

    if (this.isSelfClosing) {
      object.isSelfClosing = true;
    } // conditionally disclose whether the Element is void


    if (this.isVoid) {
      object.isVoid = true;
    } // conditionally disclose Attributes applied to the Element


    if (this.attrs.length) {
      object.attrs = this.attrs.toJSON();
    } // conditionally disclose Nodes appended to the Element


    if (!this.isSelfClosing && !this.isVoid && this.nodes.length) {
      object.nodes = this.nodes.toJSON();
    }

    return object;
  }
  /**
  * Return the stringified Element.
  * @returns {String}
  */


  toString() {
    return `${getOpeningTagString(this)}${this.nodes || ''}${`${getClosingTagString(this)}`}`;
  }

}

function getClosingTagString(element) {
  return element.isSelfClosing || element.isVoid || element.isWithoutEndTag ? '' : `</${element.name}${element.source.after || ''}>`;
}

function getOpeningTagString(element) {
  return `<${element.name}${element.attrs}${element.source.before || ''}>`;
}

/**
* @name Plugin
* @class
* @classdesc Create a new Plugin.
* @param {String} name - Name of the Plugin.
* @param {Function} pluginFunction - Function executed by the Plugin during initialization.
* @returns {Plugin}
* @example
* new Plugin('phtml-test', pluginOptions => {
*   // initialization logic
*
*   return {
*     Element (element, result) {
*       // runtime logic, do something with an element
*     },
*     Root (root, result) {
*       // runtime logic, do something with the root
*     }
*   }
* })
* @example
* new Plugin('phtml-test', pluginOptions => {
*   // initialization logic
*
*   return (root, result) => {
*     // runtime logic, do something with the root
*   }
* })
*/

class Plugin extends Function {
  constructor(name, pluginFunction) {
    return Object.defineProperties(pluginFunction, {
      constructor: {
        value: Plugin,
        configurable: true
      },
      type: {
        value: 'plugin',
        configurable: true
      },
      name: {
        value: String(name || 'phtml-plugin'),
        configurable: true
      },
      pluginFunction: {
        value: typeof pluginFunction === 'function' ? pluginFunction : () => pluginFunction,
        configurable: true
      },
      process: {
        value(...args) {
          return Plugin.prototype.process.apply(this, args);
        },

        configurable: true
      }
    });
  }
  /**
  * Process input with options and plugin options and return the result.
  * @param {String} input - Source being processed.
  * @param {ProcessOptions} processOptions - Custom settings applied to the Result.
  * @param {Object} pluginOptions - Options passed to the Plugin.
  * @returns {ResultPromise}
  * @example
  * plugin.process('some html', processOptions, pluginOptions)
  */


  process(input, processOptions, pluginOptions) {
    const initializedPlugin = this.pluginFunction(pluginOptions);
    const result = new Result(input, Object.assign({
      visitors: [initializedPlugin]
    }, Object(processOptions)));
    return result.visit(result.root);
  }

}

/**
* @name PHTML
* @class
* @classdesc Create a new instance of {@link PHTML}.
* @param {Array|Object|Plugin|Function} plugins - Plugin or plugins being added.
* @returns {PHTML}
* @example
* new PHTML(plugin)
* @example
* new PHTML([ somePlugin, anotherPlugin ])
*/

class PHTML {
  constructor(pluginOrPlugins) {
    Object.assign(this, {
      plugins: []
    });
    this.use(pluginOrPlugins);
  }
  /**
  * Process input using plugins and return the result
  * @param {String} input - Source being processed.
  * @param {ProcessOptions} processOptions - Custom settings applied to the Result.
  * @returns {ResultPromise}
  * @example
  * phtml.process('some html', processOptions)
  */


  process(input, processOptions) {
    const result = new Result(input, Object.assign({
      visitors: this.plugins
    }, Object(processOptions))); // dispatch visitors and promise the result

    return result.visit();
  }
  /**
  * Add plugins to the existing instance of PHTML
  * @param {Array|Object|Plugin|Function} plugins - Plugin or plugins being added.
  * @returns {PHTML}
  * @example
  * phtml.use(plugin)
  * @example
  * phtml.use([ somePlugin, anotherPlugin ])
  * @example
  * phtml.use(somePlugin, anotherPlugin)
  */


  use(pluginOrPlugins, ...additionalPlugins) {
    const plugins = [pluginOrPlugins, ...additionalPlugins].reduce((flattenedPlugins, plugin) => flattenedPlugins.concat(plugin), []).filter( // Plugins are either a function or an object with keys
    plugin => typeof plugin === 'function' || Object(plugin) === plugin && Object.keys(plugin).length);
    this.plugins.push(...plugins);
    return this;
  }
  /**
  * Process input and return the new {@link Result}
  * @param {ProcessOptions} [processOptions] - Custom settings applied to the {@link Result}.
  * @param {Array|Object|Plugin|Function} [plugins] - Custom settings applied to the {@link Result}.
  * @returns {ResultPromise}
  * @example
  * PHTML.process('some html', processOptions)
  * @example <caption>Process HTML with plugins.</caption>
  * PHTML.process('some html', processOptions, plugins) // returns a new PHTML instance
  */


  static process(input, processOptions, pluginOrPlugins) {
    const phtml = new PHTML(pluginOrPlugins);
    return phtml.process(input, processOptions);
  }
  /**
  * Return a new {@link PHTML} instance which will use plugins
  * @param {Array|Object|Plugin|Function} plugin - Plugin or plugins being added.
  * @returns {PHTML} - New {@link PHTML} instance
  * @example
  * PHTML.use(plugin) // returns a new PHTML instance
  * @example
  * PHTML.use([ somePlugin, anotherPlugin ]) // returns a new PHTML instance
  * @example
  * PHTML.use(somePlugin, anotherPlugin) // returns a new PHTML instance
  */


  static use(pluginOrPlugins, ...additionalPlugins) {
    return new PHTML().use(pluginOrPlugins, ...additionalPlugins);
  }

}

PHTML.AttributeList = AttributeList;
PHTML.Comment = Comment;
PHTML.Container = Container;
PHTML.Doctype = Doctype;
PHTML.Element = Element;
PHTML.Fragment = Fragment;
PHTML.Node = Node;
PHTML.NodeList = NodeList;
PHTML.Plugin = Plugin;
PHTML.Result = Result;
PHTML.Text = Text;

export default PHTML;
//# sourceMappingURL=index.mjs.map