ranuts 0.1.0-alpha → 0.1.0-alpha.2

package/dist/index.js

@@ -1,66 +1,129 @@
-const fs = require("fs");
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import fs from "node:fs";
+let fileSystem = fs;
+if (typeof process !== "undefined" && typeof fileSystem.Stats === "function") {
+  fileSystem._identification = true;
+} else {
+  fileSystem = { _identification: false, message: "require is not defined" };
+}
+const fs$1 = fileSystem;
 const writeFile = (path, content) => new Promise((resolve, reject) => {
-  fs.writeFile(path, content, {
-    mode: 438,
-    flag: "w+",
-    encoding: "utf-8"
-  }, (err) => {
-    if (err) {
-      reject({ status: false, data: err });
-      throw err;
-    } else {
-      resolve({ status: true, data: { path, content } });
+  if (!fs$1._identification)
+    return reject({ _identification: false, data: "fs is not loaded" });
+  fs$1.writeFile(
+    path,
+    content,
+    {
+      mode: 438,
+      flag: "w+",
+      encoding: "utf-8"
+    },
+    (err) => {
+      if (err) {
+        reject({ _identification: false, data: err });
+        throw err;
+      } else {
+        resolve({ _identification: true, data: { path, content } });
+      }
     }
-  });
+  );
 });
 const readFile = (path, format = "utf-8") => new Promise((resolve, reject) => {
-  fs.readFile(path, format, (err, data) => {
-    err ? reject({ status: false, data: err }) : resolve({ status: true, data });
+  if (!fs$1._identification)
+    return reject({ _identification: false, data: "fs is not loaded" });
+  fs$1.readFile(path, format, (err, data) => {
+    err ? reject({ _identification: false, data: err }) : resolve({ _identification: true, data });
   });
 });
 const watchFile = (path, interval = 20) => new Promise((resolve, reject) => {
-  fs.watchFile(path, { interval }, (curr, prev) => {
+  if (!fs$1._identification)
+    return reject({ _identification: false, data: "fs is not loaded" });
+  fs$1.watchFile(path, { interval }, (curr, prev) => {
     if (curr.mtime !== prev.mtime) {
-      fs.unwatchFile(path);
-      resolve({ status: true, data: { msg: "file is changed" } });
+      fs$1.unwatchFile(path);
+      resolve({ _identification: true, data: { msg: "file is changed" } });
     } else {
-      resolve({ status: false, data: { msg: "file is not changed" } });
+      resolve({
+        _identification: false,
+        data: { msg: "file is not changed" }
+      });
     }
   });
 });
-class EventEmitter {
+class Subscribe {
   constructor() {
-    this.on = (eventName, callback) => {
+    __publicField(this, "_events");
+    __publicField(this, "on", (eventName, eventItem) => {
       if (this._events[eventName] && eventName !== Symbol.for("new-listener")) {
         this.emit(Symbol.for("new-listener"), eventName);
       }
       const callbacks = this._events[eventName] || [];
-      callbacks.push(callback);
+      if (typeof eventItem === "function") {
+        callbacks.push({
+          name: eventName,
+          callback: eventItem
+        });
+      } else {
+        callbacks.push(eventItem);
+      }
       this._events[eventName] = callbacks;
-    };
-    this.emit = (eventName, ...args) => {
+    });
+    __publicField(this, "emit", (eventName, ...args) => {
       const callbacks = this._events[eventName] || [];
-      callbacks.forEach((cb) => cb(...args));
-    };
-    this.once = (eventName, callback) => {
-      const one = (...args) => {
+      callbacks.forEach((item) => {
+        const { callback } = item;
         callback(...args);
-        this.off(eventName, one);
-      };
-      one.initialCallback = callback;
+      });
+    });
+    __publicField(this, "once", (eventName, eventItem) => {
+      let one;
+      if (typeof eventItem === "function") {
+        one = {
+          name: eventName,
+          callback: (...args) => {
+            eventItem(...args);
+            this.off(eventName, one);
+          },
+          initialCallback: eventItem
+        };
+      } else {
+        const { callback } = eventItem;
+        one = {
+          name: eventName,
+          callback: (...args) => {
+            callback(...args);
+            this.off(eventName, one);
+          },
+          initialCallback: callback
+        };
+      }
       this.on(eventName, one);
-    };
-    this.off = (eventName, callback) => {
+    });
+    __publicField(this, "off", (eventName, eventItem) => {
       const callbacks = this._events[eventName] || [];
-      const newCallbacks = callbacks.filter((fn) => fn != callback && fn.initialCallback != callback);
+      const newCallbacks = callbacks.filter((item) => {
+        if (typeof eventItem === "function") {
+          return item.callback !== eventItem && item.initialCallback !== eventItem;
+        } else {
+          const { callback } = eventItem;
+          return item.callback !== callback && item.initialCallback !== callback;
+        }
+      });
       this._events[eventName] = newCallbacks;
-    };
+    });
     this._events = {};
   }
 }
 const queryFileInfo = (path) => new Promise((resolve, reject) => {
-  fs.stat(path, (err, data) => {
-    err ? reject({ status: false, data: err }) : resolve({ status: true, data });
+  if (!fs$1._identification)
+    return reject({ _identification: false, data: "fs is not loaded" });
+  fs$1.stat(path, (err, data) => {
+    err ? reject({ _identification: false, data: err }) : resolve({ _identification: true, data });
   });
 });
 const filterObj = (obj, list) => {
@@ -72,15 +135,986 @@ const filterObj = (obj, list) => {
   });
   return result;
 };
-const index = {
-  writeFile,
-  readFile,
-  watchFile,
-  EventEmitter,
-  queryFileInfo,
-  filterObj
+const readDir = (options) => {
+  const { dirPath } = options;
+  try {
+    return fs$1.readdirSync(dirPath);
+  } catch (error) {
+    console.log("readDir error", error);
+    throw error;
+  }
+};
+const str2Xml = (xmlStr, format = "text/xml") => {
+  if (window.DOMParser)
+    return new window.DOMParser().parseFromString(xmlStr, format).documentElement;
+  if (typeof window.ActiveXObject !== "undefined" && new window.ActiveXObject("Microsoft.XMLDOM")) {
+    const xmlDoc = new window.ActiveXObject("Microsoft.XMLDOM");
+    xmlDoc.async = "false";
+    xmlDoc.loadXML(xmlStr);
+    return xmlDoc;
+  }
+  return void 0;
+};
+function vnode$1(sel, data, children, text, elm) {
+  const key = data === void 0 ? void 0 : data.key;
+  return { sel, data, children, text, elm, key };
+}
+function createElement(tagName2, options) {
+  return document.createElement(tagName2, options);
+}
+function createElementNS(namespaceURI, qualifiedName, options) {
+  return document.createElementNS(namespaceURI, qualifiedName, options);
+}
+function createDocumentFragment() {
+  return parseFragment(document.createDocumentFragment());
+}
+function createTextNode(text) {
+  return document.createTextNode(text);
+}
+function createComment(text) {
+  return document.createComment(text);
+}
+function insertBefore(parentNode2, newNode, referenceNode) {
+  if (isDocumentFragment(parentNode2)) {
+    let node = parentNode2;
+    while (node && isDocumentFragment(node)) {
+      const fragment = parseFragment(node);
+      node = fragment.parent;
+    }
+    parentNode2 = node != null ? node : parentNode2;
+  }
+  if (isDocumentFragment(newNode)) {
+    newNode = parseFragment(newNode, parentNode2);
+  }
+  if (referenceNode && isDocumentFragment(referenceNode)) {
+    referenceNode = parseFragment(referenceNode).firstChildNode;
+  }
+  parentNode2.insertBefore(newNode, referenceNode);
+}
+function removeChild(node, child) {
+  node.removeChild(child);
+}
+function appendChild(node, child) {
+  if (isDocumentFragment(child)) {
+    child = parseFragment(child, node);
+  }
+  node.appendChild(child);
+}
+function parentNode(node) {
+  if (isDocumentFragment(node)) {
+    while (node && isDocumentFragment(node)) {
+      const fragment = parseFragment(node);
+      node = fragment.parent;
+    }
+    return node != null ? node : null;
+  }
+  return node.parentNode;
+}
+function nextSibling(node) {
+  var _a;
+  if (isDocumentFragment(node)) {
+    const fragment = parseFragment(node);
+    const parent = parentNode(fragment);
+    if (parent && fragment.lastChildNode) {
+      const children = Array.from(parent.childNodes);
+      const index = children.indexOf(fragment.lastChildNode);
+      return (_a = children[index + 1]) != null ? _a : null;
+    }
+    return null;
+  }
+  return node.nextSibling;
+}
+function tagName(elm) {
+  return elm.tagName;
+}
+function setTextContent(node, text) {
+  node.textContent = text;
+}
+function getTextContent(node) {
+  return node.textContent;
+}
+function isElement(node) {
+  return node.nodeType === 1;
+}
+function isText(node) {
+  return node.nodeType === 3;
+}
+function isComment(node) {
+  return node.nodeType === 8;
+}
+function isDocumentFragment(node) {
+  return node.nodeType === 11;
+}
+function parseFragment(fragmentNode, parentNode2) {
+  var _a, _b, _c;
+  const fragment = fragmentNode;
+  (_a = fragment.parent) != null ? _a : fragment.parent = parentNode2 != null ? parentNode2 : null;
+  (_b = fragment.firstChildNode) != null ? _b : fragment.firstChildNode = fragmentNode.firstChild;
+  (_c = fragment.lastChildNode) != null ? _c : fragment.lastChildNode = fragmentNode.lastChild;
+  return fragment;
+}
+const htmlDomApi = {
+  createElement,
+  createElementNS,
+  createTextNode,
+  createDocumentFragment,
+  createComment,
+  insertBefore,
+  removeChild,
+  appendChild,
+  parentNode,
+  nextSibling,
+  tagName,
+  setTextContent,
+  getTextContent,
+  isElement,
+  isText,
+  isComment,
+  isDocumentFragment
+};
+const array = Array.isArray;
+function primitive(s) {
+  return typeof s === "string" || typeof s === "number";
+}
+function isVnode$1(s) {
+  return !!(s == null ? void 0 : s.sel);
+}
+const xlinkNS = "http://www.w3.org/1999/xlink";
+const xmlNS = "http://www.w3.org/XML/1998/namespace";
+const colonChar = 58;
+const xChar = 120;
+function updateAttrs(oldVnode, vnode2) {
+  let key;
+  const elm = vnode2.elm;
+  let oldAttrs = oldVnode.data && oldVnode.data.attrs;
+  let attrs = vnode2.data && vnode2.data.attrs;
+  if (!oldAttrs && !attrs)
+    return;
+  if (oldAttrs === attrs)
+    return;
+  oldAttrs = oldAttrs || {};
+  attrs = attrs || {};
+  for (key in attrs) {
+    const cur = attrs[key];
+    const old = oldAttrs[key];
+    if (old !== cur) {
+      if (cur === true) {
+        elm.setAttribute(key, "");
+      } else if (cur === false) {
+        elm.removeAttribute(key);
+      } else {
+        if (key.charCodeAt(0) !== xChar) {
+          elm.setAttribute(key, cur);
+        } else if (key.charCodeAt(3) === colonChar) {
+          elm.setAttributeNS(xmlNS, key, cur);
+        } else if (key.charCodeAt(5) === colonChar) {
+          elm.setAttributeNS(xlinkNS, key, cur);
+        } else {
+          elm.setAttribute(key, `${cur}`);
+        }
+      }
+    }
+  }
+  for (key in oldAttrs) {
+    if (!(key in attrs)) {
+      elm.removeAttribute(key);
+    }
+  }
+}
+const attributesModule = { create: updateAttrs, update: updateAttrs };
+function updateClass(oldVnode, vnode2) {
+  let cur;
+  let name;
+  const elm = vnode2.elm;
+  let oldClass = oldVnode.data && oldVnode.data.class;
+  let className = vnode2.data && vnode2.data.class;
+  if (!oldClass && !className)
+    return;
+  if (oldClass === className)
+    return;
+  oldClass = oldClass || {};
+  className = className || {};
+  for (name in oldClass) {
+    if (oldClass[name] && !Object.prototype.hasOwnProperty.call(className, name)) {
+      elm.classList.remove(name);
+    }
+  }
+  for (name in className) {
+    cur = className[name];
+    if (cur !== oldClass[name]) {
+      elm.classList[cur ? "add" : "remove"](name);
+    }
+  }
+}
+const classModule = { create: updateClass, update: updateClass };
+const isFunction = (handler) => {
+  return typeof handler === "function";
+};
+function invokeHandler(handler, vnode2, event) {
+  if (isFunction(handler)) {
+    handler.call(vnode2, event, vnode2);
+  } else if (typeof handler === "object") {
+    for (let i = 0; i < handler.length; i++) {
+      invokeHandler(handler[i], vnode2, event);
+    }
+  }
+}
+function handleEvent(event, vnode2) {
+  const name = event.type;
+  const on = vnode2.data && vnode2.data.on;
+  if (on && on[name]) {
+    invokeHandler(on[name], vnode2, event);
+  }
+}
+function createListener() {
+  return function handler(event) {
+    handleEvent(event, handler.vnode);
+  };
+}
+function updateEventListeners(oldVnode, vnode2) {
+  var _a, _b;
+  const oldOn = (_a = oldVnode == null ? void 0 : oldVnode.data) == null ? void 0 : _a.on;
+  const oldListener = oldVnode == null ? void 0 : oldVnode.listener;
+  const oldElm = oldVnode.elm;
+  const on = (_b = vnode2 == null ? void 0 : vnode2.data) == null ? void 0 : _b.on;
+  const elm = vnode2 && vnode2.elm;
+  let name;
+  if (oldOn === on) {
+    return;
+  }
+  if (oldOn && oldListener) {
+    if (!on) {
+      for (name in oldOn) {
+        oldElm.removeEventListener(name, oldListener, false);
+      }
+    } else {
+      for (name in oldOn) {
+        if (!on[name]) {
+          oldElm.removeEventListener(name, oldListener, false);
+        }
+      }
+    }
+  }
+  if (on) {
+    const listener = vnode2.listener = oldVnode.listener || createListener();
+    if (!oldOn) {
+      for (name in on) {
+        elm.addEventListener(name, listener, false);
+      }
+    } else {
+      for (name in on) {
+        if (!oldOn[name]) {
+          elm.addEventListener(name, listener, false);
+        }
+      }
+    }
+  }
+}
+const eventListenersModule = {
+  create: updateEventListeners,
+  update: updateEventListeners,
+  destroy: updateEventListeners
+};
+function updateProps(oldVnode, vnode2) {
+  let key;
+  let cur;
+  let old;
+  const elm = vnode2.elm;
+  let oldProps = oldVnode.data ? oldVnode.data.props : void 0;
+  let props = vnode2.data ? vnode2.data.props : void 0;
+  if (!oldProps && !props)
+    return;
+  if (oldProps === props)
+    return;
+  oldProps = oldProps || {};
+  props = props || {};
+  for (key in props) {
+    cur = props[key];
+    old = oldProps[key];
+    if (old !== cur && (key !== "value" || elm[key] !== cur)) {
+      elm[key] = cur;
+    }
+  }
+}
+const propsModule = { create: updateProps, update: updateProps };
+let reflowForced = false;
+function updateStyle(oldVnode, vnode2) {
+  let cur;
+  let name;
+  const elm = vnode2.elm;
+  let oldStyle = oldVnode.data.style;
+  let style = vnode2.data.style;
+  if (!oldStyle && !style)
+    return;
+  if (oldStyle === style)
+    return;
+  oldStyle = oldStyle || {};
+  style = style || {};
+  for (name in oldStyle) {
+    if (!style[name]) {
+      if (name[0] === "-" && name[1] === "-") {
+        elm.style.removeProperty(name);
+      } else {
+        elm.style[name] = "";
+      }
+    }
+  }
+  for (name in style) {
+    cur = style[name];
+    if (cur !== oldStyle[name]) {
+      if (name[0] === "-" && name[1] === "-") {
+        elm.style.setProperty(name, cur);
+      } else {
+        elm.style[name] = cur;
+      }
+    }
+  }
+}
+function forceReflow() {
+  reflowForced = false;
+}
+function applyDestroyStyle(vnode2) {
+  let style;
+  let name;
+  const elm = vnode2.elm;
+  const s = vnode2.data.style;
+  if (!s || !(style = s.destroy))
+    return;
+  for (name in style) {
+    elm.style[name] = style[name];
+  }
+}
+function applyRemoveStyle(vnode2, rm) {
+  const s = vnode2.data.style;
+  if (!s || !s.remove) {
+    rm();
+    return;
+  }
+  if (!reflowForced) {
+    vnode2.elm.offsetLeft;
+    reflowForced = true;
+  }
+  let name;
+  const elm = vnode2.elm;
+  let i = 0;
+  const style = s.remove;
+  let amount = 0;
+  const applied = [];
+  for (name in style) {
+    applied.push(name);
+    elm.style[name] = style[name];
+  }
+  const compStyle = getComputedStyle(elm);
+  const props = compStyle["transition-property"].split(", ");
+  for (; i < props.length; ++i) {
+    if (applied.indexOf(props[i]) !== -1)
+      amount++;
+  }
+  elm.addEventListener(
+    "transitionend",
+    function(ev) {
+      if (ev.target === elm)
+        --amount;
+      if (amount === 0)
+        rm();
+    }
+  );
+}
+const styleModule = {
+  pre: forceReflow,
+  create: updateStyle,
+  update: updateStyle,
+  destroy: applyDestroyStyle,
+  remove: applyRemoveStyle
+};
+const modules = {
+  attributesModule,
+  classModule,
+  eventListenersModule,
+  propsModule,
+  styleModule
+};
+function sameVnode(vnode1, vnode2) {
+  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;
+}
+function isVnode(vnode2) {
+  return vnode2.sel !== void 0;
+}
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+  var _a;
+  const map = {};
+  for (let i = beginIdx; i <= endIdx; ++i) {
+    const key = (_a = children[i]) == null ? void 0 : _a.key;
+    if (key !== void 0) {
+      map[key] = i;
+    }
+  }
+  return map;
+}
+const emptyNode = vnode$1("", {}, [], void 0, void 0);
+function init() {
+  const api = htmlDomApi;
+  const cbs = {
+    create: [],
+    update: [],
+    destroy: []
+  };
+  for (const key of Object.keys(cbs)) {
+    cbs[key] = [];
+    for (const module of Object.keys(modules)) {
+      const hook = modules[module][key];
+      if (hook !== void 0) {
+        cbs[key].push(hook);
+      }
+    }
+  }
+  function emptyNodeAt(elm) {
+    const id = elm.id ? "#" + elm.id : "";
+    const c = elm.className ? "." + elm.className.split(" ").join(".") : "";
+    return vnode$1(
+      api.tagName(elm).toLowerCase() + id + c,
+      {},
+      [],
+      void 0,
+      elm
+    );
+  }
+  function isUndef(s) {
+    return s === void 0;
+  }
+  function isDef(s) {
+    return s !== void 0;
+  }
+  function createElm(vnode2) {
+    let i;
+    const children = vnode2.children;
+    const sel = vnode2.sel;
+    if (sel === "!") {
+      if (isUndef(vnode2.text)) {
+        vnode2.text = "";
+      }
+      vnode2.elm = api.createComment(`${vnode2.text}`);
+    } else if (sel !== void 0) {
+      const hashIdx = sel.indexOf("#");
+      const dotIdx = sel.indexOf(".", hashIdx);
+      const hash = hashIdx > 0 ? hashIdx : sel.length;
+      const dot = dotIdx > 0 ? dotIdx : sel.length;
+      const tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;
+      const elm = vnode2.elm = api.createElement(tag);
+      if (hash < dot)
+        elm.setAttribute("id", sel.slice(hash + 1, dot));
+      if (dotIdx > 0)
+        elm.setAttribute("class", sel.slice(dot + 1).replace(/\./g, " "));
+      for (i = 0; i < cbs.create.length; ++i) {
+        cbs.create[i](emptyNode, vnode2);
+      }
+      if (array(children)) {
+        for (i = 0; i < children.length; ++i) {
+          const ch = children[i];
+          if (ch != null) {
+            api.appendChild(elm, createElm(ch));
+          }
+        }
+      } else if (primitive(vnode2.text)) {
+        api.appendChild(elm, api.createTextNode(`${vnode2.text}`));
+      }
+    } else {
+      vnode2.elm = api.createTextNode(`${vnode2.text}`);
+    }
+    return vnode2.elm;
+  }
+  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {
+    for (; startIdx <= endIdx; ++startIdx) {
+      const ch = vnodes[startIdx];
+      if (ch != null) {
+        api.insertBefore(parentElm, createElm(ch), before);
+      }
+    }
+  }
+  function invokeDestroyHook(vnode2) {
+    const data = vnode2.data;
+    if (data !== void 0) {
+      for (let i = 0; i < cbs.destroy.length; ++i)
+        cbs.destroy[i](vnode2);
+      if (vnode2.children !== void 0) {
+        for (let j = 0; j < vnode2.children.length; ++j) {
+          const child = vnode2.children[j];
+          if (child != null && typeof child !== "string" && typeof child !== "number") {
+            invokeDestroyHook(child);
+          }
+        }
+      }
+    }
+  }
+  function createRmCb(childElm) {
+    return function rmCb() {
+      const parent = api.parentNode(childElm);
+      api.removeChild(parent, childElm);
+    };
+  }
+  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {
+    for (; startIdx <= endIdx; ++startIdx) {
+      let rm;
+      const ch = vnodes[startIdx];
+      if (ch != null) {
+        if (isDef(ch.sel)) {
+          invokeDestroyHook(ch);
+          rm = createRmCb(ch.elm);
+          rm();
+        } else {
+          api.removeChild(parentElm, ch.elm);
+        }
+      }
+    }
+  }
+  function updateChildren(parentElm, oldCh, newCh) {
+    let oldStartIdx = 0;
+    let newStartIdx = 0;
+    let oldEndIdx = oldCh.length - 1;
+    let newEndIdx = newCh.length - 1;
+    let oldStartVnode = oldCh[0];
+    let oldEndVnode = oldCh[oldEndIdx];
+    let newStartVnode = newCh[0];
+    let newEndVnode = newCh[newEndIdx];
+    let oldKeyToIdx;
+    let idxInOld;
+    let elmToMove;
+    let before;
+    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+      if (oldStartVnode == null) {
+        oldStartVnode = oldCh[++oldStartIdx];
+      } else if (oldEndVnode == null) {
+        oldEndVnode = oldCh[--oldEndIdx];
+      } else if (newStartVnode == null) {
+        newStartVnode = newCh[++newStartIdx];
+      } else if (newEndVnode == null) {
+        newEndVnode = newCh[--newEndIdx];
+      } else if (sameVnode(oldStartVnode, newStartVnode)) {
+        patchVnode(oldStartVnode, newStartVnode);
+        oldStartVnode = oldCh[++oldStartIdx];
+        newStartVnode = newCh[++newStartIdx];
+      } else if (sameVnode(oldEndVnode, newEndVnode)) {
+        patchVnode(oldEndVnode, newEndVnode);
+        oldEndVnode = oldCh[--oldEndIdx];
+        newEndVnode = newCh[--newEndIdx];
+      } else if (sameVnode(oldStartVnode, newEndVnode)) {
+        patchVnode(oldStartVnode, newEndVnode);
+        api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));
+        oldStartVnode = oldCh[++oldStartIdx];
+        newEndVnode = newCh[--newEndIdx];
+      } else if (sameVnode(oldEndVnode, newStartVnode)) {
+        patchVnode(oldEndVnode, newStartVnode);
+        api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+        oldEndVnode = oldCh[--oldEndIdx];
+        newStartVnode = newCh[++newStartIdx];
+      } else {
+        if (oldKeyToIdx === void 0) {
+          oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+        }
+        idxInOld = oldKeyToIdx[newStartVnode.key];
+        if (isUndef(idxInOld)) {
+          api.insertBefore(
+            parentElm,
+            createElm(newStartVnode),
+            oldStartVnode.elm
+          );
+        } else {
+          elmToMove = oldCh[idxInOld];
+          if (elmToMove.sel !== newStartVnode.sel) {
+            api.insertBefore(
+              parentElm,
+              createElm(newStartVnode),
+              oldStartVnode.elm
+            );
+          } else {
+            patchVnode(elmToMove, newStartVnode);
+            oldCh[idxInOld] = void 0;
+            api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);
+          }
+        }
+        newStartVnode = newCh[++newStartIdx];
+      }
+    }
+    if (oldStartIdx <= oldEndIdx || newStartIdx <= newEndIdx) {
+      if (oldStartIdx > oldEndIdx) {
+        before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;
+        addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);
+      } else {
+        removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
+      }
+    }
+  }
+  function patchVnode(oldVnode, vnode2) {
+    if (vnode2.data !== void 0) {
+      for (let i = 0; i < cbs.update.length; ++i) {
+        cbs.update[i](oldVnode, vnode2);
+      }
+    }
+    const elm = vnode2.elm = oldVnode.elm;
+    const oldCh = oldVnode.children;
+    const ch = vnode2.children;
+    if (oldVnode === vnode2)
+      return;
+    if (isUndef(vnode2.text)) {
+      if (isDef(oldCh) && isDef(ch)) {
+        if (oldCh !== ch) {
+          updateChildren(elm, oldCh, ch);
+        }
+      }
+    }
+  }
+  return function patch(oldVnode, vnode2) {
+    let elm, parent;
+    if (!isVnode(oldVnode)) {
+      oldVnode = emptyNodeAt(oldVnode);
+    }
+    if (sameVnode(oldVnode, vnode2)) {
+      patchVnode(oldVnode, vnode2);
+    } else {
+      elm = oldVnode.elm;
+      parent = api.parentNode(elm);
+      createElm(vnode2);
+      if (parent != null) {
+        api.insertBefore(parent, vnode2.elm, api.nextSibling(elm));
+        removeVnodes(parent, [oldVnode], 0, 0);
+      }
+    }
+    return vnode2;
+  };
+}
+function addNS(data, children, sel) {
+  data.ns = "http://www.w3.org/2000/svg";
+  if (sel !== "foreignObject" && children !== void 0) {
+    for (let i = 0; i < children.length; ++i) {
+      const child = children[i];
+      if (typeof child === "string" || typeof child === "number")
+        continue;
+      const childData = child.data;
+      if (childData !== void 0) {
+        addNS(childData, child.children, child.sel);
+      }
+    }
+  }
+}
+function h(sel, b, c) {
+  let data = {};
+  let children = void 0;
+  let text;
+  let i;
+  if (c !== void 0) {
+    if (b != null) {
+      data = b;
+    }
+    if (array(c)) {
+      children = c;
+    } else if (primitive(c)) {
+      text = c;
+    } else if (c && c.sel) {
+      children = [c];
+    }
+  } else if (b !== void 0 && b != null) {
+    if (array(b)) {
+      children = b;
+    } else if (primitive(b)) {
+      text = b;
+    } else {
+      if (isVnode$1(b)) {
+        children = [b];
+      } else {
+        data = b;
+      }
+    }
+  }
+  if (typeof children !== "undefined") {
+    for (i = 0; i < children.length; ++i) {
+      const msg = children[i];
+      if (primitive(msg)) {
+        children[i] = vnode$1(void 0, void 0, void 0, msg, void 0);
+      }
+    }
+  }
+  if (sel[0] === "s" && sel[1] === "v" && sel[2] === "g" && (sel.length === 3 || sel[3] === "." || sel[3] === "#")) {
+    addNS(data, children, sel);
+  }
+  return vnode$1(sel, data, children, text, void 0);
+}
+function querystring(data = {}) {
+  if (typeof data !== "object") {
+    throw new TypeError("param must be object");
+  }
+  return Object.entries(data).reduce((searchParams, [name, value]) => value === void 0 || value == null ? searchParams : (searchParams.append(decodeURIComponent(name), decodeURIComponent(value)), searchParams), new URLSearchParams()).toString();
+}
+function randomString(len = 8) {
+  const chars = "ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678";
+  const maxPos = chars.length;
+  let pwd = "";
+  for (let i = 0; i < len; i++) {
+    pwd += chars.charAt(Math.floor(Math.random() * maxPos));
+  }
+  return `${Date.now()}-${pwd}`;
+}
+function getCookie(name) {
+  const cookieList = window.document.cookie.match(
+    new RegExp(`(^| )${name}(?:=([^;]*))?(;|$)`)
+  );
+  if (cookieList && cookieList[2])
+    return cookieList[2];
+  return "";
+}
+function createData(params = {}) {
+  return Object.assign({}, {
+    id: randomString(),
+    path: window.location.href,
+    time: Date.now(),
+    userAgent: window.navigator.userAgent,
+    referrer: document.referrer,
+    ip: window.returnCitySN || { cid: "", cip: "", cname: "" },
+    userId: getCookie("chaxus_prod")
+  }, params);
+}
+const throttle = (fn, wait = 300) => {
+  let timer = null;
+  return function(...args) {
+    const context = this;
+    if (!timer) {
+      timer = setTimeout(() => {
+        timer = null;
+        fn.apply(context, args);
+      }, wait);
+    }
+  };
+};
+const Noop = () => {
+};
+function replaceOld(source, name, replacement, isForced) {
+  if (typeof source === "undefined")
+    return;
+  if (name in source || isForced) {
+    const original = source[name];
+    const wrapped = replacement(original);
+    if (typeof wrapped === "function") {
+      source[name] = wrapped;
+    }
+  }
+}
+const isString = (obj) => {
+  return toString.call(obj) === "[object String]";
+};
+const handleClick = (hooks = Noop) => {
+  document.addEventListener("click", function(event) {
+    hooks(event);
+  }, true);
+};
+const handleError = (hooks = Noop) => {
+  window.addEventListener("unhandledrejection", (error) => {
+    hooks(error);
+  }, true);
+  window.addEventListener("error", (error) => {
+    hooks(error);
+    return false;
+  }, true);
+};
+function getPerformance() {
+  const [performanceNavigationTiming] = performance.getEntriesByType("navigation");
+  const [firstPaint, firstContentfulPaint] = performance.getEntriesByType("paint");
+  const {
+    domainLookupEnd,
+    domainLookupStart,
+    connectEnd,
+    connectStart,
+    secureConnectionStart,
+    loadEventStart,
+    domInteractive,
+    domContentLoadedEventEnd,
+    duration,
+    responseStart,
+    requestStart,
+    responseEnd,
+    fetchStart,
+    transferSize,
+    encodedBodySize,
+    redirectEnd,
+    redirectStart,
+    redirectCount
+  } = performanceNavigationTiming;
+  const { startTime: fp } = firstPaint;
+  const { startTime: fcp } = firstContentfulPaint;
+  return {
+    dnsSearch: domainLookupEnd - domainLookupStart,
+    tcpConnect: connectEnd - connectStart,
+    sslConnect: connectEnd - secureConnectionStart,
+    request: responseStart - requestStart,
+    response: responseEnd - responseStart,
+    parseDomTree: domInteractive - responseEnd,
+    resource: loadEventStart - domContentLoadedEventEnd,
+    domReady: domContentLoadedEventEnd - fetchStart,
+    interactive: domInteractive - fetchStart,
+    complete: loadEventStart - fetchStart,
+    httpHead: transferSize - encodedBodySize,
+    redirect: redirectCount,
+    redirectTime: redirectEnd - redirectStart,
+    duration,
+    fp,
+    fcp
+  };
+}
+const getHost = (env) => {
+  let host = "";
+  if (env && isString(env)) {
+    if (/trunk|neibu|release/.test(env)) {
+      host = `.${env}`;
+    } else if (/test/.test(env)) {
+      host = env;
+    } else if (/prod/.test(env)) {
+      host = "";
+    } else {
+      host = "";
+    }
+  } else {
+    const env2 = /\w(\.trunk|\.neibu|\.release|test)\./.exec(
+      window.location.hostname
+    );
+    if (env2) {
+      host = env2[1];
+    }
+  }
+  return host ? `https://log${host}.chaxus.com` : "https://log.chaxus.com";
+};
+const sendBeacon = ({ url = "", type = "application/json; charset=UTF-8", payload = {} }) => {
+  const requestUrl = url ? url : getHost();
+  if (navigator.sendBeacon) {
+    const param = new Blob([JSON.stringify(payload)], { type });
+    return navigator.sendBeacon(requestUrl, param);
+  }
+};
+const sendImage = ({ url = "", payload = {} }) => {
+  const requestUrl = url ? url : getHost();
+  const image = new Image();
+  image.width = 1;
+  image.height = 1;
+  image.src = `${requestUrl}?${querystring(payload)}`;
+};
+const report = ({ url = "", type = "application/json; charset=UTF-8", payload = {} }) => {
+  const requestUrl = url ? url : getHost();
+  if (typeof navigator.sendBeacon !== "undefined") {
+    return sendBeacon({ url: requestUrl, type, payload });
+  }
+  return sendImage({ url: requestUrl, payload });
+};
+const handleFetchHook = (options = {}) => {
+  if (typeof window !== "undefined") {
+    const { requestHook = Noop, responseHook = Noop, errorHook = Noop } = options;
+    const replacement = (originalFetch) => {
+      return (url, config) => {
+        requestHook(url, config);
+        return originalFetch.apply(window, [url, config]).then((response) => {
+          responseHook(url, config, response);
+          return response;
+        }).catch((error) => {
+          errorHook(url, error);
+          throw error;
+        });
+      };
+    };
+    replaceOld(window, "fetch", replacement);
+  }
+};
+const handleXhrHook = (options = {}) => {
+  const originalXhrProto = XMLHttpRequest.prototype;
+  const { requestHook = Noop, responseHook = Noop, errorHook = Noop } = options;
+  const replacementXhrOpen = (originalOpen) => {
+    return function(...args) {
+      requestHook(args);
+      originalOpen.apply(this, args);
+    };
+  };
+  replaceOld(originalXhrProto, "open", replacementXhrOpen);
+  const replacementXhrSend = (originalSend) => {
+    return function(...args) {
+      this.addEventListener("loadend", function() {
+        responseHook(this);
+      });
+      this.addEventListener("error", function() {
+        errorHook(this);
+      });
+      originalSend.apply(this, args);
+    };
+  };
+  replaceOld(originalXhrProto, "send", replacementXhrSend);
+};
+class Monitor {
+  reportPerformance() {
+    const params = getPerformance();
+    const payload = createData();
+    report({
+      payload: {
+        ...params,
+        ...payload
+      }
+    });
+  }
+  log(payload) {
+    report({ payload });
+  }
+  reportClick() {
+    const throttleReport = throttle(report);
+    const payload = createData();
+    const hook = (event) => {
+      throttleReport({ payload: { ...payload, event, type: "click" } });
+    };
+    handleClick(hook);
+  }
+  reportXhr() {
+    const throttleReport = throttle(report);
+    const payload = createData();
+    const requestHook = (...args) => {
+      throttleReport({ payload: { ...payload, ...args, type: "xhrRequest" } });
+    };
+    const responseHook = (...args) => {
+      throttleReport({ payload: { ...payload, ...args, type: "xhrResponse" } });
+    };
+    const errorHook = (...args) => {
+      throttleReport({ payload: { ...payload, ...args, type: "xhrError" } });
+    };
+    handleXhrHook({ requestHook, responseHook, errorHook });
+  }
+  reportFetch() {
+    const throttleReport = throttle(report);
+    const payload = createData();
+    const requestHook = (...args) => {
+      throttleReport({ payload: { ...payload, ...args, type: "fetchRequest" } });
+    };
+    const responseHook = (...args) => {
+      throttleReport({ payload: { ...payload, ...args, type: "fetchResponse" } });
+    };
+    const errorHook = (...args) => {
+      throttleReport({ payload: { ...payload, ...args, type: "fetchError" } });
+    };
+    handleFetchHook({ requestHook, responseHook, errorHook });
+  }
+  reportError() {
+    const throttleReport = throttle(report);
+    const payload = createData();
+    const hook = (...args) => {
+      throttleReport({ payload: { ...payload, ...args, type: "error" } });
+    };
+    handleError(hook);
+  }
+}
+const vnode = {
+  init,
+  h
 };
 export {
-  index as default
+  Subscribe as EventEmitter,
+  Monitor,
+  filterObj,
+  queryFileInfo,
+  readDir,
+  readFile,
+  str2Xml,
+  vnode,
+  watchFile,
+  writeFile
 };
 //# sourceMappingURL=index.js.map