text: module.exports =
  /******/ (function(modules, runtime) { // webpackBootstrap
  /******/ 	"use strict";
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	__webpack_require__.ab = __dirname + "/";
  /******/
  /******/ 	// the startup function
  /******/ 	function startup() {
  /******/ 		// Load entry module and return exports
  /******/ 		return __webpack_require__(676);
  /******/ 	};
  /******/
  /******/ 	// run startup
  /******/ 	return startup();
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 82:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.toCommandValue = void 0;
  /**
   * Sanitizes an input into a string so it can be passed into issueCommand safely
   * @param input input to sanitize into a string
   */
  function toCommandValue(input) {
      if (input === null || input === undefined) {
          return '';
      }
      else if (typeof input === 'string' || input instanceof String) {
          return input;
      }
      return JSON.stringify(input);
  }
  exports.toCommandValue = toCommandValue;
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  
  /***/ 87:
  /***/ (function(module) {
  
  module.exports = require("os");
  
  /***/ }),
  
  /***/ 102:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  // For internal use, subject to change.
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.issueCommand = void 0;
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  const fs = __importStar(__webpack_require__(747));
  const os = __importStar(__webpack_require__(87));
  const utils_1 = __webpack_require__(82);
  function issueCommand(command, message) {
      const filePath = process.env[`GITHUB_${command}`];
      if (!filePath) {
          throw new Error(`Unable to find environment variable for file command ${command}`);
      }
      if (!fs.existsSync(filePath)) {
          throw new Error(`Missing file at path: ${filePath}`);
      }
      fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, {
          encoding: 'utf8'
      });
  }
  exports.issueCommand = issueCommand;
  //# sourceMappingURL=file-command.js.map
  
  /***/ }),
  
  /***/ 431:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.issue = exports.issueCommand = void 0;
  const os = __importStar(__webpack_require__(87));
  const utils_1 = __webpack_require__(82);
  /**
   * Commands
   *
   * Command Format:
   *   ::name key=value,key=value::message
   *
   * Examples:
   *   ::warning::This is the message
   *   ::set-env name=MY_VAR::some value
   */
  function issueCommand(command, properties, message) {
      const cmd = new Command(command, properties, message);
      process.stdout.write(cmd.toString() + os.EOL);
  }
  exports.issueCommand = issueCommand;
  function issue(name, message = '') {
      issueCommand(name, {}, message);
  }
  exports.issue = issue;
  const CMD_STRING = '::';
  class Command {
      constructor(command, properties, message) {
          if (!command) {
              command = 'missing.command';
          }
          this.command = command;
          this.properties = properties;
          this.message = message;
      }
      toString() {
          let cmdStr = CMD_STRING + this.command;
          if (this.properties && Object.keys(this.properties).length > 0) {
              cmdStr += ' ';
              let first = true;
              for (const key in this.properties) {
                  if (this.properties.hasOwnProperty(key)) {
                      const val = this.properties[key];
                      if (val) {
                          if (first) {
                              first = false;
                          }
                          else {
                              cmdStr += ',';
                          }
                          cmdStr += `${key}=${escapeProperty(val)}`;
                      }
                  }
              }
          }
          cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
          return cmdStr;
      }
  }
  function escapeData(s) {
      return utils_1.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A');
  }
  function escapeProperty(s) {
      return utils_1.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A')
          .replace(/:/g, '%3A')
          .replace(/,/g, '%2C');
  }
  //# sourceMappingURL=command.js.map
  
  /***/ }),
  
  /***/ 440:
  /***/ (function(__unusedmodule, exports) {
  
  function copy(src,dest){
  	for(var p in src){
  		dest[p] = src[p];
  	}
  }
  /**
  ^\w+\.prototype\.([_\w]+)\s*=\s*((?:.*\{\s*?[\r\n][\s\S]*?^})|\S.*?(?=[;\r\n]));?
  ^\w+\.prototype\.([_\w]+)\s*=\s*(\S.*?(?=[;\r\n]));?
   */
  function _extends(Class,Super){
  	var pt = Class.prototype;
  	if(!(pt instanceof Super)){
  		function t(){};
  		t.prototype = Super.prototype;
  		t = new t();
  		copy(pt,t);
  		Class.prototype = pt = t;
  	}
  	if(pt.constructor != Class){
  		if(typeof Class != 'function'){
  			console.error("unknow Class:"+Class)
  		}
  		pt.constructor = Class
  	}
  }
  var htmlns = 'http://www.w3.org/1999/xhtml' ;
  // Node Types
  var NodeType = {}
  var ELEMENT_NODE                = NodeType.ELEMENT_NODE                = 1;
  var ATTRIBUTE_NODE              = NodeType.ATTRIBUTE_NODE              = 2;
  var TEXT_NODE                   = NodeType.TEXT_NODE                   = 3;
  var CDATA_SECTION_NODE          = NodeType.CDATA_SECTION_NODE          = 4;
  var ENTITY_REFERENCE_NODE       = NodeType.ENTITY_REFERENCE_NODE       = 5;
  var ENTITY_NODE                 = NodeType.ENTITY_NODE                 = 6;
  var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;
  var COMMENT_NODE                = NodeType.COMMENT_NODE                = 8;
  var DOCUMENT_NODE               = NodeType.DOCUMENT_NODE               = 9;
  var DOCUMENT_TYPE_NODE          = NodeType.DOCUMENT_TYPE_NODE          = 10;
  var DOCUMENT_FRAGMENT_NODE      = NodeType.DOCUMENT_FRAGMENT_NODE      = 11;
  var NOTATION_NODE               = NodeType.NOTATION_NODE               = 12;
  
  // ExceptionCode
  var ExceptionCode = {}
  var ExceptionMessage = {};
  var INDEX_SIZE_ERR              = ExceptionCode.INDEX_SIZE_ERR              = ((ExceptionMessage[1]="Index size error"),1);
  var DOMSTRING_SIZE_ERR          = ExceptionCode.DOMSTRING_SIZE_ERR          = ((ExceptionMessage[2]="DOMString size error"),2);
  var HIERARCHY_REQUEST_ERR       = ExceptionCode.HIERARCHY_REQUEST_ERR       = ((ExceptionMessage[3]="Hierarchy request error"),3);
  var WRONG_DOCUMENT_ERR          = ExceptionCode.WRONG_DOCUMENT_ERR          = ((ExceptionMessage[4]="Wrong document"),4);
  var INVALID_CHARACTER_ERR       = ExceptionCode.INVALID_CHARACTER_ERR       = ((ExceptionMessage[5]="Invalid character"),5);
  var NO_DATA_ALLOWED_ERR         = ExceptionCode.NO_DATA_ALLOWED_ERR         = ((ExceptionMessage[6]="No data allowed"),6);
  var NO_MODIFICATION_ALLOWED_ERR = ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = ((ExceptionMessage[7]="No modification allowed"),7);
  var NOT_FOUND_ERR               = ExceptionCode.NOT_FOUND_ERR               = ((ExceptionMessage[8]="Not found"),8);
  var NOT_SUPPORTED_ERR           = ExceptionCode.NOT_SUPPORTED_ERR           = ((ExceptionMessage[9]="Not supported"),9);
  var INUSE_ATTRIBUTE_ERR         = ExceptionCode.INUSE_ATTRIBUTE_ERR         = ((ExceptionMessage[10]="Attribute in use"),10);
  //level2
  var INVALID_STATE_ERR        	= ExceptionCode.INVALID_STATE_ERR        	= ((ExceptionMessage[11]="Invalid state"),11);
  var SYNTAX_ERR               	= ExceptionCode.SYNTAX_ERR               	= ((ExceptionMessage[12]="Syntax error"),12);
  var INVALID_MODIFICATION_ERR 	= ExceptionCode.INVALID_MODIFICATION_ERR 	= ((ExceptionMessage[13]="Invalid modification"),13);
  var NAMESPACE_ERR            	= ExceptionCode.NAMESPACE_ERR           	= ((ExceptionMessage[14]="Invalid namespace"),14);
  var INVALID_ACCESS_ERR       	= ExceptionCode.INVALID_ACCESS_ERR      	= ((ExceptionMessage[15]="Invalid access"),15);
  
  /**
   * DOM Level 2
   * Object DOMException
   * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/ecma-script-binding.html
   * @see http://www.w3.org/TR/REC-DOM-Level-1/ecma-script-language-binding.html
   */
  function DOMException(code, message) {
  	if(message instanceof Error){
  		var error = message;
  	}else{
  		error = this;
  		Error.call(this, ExceptionMessage[code]);
  		this.message = ExceptionMessage[code];
  		if(Error.captureStackTrace) Error.captureStackTrace(this, DOMException);
  	}
  	error.code = code;
  	if(message) this.message = this.message + ": " + message;
  	return error;
  };
  DOMException.prototype = Error.prototype;
  copy(ExceptionCode,DOMException)
  /**
   * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-536297177
   * The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented. NodeList objects in the DOM are live.
   * The items in the NodeList are accessible via an integral index, starting from 0.
   */
  function NodeList() {
  };
  NodeList.prototype = {
  	/**
  	 * The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.
  	 * @standard level1
  	 */
  	length:0, 
  	/**
  	 * Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.
  	 * @standard level1
  	 * @param index  unsigned long 
  	 *   Index into the collection.
  	 * @return Node
  	 * 	The node at the indexth position in the NodeList, or null if that is not a valid index. 
  	 */
  	item: function(index) {
  		return this[index] || null;
  	},
  	toString:function(isHTML,nodeFilter){
  		for(var buf = [], i = 0;i<this.length;i++){
  			serializeToString(this[i],buf,isHTML,nodeFilter);
  		}
  		return buf.join('');
  	}
  };
  function LiveNodeList(node,refresh){
  	this._node = node;
  	this._refresh = refresh
  	_updateLiveList(this);
  }
  function _updateLiveList(list){
  	var inc = list._node._inc || list._node.ownerDocument._inc;
  	if(list._inc != inc){
  		var ls = list._refresh(list._node);
  		//console.log(ls.length)
  		__set__(list,'length',ls.length);
  		copy(ls,list);
  		list._inc = inc;
  	}
  }
  LiveNodeList.prototype.item = function(i){
  	_updateLiveList(this);
  	return this[i];
  }
  
  _extends(LiveNodeList,NodeList);
  /**
   * 
   * Objects implementing the NamedNodeMap interface are used to represent collections of nodes that can be accessed by name. Note that NamedNodeMap does not inherit from NodeList; NamedNodeMaps are not maintained in any particular order. Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal index, but this is simply to allow convenient enumeration of the contents of a NamedNodeMap, and does not imply that the DOM specifies an order to these Nodes.
   * NamedNodeMap objects in the DOM are live.
   * used for attributes or DocumentType entities 
   */
  function NamedNodeMap() {
  };
  
  function _findNodeIndex(list,node){
  	var i = list.length;
  	while(i--){
  		if(list[i] === node){return i}
  	}
  }
  
  function _addNamedNode(el,list,newAttr,oldAttr){
  	if(oldAttr){
  		list[_findNodeIndex(list,oldAttr)] = newAttr;
  	}else{
  		list[list.length++] = newAttr;
  	}
  	if(el){
  		newAttr.ownerElement = el;
  		var doc = el.ownerDocument;
  		if(doc){
  			oldAttr && _onRemoveAttribute(doc,el,oldAttr);
  			_onAddAttribute(doc,el,newAttr);
  		}
  	}
  }
  function _removeNamedNode(el,list,attr){
  	//console.log('remove attr:'+attr)
  	var i = _findNodeIndex(list,attr);
  	if(i>=0){
  		var lastIndex = list.length-1
  		while(i<lastIndex){
  			list[i] = list[++i]
  		}
  		list.length = lastIndex;
  		if(el){
  			var doc = el.ownerDocument;
  			if(doc){
  				_onRemoveAttribute(doc,el,attr);
  				attr.ownerElement = null;
  			}
  		}
  	}else{
  		throw DOMException(NOT_FOUND_ERR,new Error(el.tagName+'@'+attr))
  	}
  }
  NamedNodeMap.prototype = {
  	length:0,
  	item:NodeList.prototype.item,
  	getNamedItem: function(key) {
  //		if(key.indexOf(':')>0 || key == 'xmlns'){
  //			return null;
  //		}
  		//console.log()
  		var i = this.length;
  		while(i--){
  			var attr = this[i];
  			//console.log(attr.nodeName,key)
  			if(attr.nodeName == key){
  				return attr;
  			}
  		}
  	},
  	setNamedItem: function(attr) {
  		var el = attr.ownerElement;
  		if(el && el!=this._ownerElement){
  			throw new DOMException(INUSE_ATTRIBUTE_ERR);
  		}
  		var oldAttr = this.getNamedItem(attr.nodeName);
  		_addNamedNode(this._ownerElement,this,attr,oldAttr);
  		return oldAttr;
  	},
  	/* returns Node */
  	setNamedItemNS: function(attr) {// raises: WRONG_DOCUMENT_ERR,NO_MODIFICATION_ALLOWED_ERR,INUSE_ATTRIBUTE_ERR
  		var el = attr.ownerElement, oldAttr;
  		if(el && el!=this._ownerElement){
  			throw new DOMException(INUSE_ATTRIBUTE_ERR);
  		}
  		oldAttr = this.getNamedItemNS(attr.namespaceURI,attr.localName);
  		_addNamedNode(this._ownerElement,this,attr,oldAttr);
  		return oldAttr;
  	},
  
  	/* returns Node */
  	removeNamedItem: function(key) {
  		var attr = this.getNamedItem(key);
  		_removeNamedNode(this._ownerElement,this,attr);
  		return attr;
  		
  		
  	},// raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
  	
  	//for level2
  	removeNamedItemNS:function(namespaceURI,localName){
  		var attr = this.getNamedItemNS(namespaceURI,localName);
  		_removeNamedNode(this._ownerElement,this,attr);
  		return attr;
  	},
  	getNamedItemNS: function(namespaceURI, localName) {
  		var i = this.length;
  		while(i--){
  			var node = this[i];
  			if(node.localName == localName && node.namespaceURI == namespaceURI){
  				return node;
  			}
  		}
  		return null;
  	}
  };
  /**
   * @see http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490
   */
  function DOMImplementation(/* Object */ features) {
  	this._features = {};
  	if (features) {
  		for (var feature in features) {
  			 this._features = features[feature];
  		}
  	}
  };
  
  DOMImplementation.prototype = {
  	hasFeature: function(/* string */ feature, /* string */ version) {
  		var versions = this._features[feature.toLowerCase()];
  		if (versions && (!version || version in versions)) {
  			return true;
  		} else {
  			return false;
  		}
  	},
  	// Introduced in DOM Level 2:
  	createDocument:function(namespaceURI,  qualifiedName, doctype){// raises:INVALID_CHARACTER_ERR,NAMESPACE_ERR,WRONG_DOCUMENT_ERR
  		var doc = new Document();
  		doc.implementation = this;
  		doc.childNodes = new NodeList();
  		doc.doctype = doctype;
  		if(doctype){
  			doc.appendChild(doctype);
  		}
  		if(qualifiedName){
  			var root = doc.createElementNS(namespaceURI,qualifiedName);
  			doc.appendChild(root);
  		}
  		return doc;
  	},
  	// Introduced in DOM Level 2:
  	createDocumentType:function(qualifiedName, publicId, systemId){// raises:INVALID_CHARACTER_ERR,NAMESPACE_ERR
  		var node = new DocumentType();
  		node.name = qualifiedName;
  		node.nodeName = qualifiedName;
  		node.publicId = publicId;
  		node.systemId = systemId;
  		// Introduced in DOM Level 2:
  		//readonly attribute DOMString        internalSubset;
  		
  		//TODO:..
  		//  readonly attribute NamedNodeMap     entities;
  		//  readonly attribute NamedNodeMap     notations;
  		return node;
  	}
  };
  
  
  /**
   * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247
   */
  
  function Node() {
  };
  
  Node.prototype = {
  	firstChild : null,
  	lastChild : null,
  	previousSibling : null,
  	nextSibling : null,
  	attributes : null,
  	parentNode : null,
  	childNodes : null,
  	ownerDocument : null,
  	nodeValue : null,
  	namespaceURI : null,
  	prefix : null,
  	localName : null,
  	// Modified in DOM Level 2:
  	insertBefore:function(newChild, refChild){//raises 
  		return _insertBefore(this,newChild,refChild);
  	},
  	replaceChild:function(newChild, oldChild){//raises 
  		this.insertBefore(newChild,oldChild);
  		if(oldChild){
  			this.removeChild(oldChild);
  		}
  	},
  	removeChild:function(oldChild){
  		return _removeChild(this,oldChild);
  	},
  	appendChild:function(newChild){
  		return this.insertBefore(newChild,null);
  	},
  	hasChildNodes:function(){
  		return this.firstChild != null;
  	},
  	cloneNode:function(deep){
  		return cloneNode(this.ownerDocument||this,this,deep);
  	},
  	// Modified in DOM Level 2:
  	normalize:function(){
  		var child = this.firstChild;
  		while(child){
  			var next = child.nextSibling;
  			if(next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE){
  				this.removeChild(next);
  				child.appendData(next.data);
  			}else{
  				child.normalize();
  				child = next;
  			}
  		}
  	},
    	// Introduced in DOM Level 2:
  	isSupported:function(feature, version){
  		return this.ownerDocument.implementation.hasFeature(feature,version);
  	},
      // Introduced in DOM Level 2:
      hasAttributes:function(){
      	return this.attributes.length>0;
      },
      lookupPrefix:function(namespaceURI){
      	var el = this;
      	while(el){
      		var map = el._nsMap;
      		//console.dir(map)
      		if(map){
      			for(var n in map){
      				if(map[n] == namespaceURI){
      					return n;
      				}
      			}
      		}
      		el = el.nodeType == ATTRIBUTE_NODE?el.ownerDocument : el.parentNode;
      	}
      	return null;
      },
      // Introduced in DOM Level 3:
      lookupNamespaceURI:function(prefix){
      	var el = this;
      	while(el){
      		var map = el._nsMap;
      		//console.dir(map)
      		if(map){
      			if(prefix in map){
      				return map[prefix] ;
      			}
      		}
      		el = el.nodeType == ATTRIBUTE_NODE?el.ownerDocument : el.parentNode;
      	}
      	return null;
      },
      // Introduced in DOM Level 3:
      isDefaultNamespace:function(namespaceURI){
      	var prefix = this.lookupPrefix(namespaceURI);
      	return prefix == null;
      }
  };
  
  
  function _xmlEncoder(c){
  	return c == '<' && '&lt;' ||
           c == '>' && '&gt;' ||
           c == '&' && '&amp;' ||
           c == '"' && '&quot;' ||
           '&#'+c.charCodeAt()+';'
  }
  
  
  copy(NodeType,Node);
  copy(NodeType,Node.prototype);
  
  /**
   * @param callback return true for continue,false for break
   * @return boolean true: break visit;
   */
  function _visitNode(node,callback){
  	if(callback(node)){
  		return true;
  	}
  	if(node = node.firstChild){
  		do{
  			if(_visitNode(node,callback)){return true}
          }while(node=node.nextSibling)
      }
  }
  
  
  
  function Document(){
  }
  function _onAddAttribute(doc,el,newAttr){
  	doc && doc._inc++;
  	var ns = newAttr.namespaceURI ;
  	if(ns == 'http://www.w3.org/2000/xmlns/'){
  		//update namespace
  		el._nsMap[newAttr.prefix?newAttr.localName:''] = newAttr.value
  	}
  }
  function _onRemoveAttribute(doc,el,newAttr,remove){
  	doc && doc._inc++;
  	var ns = newAttr.namespaceURI ;
  	if(ns == 'http://www.w3.org/2000/xmlns/'){
  		//update namespace
  		delete el._nsMap[newAttr.prefix?newAttr.localName:'']
  	}
  }
  function _onUpdateChild(doc,el,newChild){
  	if(doc && doc._inc){
  		doc._inc++;
  		//update childNodes
  		var cs = el.childNodes;
  		if(newChild){
  			cs[cs.length++] = newChild;
  		}else{
  			//console.log(1)
  			var child = el.firstChild;
  			var i = 0;
  			while(child){
  				cs[i++] = child;
  				child =child.nextSibling;
  			}
  			cs.length = i;
  		}
  	}
  }
  
  /**
   * attributes;
   * children;
   * 
   * writeable properties:
   * nodeValue,Attr:value,CharacterData:data
   * prefix
   */
  function _removeChild(parentNode,child){
  	var previous = child.previousSibling;
  	var next = child.nextSibling;
  	if(previous){
  		previous.nextSibling = next;
  	}else{
  		parentNode.firstChild = next
  	}
  	if(next){
  		next.previousSibling = previous;
  	}else{
  		parentNode.lastChild = previous;
  	}
  	_onUpdateChild(parentNode.ownerDocument,parentNode);
  	return child;
  }
  /**
   * preformance key(refChild == null)
   */
  function _insertBefore(parentNode,newChild,nextChild){
  	var cp = newChild.parentNode;
  	if(cp){
  		cp.removeChild(newChild);//remove and update
  	}
  	if(newChild.nodeType === DOCUMENT_FRAGMENT_NODE){
  		var newFirst = newChild.firstChild;
  		if (newFirst == null) {
  			return newChild;
  		}
  		var newLast = newChild.lastChild;
  	}else{
  		newFirst = newLast = newChild;
  	}
  	var pre = nextChild ? nextChild.previousSibling : parentNode.lastChild;
  
  	newFirst.previousSibling = pre;
  	newLast.nextSibling = nextChild;
  	
  	
  	if(pre){
  		pre.nextSibling = newFirst;
  	}else{
  		parentNode.firstChild = newFirst;
  	}
  	if(nextChild == null){
  		parentNode.lastChild = newLast;
  	}else{
  		nextChild.previousSibling = newLast;
  	}
  	do{
  		newFirst.parentNode = parentNode;
  	}while(newFirst !== newLast && (newFirst= newFirst.nextSibling))
  	_onUpdateChild(parentNode.ownerDocument||parentNode,parentNode);
  	//console.log(parentNode.lastChild.nextSibling == null)
  	if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
  		newChild.firstChild = newChild.lastChild = null;
  	}
  	return newChild;
  }
  function _appendSingleChild(parentNode,newChild){
  	var cp = newChild.parentNode;
  	if(cp){
  		var pre = parentNode.lastChild;
  		cp.removeChild(newChild);//remove and update
  		var pre = parentNode.lastChild;
  	}
  	var pre = parentNode.lastChild;
  	newChild.parentNode = parentNode;
  	newChild.previousSibling = pre;
  	newChild.nextSibling = null;
  	if(pre){
  		pre.nextSibling = newChild;
  	}else{
  		parentNode.firstChild = newChild;
  	}
  	parentNode.lastChild = newChild;
  	_onUpdateChild(parentNode.ownerDocument,parentNode,newChild);
  	return newChild;
  	//console.log("__aa",parentNode.lastChild.nextSibling == null)
  }
  Document.prototype = {
  	//implementation : null,
  	nodeName :  '#document',
  	nodeType :  DOCUMENT_NODE,
  	doctype :  null,
  	documentElement :  null,
  	_inc : 1,
  	
  	insertBefore :  function(newChild, refChild){//raises 
  		if(newChild.nodeType == DOCUMENT_FRAGMENT_NODE){
  			var child = newChild.firstChild;
  			while(child){
  				var next = child.nextSibling;
  				this.insertBefore(child,refChild);
  				child = next;
  			}
  			return newChild;
  		}
  		if(this.documentElement == null && newChild.nodeType == ELEMENT_NODE){
  			this.documentElement = newChild;
  		}
  		
  		return _insertBefore(this,newChild,refChild),(newChild.ownerDocument = this),newChild;
  	},
  	removeChild :  function(oldChild){
  		if(this.documentElement == oldChild){
  			this.documentElement = null;
  		}
  		return _removeChild(this,oldChild);
  	},
  	// Introduced in DOM Level 2:
  	importNode : function(importedNode,deep){
  		return importNode(this,importedNode,deep);
  	},
  	// Introduced in DOM Level 2:
  	getElementById :	function(id){
  		var rtv = null;
  		_visitNode(this.documentElement,function(node){
  			if(node.nodeType == ELEMENT_NODE){
  				if(node.getAttribute('id') == id){
  					rtv = node;
  					return true;
  				}
  			}
  		})
  		return rtv;
  	},
  	
  	getElementsByClassName: function(className) {
  		var pattern = new RegExp("(^|\\s)" + className + "(\\s|$)");
  		return new LiveNodeList(this, function(base) {
  			var ls = [];
  			_visitNode(base.documentElement, function(node) {
  				if(node !== base && node.nodeType == ELEMENT_NODE) {
  					if(pattern.test(node.getAttribute('class'))) {
  						ls.push(node);
  					}
  				}
  			});
  			return ls;
  		});
  	},
  	
  	//document factory method:
  	createElement :	function(tagName){
  		var node = new Element();
  		node.ownerDocument = this;
  		node.nodeName = tagName;
  		node.tagName = tagName;
  		node.childNodes = new NodeList();
  		var attrs	= node.attributes = new NamedNodeMap();
  		attrs._ownerElement = node;
  		return node;
  	},
  	createDocumentFragment :	function(){
  		var node = new DocumentFragment();
  		node.ownerDocument = this;
  		node.childNodes = new NodeList();
  		return node;
  	},
  	createTextNode :	function(data){
  		var node = new Text();
  		node.ownerDocument = this;
  		node.appendData(data)
  		return node;
  	},
  	createComment :	function(data){
  		var node = new Comment();
  		node.ownerDocument = this;
  		node.appendData(data)
  		return node;
  	},
  	createCDATASection :	function(data){
  		var node = new CDATASection();
  		node.ownerDocument = this;
  		node.appendData(data)
  		return node;
  	},
  	createProcessingInstruction :	function(target,data){
  		var node = new ProcessingInstruction();
  		node.ownerDocument = this;
  		node.tagName = node.target = target;
  		node.nodeValue= node.data = data;
  		return node;
  	},
  	createAttribute :	function(name){
  		var node = new Attr();
  		node.ownerDocument	= this;
  		node.name = name;
  		node.nodeName	= name;
  		node.localName = name;
  		node.specified = true;
  		return node;
  	},
  	createEntityReference :	function(name){
  		var node = new EntityReference();
  		node.ownerDocument	= this;
  		node.nodeName	= name;
  		return node;
  	},
  	// Introduced in DOM Level 2:
  	createElementNS :	function(namespaceURI,qualifiedName){
  		var node = new Element();
  		var pl = qualifiedName.split(':');
  		var attrs	= node.attributes = new NamedNodeMap();
  		node.childNodes = new NodeList();
  		node.ownerDocument = this;
  		node.nodeName = qualifiedName;
  		node.tagName = qualifiedName;
  		node.namespaceURI = namespaceURI;
  		if(pl.length == 2){
  			node.prefix = pl[0];
  			node.localName = pl[1];
  		}else{
  			//el.prefix = null;
  			node.localName = qualifiedName;
  		}
  		attrs._ownerElement = node;
  		return node;
  	},
  	// Introduced in DOM Level 2:
  	createAttributeNS :	function(namespaceURI,qualifiedName){
  		var node = new Attr();
  		var pl = qualifiedName.split(':');
  		node.ownerDocument = this;
  		node.nodeName = qualifiedName;
  		node.name = qualifiedName;
  		node.namespaceURI = namespaceURI;
  		node.specified = true;
  		if(pl.length == 2){
  			node.prefix = pl[0];
  			node.localName = pl[1];
  		}else{
  			//el.prefix = null;
  			node.localName = qualifiedName;
  		}
  		return node;
  	}
  };
  _extends(Document,Node);
  
  
  function Element() {
  	this._nsMap = {};
  };
  Element.prototype = {
  	nodeType : ELEMENT_NODE,
  	hasAttribute : function(name){
  		return this.getAttributeNode(name)!=null;
  	},
  	getAttribute : function(name){
  		var attr = this.getAttributeNode(name);
  		return attr && attr.value || '';
  	},
  	getAttributeNode : function(name){
  		return this.attributes.getNamedItem(name);
  	},
  	setAttribute : function(name, value){
  		var attr = this.ownerDocument.createAttribute(name);
  		attr.value = attr.nodeValue = "" + value;
  		this.setAttributeNode(attr)
  	},
  	removeAttribute : function(name){
  		var attr = this.getAttributeNode(name)
  		attr && this.removeAttributeNode(attr);
  	},
  	
  	//four real opeartion method
  	appendChild:function(newChild){
  		if(newChild.nodeType === DOCUMENT_FRAGMENT_NODE){
  			return this.insertBefore(newChild,null);
  		}else{
  			return _appendSingleChild(this,newChild);
  		}
  	},
  	setAttributeNode : function(newAttr){
  		return this.attributes.setNamedItem(newAttr);
  	},
  	setAttributeNodeNS : function(newAttr){
  		return this.attributes.setNamedItemNS(newAttr);
  	},
  	removeAttributeNode : function(oldAttr){
  		//console.log(this == oldAttr.ownerElement)
  		return this.attributes.removeNamedItem(oldAttr.nodeName);
  	},
  	//get real attribute name,and remove it by removeAttributeNode
  	removeAttributeNS : function(namespaceURI, localName){
  		var old = this.getAttributeNodeNS(namespaceURI, localName);
  		old && this.removeAttributeNode(old);
  	},
  	
  	hasAttributeNS : function(namespaceURI, localName){
  		return this.getAttributeNodeNS(namespaceURI, localName)!=null;
  	},
  	getAttributeNS : function(namespaceURI, localName){
  		var attr = this.getAttributeNodeNS(namespaceURI, localName);
  		return attr && attr.value || '';
  	},
  	setAttributeNS : function(namespaceURI, qualifiedName, value){
  		var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
  		attr.value = attr.nodeValue = "" + value;
  		this.setAttributeNode(attr)
  	},
  	getAttributeNodeNS : function(namespaceURI, localName){
  		return this.attributes.getNamedItemNS(namespaceURI, localName);
  	},
  	
  	getElementsByTagName : function(tagName){
  		return new LiveNodeList(this,function(base){
  			var ls = [];
  			_visitNode(base,function(node){
  				if(node !== base && node.nodeType == ELEMENT_NODE && (tagName === '*' || node.tagName == tagName)){
  					ls.push(node);
  				}
  			});
  			return ls;
  		});
  	},
  	getElementsByTagNameNS : function(namespaceURI, localName){
  		return new LiveNodeList(this,function(base){
  			var ls = [];
  			_visitNode(base,function(node){
  				if(node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === '*' || node.namespaceURI === namespaceURI) && (localName === '*' || node.localName == localName)){
  					ls.push(node);
  				}
  			});
  			return ls;
  			
  		});
  	}
  };
  Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;
  Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
  
  
  _extends(Element,Node);
  function Attr() {
  };
  Attr.prototype.nodeType = ATTRIBUTE_NODE;
  _extends(Attr,Node);
  
  
  function CharacterData() {
  };
  CharacterData.prototype = {
  	data : '',
  	substringData : function(offset, count) {
  		return this.data.substring(offset, offset+count);
  	},
  	appendData: function(text) {
  		text = this.data+text;
  		this.nodeValue = this.data = text;
  		this.length = text.length;
  	},
  	insertData: function(offset,text) {
  		this.replaceData(offset,0,text);
  	
  	},
  	appendChild:function(newChild){
  		throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR])
  	},
  	deleteData: function(offset, count) {
  		this.replaceData(offset,count,"");
  	},
  	replaceData: function(offset, count, text) {
  		var start = this.data.substring(0,offset);
  		var end = this.data.substring(offset+count);
  		text = start + text + end;
  		this.nodeValue = this.data = text;
  		this.length = text.length;
  	}
  }
  _extends(CharacterData,Node);
  function Text() {
  };
  Text.prototype = {
  	nodeName : "#text",
  	nodeType : TEXT_NODE,
  	splitText : function(offset) {
  		var text = this.data;
  		var newText = text.substring(offset);
  		text = text.substring(0, offset);
  		this.data = this.nodeValue = text;
  		this.length = text.length;
  		var newNode = this.ownerDocument.createTextNode(newText);
  		if(this.parentNode){
  			this.parentNode.insertBefore(newNode, this.nextSibling);
  		}
  		return newNode;
  	}
  }
  _extends(Text,CharacterData);
  function Comment() {
  };
  Comment.prototype = {
  	nodeName : "#comment",
  	nodeType : COMMENT_NODE
  }
  _extends(Comment,CharacterData);
  
  function CDATASection() {
  };
  CDATASection.prototype = {
  	nodeName : "#cdata-section",
  	nodeType : CDATA_SECTION_NODE
  }
  _extends(CDATASection,CharacterData);
  
  
  function DocumentType() {
  };
  DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
  _extends(DocumentType,Node);
  
  function Notation() {
  };
  Notation.prototype.nodeType = NOTATION_NODE;
  _extends(Notation,Node);
  
  function Entity() {
  };
  Entity.prototype.nodeType = ENTITY_NODE;
  _extends(Entity,Node);
  
  function EntityReference() {
  };
  EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
  _extends(EntityReference,Node);
  
  function DocumentFragment() {
  };
  DocumentFragment.prototype.nodeName =	"#document-fragment";
  DocumentFragment.prototype.nodeType =	DOCUMENT_FRAGMENT_NODE;
  _extends(DocumentFragment,Node);
  
  
  function ProcessingInstruction() {
  }
  ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
  _extends(ProcessingInstruction,Node);
  function XMLSerializer(){}
  XMLSerializer.prototype.serializeToString = function(node,isHtml,nodeFilter){
  	return nodeSerializeToString.call(node,isHtml,nodeFilter);
  }
  Node.prototype.toString = nodeSerializeToString;
  function nodeSerializeToString(isHtml,nodeFilter){
  	var buf = [];
  	var refNode = this.nodeType == 9 && this.documentElement || this;
  	var prefix = refNode.prefix;
  	var uri = refNode.namespaceURI;
  	
  	if(uri && prefix == null){
  		//console.log(prefix)
  		var prefix = refNode.lookupPrefix(uri);
  		if(prefix == null){
  			//isHTML = true;
  			var visibleNamespaces=[
  			{namespace:uri,prefix:null}
  			//{namespace:uri,prefix:''}
  			]
  		}
  	}
  	serializeToString(this,buf,isHtml,nodeFilter,visibleNamespaces);
  	//console.log('###',this.nodeType,uri,prefix,buf.join(''))
  	return buf.join('');
  }
  function needNamespaceDefine(node,isHTML, visibleNamespaces) {
  	var prefix = node.prefix||'';
  	var uri = node.namespaceURI;
  	if (!prefix && !uri){
  		return false;
  	}
  	if (prefix === "xml" && uri === "http://www.w3.org/XML/1998/namespace" 
  		|| uri == 'http://www.w3.org/2000/xmlns/'){
  		return false;
  	}
  	
  	var i = visibleNamespaces.length 
  	//console.log('@@@@',node.tagName,prefix,uri,visibleNamespaces)
  	while (i--) {
  		var ns = visibleNamespaces[i];
  		// get namespace prefix
  		//console.log(node.nodeType,node.tagName,ns.prefix,prefix)
  		if (ns.prefix == prefix){
  			return ns.namespace != uri;
  		}
  	}
  	//console.log(isHTML,uri,prefix=='')
  	//if(isHTML && prefix ==null && uri == 'http://www.w3.org/1999/xhtml'){
  	//	return false;
  	//}
  	//node.flag = '11111'
  	//console.error(3,true,node.flag,node.prefix,node.namespaceURI)
  	return true;
  }
  function serializeToString(node,buf,isHTML,nodeFilter,visibleNamespaces){
  	if(nodeFilter){
  		node = nodeFilter(node);
  		if(node){
  			if(typeof node == 'string'){
  				buf.push(node);
  				return;
  			}
  		}else{
  			return;
  		}
  		//buf.sort.apply(attrs, attributeSorter);
  	}
  	switch(node.nodeType){
  	case ELEMENT_NODE:
  		if (!visibleNamespaces) visibleNamespaces = [];
  		var startVisibleNamespaces = visibleNamespaces.length;
  		var attrs = node.attributes;
  		var len = attrs.length;
  		var child = node.firstChild;
  		var nodeName = node.tagName;
  		
  		isHTML =  (htmlns === node.namespaceURI) ||isHTML 
  		buf.push('<',nodeName);
  		
  		
  		
  		for(var i=0;i<len;i++){
  			// add namespaces for attributes
  			var attr = attrs.item(i);
  			if (attr.prefix == 'xmlns') {
  				visibleNamespaces.push({ prefix: attr.localName, namespace: attr.value });
  			}else if(attr.nodeName == 'xmlns'){
  				visibleNamespaces.push({ prefix: '', namespace: attr.value });
  			}
  		}
  		for(var i=0;i<len;i++){
  			var attr = attrs.item(i);
  			if (needNamespaceDefine(attr,isHTML, visibleNamespaces)) {
  				var prefix = attr.prefix||'';
  				var uri = attr.namespaceURI;
  				var ns = prefix ? ' xmlns:' + prefix : " xmlns";
  				buf.push(ns, '="' , uri , '"');
  				visibleNamespaces.push({ prefix: prefix, namespace:uri });
  			}
  			serializeToString(attr,buf,isHTML,nodeFilter,visibleNamespaces);
  		}
  		// add namespace for current node		
  		if (needNamespaceDefine(node,isHTML, visibleNamespaces)) {
  			var prefix = node.prefix||'';
  			var uri = node.namespaceURI;
  			var ns = prefix ? ' xmlns:' + prefix : " xmlns";
  			buf.push(ns, '="' , uri , '"');
  			visibleNamespaces.push({ prefix: prefix, namespace:uri });
  		}
  		
  		if(child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)){
  			buf.push('>');
  			//if is cdata child node
  			if(isHTML && /^script$/i.test(nodeName)){
  				while(child){
  					if(child.data){
  						buf.push(child.data);
  					}else{
  						serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
  					}
  					child = child.nextSibling;
  				}
  			}else
  			{
  				while(child){
  					serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
  					child = child.nextSibling;
  				}
  			}
  			buf.push('</',nodeName,'>');
  		}else{
  			buf.push('/>');
  		}
  		// remove added visible namespaces
  		//visibleNamespaces.length = startVisibleNamespaces;
  		return;
  	case DOCUMENT_NODE:
  	case DOCUMENT_FRAGMENT_NODE:
  		var child = node.firstChild;
  		while(child){
  			serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
  			child = child.nextSibling;
  		}
  		return;
  	case ATTRIBUTE_NODE:
  		return buf.push(' ',node.name,'="',node.value.replace(/[&"]/g,_xmlEncoder),'"');
  	case TEXT_NODE:
  		/**
  		 * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,
  		 * except when used as markup delimiters, or within a comment, a processing instruction, or a CDATA section.
  		 * If they are needed elsewhere, they must be escaped using either numeric character references or the strings
  		 * `&amp;` and `&lt;` respectively.
  		 * The right angle bracket (>) may be represented using the string " &gt; ", and must, for compatibility,
  		 * be escaped using either `&gt;` or a character reference when it appears in the string `]]>` in content,
  		 * when that string is not marking the end of a CDATA section.
  		 *
  		 * In the content of elements, character data is any string of characters
  		 * which does not contain the start-delimiter of any markup
  		 * and does not include the CDATA-section-close delimiter, `]]>`.
  		 *
  		 * @see https://www.w3.org/TR/xml/#NT-CharData
  		 */
  		return buf.push(node.data
  			.replace(/[<&]/g,_xmlEncoder)
  			.replace(/]]>/g, ']]&gt;')
  		);
  	case CDATA_SECTION_NODE:
  		return buf.push( '<![CDATA[',node.data,']]>');
  	case COMMENT_NODE:
  		return buf.push( "<!--",node.data,"-->");
  	case DOCUMENT_TYPE_NODE:
  		var pubid = node.publicId;
  		var sysid = node.systemId;
  		buf.push('<!DOCTYPE ',node.name);
  		if(pubid){
  			buf.push(' PUBLIC ', pubid);
  			if (sysid && sysid!='.') {
  				buf.push(' ', sysid);
  			}
  			buf.push('>');
  		}else if(sysid && sysid!='.'){
  			buf.push(' SYSTEM ', sysid, '>');
  		}else{
  			var sub = node.internalSubset;
  			if(sub){
  				buf.push(" [",sub,"]");
  			}
  			buf.push(">");
  		}
  		return;
  	case PROCESSING_INSTRUCTION_NODE:
  		return buf.push( "<?",node.target," ",node.data,"?>");
  	case ENTITY_REFERENCE_NODE:
  		return buf.push( '&',node.nodeName,';');
  	//case ENTITY_NODE:
  	//case NOTATION_NODE:
  	default:
  		buf.push('??',node.nodeName);
  	}
  }
  function importNode(doc,node,deep){
  	var node2;
  	switch (node.nodeType) {
  	case ELEMENT_NODE:
  		node2 = node.cloneNode(false);
  		node2.ownerDocument = doc;
  		//var attrs = node2.attributes;
  		//var len = attrs.length;
  		//for(var i=0;i<len;i++){
  			//node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
  		//}
  	case DOCUMENT_FRAGMENT_NODE:
  		break;
  	case ATTRIBUTE_NODE:
  		deep = true;
  		break;
  	//case ENTITY_REFERENCE_NODE:
  	//case PROCESSING_INSTRUCTION_NODE:
  	////case TEXT_NODE:
  	//case CDATA_SECTION_NODE:
  	//case COMMENT_NODE:
  	//	deep = false;
  	//	break;
  	//case DOCUMENT_NODE:
  	//case DOCUMENT_TYPE_NODE:
  	//cannot be imported.
  	//case ENTITY_NODE:
  	//case NOTATION_NODE：
  	//can not hit in level3
  	//default:throw e;
  	}
  	if(!node2){
  		node2 = node.cloneNode(false);//false
  	}
  	node2.ownerDocument = doc;
  	node2.parentNode = null;
  	if(deep){
  		var child = node.firstChild;
  		while(child){
  			node2.appendChild(importNode(doc,child,deep));
  			child = child.nextSibling;
  		}
  	}
  	return node2;
  }
  //
  //var _relationMap = {firstChild:1,lastChild:1,previousSibling:1,nextSibling:1,
  //					attributes:1,childNodes:1,parentNode:1,documentElement:1,doctype,};
  function cloneNode(doc,node,deep){
  	var node2 = new node.constructor();
  	for(var n in node){
  		var v = node[n];
  		if(typeof v != 'object' ){
  			if(v != node2[n]){
  				node2[n] = v;
  			}
  		}
  	}
  	if(node.childNodes){
  		node2.childNodes = new NodeList();
  	}
  	node2.ownerDocument = doc;
  	switch (node2.nodeType) {
  	case ELEMENT_NODE:
  		var attrs	= node.attributes;
  		var attrs2	= node2.attributes = new NamedNodeMap();
  		var len = attrs.length
  		attrs2._ownerElement = node2;
  		for(var i=0;i<len;i++){
  			node2.setAttributeNode(cloneNode(doc,attrs.item(i),true));
  		}
  		break;;
  	case ATTRIBUTE_NODE:
  		deep = true;
  	}
  	if(deep){
  		var child = node.firstChild;
  		while(child){
  			node2.appendChild(cloneNode(doc,child,deep));
  			child = child.nextSibling;
  		}
  	}
  	return node2;
  }
  
  function __set__(object,key,value){
  	object[key] = value
  }
  //do dynamic
  try{
  	if(Object.defineProperty){
  		Object.defineProperty(LiveNodeList.prototype,'length',{
  			get:function(){
  				_updateLiveList(this);
  				return this.$$length;
  			}
  		});
  		Object.defineProperty(Node.prototype,'textContent',{
  			get:function(){
  				return getTextContent(this);
  			},
  			set:function(data){
  				switch(this.nodeType){
  				case ELEMENT_NODE:
  				case DOCUMENT_FRAGMENT_NODE:
  					while(this.firstChild){
  						this.removeChild(this.firstChild);
  					}
  					if(data || String(data)){
  						this.appendChild(this.ownerDocument.createTextNode(data));
  					}
  					break;
  				default:
  					//TODO:
  					this.data = data;
  					this.value = data;
  					this.nodeValue = data;
  				}
  			}
  		})
  		
  		function getTextContent(node){
  			switch(node.nodeType){
  			case ELEMENT_NODE:
  			case DOCUMENT_FRAGMENT_NODE:
  				var buf = [];
  				node = node.firstChild;
  				while(node){
  					if(node.nodeType!==7 && node.nodeType !==8){
  						buf.push(getTextContent(node));
  					}
  					node = node.nextSibling;
  				}
  				return buf.join('');
  			default:
  				return node.nodeValue;
  			}
  		}
  		__set__ = function(object,key,value){
  			//console.log(value)
  			object['$$'+key] = value
  		}
  	}
  }catch(e){//ie8
  }
  
  //if(typeof require == 'function'){
  	exports.Node = Node;
  	exports.DOMException = DOMException;
  	exports.DOMImplementation = DOMImplementation;
  	exports.XMLSerializer = XMLSerializer;
  //}
  
  
  /***/ }),
  
  /***/ 470:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0;
  const command_1 = __webpack_require__(431);
  const file_command_1 = __webpack_require__(102);
  const utils_1 = __webpack_require__(82);
  const os = __importStar(__webpack_require__(87));
  const path = __importStar(__webpack_require__(622));
  /**
   * The code to exit an action
   */
  var ExitCode;
  (function (ExitCode) {
      /**
       * A code indicating that the action was successful
       */
      ExitCode[ExitCode["Success"] = 0] = "Success";
      /**
       * A code indicating that the action was a failure
       */
      ExitCode[ExitCode["Failure"] = 1] = "Failure";
  })(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
  //-----------------------------------------------------------------------
  // Variables
  //-----------------------------------------------------------------------
  /**
   * Sets env variable for this action and future actions in the job
   * @param name the name of the variable to set
   * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function exportVariable(name, val) {
      const convertedVal = utils_1.toCommandValue(val);
      process.env[name] = convertedVal;
      const filePath = process.env['GITHUB_ENV'] || '';
      if (filePath) {
          const delimiter = '_GitHubActionsFileCommandDelimeter_';
          const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`;
          file_command_1.issueCommand('ENV', commandValue);
      }
      else {
          command_1.issueCommand('set-env', { name }, convertedVal);
      }
  }
  exports.exportVariable = exportVariable;
  /**
   * Registers a secret which will get masked from logs
   * @param secret value of the secret
   */
  function setSecret(secret) {
      command_1.issueCommand('add-mask', {}, secret);
  }
  exports.setSecret = setSecret;
  /**
   * Prepends inputPath to the PATH (for this action and future actions)
   * @param inputPath
   */
  function addPath(inputPath) {
      const filePath = process.env['GITHUB_PATH'] || '';
      if (filePath) {
          file_command_1.issueCommand('PATH', inputPath);
      }
      else {
          command_1.issueCommand('add-path', {}, inputPath);
      }
      process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
  }
  exports.addPath = addPath;
  /**
   * Gets the value of an input.
   * Unless trimWhitespace is set to false in InputOptions, the value is also trimmed.
   * Returns an empty string if the value is not defined.
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   string
   */
  function getInput(name, options) {
      const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
      if (options && options.required && !val) {
          throw new Error(`Input required and not supplied: ${name}`);
      }
      if (options && options.trimWhitespace === false) {
          return val;
      }
      return val.trim();
  }
  exports.getInput = getInput;
  /**
   * Gets the input value of the boolean type in the YAML 1.2 "core schema" specification.
   * Support boolean input list: `true | True | TRUE | false | False | FALSE` .
   * The return value is also in boolean type.
   * ref: https://yaml.org/spec/1.2/spec.html#id2804923
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   boolean
   */
  function getBooleanInput(name, options) {
      const trueValue = ['true', 'True', 'TRUE'];
      const falseValue = ['false', 'False', 'FALSE'];
      const val = getInput(name, options);
      if (trueValue.includes(val))
          return true;
      if (falseValue.includes(val))
          return false;
      throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` +
          `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``);
  }
  exports.getBooleanInput = getBooleanInput;
  /**
   * Sets the value of an output.
   *
   * @param     name     name of the output to set
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function setOutput(name, value) {
      process.stdout.write(os.EOL);
      command_1.issueCommand('set-output', { name }, value);
  }
  exports.setOutput = setOutput;
  /**
   * Enables or disables the echoing of commands into stdout for the rest of the step.
   * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
   *
   */
  function setCommandEcho(enabled) {
      command_1.issue('echo', enabled ? 'on' : 'off');
  }
  exports.setCommandEcho = setCommandEcho;
  //-----------------------------------------------------------------------
  // Results
  //-----------------------------------------------------------------------
  /**
   * Sets the action status to failed.
   * When the action exits it will be with an exit code of 1
   * @param message add error issue message
   */
  function setFailed(message) {
      process.exitCode = ExitCode.Failure;
      error(message);
  }
  exports.setFailed = setFailed;
  //-----------------------------------------------------------------------
  // Logging Commands
  //-----------------------------------------------------------------------
  /**
   * Gets whether Actions Step Debug is on or not
   */
  function isDebug() {
      return process.env['RUNNER_DEBUG'] === '1';
  }
  exports.isDebug = isDebug;
  /**
   * Writes debug message to user log
   * @param message debug message
   */
  function debug(message) {
      command_1.issueCommand('debug', {}, message);
  }
  exports.debug = debug;
  /**
   * Adds an error issue
   * @param message error issue message. Errors will be converted to string via toString()
   */
  function error(message) {
      command_1.issue('error', message instanceof Error ? message.toString() : message);
  }
  exports.error = error;
  /**
   * Adds an warning issue
   * @param message warning issue message. Errors will be converted to string via toString()
   */
  function warning(message) {
      command_1.issue('warning', message instanceof Error ? message.toString() : message);
  }
  exports.warning = warning;
  /**
   * Writes info to log with console.log.
   * @param message info message
   */
  function info(message) {
      process.stdout.write(message + os.EOL);
  }
  exports.info = info;
  /**
   * Begin an output group.
   *
   * Output until the next `groupEnd` will be foldable in this group
   *
   * @param name The name of the output group
   */
  function startGroup(name) {
      command_1.issue('group', name);
  }
  exports.startGroup = startGroup;
  /**
   * End an output group.
   */
  function endGroup() {
      command_1.issue('endgroup');
  }
  exports.endGroup = endGroup;
  /**
   * Wrap an asynchronous function call in a group.
   *
   * Returns the same type as the function itself.
   *
   * @param name The name of the group
   * @param fn The function to wrap in the group
   */
  function group(name, fn) {
      return __awaiter(this, void 0, void 0, function* () {
          startGroup(name);
          let result;
          try {
              result = yield fn();
          }
          finally {
              endGroup();
          }
          return result;
      });
  }
  exports.group = group;
  //-----------------------------------------------------------------------
  // Wrapper action state
  //-----------------------------------------------------------------------
  /**
   * Saves state for current action, the state can only be retrieved by this action's post job execution.
   *
   * @param     name     name of the state to store
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function saveState(name, value) {
      command_1.issueCommand('save-state', { name }, value);
  }
  exports.saveState = saveState;
  /**
   * Gets the value of an state set by this action's main execution.
   *
   * @param     name     name of the state to get
   * @returns   string
   */
  function getState(name) {
      return process.env[`STATE_${name}`] || '';
  }
  exports.getState = getState;
  //# sourceMappingURL=core.js.map
  
  /***/ }),
  
  /***/ 503:
  /***/ (function(__unusedmodule, exports) {
  
  //[4]   	NameStartChar	   ::=   	":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
  //[4a]   	NameChar	   ::=   	NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
  //[5]   	Name	   ::=   	NameStartChar (NameChar)*
  var nameStartChar = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]///\u10000-\uEFFFF
  var nameChar = new RegExp("[\\-\\.0-9"+nameStartChar.source.slice(1,-1)+"\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
  var tagNamePattern = new RegExp('^'+nameStartChar.source+nameChar.source+'*(?:\:'+nameStartChar.source+nameChar.source+'*)?$');
  //var tagNamePattern = /^[a-zA-Z_][\w\-\.]*(?:\:[a-zA-Z_][\w\-\.]*)?$/
  //var handlers = 'resolveEntity,getExternalSubset,characters,endDocument,endElement,endPrefixMapping,ignorableWhitespace,processingInstruction,setDocumentLocator,skippedEntity,startDocument,startElement,startPrefixMapping,notationDecl,unparsedEntityDecl,error,fatalError,warning,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,comment,endCDATA,endDTD,endEntity,startCDATA,startDTD,startEntity'.split(',')
  
  //S_TAG,	S_ATTR,	S_EQ,	S_ATTR_NOQUOT_VALUE
  //S_ATTR_SPACE,	S_ATTR_END,	S_TAG_SPACE, S_TAG_CLOSE
  var S_TAG = 0;//tag name offerring
  var S_ATTR = 1;//attr name offerring 
  var S_ATTR_SPACE=2;//attr name end and space offer
  var S_EQ = 3;//=space?
  var S_ATTR_NOQUOT_VALUE = 4;//attr value(no quot value only)
  var S_ATTR_END = 5;//attr value end and no space(quot end)
  var S_TAG_SPACE = 6;//(attr value end || tag end ) && (space offer)
  var S_TAG_CLOSE = 7;//closed el<el />
  
  /**
   * Creates an error that will not be caught by XMLReader aka the SAX parser.
   *
   * @param {string} message
   * @param {any?} locator Optional, can provide details about the location in the source
   * @constructor
   */
  function ParseError(message, locator) {
  	this.message = message
  	this.locator = locator
  	if(Error.captureStackTrace) Error.captureStackTrace(this, ParseError);
  }
  ParseError.prototype = new Error();
  ParseError.prototype.name = ParseError.name
  
  function XMLReader(){
  	
  }
  
  XMLReader.prototype = {
  	parse:function(source,defaultNSMap,entityMap){
  		var domBuilder = this.domBuilder;
  		domBuilder.startDocument();
  		_copy(defaultNSMap ,defaultNSMap = {})
  		parse(source,defaultNSMap,entityMap,
  				domBuilder,this.errorHandler);
  		domBuilder.endDocument();
  	}
  }
  function parse(source,defaultNSMapCopy,entityMap,domBuilder,errorHandler){
  	function fixedFromCharCode(code) {
  		// String.prototype.fromCharCode does not supports
  		// > 2 bytes unicode chars directly
  		if (code > 0xffff) {
  			code -= 0x10000;
  			var surrogate1 = 0xd800 + (code >> 10)
  				, surrogate2 = 0xdc00 + (code & 0x3ff);
  
  			return String.fromCharCode(surrogate1, surrogate2);
  		} else {
  			return String.fromCharCode(code);
  		}
  	}
  	function entityReplacer(a){
  		var k = a.slice(1,-1);
  		if(k in entityMap){
  			return entityMap[k]; 
  		}else if(k.charAt(0) === '#'){
  			return fixedFromCharCode(parseInt(k.substr(1).replace('x','0x')))
  		}else{
  			errorHandler.error('entity not found:'+a);
  			return a;
  		}
  	}
  	function appendText(end){//has some bugs
  		if(end>start){
  			var xt = source.substring(start,end).replace(/&#?\w+;/g,entityReplacer);
  			locator&&position(start);
  			domBuilder.characters(xt,0,end-start);
  			start = end
  		}
  	}
  	function position(p,m){
  		while(p>=lineEnd && (m = linePattern.exec(source))){
  			lineStart = m.index;
  			lineEnd = lineStart + m[0].length;
  			locator.lineNumber++;
  			//console.log('line++:',locator,startPos,endPos)
  		}
  		locator.columnNumber = p-lineStart+1;
  	}
  	var lineStart = 0;
  	var lineEnd = 0;
  	var linePattern = /.*(?:\r\n?|\n)|.*$/g
  	var locator = domBuilder.locator;
  	
  	var parseStack = [{currentNSMap:defaultNSMapCopy}]
  	var closeMap = {};
  	var start = 0;
  	while(true){
  		try{
  			var tagStart = source.indexOf('<',start);
  			if(tagStart<0){
  				if(!source.substr(start).match(/^\s*$/)){
  					var doc = domBuilder.doc;
  	    			var text = doc.createTextNode(source.substr(start));
  	    			doc.appendChild(text);
  	    			domBuilder.currentElement = text;
  				}
  				return;
  			}
  			if(tagStart>start){
  				appendText(tagStart);
  			}
  			switch(source.charAt(tagStart+1)){
  			case '/':
  				var end = source.indexOf('>',tagStart+3);
  				var tagName = source.substring(tagStart+2,end);
  				var config = parseStack.pop();
  				if(end<0){
  					
  	        		tagName = source.substring(tagStart+2).replace(/[\s<].*/,'');
  	        		//console.error('#@@@@@@'+tagName)
  	        		errorHandler.error("end tag name: "+tagName+' is not complete:'+config.tagName);
  	        		end = tagStart+1+tagName.length;
  	        	}else if(tagName.match(/\s</)){
  	        		tagName = tagName.replace(/[\s<].*/,'');
  	        		errorHandler.error("end tag name: "+tagName+' maybe not complete');
  	        		end = tagStart+1+tagName.length;
  				}
  				//console.error(parseStack.length,parseStack)
  				//console.error(config);
  				var localNSMap = config.localNSMap;
  				var endMatch = config.tagName == tagName;
  				var endIgnoreCaseMach = endMatch || config.tagName&&config.tagName.toLowerCase() == tagName.toLowerCase()
  		        if(endIgnoreCaseMach){
  		        	domBuilder.endElement(config.uri,config.localName,tagName);
  					if(localNSMap){
  						for(var prefix in localNSMap){
  							domBuilder.endPrefixMapping(prefix) ;
  						}
  					}
  					if(!endMatch){
  		            	errorHandler.fatalError("end tag name: "+tagName+' is not match the current start tagName:'+config.tagName ); // No known test case
  					}
  		        }else{
  		        	parseStack.push(config)
  		        }
  				
  				end++;
  				break;
  				// end elment
  			case '?':// <?...?>
  				locator&&position(tagStart);
  				end = parseInstruction(source,tagStart,domBuilder);
  				break;
  			case '!':// <!doctype,<![CDATA,<!--
  				locator&&position(tagStart);
  				end = parseDCC(source,tagStart,domBuilder,errorHandler);
  				break;
  			default:
  				locator&&position(tagStart);
  				var el = new ElementAttributes();
  				var currentNSMap = parseStack[parseStack.length-1].currentNSMap;
  				//elStartEnd
  				var end = parseElementStartPart(source,tagStart,el,currentNSMap,entityReplacer,errorHandler);
  				var len = el.length;
  				
  				
  				if(!el.closed && fixSelfClosed(source,end,el.tagName,closeMap)){
  					el.closed = true;
  					if(!entityMap.nbsp){
  						errorHandler.warning('unclosed xml attribute');
  					}
  				}
  				if(locator && len){
  					var locator2 = copyLocator(locator,{});
  					//try{//attribute position fixed
  					for(var i = 0;i<len;i++){
  						var a = el[i];
  						position(a.offset);
  						a.locator = copyLocator(locator,{});
  					}
  					//}catch(e){console.error('@@@@@'+e)}
  					domBuilder.locator = locator2
  					if(appendElement(el,domBuilder,currentNSMap)){
  						parseStack.push(el)
  					}
  					domBuilder.locator = locator;
  				}else{
  					if(appendElement(el,domBuilder,currentNSMap)){
  						parseStack.push(el)
  					}
  				}
  				
  				
  				
  				if(el.uri === 'http://www.w3.org/1999/xhtml' && !el.closed){
  					end = parseHtmlSpecialContent(source,end,el.tagName,entityReplacer,domBuilder)
  				}else{
  					end++;
  				}
  			}
  		}catch(e){
  			if (e instanceof ParseError) {
  				throw e;
  			}
  			errorHandler.error('element parse error: '+e)
  			end = -1;
  		}
  		if(end>start){
  			start = end;
  		}else{
  			//TODO: 这里有可能sax回退，有位置错误风险
  			appendText(Math.max(tagStart,start)+1);
  		}
  	}
  }
  function copyLocator(f,t){
  	t.lineNumber = f.lineNumber;
  	t.columnNumber = f.columnNumber;
  	return t;
  }
  
  /**
   * @see #appendElement(source,elStartEnd,el,selfClosed,entityReplacer,domBuilder,parseStack);
   * @return end of the elementStartPart(end of elementEndPart for selfClosed el)
   */
  function parseElementStartPart(source,start,el,currentNSMap,entityReplacer,errorHandler){
  
  	/**
  	 * @param {string} qname
  	 * @param {string} value
  	 * @param {number} startIndex
  	 */
  	function addAttribute(qname, value, startIndex) {
  		if (qname in el.attributeNames) errorHandler.fatalError('Attribute ' + qname + ' redefined')
  		el.addValue(qname, value, startIndex)
  	}
  	var attrName;
  	var value;
  	var p = ++start;
  	var s = S_TAG;//status
  	while(true){
  		var c = source.charAt(p);
  		switch(c){
  		case '=':
  			if(s === S_ATTR){//attrName
  				attrName = source.slice(start,p);
  				s = S_EQ;
  			}else if(s === S_ATTR_SPACE){
  				s = S_EQ;
  			}else{
  				//fatalError: equal must after attrName or space after attrName
  				throw new Error('attribute equal must after attrName'); // No known test case
  			}
  			break;
  		case '\'':
  		case '"':
  			if(s === S_EQ || s === S_ATTR //|| s == S_ATTR_SPACE
  				){//equal
  				if(s === S_ATTR){
  					errorHandler.warning('attribute value must after "="')
  					attrName = source.slice(start,p)
  				}
  				start = p+1;
  				p = source.indexOf(c,start)
  				if(p>0){
  					value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
  					addAttribute(attrName, value, start-1);
  					s = S_ATTR_END;
  				}else{
  					//fatalError: no end quot match
  					throw new Error('attribute value no end \''+c+'\' match');
  				}
  			}else if(s == S_ATTR_NOQUOT_VALUE){
  				value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
  				//console.log(attrName,value,start,p)
  				addAttribute(attrName, value, start);
  				//console.dir(el)
  				errorHandler.warning('attribute "'+attrName+'" missed start quot('+c+')!!');
  				start = p+1;
  				s = S_ATTR_END
  			}else{
  				//fatalError: no equal before
  				throw new Error('attribute value must after "="'); // No known test case
  			}
  			break;
  		case '/':
  			switch(s){
  			case S_TAG:
  				el.setTagName(source.slice(start,p));
  			case S_ATTR_END:
  			case S_TAG_SPACE:
  			case S_TAG_CLOSE:
  				s =S_TAG_CLOSE;
  				el.closed = true;
  			case S_ATTR_NOQUOT_VALUE:
  			case S_ATTR:
  			case S_ATTR_SPACE:
  				break;
  			//case S_EQ:
  			default:
  				throw new Error("attribute invalid close char('/')") // No known test case
  			}
  			break;
  		case ''://end document
  			errorHandler.error('unexpected end of input');
  			if(s == S_TAG){
  				el.setTagName(source.slice(start,p));
  			}
  			return p;
  		case '>':
  			switch(s){
  			case S_TAG:
  				el.setTagName(source.slice(start,p));
  			case S_ATTR_END:
  			case S_TAG_SPACE:
  			case S_TAG_CLOSE:
  				break;//normal
  			case S_ATTR_NOQUOT_VALUE://Compatible state
  			case S_ATTR:
  				value = source.slice(start,p);
  				if(value.slice(-1) === '/'){
  					el.closed  = true;
  					value = value.slice(0,-1)
  				}
  			case S_ATTR_SPACE:
  				if(s === S_ATTR_SPACE){
  					value = attrName;
  				}
  				if(s == S_ATTR_NOQUOT_VALUE){
  					errorHandler.warning('attribute "'+value+'" missed quot(")!');
  					addAttribute(attrName, value.replace(/&#?\w+;/g,entityReplacer), start)
  				}else{
  					if(currentNSMap[''] !== 'http://www.w3.org/1999/xhtml' || !value.match(/^(?:disabled|checked|selected)$/i)){
  						errorHandler.warning('attribute "'+value+'" missed value!! "'+value+'" instead!!')
  					}
  					addAttribute(value, value, start)
  				}
  				break;
  			case S_EQ:
  				throw new Error('attribute value missed!!');
  			}
  //			console.log(tagName,tagNamePattern,tagNamePattern.test(tagName))
  			return p;
  		/*xml space '\x20' | #x9 | #xD | #xA; */
  		case '\u0080':
  			c = ' ';
  		default:
  			if(c<= ' '){//space
  				switch(s){
  				case S_TAG:
  					el.setTagName(source.slice(start,p));//tagName
  					s = S_TAG_SPACE;
  					break;
  				case S_ATTR:
  					attrName = source.slice(start,p)
  					s = S_ATTR_SPACE;
  					break;
  				case S_ATTR_NOQUOT_VALUE:
  					var value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
  					errorHandler.warning('attribute "'+value+'" missed quot(")!!');
  					addAttribute(attrName, value, start)
  				case S_ATTR_END:
  					s = S_TAG_SPACE;
  					break;
  				//case S_TAG_SPACE:
  				//case S_EQ:
  				//case S_ATTR_SPACE:
  				//	void();break;
  				//case S_TAG_CLOSE:
  					//ignore warning
  				}
  			}else{//not space
  //S_TAG,	S_ATTR,	S_EQ,	S_ATTR_NOQUOT_VALUE
  //S_ATTR_SPACE,	S_ATTR_END,	S_TAG_SPACE, S_TAG_CLOSE
  				switch(s){
  				//case S_TAG:void();break;
  				//case S_ATTR:void();break;
  				//case S_ATTR_NOQUOT_VALUE:void();break;
  				case S_ATTR_SPACE:
  					var tagName =  el.tagName;
  					if(currentNSMap[''] !== 'http://www.w3.org/1999/xhtml' || !attrName.match(/^(?:disabled|checked|selected)$/i)){
  						errorHandler.warning('attribute "'+attrName+'" missed value!! "'+attrName+'" instead2!!')
  					}
  					addAttribute(attrName, attrName, start);
  					start = p;
  					s = S_ATTR;
  					break;
  				case S_ATTR_END:
  					errorHandler.warning('attribute space is required"'+attrName+'"!!')
  				case S_TAG_SPACE:
  					s = S_ATTR;
  					start = p;
  					break;
  				case S_EQ:
  					s = S_ATTR_NOQUOT_VALUE;
  					start = p;
  					break;
  				case S_TAG_CLOSE:
  					throw new Error("elements closed character '/' and '>' must be connected to");
  				}
  			}
  		}//end outer switch
  		//console.log('p++',p)
  		p++;
  	}
  }
  /**
   * @return true if has new namespace define
   */
  function appendElement(el,domBuilder,currentNSMap){
  	var tagName = el.tagName;
  	var localNSMap = null;
  	//var currentNSMap = parseStack[parseStack.length-1].currentNSMap;
  	var i = el.length;
  	while(i--){
  		var a = el[i];
  		var qName = a.qName;
  		var value = a.value;
  		var nsp = qName.indexOf(':');
  		if(nsp>0){
  			var prefix = a.prefix = qName.slice(0,nsp);
  			var localName = qName.slice(nsp+1);
  			var nsPrefix = prefix === 'xmlns' && localName
  		}else{
  			localName = qName;
  			prefix = null
  			nsPrefix = qName === 'xmlns' && ''
  		}
  		//can not set prefix,because prefix !== ''
  		a.localName = localName ;
  		//prefix == null for no ns prefix attribute 
  		if(nsPrefix !== false){//hack!!
  			if(localNSMap == null){
  				localNSMap = {}
  				//console.log(currentNSMap,0)
  				_copy(currentNSMap,currentNSMap={})
  				//console.log(currentNSMap,1)
  			}
  			currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
  			a.uri = 'http://www.w3.org/2000/xmlns/'
  			domBuilder.startPrefixMapping(nsPrefix, value) 
  		}
  	}
  	var i = el.length;
  	while(i--){
  		a = el[i];
  		var prefix = a.prefix;
  		if(prefix){//no prefix attribute has no namespace
  			if(prefix === 'xml'){
  				a.uri = 'http://www.w3.org/XML/1998/namespace';
  			}if(prefix !== 'xmlns'){
  				a.uri = currentNSMap[prefix || '']
  				
  				//{console.log('###'+a.qName,domBuilder.locator.systemId+'',currentNSMap,a.uri)}
  			}
  		}
  	}
  	var nsp = tagName.indexOf(':');
  	if(nsp>0){
  		prefix = el.prefix = tagName.slice(0,nsp);
  		localName = el.localName = tagName.slice(nsp+1);
  	}else{
  		prefix = null;//important!!
  		localName = el.localName = tagName;
  	}
  	//no prefix element has default namespace
  	var ns = el.uri = currentNSMap[prefix || ''];
  	domBuilder.startElement(ns,localName,tagName,el);
  	//endPrefixMapping and startPrefixMapping have not any help for dom builder
  	//localNSMap = null
  	if(el.closed){
  		domBuilder.endElement(ns,localName,tagName);
  		if(localNSMap){
  			for(prefix in localNSMap){
  				domBuilder.endPrefixMapping(prefix) 
  			}
  		}
  	}else{
  		el.currentNSMap = currentNSMap;
  		el.localNSMap = localNSMap;
  		//parseStack.push(el);
  		return true;
  	}
  }
  function parseHtmlSpecialContent(source,elStartEnd,tagName,entityReplacer,domBuilder){
  	if(/^(?:script|textarea)$/i.test(tagName)){
  		var elEndStart =  source.indexOf('</'+tagName+'>',elStartEnd);
  		var text = source.substring(elStartEnd+1,elEndStart);
  		if(/[&<]/.test(text)){
  			if(/^script$/i.test(tagName)){
  				//if(!/\]\]>/.test(text)){
  					//lexHandler.startCDATA();
  					domBuilder.characters(text,0,text.length);
  					//lexHandler.endCDATA();
  					return elEndStart;
  				//}
  			}//}else{//text area
  				text = text.replace(/&#?\w+;/g,entityReplacer);
  				domBuilder.characters(text,0,text.length);
  				return elEndStart;
  			//}
  			
  		}
  	}
  	return elStartEnd+1;
  }
  function fixSelfClosed(source,elStartEnd,tagName,closeMap){
  	//if(tagName in closeMap){
  	var pos = closeMap[tagName];
  	if(pos == null){
  		//console.log(tagName)
  		pos =  source.lastIndexOf('</'+tagName+'>')
  		if(pos<elStartEnd){//忘记闭合
  			pos = source.lastIndexOf('</'+tagName)
  		}
  		closeMap[tagName] =pos
  	}
  	return pos<elStartEnd;
  	//} 
  }
  function _copy(source,target){
  	for(var n in source){target[n] = source[n]}
  }
  function parseDCC(source,start,domBuilder,errorHandler){//sure start with '<!'
  	var next= source.charAt(start+2)
  	switch(next){
  	case '-':
  		if(source.charAt(start + 3) === '-'){
  			var end = source.indexOf('-->',start+4);
  			//append comment source.substring(4,end)//<!--
  			if(end>start){
  				domBuilder.comment(source,start+4,end-start-4);
  				return end+3;
  			}else{
  				errorHandler.error("Unclosed comment");
  				return -1;
  			}
  		}else{
  			//error
  			return -1;
  		}
  	default:
  		if(source.substr(start+3,6) == 'CDATA['){
  			var end = source.indexOf(']]>',start+9);
  			domBuilder.startCDATA();
  			domBuilder.characters(source,start+9,end-start-9);
  			domBuilder.endCDATA() 
  			return end+3;
  		}
  		//<!DOCTYPE
  		//startDTD(java.lang.String name, java.lang.String publicId, java.lang.String systemId) 
  		var matchs = split(source,start);
  		var len = matchs.length;
  		if(len>1 && /!doctype/i.test(matchs[0][0])){
  			var name = matchs[1][0];
  			var pubid = false;
  			var sysid = false;
  			if(len>3){
  				if(/^public$/i.test(matchs[2][0])){
  					pubid = matchs[3][0];
  					sysid = len>4 && matchs[4][0];
  				}else if(/^system$/i.test(matchs[2][0])){
  					sysid = matchs[3][0];
  				}
  			}
  			var lastMatch = matchs[len-1]
  			domBuilder.startDTD(name, pubid, sysid);
  			domBuilder.endDTD();
  			
  			return lastMatch.index+lastMatch[0].length
  		}
  	}
  	return -1;
  }
  
  
  
  function parseInstruction(source,start,domBuilder){
  	var end = source.indexOf('?>',start);
  	if(end){
  		var match = source.substring(start,end).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
  		if(match){
  			var len = match[0].length;
  			domBuilder.processingInstruction(match[1], match[2]) ;
  			return end+2;
  		}else{//error
  			return -1;
  		}
  	}
  	return -1;
  }
  
  function ElementAttributes(){
  	this.attributeNames = {}
  }
  ElementAttributes.prototype = {
  	setTagName:function(tagName){
  		if(!tagNamePattern.test(tagName)){
  			throw new Error('invalid tagName:'+tagName)
  		}
  		this.tagName = tagName
  	},
  	addValue:function(qName, value, offset) {
  		if(!tagNamePattern.test(qName)){
  			throw new Error('invalid attribute:'+qName)
  		}
  		this.attributeNames[qName] = this.length;
  		this[this.length++] = {qName:qName,value:value,offset:offset}
  	},
  	length:0,
  	getLocalName:function(i){return this[i].localName},
  	getLocator:function(i){return this[i].locator},
  	getQName:function(i){return this[i].qName},
  	getURI:function(i){return this[i].uri},
  	getValue:function(i){return this[i].value}
  //	,getIndex:function(uri, localName)){
  //		if(localName){
  //			
  //		}else{
  //			var qName = uri
  //		}
  //	},
  //	getValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},
  //	getType:function(uri,localName){}
  //	getType:function(i){},
  }
  
  
  
  function split(source,start){
  	var match;
  	var buf = [];
  	var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
  	reg.lastIndex = start;
  	reg.exec(source);//skip <
  	while(match = reg.exec(source)){
  		buf.push(match);
  		if(match[1])return buf;
  	}
  }
  
  exports.XMLReader = XMLReader;
  exports.ParseError = ParseError;
  
  
  /***/ }),
  
  /***/ 506:
  /***/ (function(module) {
  
  /**
   * @typedef {Object} ParsingOptions
   *  @property {function(node)} filter Returns false to exclude a node. Default is true.
   */
  
  /**
   * Parse the given XML string into an object.
   *
   * @param {String} xml
   * @param {ParsingOptions} [options]
   * @return {Object}
   * @api public
   */
  function parse(xml, options = {}) {
  
      options.filter = options.filter || (() => true);
  
      function nextChild() {
          return tag() || content() || comment() || cdata();
      }
  
      function nextRootChild() {
          match(/\s*/);
          return tag(true) || comment() || doctype() || processingInstruction(false);
      }
  
      function document() {
          const decl = declaration();
          const children = [];
          let documentRootNode;
          let child = nextRootChild();
  
          while (child) {
              if (child.node.type === 'Element') {
                  if (documentRootNode) {
                      throw new Error('Found multiple root nodes');
                  }
                  documentRootNode = child.node;
              }
  
              if (!child.excluded) {
                  children.push(child.node);
              }
  
              child = nextRootChild();
          }
  
          if (!documentRootNode) {
              throw new Error('Failed to parse XML');
          }
  
          return {
              declaration: decl ? decl.node : null,
              root: documentRootNode,
              children
          };
      }
  
      function declaration() {
          return processingInstruction(true);
      }
  
      function processingInstruction(matchDeclaration) {
          const m = matchDeclaration ? match(/^<\?(xml)\s*/) : match(/^<\?([\w-:.]+)\s*/);
          if (!m) return;
  
          // tag
          const node = {
              name: m[1],
              type: 'ProcessingInstruction',
              attributes: {}
          };
  
          // attributes
          while (!(eos() || is('?>'))) {
              const attr = attribute();
              if (!attr) return node;
              node.attributes[attr.name] = attr.value;
          }
  
          match(/\?>/);
  
          return {
              excluded: matchDeclaration ? false : options.filter(node) === false,
              node
          };
      }
  
      function tag(matchRoot) {
          const m = match(/^<([\w-:.]+)\s*/);
          if (!m) return;
  
          // name
          const node = {
              type: 'Element',
              name: m[1],
              attributes: {},
              children: []
          };
  
          // attributes
          while (!(eos() || is('>') || is('?>') || is('/>'))) {
              const attr = attribute();
              if (!attr) return node;
              node.attributes[attr.name] = attr.value;
          }
  
          const excluded = matchRoot ? false : options.filter(node) === false;
  
          // self closing tag
          if (match(/^\s*\/>/)) {
              node.children = null;
              return {
                  excluded,
                  node
              };
          }
  
          match(/\??>/);
  
          if (!excluded) {
              // children
              let child = nextChild();
              while (child) {
                  if (!child.excluded) {
                      node.children.push(child.node);
                  }
                  child = nextChild();
              }
          }
  
          // closing
          match(/^<\/[\w-:.]+>/);
  
          return {
              excluded,
              node
          };
      }
  
      function doctype() {
          const m = match(/^<!DOCTYPE\s+[^>]*>/);
          if (m) {
              const node = {
                  type: 'DocumentType',
                  content: m[0]
              };
              return {
                  excluded: options.filter(node) === false,
                  node
              };
          }
      }
  
      function cdata() {
          if (xml.startsWith('<![CDATA[')) {
              const endPositionStart = xml.indexOf(']]>');
              if (endPositionStart > -1) {
                  const endPositionFinish  = endPositionStart + 3;
                  const node = {
                      type: 'CDATA',
                      content: xml.substring(0, endPositionFinish)
                  };
                  xml = xml.slice(endPositionFinish);
                  return {
                      excluded: options.filter(node) === false,
                      node
                  };
              }
          }
      }
  
      function comment() {
          const m = match(/^<!--[\s\S]*?-->/);
          if (m) {
              const node = {
                  type: 'Comment',
                  content: m[0]
              };
              return {
                  excluded: options.filter(node) === false,
                  node
              };
          }
      }
  
      function content() {
          const m = match(/^([^<]+)/);
          if (m) {
              const node = {
                  type: 'Text',
                  content: m[1]
              };
              return {
                  excluded: options.filter(node) === false,
                  node
              };
          }
      }
  
      function attribute() {
          const m = match(/([\w:-]+)\s*=\s*("[^"]*"|'[^']*'|\w+)\s*/);
          if (!m) return;
          return {name: m[1], value: strip(m[2])}
      }
  
      /**
       * Strip quotes from `val`.
       */
      function strip(val) {
          return val.replace(/^['"]|['"]$/g, '');
      }
  
      /**
       * Match `re` and advance the string.
       */
      function match(re) {
          const m = xml.match(re);
          if (!m) return;
          xml = xml.slice(m[0].length);
          return m;
      }
  
      /**
       * End-of-source.
       */
      function eos() {
          return 0 === xml.length;
      }
  
      /**
       * Check for `prefix`.
       */
      function is(prefix) {
          return 0 === xml.indexOf(prefix);
      }
  
      xml = xml.trim();
  
      return document();
  }
  
  module.exports = parse;
  
  
  /***/ }),
  
  /***/ 622:
  /***/ (function(module) {
  
  module.exports = require("path");
  
  /***/ }),
  
  /***/ 676:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var core = __webpack_require__(470);
  var settings = __webpack_require__(814);
  var os = __webpack_require__(87);
  var path = __webpack_require__(622);
  var fs = __webpack_require__(747);
  
  function run() {
    try {
      // open default template
      var templateXml = settings.getSettingsTemplate();
  
      // update from action input
      settings.update(templateXml);
  
      // format to xml
      var formattedXml = settings.formatSettings(templateXml);
  
      // get custom output path
      var settingsPath = getSettingsPath();
   
      // write template to filepath
      writeSettings(settingsPath, formattedXml);
  
    } catch (error) {
      core.setFailed(error.message);
    }
  }
  
  function getSettingsPath() {
    var outputFileInput = core.getInput('output_file');
  
    if (!outputFileInput) {
      return getDefaultSettingsPath();
    }
  
    // resolve env variables in path
    if (outputFileInput.trim() != '') {
      return outputFileInput.trim().replace(/\$([A-Z_]+[A-Z0-9_]*)|\${([A-Z0-9_]*)}/ig, (_, a, b) => process.env[a || b])
    }
  
    return getDefaultSettingsPath();
  }
  
  function getDefaultSettingsPath() { 
    return path.join(os.homedir(), '.m2', 'settings.xml');
  }
  
  function writeSettings(settingsPath, formattedXml) {
    if (!fs.existsSync(path.dirname(settingsPath))) {
        core.info("creating directory for settings.xml: " + settingsPath);
        fs.mkdirSync(path.dirname(settingsPath));
    }
  
    core.info("writing settings.xml to path: " + path.resolve(settingsPath));
    fs.writeFileSync(settingsPath, formattedXml);
  }
  
  run();
  
  module.exports = {
    run,
    getSettingsPath,
    getDefaultSettingsPath,
    writeSettings
  }
  
  /***/ }),
  
  /***/ 701:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  /**
   * @typedef {Object} XMLFormatterOptions
   *  @property {String} [indentation='    '] The value used for indentation
   *  @property {function(node): boolean} [filter] Return false to exclude the node.
   *  @property {Boolean} [collapseContent=false] True to keep content in the same line as the element. Only works if element contains at least one text node
   *  @property {String} [lineSeparator='\r\n'] The line separator to use
   *  @property {String} [whiteSpaceAtEndOfSelfclosingTag=false] to either end ad self closing tag with `<tag/>` or `<tag />`
   */
  
  /**
   * @typedef {Object} XMLFormatterState
   * @param {String} content
   * @param {Number} level
   * @param {XMLFormatterOptions} options
   */
  
  /**
   * @param {XMLFormatterState} state
   * @return {void}
   */
  function newLine(state) {
      if (!state.options.indentation && !state.options.lineSeparator) return;
      state.content += state.options.lineSeparator;
      let i;
      for (i = 0; i < state.level; i++) {
          state.content += state.options.indentation;
      }
  }
  
  /**
   * @param {XMLFormatterState} state
   * @param {String} content
   * @return {void}
   */
  function appendContent(state, content) {
      state.content += content;
  }
  
  /**
   * @param {Object} node
   * @param {XMLFormatterState} state
   * @param {Boolean} preserveSpace
   * @return {void}
   */
  function processNode(node, state, preserveSpace) {
      if (typeof node.content === 'string') {
          processContentNode(node, state, preserveSpace);
      } else if (node.type === 'Element') {
          processElementNode(node, state, preserveSpace);
      } else if (node.type === 'ProcessingInstruction') {
          processProcessingIntruction(node, state, preserveSpace);
      } else {
          throw new Error('Unknown node type: ' + node.type);
      }
  }
  
  /**
   * @param {Object} node
   * @param {XMLFormatterState} state
   * @param {Boolean} preserveSpace
   * @return {void}
   */
  function processContentNode(node, state, preserveSpace) {
      if (!preserveSpace) {
          node.content = node.content.trim();
      }
      if (node.content.length > 0) {
          if (!preserveSpace && state.content.length > 0) {
              newLine(state);
          }
          appendContent(state, node.content);
      }
  }
  
  /**
   * @param {Object} node
   * @param {XMLFormatterState} state
   * @param {Boolean} preserveSpace
   * @return {void}
   */
  function processElementNode(node, state, preserveSpace) {
      if (!preserveSpace && state.content.length > 0) {
          newLine(state);
      }
  
      appendContent(state, '<' + node.name);
      processAttributes(state, node.attributes);
  
      if (node.children === null) {
          const selfClosingNodeClosingTag = state.options.whiteSpaceAtEndOfSelfclosingTag ? ' />' : '/>'
          // self-closing node
          appendContent(state, selfClosingNodeClosingTag);
      } else if (node.children.length === 0) {
          // empty node
          appendContent(state, '></' + node.name + '>');
      } else {
  
          appendContent(state, '>');
  
          state.level++;
  
          let nodePreserveSpace = node.attributes['xml:space'] === 'preserve';
  
          if (!nodePreserveSpace && state.options.collapseContent) {
  
              const containsTextNodes = node.children.some(function(child) {
                  return child.type === 'Text' && child.content.trim() !== '';
              });
  
              if (containsTextNodes) {
                  nodePreserveSpace = true;
              }
          }
  
          node.children.forEach(function(child) {
              processNode(child, state, preserveSpace || nodePreserveSpace, state.options);
          });
  
          state.level--;
  
          if (!preserveSpace && !nodePreserveSpace) {
              newLine(state);
          }
          appendContent(state, '</' + node.name + '>');
      }
  }
  
  /**
   * @param {XMLFormatterState} state
   * @param {Record<String, String>} attributes
   * @return {void}
   */
  function processAttributes(state, attributes) {
      Object.keys(attributes).forEach(function(attr) {
          const escaped = attributes[attr].replace(/"/g, '&quot;');
          appendContent(state, ' ' + attr + '="' + escaped + '"');
      });
  }
  
  /**
   * @param {Object} node
   * @param {XMLFormatterState} state
   * @return {void}
   */
  function processProcessingIntruction(node, state) {
      if (state.content.length > 0) {
          newLine(state);
      }
      appendContent(state, '<?' + node.name);
      processAttributes(state, node.attributes);
      appendContent(state, '?>');
  }
  
  
  /**
   * Converts the given XML into human readable format.
   *
   * @param {String} xml
   * @param {XMLFormatterOptions} options
   * @returns {string}
   */
  function format(xml, options = {}) {
      options.indentation = 'indentation' in options ? options.indentation : '    ';
      options.collapseContent = options.collapseContent === true;
      options.lineSeparator = 'lineSeparator' in options ? options.lineSeparator : '\r\n';
      options.whiteSpaceAtEndOfSelfclosingTag = !!options.whiteSpaceAtEndOfSelfclosingTag;
  
      const parser = __webpack_require__(506);
      const parsedXml = parser(xml, {filter: options.filter});
      const state = {content: '', level: 0, options: options};
  
      if (parsedXml.declaration) {
          processProcessingIntruction(parsedXml.declaration, state);
      }
  
      parsedXml.children.forEach(function(child) {
          processNode(child, state, false);
      });
  
      return state.content;
  }
  
  
  module.exports = format;
  
  
  /***/ }),
  
  /***/ 721:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  function DOMParser(options){
  	this.options = options ||{locator:{}};
  }
  
  DOMParser.prototype.parseFromString = function(source,mimeType){
  	var options = this.options;
  	var sax =  new XMLReader();
  	var domBuilder = options.domBuilder || new DOMHandler();//contentHandler and LexicalHandler
  	var errorHandler = options.errorHandler;
  	var locator = options.locator;
  	var defaultNSMap = options.xmlns||{};
  	var isHTML = /\/x?html?$/.test(mimeType);//mimeType.toLowerCase().indexOf('html') > -1;
    	var entityMap = isHTML?htmlEntity.entityMap:{'lt':'<','gt':'>','amp':'&','quot':'"','apos':"'"};
  	if(locator){
  		domBuilder.setDocumentLocator(locator)
  	}
  
  	sax.errorHandler = buildErrorHandler(errorHandler,domBuilder,locator);
  	sax.domBuilder = options.domBuilder || domBuilder;
  	if(isHTML){
  		defaultNSMap['']= 'http://www.w3.org/1999/xhtml';
  	}
  	defaultNSMap.xml = defaultNSMap.xml || 'http://www.w3.org/XML/1998/namespace';
  	if(source && typeof source === 'string'){
  		sax.parse(source,defaultNSMap,entityMap);
  	}else{
  		sax.errorHandler.error("invalid doc source");
  	}
  	return domBuilder.doc;
  }
  function buildErrorHandler(errorImpl,domBuilder,locator){
  	if(!errorImpl){
  		if(domBuilder instanceof DOMHandler){
  			return domBuilder;
  		}
  		errorImpl = domBuilder ;
  	}
  	var errorHandler = {}
  	var isCallback = errorImpl instanceof Function;
  	locator = locator||{}
  	function build(key){
  		var fn = errorImpl[key];
  		if(!fn && isCallback){
  			fn = errorImpl.length == 2?function(msg){errorImpl(key,msg)}:errorImpl;
  		}
  		errorHandler[key] = fn && function(msg){
  			fn('[xmldom '+key+']\t'+msg+_locator(locator));
  		}||function(){};
  	}
  	build('warning');
  	build('error');
  	build('fatalError');
  	return errorHandler;
  }
  
  //console.log('#\n\n\n\n\n\n\n####')
  /**
   * +ContentHandler+ErrorHandler
   * +LexicalHandler+EntityResolver2
   * -DeclHandler-DTDHandler
   *
   * DefaultHandler:EntityResolver, DTDHandler, ContentHandler, ErrorHandler
   * DefaultHandler2:DefaultHandler,LexicalHandler, DeclHandler, EntityResolver2
   * @link http://www.saxproject.org/apidoc/org/xml/sax/helpers/DefaultHandler.html
   */
  function DOMHandler() {
      this.cdata = false;
  }
  function position(locator,node){
  	node.lineNumber = locator.lineNumber;
  	node.columnNumber = locator.columnNumber;
  }
  /**
   * @see org.xml.sax.ContentHandler#startDocument
   * @link http://www.saxproject.org/apidoc/org/xml/sax/ContentHandler.html
   */
  DOMHandler.prototype = {
  	startDocument : function() {
      	this.doc = new DOMImplementation().createDocument(null, null, null);
      	if (this.locator) {
          	this.doc.documentURI = this.locator.systemId;
      	}
  	},
  	startElement:function(namespaceURI, localName, qName, attrs) {
  		var doc = this.doc;
  	    var el = doc.createElementNS(namespaceURI, qName||localName);
  	    var len = attrs.length;
  	    appendElement(this, el);
  	    this.currentElement = el;
  
  		this.locator && position(this.locator,el)
  	    for (var i = 0 ; i < len; i++) {
  	        var namespaceURI = attrs.getURI(i);
  	        var value = attrs.getValue(i);
  	        var qName = attrs.getQName(i);
  			var attr = doc.createAttributeNS(namespaceURI, qName);
  			this.locator &&position(attrs.getLocator(i),attr);
  			attr.value = attr.nodeValue = value;
  			el.setAttributeNode(attr)
  	    }
  	},
  	endElement:function(namespaceURI, localName, qName) {
  		var current = this.currentElement
  		var tagName = current.tagName;
  		this.currentElement = current.parentNode;
  	},
  	startPrefixMapping:function(prefix, uri) {
  	},
  	endPrefixMapping:function(prefix) {
  	},
  	processingInstruction:function(target, data) {
  	    var ins = this.doc.createProcessingInstruction(target, data);
  	    this.locator && position(this.locator,ins)
  	    appendElement(this, ins);
  	},
  	ignorableWhitespace:function(ch, start, length) {
  	},
  	characters:function(chars, start, length) {
  		chars = _toString.apply(this,arguments)
  		//console.log(chars)
  		if(chars){
  			if (this.cdata) {
  				var charNode = this.doc.createCDATASection(chars);
  			} else {
  				var charNode = this.doc.createTextNode(chars);
  			}
  			if(this.currentElement){
  				this.currentElement.appendChild(charNode);
  			}else if(/^\s*$/.test(chars)){
  				this.doc.appendChild(charNode);
  				//process xml
  			}
  			this.locator && position(this.locator,charNode)
  		}
  	},
  	skippedEntity:function(name) {
  	},
  	endDocument:function() {
  		this.doc.normalize();
  	},
  	setDocumentLocator:function (locator) {
  	    if(this.locator = locator){// && !('lineNumber' in locator)){
  	    	locator.lineNumber = 0;
  	    }
  	},
  	//LexicalHandler
  	comment:function(chars, start, length) {
  		chars = _toString.apply(this,arguments)
  	    var comm = this.doc.createComment(chars);
  	    this.locator && position(this.locator,comm)
  	    appendElement(this, comm);
  	},
  
  	startCDATA:function() {
  	    //used in characters() methods
  	    this.cdata = true;
  	},
  	endCDATA:function() {
  	    this.cdata = false;
  	},
  
  	startDTD:function(name, publicId, systemId) {
  		var impl = this.doc.implementation;
  	    if (impl && impl.createDocumentType) {
  	        var dt = impl.createDocumentType(name, publicId, systemId);
  	        this.locator && position(this.locator,dt)
  	        appendElement(this, dt);
  	    }
  	},
  	/**
  	 * @see org.xml.sax.ErrorHandler
  	 * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
  	 */
  	warning:function(error) {
  		console.warn('[xmldom warning]\t'+error,_locator(this.locator));
  	},
  	error:function(error) {
  		console.error('[xmldom error]\t'+error,_locator(this.locator));
  	},
  	fatalError:function(error) {
  		throw new ParseError(error, this.locator);
  	}
  }
  function _locator(l){
  	if(l){
  		return '\n@'+(l.systemId ||'')+'#[line:'+l.lineNumber+',col:'+l.columnNumber+']'
  	}
  }
  function _toString(chars,start,length){
  	if(typeof chars == 'string'){
  		return chars.substr(start,length)
  	}else{//java sax connect width xmldom on rhino(what about: "? && !(chars instanceof String)")
  		if(chars.length >= start+length || start){
  			return new java.lang.String(chars,start,length)+'';
  		}
  		return chars;
  	}
  }
  
  /*
   * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/LexicalHandler.html
   * used method of org.xml.sax.ext.LexicalHandler:
   *  #comment(chars, start, length)
   *  #startCDATA()
   *  #endCDATA()
   *  #startDTD(name, publicId, systemId)
   *
   *
   * IGNORED method of org.xml.sax.ext.LexicalHandler:
   *  #endDTD()
   *  #startEntity(name)
   *  #endEntity(name)
   *
   *
   * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/DeclHandler.html
   * IGNORED method of org.xml.sax.ext.DeclHandler
   * 	#attributeDecl(eName, aName, type, mode, value)
   *  #elementDecl(name, model)
   *  #externalEntityDecl(name, publicId, systemId)
   *  #internalEntityDecl(name, value)
   * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/EntityResolver2.html
   * IGNORED method of org.xml.sax.EntityResolver2
   *  #resolveEntity(String name,String publicId,String baseURI,String systemId)
   *  #resolveEntity(publicId, systemId)
   *  #getExternalSubset(name, baseURI)
   * @link http://www.saxproject.org/apidoc/org/xml/sax/DTDHandler.html
   * IGNORED method of org.xml.sax.DTDHandler
   *  #notationDecl(name, publicId, systemId) {};
   *  #unparsedEntityDecl(name, publicId, systemId, notationName) {};
   */
  "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g,function(key){
  	DOMHandler.prototype[key] = function(){return null}
  })
  
  /* Private static helpers treated below as private instance methods, so don't need to add these to the public API; we might use a Relator to also get rid of non-standard public properties */
  function appendElement (hander,node) {
      if (!hander.currentElement) {
          hander.doc.appendChild(node);
      } else {
          hander.currentElement.appendChild(node);
      }
  }//appendChild and setAttributeNS are preformance key
  
  //if(typeof require == 'function'){
  var htmlEntity = __webpack_require__(740);
  var sax = __webpack_require__(503);
  var XMLReader = sax.XMLReader;
  var ParseError = sax.ParseError;
  var DOMImplementation = exports.DOMImplementation = __webpack_require__(440).DOMImplementation;
  exports.XMLSerializer = __webpack_require__(440).XMLSerializer ;
  exports.DOMParser = DOMParser;
  exports.__DOMHandler = DOMHandler;
  //}
  
  
  /***/ }),
  
  /***/ 740:
  /***/ (function(__unusedmodule, exports) {
  
  exports.entityMap = {
         lt: '<',
         gt: '>',
         amp: '&',
         quot: '"',
         apos: "'",
         Agrave: "À",
         Aacute: "Á",
         Acirc: "Â",
         Atilde: "Ã",
         Auml: "Ä",
         Aring: "Å",
         AElig: "Æ",
         Ccedil: "Ç",
         Egrave: "È",
         Eacute: "É",
         Ecirc: "Ê",
         Euml: "Ë",
         Igrave: "Ì",
         Iacute: "Í",
         Icirc: "Î",
         Iuml: "Ï",
         ETH: "Ð",
         Ntilde: "Ñ",
         Ograve: "Ò",
         Oacute: "Ó",
         Ocirc: "Ô",
         Otilde: "Õ",
         Ouml: "Ö",
         Oslash: "Ø",
         Ugrave: "Ù",
         Uacute: "Ú",
         Ucirc: "Û",
         Uuml: "Ü",
         Yacute: "Ý",
         THORN: "Þ",
         szlig: "ß",
         agrave: "à",
         aacute: "á",
         acirc: "â",
         atilde: "ã",
         auml: "ä",
         aring: "å",
         aelig: "æ",
         ccedil: "ç",
         egrave: "è",
         eacute: "é",
         ecirc: "ê",
         euml: "ë",
         igrave: "ì",
         iacute: "í",
         icirc: "î",
         iuml: "ï",
         eth: "ð",
         ntilde: "ñ",
         ograve: "ò",
         oacute: "ó",
         ocirc: "ô",
         otilde: "õ",
         ouml: "ö",
         oslash: "ø",
         ugrave: "ù",
         uacute: "ú",
         ucirc: "û",
         uuml: "ü",
         yacute: "ý",
         thorn: "þ",
         yuml: "ÿ",
         nbsp: "\u00a0",
         iexcl: "¡",
         cent: "¢",
         pound: "£",
         curren: "¤",
         yen: "¥",
         brvbar: "¦",
         sect: "§",
         uml: "¨",
         copy: "©",
         ordf: "ª",
         laquo: "«",
         not: "¬",
         shy: "­­",
         reg: "®",
         macr: "¯",
         deg: "°",
         plusmn: "±",
         sup2: "²",
         sup3: "³",
         acute: "´",
         micro: "µ",
         para: "¶",
         middot: "·",
         cedil: "¸",
         sup1: "¹",
         ordm: "º",
         raquo: "»",
         frac14: "¼",
         frac12: "½",
         frac34: "¾",
         iquest: "¿",
         times: "×",
         divide: "÷",
         forall: "∀",
         part: "∂",
         exist: "∃",
         empty: "∅",
         nabla: "∇",
         isin: "∈",
         notin: "∉",
         ni: "∋",
         prod: "∏",
         sum: "∑",
         minus: "−",
         lowast: "∗",
         radic: "√",
         prop: "∝",
         infin: "∞",
         ang: "∠",
         and: "∧",
         or: "∨",
         cap: "∩",
         cup: "∪",
         'int': "∫",
         there4: "∴",
         sim: "∼",
         cong: "≅",
         asymp: "≈",
         ne: "≠",
         equiv: "≡",
         le: "≤",
         ge: "≥",
         sub: "⊂",
         sup: "⊃",
         nsub: "⊄",
         sube: "⊆",
         supe: "⊇",
         oplus: "⊕",
         otimes: "⊗",
         perp: "⊥",
         sdot: "⋅",
         Alpha: "Α",
         Beta: "Β",
         Gamma: "Γ",
         Delta: "Δ",
         Epsilon: "Ε",
         Zeta: "Ζ",
         Eta: "Η",
         Theta: "Θ",
         Iota: "Ι",
         Kappa: "Κ",
         Lambda: "Λ",
         Mu: "Μ",
         Nu: "Ν",
         Xi: "Ξ",
         Omicron: "Ο",
         Pi: "Π",
         Rho: "Ρ",
         Sigma: "Σ",
         Tau: "Τ",
         Upsilon: "Υ",
         Phi: "Φ",
         Chi: "Χ",
         Psi: "Ψ",
         Omega: "Ω",
         alpha: "α",
         beta: "β",
         gamma: "γ",
         delta: "δ",
         epsilon: "ε",
         zeta: "ζ",
         eta: "η",
         theta: "θ",
         iota: "ι",
         kappa: "κ",
         lambda: "λ",
         mu: "μ",
         nu: "ν",
         xi: "ξ",
         omicron: "ο",
         pi: "π",
         rho: "ρ",
         sigmaf: "ς",
         sigma: "σ",
         tau: "τ",
         upsilon: "υ",
         phi: "φ",
         chi: "χ",
         psi: "ψ",
         omega: "ω",
         thetasym: "ϑ",
         upsih: "ϒ",
         piv: "ϖ",
         OElig: "Œ",
         oelig: "œ",
         Scaron: "Š",
         scaron: "š",
         Yuml: "Ÿ",
         fnof: "ƒ",
         circ: "ˆ",
         tilde: "˜",
         ensp: " ",
         emsp: " ",
         thinsp: " ",
         zwnj: "‌",
         zwj: "‍",
         lrm: "‎",
         rlm: "‏",
         ndash: "–",
         mdash: "—",
         lsquo: "‘",
         rsquo: "’",
         sbquo: "‚",
         ldquo: "“",
         rdquo: "”",
         bdquo: "„",
         dagger: "†",
         Dagger: "‡",
         bull: "•",
         hellip: "…",
         permil: "‰",
         prime: "′",
         Prime: "″",
         lsaquo: "‹",
         rsaquo: "›",
         oline: "‾",
         euro: "€",
         trade: "™",
         larr: "←",
         uarr: "↑",
         rarr: "→",
         darr: "↓",
         harr: "↔",
         crarr: "↵",
         lceil: "⌈",
         rceil: "⌉",
         lfloor: "⌊",
         rfloor: "⌋",
         loz: "◊",
         spades: "♠",
         clubs: "♣",
         hearts: "♥",
         diams: "♦"
  };
  
  
  /***/ }),
  
  /***/ 747:
  /***/ (function(module) {
  
  module.exports = require("fs");
  
  /***/ }),
  
  /***/ 814:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var core = __webpack_require__(470);
  var path = __webpack_require__(622);
  var fs = __webpack_require__(747);
  var DOMParser = __webpack_require__(721).DOMParser;
  var XMLSerializer = __webpack_require__(721).XMLSerializer;
  var format = __webpack_require__(701);
  
  function getSettingsTemplate() {
      return getTemplate('../template', 'settings.xml');
  }
  
  function getDefaultRepositoryTemplate() {
      return getTemplate('../template', 'default-repository.xml');
  }
  
  function getDefaultActiveProfileTemplate() {
      return getTemplate('../template', 'default-active-profile.xml');
  }
  
  function getTemplate(filepath, filename) {
      var templatePath = path.join(__dirname, filepath, filename);
      var template = fs.readFileSync(templatePath).toString();
      return new DOMParser().parseFromString(template, 'text/xml');
  }
  
  function formatSettings(templateXml) {
      var settingStr = new XMLSerializer().serializeToString(templateXml);
  
      // format xml to standard format
      return format(settingStr, {
          indentation: '  ',
          collapsetent: true,
          lineSeparator: '\n'
      });
  }
  
  function update(templateXml) {
      this.updateActiveProfiles(templateXml);
      this.updateServers(templateXml);
      this.updateMirrors(templateXml);
      this.updateRepositories(templateXml);
      this.updatePluginRepositories(templateXml);
      this.updateProfiles(templateXml)
      this.updatePluginGroups(templateXml)
  }
  
  function updateActiveProfiles(templateXml) {
  
      var activeProfilesInput = core.getInput('active_profiles');
  
      if (!activeProfilesInput) {
          applyDefaultActiveProfile(templateXml);
          return;
      }
  
      var activeProfiles = JSON.parse(activeProfilesInput);
  
      if (activeProfiles.length == 0) {
          applyDefaultActiveProfile(templateXml);
          return;
      }
  
      // apply custom repostories
      activeProfiles.forEach((activeProfileInput) => {
          var activeProfileXml = templateXml.createElement("activeProfile");
          activeProfileXml.textContent = activeProfileInput;
          templateXml
              .getElementsByTagName('activeProfiles')[0]
              .appendChild(activeProfileXml);
      });
  
  }
  
  function applyDefaultActiveProfile(templateXml) {
      var defaultActiveProfile = getDefaultActiveProfileTemplate();
  
      templateXml
          .getElementsByTagName('activeProfiles')[0]
          .appendChild(defaultActiveProfile);
  }
  
  function updateServers(templateXml) {
      var serversInput = core.getInput('servers');
  
      if (!serversInput) {
          return;
      }
  
      var serversXml = templateXml.getElementsByTagName('servers')[0];
  
      JSON.parse(serversInput).forEach((serverInput) => {
          var serverXml = templateXml.createElement('server');
          for (var key in serverInput) {
              var keyXml = templateXml.createElement(key);
  
              // convert all json content as xml
              var value = objectToXml(serverInput[key]);
              var xmlValue = new DOMParser().parseFromString(value, 'text/xml');
  
              // append new xml to current node
              keyXml.appendChild(xmlValue);
              serverXml.appendChild(keyXml);
          }
          serversXml.appendChild(serverXml);
      });
  
  }
  
  function updateMirrors(templateXml) {
      var mirrorsInput = core.getInput('mirrors');
  
      if (!mirrorsInput) {
          return;
      }
  
      var mirrorsXml = templateXml.getElementsByTagName('mirrors')[0];
  
      JSON.parse(mirrorsInput).forEach((mirrorInput) => {
          var mirrorXml = templateXml.createElement('mirror');
          for (var key in mirrorInput) {
              var keyXml = templateXml.createElement(key);
              keyXml.textContent = mirrorInput[key];
              mirrorXml.appendChild(keyXml);
          }
          mirrorsXml.appendChild(mirrorXml);
      });
  
  }
  
  function updateRepositories(templateXml) {
      var repositoriesInput = core.getInput('repositories');
  
      if (!repositoriesInput) {
          applyDefaultRepository(templateXml);
          return;
      }
  
      var repositories = JSON.parse(repositoriesInput);
  
      if (repositories.length == 0) {
          applyDefaultRepository(templateXml);
          return;
      }
  
      // apply custom repostories
      repositories.forEach((repositoryInput) => {
          var repositoryXml = templateXml.createElement('repository');
          for (var key in repositoryInput) {
              var keyXml = templateXml.createElement(key);
              var child = repositoryInput[key];
              if (child === Object(child)) {
                  var childXml = templateXml.createElement(key);
                  for (var childKey in child) {
                      if (Object.prototype.hasOwnProperty.call(child, childKey)) {
                          var childElement = templateXml.createElement(childKey);
                          childElement.textContent = child[childKey];
                          childXml.appendChild(childElement);
                      }
                  }
                  repositoryXml.appendChild(childXml);
              } else {
                  keyXml.textContent = repositoryInput[key];
                  repositoryXml.appendChild(keyXml);
              }
          }
          templateXml
              .getElementsByTagName('profiles')[0]
              .getElementsByTagName('repositories')[0]
              .appendChild(repositoryXml);
      });
  }
  
  function applyDefaultRepository(templateXml) {
      var defaultRepositoryTemplate = getDefaultRepositoryTemplate();
  
      templateXml
          .getElementsByTagName('profiles')[0]
          .getElementsByTagName('repositories')[0]
          .appendChild(defaultRepositoryTemplate);
  }
  
  function updatePluginRepositories(templateXml) {
      var pluginRepositoriesInput = core.getInput('plugin_repositories');
  
      if (!pluginRepositoriesInput) {
          return;
      }
  
      var pluginRepositoriesXml =
          templateXml.getElementsByTagName('profiles')[0]
              .getElementsByTagName('pluginRepositories')[0];
  
      JSON.parse(pluginRepositoriesInput).forEach((pluginRepositoryInput) => {
          var pluginRepositoryXml = templateXml.createElement('pluginRepository');
          for (var key in pluginRepositoryInput) {
              var keyXml = templateXml.createElement(key);
              var child = pluginRepositoryInput[key];
              if (child === Object(child)) {
                  var childXml = templateXml.createElement(key);
                  for (var childKey in child) {
                      if (Object.prototype.hasOwnProperty.call(child, childKey)) {
                          var childElement = templateXml.createElement(childKey);
                          childElement.textContent = child[childKey];
                          childXml.appendChild(childElement);
                      }
                  }
                  pluginRepositoryXml.appendChild(childXml);
              } else {
                  keyXml.textContent = pluginRepositoryInput[key];
                  pluginRepositoryXml.appendChild(keyXml);
              }
          }
          pluginRepositoriesXml.appendChild(pluginRepositoryXml);
      });
  }
  
  function updateProfiles(templateXml) {
      var profilesInput = core.getInput('profiles');
  
      if (!profilesInput) {
          return;
      }
  
      var profilesXml =
          templateXml.getElementsByTagName('profiles')[0];
  
      JSON.parse(profilesInput).forEach((profileInput) => {
          var profileXml = templateXml.createElement('profile');
          for (var key in profileInput) {
              var keyXml = templateXml.createElement(key);
              var child = profileInput[key];
              if (child === Object(child)) {
                  var childXml = templateXml.createElement(key);
                  for (var childKey in child) {
                      if (Object.prototype.hasOwnProperty.call(child, childKey)) {
                          var childElement = templateXml.createElement(childKey);
                          childElement.textContent = child[childKey];
                          childXml.appendChild(childElement);
                      }
                  }
                  profileXml.appendChild(childXml);
              } else {
                  keyXml.textContent = profileInput[key];
                  profileXml.appendChild(keyXml);
              }
          }
          profilesXml.appendChild(profileXml);
      });
  }
  
  function updatePluginGroups(templateXml) {
      var pluginGroupsInput = core.getInput('plugin_groups');
  
      if (!pluginGroupsInput) {
          return;
      }
  
      var pluginGroupsXml = templateXml.getElementsByTagName('pluginGroups')[0];
  
      JSON.parse(pluginGroupsInput).forEach((pluginGroupInput) => {
          var pluginGroupXml = templateXml.createElement('pluginGroup');
          pluginGroupXml.textContent = pluginGroupInput;
          pluginGroupsXml.appendChild(pluginGroupXml);
      });
  
  }
  
  function objectToXml(obj) {
      var xml = '';
      for (var prop in obj) {
          xml += obj[prop] instanceof Array ? '' : "<" + prop + ">";
          if (obj[prop] instanceof Array) {
              for (var array in obj[prop]) {
                  xml += "<" + prop + ">";
                  xml += objectToXml(new Object(obj[prop][array]));
                  xml += "</" + prop + ">";
              }
          } else if (typeof obj[prop] == "object") {
              xml += objectToXml(new Object(obj[prop]));
          } else {
              xml += obj[prop];
          }
          xml += obj[prop] instanceof Array ? '' : "</" + prop + ">";
      }
      xml = xml.replace(/<\/?[0-9]{1,}>/g, '');
      return xml
  }
  
  module.exports = {
      getSettingsTemplate,
      getTemplate,
      formatSettings,
      update,
      updateActiveProfiles,
      updateServers,
      updateMirrors,
      updateRepositories,
      updatePluginRepositories,
      updateProfiles,
      updatePluginGroups
  }
  
  
  /***/ })
  
  /******/ });