"no use strict";

!function (window) {
  if (typeof window.window != "undefined" && window.document) return;
  if (window.require && window.define) return;

  if (!window.console) {
    window.console = function () {
      var msgs = Array.prototype.slice.call(arguments, 0);
      postMessage({
        type: "log",
        data: msgs
      });
    };

    window.console.error = window.console.warn = window.console.log = window.console.trace = window.console;
  }

  window.window = window;
  window.ace = window;

  window.onerror = function (message, file, line, col, err) {
    postMessage({
      type: "error",
      data: {
        message: message,
        data: err.data,
        file: file,
        line: line,
        col: col,
        stack: err.stack
      }
    });
  };

  window.normalizeModule = function (parentId, moduleName) {
    // normalize plugin requires
    if (moduleName.indexOf("!") !== -1) {
      var chunks = moduleName.split("!");
      return window.normalizeModule(parentId, chunks[0]) + "!" + window.normalizeModule(parentId, chunks[1]);
    } // normalize relative requires


    if (moduleName.charAt(0) == ".") {
      var base = parentId.split("/").slice(0, -1).join("/");
      moduleName = (base ? base + "/" : "") + moduleName;

      while (moduleName.indexOf(".") !== -1 && previous != moduleName) {
        var previous = moduleName;
        moduleName = moduleName.replace(/^\.\//, "").replace(/\/\.\//, "/").replace(/[^\/]+\/\.\.\//, "");
      }
    }

    return moduleName;
  };

  window.require = function require(parentId, id) {
    if (!id) {
      id = parentId;
      parentId = null;
    }

    if (!id.charAt) throw new Error("worker.js require() accepts only (parentId, id) as arguments");
    id = window.normalizeModule(parentId, id);
    var module = window.require.modules[id];

    if (module) {
      if (!module.initialized) {
        module.initialized = true;
        module.exports = module.factory().exports;
      }

      return module.exports;
    }

    if (!window.require.tlns) return console.log("unable to load " + id);
    var path = resolveModuleId(id, window.require.tlns);
    if (path.slice(-3) != ".js") path += ".js";
    window.require.id = id;
    window.require.modules[id] = {}; // prevent infinite loop on broken modules

    importScripts(path);
    return window.require(parentId, id);
  };

  function resolveModuleId(id, paths) {
    var testPath = id,
        tail = "";

    while (testPath) {
      var alias = paths[testPath];

      if (typeof alias == "string") {
        return alias + tail;
      } else if (alias) {
        return alias.location.replace(/\/*$/, "/") + (tail || alias.main || alias.name);
      } else if (alias === false) {
        return "";
      }

      var i = testPath.lastIndexOf("/");
      if (i === -1) break;
      tail = testPath.substr(i) + tail;
      testPath = testPath.slice(0, i);
    }

    return id;
  }

  window.require.modules = {};
  window.require.tlns = {};

  window.define = function (id, deps, _factory) {
    if (arguments.length == 2) {
      _factory = deps;

      if (typeof id != "string") {
        deps = id;
        id = window.require.id;
      }
    } else if (arguments.length == 1) {
      _factory = id;
      deps = [];
      id = window.require.id;
    }

    if (typeof _factory != "function") {
      window.require.modules[id] = {
        exports: _factory,
        initialized: true
      };
      return;
    }

    if (!deps.length) // If there is no dependencies, we inject "require", "exports" and
      // "module" as dependencies, to provide CommonJS compatibility.
      deps = ["require", "exports", "module"];

    var req = function req(childId) {
      return window.require(id, childId);
    };

    window.require.modules[id] = {
      exports: {},
      factory: function factory() {
        var module = this;

        var returnExports = _factory.apply(this, deps.slice(0, _factory.length).map(function (dep) {
          switch (dep) {
            // Because "require", "exports" and "module" aren't actual
            // dependencies, we must handle them seperately.
            case "require":
              return req;

            case "exports":
              return module.exports;

            case "module":
              return module;
            // But for all other dependencies, we can just go ahead and
            // require them.

            default:
              return req(dep);
          }
        }));

        if (returnExports) module.exports = returnExports;
        return module;
      }
    };
  };

  window.define.amd = {};
  require.tlns = {};

  window.initBaseUrls = function initBaseUrls(topLevelNamespaces) {
    for (var i in topLevelNamespaces) {
      require.tlns[i] = topLevelNamespaces[i];
    }
  };

  window.initSender = function initSender() {
    var EventEmitter = window.require("ace/lib/event_emitter").EventEmitter;

    var oop = window.require("ace/lib/oop");

    var Sender = function Sender() {};

    (function () {
      oop.implement(this, EventEmitter);

      this.callback = function (data, callbackId) {
        postMessage({
          type: "call",
          id: callbackId,
          data: data
        });
      };

      this.emit = function (name, data) {
        postMessage({
          type: "event",
          name: name,
          data: data
        });
      };
    }).call(Sender.prototype);
    return new Sender();
  };

  var main = window.main = null;
  var sender = window.sender = null;

  window.onmessage = function (e) {
    var msg = e.data;

    if (msg.event && sender) {
      sender._signal(msg.event, msg.data);
    } else if (msg.command) {
      if (main[msg.command]) main[msg.command].apply(main, msg.args);else if (window[msg.command]) window[msg.command].apply(window, msg.args);else throw new Error("Unknown command:" + msg.command);
    } else if (msg.init) {
      window.initBaseUrls(msg.tlns);

      require("ace/lib/es5-shim");

      sender = window.sender = window.initSender();

      var clazz = require(msg.module)[msg.classname];

      main = window.main = new clazz(sender);
    }
  };
}(this);
ace.define("ace/lib/oop", [], function (require, exports, module) {
  "use strict";

  exports.inherits = function (ctor, superCtor) {
    ctor.super_ = superCtor;
    ctor.prototype = Object.create(superCtor.prototype, {
      constructor: {
        value: ctor,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
  };

  exports.mixin = function (obj, mixin) {
    for (var key in mixin) {
      obj[key] = mixin[key];
    }

    return obj;
  };

  exports.implement = function (proto, mixin) {
    exports.mixin(proto, mixin);
  };
});
ace.define("ace/lib/lang", [], function (require, exports, module) {
  "use strict";

  exports.last = function (a) {
    return a[a.length - 1];
  };

  exports.stringReverse = function (string) {
    return string.split("").reverse().join("");
  };

  exports.stringRepeat = function (string, count) {
    var result = '';

    while (count > 0) {
      if (count & 1) result += string;
      if (count >>= 1) string += string;
    }

    return result;
  };

  var trimBeginRegexp = /^\s\s*/;
  var trimEndRegexp = /\s\s*$/;

  exports.stringTrimLeft = function (string) {
    return string.replace(trimBeginRegexp, '');
  };

  exports.stringTrimRight = function (string) {
    return string.replace(trimEndRegexp, '');
  };

  exports.copyObject = function (obj) {
    var copy = {};

    for (var key in obj) {
      copy[key] = obj[key];
    }

    return copy;
  };

  exports.copyArray = function (array) {
    var copy = [];

    for (var i = 0, l = array.length; i < l; i++) {
      if (array[i] && typeof array[i] == "object") copy[i] = this.copyObject(array[i]);else copy[i] = array[i];
    }

    return copy;
  };

  exports.deepCopy = function deepCopy(obj) {
    if (typeof obj !== "object" || !obj) return obj;
    var copy;

    if (Array.isArray(obj)) {
      copy = [];

      for (var key = 0; key < obj.length; key++) {
        copy[key] = deepCopy(obj[key]);
      }

      return copy;
    }

    if (Object.prototype.toString.call(obj) !== "[object Object]") return obj;
    copy = {};

    for (var key in obj) {
      copy[key] = deepCopy(obj[key]);
    }

    return copy;
  };

  exports.arrayToMap = function (arr) {
    var map = {};

    for (var i = 0; i < arr.length; i++) {
      map[arr[i]] = 1;
    }

    return map;
  };

  exports.createMap = function (props) {
    var map = Object.create(null);

    for (var i in props) {
      map[i] = props[i];
    }

    return map;
  };

  exports.arrayRemove = function (array, value) {
    for (var i = 0; i <= array.length; i++) {
      if (value === array[i]) {
        array.splice(i, 1);
      }
    }
  };

  exports.escapeRegExp = function (str) {
    return str.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');
  };

  exports.escapeHTML = function (str) {
    return ("" + str).replace(/&/g, "&#38;").replace(/"/g, "&#34;").replace(/'/g, "&#39;").replace(/</g, "&#60;");
  };

  exports.getMatchOffsets = function (string, regExp) {
    var matches = [];
    string.replace(regExp, function (str) {
      matches.push({
        offset: arguments[arguments.length - 2],
        length: str.length
      });
    });
    return matches;
  };

  exports.deferredCall = function (fcn) {
    var timer = null;

    var callback = function callback() {
      timer = null;
      fcn();
    };

    var deferred = function deferred(timeout) {
      deferred.cancel();
      timer = setTimeout(callback, timeout || 0);
      return deferred;
    };

    deferred.schedule = deferred;

    deferred.call = function () {
      this.cancel();
      fcn();
      return deferred;
    };

    deferred.cancel = function () {
      clearTimeout(timer);
      timer = null;
      return deferred;
    };

    deferred.isPending = function () {
      return timer;
    };

    return deferred;
  };

  exports.delayedCall = function (fcn, defaultTimeout) {
    var timer = null;

    var callback = function callback() {
      timer = null;
      fcn();
    };

    var _self = function _self(timeout) {
      if (timer == null) timer = setTimeout(callback, timeout || defaultTimeout);
    };

    _self.delay = function (timeout) {
      timer && clearTimeout(timer);
      timer = setTimeout(callback, timeout || defaultTimeout);
    };

    _self.schedule = _self;

    _self.call = function () {
      this.cancel();
      fcn();
    };

    _self.cancel = function () {
      timer && clearTimeout(timer);
      timer = null;
    };

    _self.isPending = function () {
      return timer;
    };

    return _self;
  };
});
ace.define("ace/range", [], function (require, exports, module) {
  "use strict";

  var comparePoints = function comparePoints(p1, p2) {
    return p1.row - p2.row || p1.column - p2.column;
  };

  var Range = function Range(startRow, startColumn, endRow, endColumn) {
    this.start = {
      row: startRow,
      column: startColumn
    };
    this.end = {
      row: endRow,
      column: endColumn
    };
  };

  (function () {
    this.isEqual = function (range) {
      return this.start.row === range.start.row && this.end.row === range.end.row && this.start.column === range.start.column && this.end.column === range.end.column;
    };

    this.toString = function () {
      return "Range: [" + this.start.row + "/" + this.start.column + "] -> [" + this.end.row + "/" + this.end.column + "]";
    };

    this.contains = function (row, column) {
      return this.compare(row, column) == 0;
    };

    this.compareRange = function (range) {
      var cmp,
          end = range.end,
          start = range.start;
      cmp = this.compare(end.row, end.column);

      if (cmp == 1) {
        cmp = this.compare(start.row, start.column);

        if (cmp == 1) {
          return 2;
        } else if (cmp == 0) {
          return 1;
        } else {
          return 0;
        }
      } else if (cmp == -1) {
        return -2;
      } else {
        cmp = this.compare(start.row, start.column);

        if (cmp == -1) {
          return -1;
        } else if (cmp == 1) {
          return 42;
        } else {
          return 0;
        }
      }
    };

    this.comparePoint = function (p) {
      return this.compare(p.row, p.column);
    };

    this.containsRange = function (range) {
      return this.comparePoint(range.start) == 0 && this.comparePoint(range.end) == 0;
    };

    this.intersects = function (range) {
      var cmp = this.compareRange(range);
      return cmp == -1 || cmp == 0 || cmp == 1;
    };

    this.isEnd = function (row, column) {
      return this.end.row == row && this.end.column == column;
    };

    this.isStart = function (row, column) {
      return this.start.row == row && this.start.column == column;
    };

    this.setStart = function (row, column) {
      if (typeof row == "object") {
        this.start.column = row.column;
        this.start.row = row.row;
      } else {
        this.start.row = row;
        this.start.column = column;
      }
    };

    this.setEnd = function (row, column) {
      if (typeof row == "object") {
        this.end.column = row.column;
        this.end.row = row.row;
      } else {
        this.end.row = row;
        this.end.column = column;
      }
    };

    this.inside = function (row, column) {
      if (this.compare(row, column) == 0) {
        if (this.isEnd(row, column) || this.isStart(row, column)) {
          return false;
        } else {
          return true;
        }
      }

      return false;
    };

    this.insideStart = function (row, column) {
      if (this.compare(row, column) == 0) {
        if (this.isEnd(row, column)) {
          return false;
        } else {
          return true;
        }
      }

      return false;
    };

    this.insideEnd = function (row, column) {
      if (this.compare(row, column) == 0) {
        if (this.isStart(row, column)) {
          return false;
        } else {
          return true;
        }
      }

      return false;
    };

    this.compare = function (row, column) {
      if (!this.isMultiLine()) {
        if (row === this.start.row) {
          return column < this.start.column ? -1 : column > this.end.column ? 1 : 0;
        }
      }

      if (row < this.start.row) return -1;
      if (row > this.end.row) return 1;
      if (this.start.row === row) return column >= this.start.column ? 0 : -1;
      if (this.end.row === row) return column <= this.end.column ? 0 : 1;
      return 0;
    };

    this.compareStart = function (row, column) {
      if (this.start.row == row && this.start.column == column) {
        return -1;
      } else {
        return this.compare(row, column);
      }
    };

    this.compareEnd = function (row, column) {
      if (this.end.row == row && this.end.column == column) {
        return 1;
      } else {
        return this.compare(row, column);
      }
    };

    this.compareInside = function (row, column) {
      if (this.end.row == row && this.end.column == column) {
        return 1;
      } else if (this.start.row == row && this.start.column == column) {
        return -1;
      } else {
        return this.compare(row, column);
      }
    };

    this.clipRows = function (firstRow, lastRow) {
      if (this.end.row > lastRow) var end = {
        row: lastRow + 1,
        column: 0
      };else if (this.end.row < firstRow) var end = {
        row: firstRow,
        column: 0
      };
      if (this.start.row > lastRow) var start = {
        row: lastRow + 1,
        column: 0
      };else if (this.start.row < firstRow) var start = {
        row: firstRow,
        column: 0
      };
      return Range.fromPoints(start || this.start, end || this.end);
    };

    this.extend = function (row, column) {
      var cmp = this.compare(row, column);
      if (cmp == 0) return this;else if (cmp == -1) var start = {
        row: row,
        column: column
      };else var end = {
        row: row,
        column: column
      };
      return Range.fromPoints(start || this.start, end || this.end);
    };

    this.isEmpty = function () {
      return this.start.row === this.end.row && this.start.column === this.end.column;
    };

    this.isMultiLine = function () {
      return this.start.row !== this.end.row;
    };

    this.clone = function () {
      return Range.fromPoints(this.start, this.end);
    };

    this.collapseRows = function () {
      if (this.end.column == 0) return new Range(this.start.row, 0, Math.max(this.start.row, this.end.row - 1), 0);else return new Range(this.start.row, 0, this.end.row, 0);
    };

    this.toScreenRange = function (session) {
      var screenPosStart = session.documentToScreenPosition(this.start);
      var screenPosEnd = session.documentToScreenPosition(this.end);
      return new Range(screenPosStart.row, screenPosStart.column, screenPosEnd.row, screenPosEnd.column);
    };

    this.moveBy = function (row, column) {
      this.start.row += row;
      this.start.column += column;
      this.end.row += row;
      this.end.column += column;
    };
  }).call(Range.prototype);

  Range.fromPoints = function (start, end) {
    return new Range(start.row, start.column, end.row, end.column);
  };

  Range.comparePoints = comparePoints;

  Range.comparePoints = function (p1, p2) {
    return p1.row - p2.row || p1.column - p2.column;
  };

  exports.Range = Range;
});
ace.define("ace/apply_delta", [], function (require, exports, module) {
  "use strict";

  function throwDeltaError(delta, errorText) {
    console.log("Invalid Delta:", delta);
    throw "Invalid Delta: " + errorText;
  }

  function positionInDocument(docLines, position) {
    return position.row >= 0 && position.row < docLines.length && position.column >= 0 && position.column <= docLines[position.row].length;
  }

  function validateDelta(docLines, delta) {
    if (delta.action != "insert" && delta.action != "remove") throwDeltaError(delta, "delta.action must be 'insert' or 'remove'");
    if (!(delta.lines instanceof Array)) throwDeltaError(delta, "delta.lines must be an Array");
    if (!delta.start || !delta.end) throwDeltaError(delta, "delta.start/end must be an present");
    var start = delta.start;
    if (!positionInDocument(docLines, delta.start)) throwDeltaError(delta, "delta.start must be contained in document");
    var end = delta.end;
    if (delta.action == "remove" && !positionInDocument(docLines, end)) throwDeltaError(delta, "delta.end must contained in document for 'remove' actions");
    var numRangeRows = end.row - start.row;
    var numRangeLastLineChars = end.column - (numRangeRows == 0 ? start.column : 0);
    if (numRangeRows != delta.lines.length - 1 || delta.lines[numRangeRows].length != numRangeLastLineChars) throwDeltaError(delta, "delta.range must match delta lines");
  }

  exports.applyDelta = function (docLines, delta, doNotValidate) {
    var row = delta.start.row;
    var startColumn = delta.start.column;
    var line = docLines[row] || "";

    switch (delta.action) {
      case "insert":
        var lines = delta.lines;

        if (lines.length === 1) {
          docLines[row] = line.substring(0, startColumn) + delta.lines[0] + line.substring(startColumn);
        } else {
          var args = [row, 1].concat(delta.lines);
          docLines.splice.apply(docLines, args);
          docLines[row] = line.substring(0, startColumn) + docLines[row];
          docLines[row + delta.lines.length - 1] += line.substring(startColumn);
        }

        break;

      case "remove":
        var endColumn = delta.end.column;
        var endRow = delta.end.row;

        if (row === endRow) {
          docLines[row] = line.substring(0, startColumn) + line.substring(endColumn);
        } else {
          docLines.splice(row, endRow - row + 1, line.substring(0, startColumn) + docLines[endRow].substring(endColumn));
        }

        break;
    }
  };
});
ace.define("ace/lib/event_emitter", [], function (require, exports, module) {
  "use strict";

  var EventEmitter = {};

  var stopPropagation = function stopPropagation() {
    this.propagationStopped = true;
  };

  var preventDefault = function preventDefault() {
    this.defaultPrevented = true;
  };

  EventEmitter._emit = EventEmitter._dispatchEvent = function (eventName, e) {
    this._eventRegistry || (this._eventRegistry = {});
    this._defaultHandlers || (this._defaultHandlers = {});
    var listeners = this._eventRegistry[eventName] || [];
    var defaultHandler = this._defaultHandlers[eventName];
    if (!listeners.length && !defaultHandler) return;
    if (typeof e != "object" || !e) e = {};
    if (!e.type) e.type = eventName;
    if (!e.stopPropagation) e.stopPropagation = stopPropagation;
    if (!e.preventDefault) e.preventDefault = preventDefault;
    listeners = listeners.slice();

    for (var i = 0; i < listeners.length; i++) {
      listeners[i](e, this);
      if (e.propagationStopped) break;
    }

    if (defaultHandler && !e.defaultPrevented) return defaultHandler(e, this);
  };

  EventEmitter._signal = function (eventName, e) {
    var listeners = (this._eventRegistry || {})[eventName];
    if (!listeners) return;
    listeners = listeners.slice();

    for (var i = 0; i < listeners.length; i++) {
      listeners[i](e, this);
    }
  };

  EventEmitter.once = function (eventName, callback) {
    var _self = this;

    this.on(eventName, function newCallback() {
      _self.off(eventName, newCallback);

      callback.apply(null, arguments);
    });

    if (!callback) {
      return new Promise(function (resolve) {
        callback = resolve;
      });
    }
  };

  EventEmitter.setDefaultHandler = function (eventName, callback) {
    var handlers = this._defaultHandlers;
    if (!handlers) handlers = this._defaultHandlers = {
      _disabled_: {}
    };

    if (handlers[eventName]) {
      var old = handlers[eventName];
      var disabled = handlers._disabled_[eventName];
      if (!disabled) handlers._disabled_[eventName] = disabled = [];
      disabled.push(old);
      var i = disabled.indexOf(callback);
      if (i != -1) disabled.splice(i, 1);
    }

    handlers[eventName] = callback;
  };

  EventEmitter.removeDefaultHandler = function (eventName, callback) {
    var handlers = this._defaultHandlers;
    if (!handlers) return;
    var disabled = handlers._disabled_[eventName];

    if (handlers[eventName] == callback) {
      if (disabled) this.setDefaultHandler(eventName, disabled.pop());
    } else if (disabled) {
      var i = disabled.indexOf(callback);
      if (i != -1) disabled.splice(i, 1);
    }
  };

  EventEmitter.on = EventEmitter.addEventListener = function (eventName, callback, capturing) {
    this._eventRegistry = this._eventRegistry || {};
    var listeners = this._eventRegistry[eventName];
    if (!listeners) listeners = this._eventRegistry[eventName] = [];
    if (listeners.indexOf(callback) == -1) listeners[capturing ? "unshift" : "push"](callback);
    return callback;
  };

  EventEmitter.off = EventEmitter.removeListener = EventEmitter.removeEventListener = function (eventName, callback) {
    this._eventRegistry = this._eventRegistry || {};
    var listeners = this._eventRegistry[eventName];
    if (!listeners) return;
    var index = listeners.indexOf(callback);
    if (index !== -1) listeners.splice(index, 1);
  };

  EventEmitter.removeAllListeners = function (eventName) {
    if (!eventName) this._eventRegistry = this._defaultHandlers = undefined;
    if (this._eventRegistry) this._eventRegistry[eventName] = undefined;
    if (this._defaultHandlers) this._defaultHandlers[eventName] = undefined;
  };

  exports.EventEmitter = EventEmitter;
});
ace.define("ace/anchor", [], function (require, exports, module) {
  "use strict";

  var oop = require("./lib/oop");

  var EventEmitter = require("./lib/event_emitter").EventEmitter;

  var Anchor = exports.Anchor = function (doc, row, column) {
    this.$onChange = this.onChange.bind(this);
    this.attach(doc);
    if (typeof column == "undefined") this.setPosition(row.row, row.column);else this.setPosition(row, column);
  };

  (function () {
    oop.implement(this, EventEmitter);

    this.getPosition = function () {
      return this.$clipPositionToDocument(this.row, this.column);
    };

    this.getDocument = function () {
      return this.document;
    };

    this.$insertRight = false;

    this.onChange = function (delta) {
      if (delta.start.row == delta.end.row && delta.start.row != this.row) return;
      if (delta.start.row > this.row) return;
      var point = $getTransformedPoint(delta, {
        row: this.row,
        column: this.column
      }, this.$insertRight);
      this.setPosition(point.row, point.column, true);
    };

    function $pointsInOrder(point1, point2, equalPointsInOrder) {
      var bColIsAfter = equalPointsInOrder ? point1.column <= point2.column : point1.column < point2.column;
      return point1.row < point2.row || point1.row == point2.row && bColIsAfter;
    }

    function $getTransformedPoint(delta, point, moveIfEqual) {
      var deltaIsInsert = delta.action == "insert";
      var deltaRowShift = (deltaIsInsert ? 1 : -1) * (delta.end.row - delta.start.row);
      var deltaColShift = (deltaIsInsert ? 1 : -1) * (delta.end.column - delta.start.column);
      var deltaStart = delta.start;
      var deltaEnd = deltaIsInsert ? deltaStart : delta.end; // Collapse insert range.

      if ($pointsInOrder(point, deltaStart, moveIfEqual)) {
        return {
          row: point.row,
          column: point.column
        };
      }

      if ($pointsInOrder(deltaEnd, point, !moveIfEqual)) {
        return {
          row: point.row + deltaRowShift,
          column: point.column + (point.row == deltaEnd.row ? deltaColShift : 0)
        };
      }

      return {
        row: deltaStart.row,
        column: deltaStart.column
      };
    }

    this.setPosition = function (row, column, noClip) {
      var pos;

      if (noClip) {
        pos = {
          row: row,
          column: column
        };
      } else {
        pos = this.$clipPositionToDocument(row, column);
      }

      if (this.row == pos.row && this.column == pos.column) return;
      var old = {
        row: this.row,
        column: this.column
      };
      this.row = pos.row;
      this.column = pos.column;

      this._signal("change", {
        old: old,
        value: pos
      });
    };

    this.detach = function () {
      this.document.off("change", this.$onChange);
    };

    this.attach = function (doc) {
      this.document = doc || this.document;
      this.document.on("change", this.$onChange);
    };

    this.$clipPositionToDocument = function (row, column) {
      var pos = {};

      if (row >= this.document.getLength()) {
        pos.row = Math.max(0, this.document.getLength() - 1);
        pos.column = this.document.getLine(pos.row).length;
      } else if (row < 0) {
        pos.row = 0;
        pos.column = 0;
      } else {
        pos.row = row;
        pos.column = Math.min(this.document.getLine(pos.row).length, Math.max(0, column));
      }

      if (column < 0) pos.column = 0;
      return pos;
    };
  }).call(Anchor.prototype);
});
ace.define("ace/document", [], function (require, exports, module) {
  "use strict";

  var oop = require("./lib/oop");

  var applyDelta = require("./apply_delta").applyDelta;

  var EventEmitter = require("./lib/event_emitter").EventEmitter;

  var Range = require("./range").Range;

  var Anchor = require("./anchor").Anchor;

  var Document = function Document(textOrLines) {
    this.$lines = [""];

    if (textOrLines.length === 0) {
      this.$lines = [""];
    } else if (Array.isArray(textOrLines)) {
      this.insertMergedLines({
        row: 0,
        column: 0
      }, textOrLines);
    } else {
      this.insert({
        row: 0,
        column: 0
      }, textOrLines);
    }
  };

  (function () {
    oop.implement(this, EventEmitter);

    this.setValue = function (text) {
      var len = this.getLength() - 1;
      this.remove(new Range(0, 0, len, this.getLine(len).length));
      this.insert({
        row: 0,
        column: 0
      }, text);
    };

    this.getValue = function () {
      return this.getAllLines().join(this.getNewLineCharacter());
    };

    this.createAnchor = function (row, column) {
      return new Anchor(this, row, column);
    };

    if ("aaa".split(/a/).length === 0) {
      this.$split = function (text) {
        return text.replace(/\r\n|\r/g, "\n").split("\n");
      };
    } else {
      this.$split = function (text) {
        return text.split(/\r\n|\r|\n/);
      };
    }

    this.$detectNewLine = function (text) {
      var match = text.match(/^.*?(\r\n|\r|\n)/m);
      this.$autoNewLine = match ? match[1] : "\n";

      this._signal("changeNewLineMode");
    };

    this.getNewLineCharacter = function () {
      switch (this.$newLineMode) {
        case "windows":
          return "\r\n";

        case "unix":
          return "\n";

        default:
          return this.$autoNewLine || "\n";
      }
    };

    this.$autoNewLine = "";
    this.$newLineMode = "auto";

    this.setNewLineMode = function (newLineMode) {
      if (this.$newLineMode === newLineMode) return;
      this.$newLineMode = newLineMode;

      this._signal("changeNewLineMode");
    };

    this.getNewLineMode = function () {
      return this.$newLineMode;
    };

    this.isNewLine = function (text) {
      return text == "\r\n" || text == "\r" || text == "\n";
    };

    this.getLine = function (row) {
      return this.$lines[row] || "";
    };

    this.getLines = function (firstRow, lastRow) {
      return this.$lines.slice(firstRow, lastRow + 1);
    };

    this.getAllLines = function () {
      return this.getLines(0, this.getLength());
    };

    this.getLength = function () {
      return this.$lines.length;
    };

    this.getTextRange = function (range) {
      return this.getLinesForRange(range).join(this.getNewLineCharacter());
    };

    this.getLinesForRange = function (range) {
      var lines;

      if (range.start.row === range.end.row) {
        lines = [this.getLine(range.start.row).substring(range.start.column, range.end.column)];
      } else {
        lines = this.getLines(range.start.row, range.end.row);
        lines[0] = (lines[0] || "").substring(range.start.column);
        var l = lines.length - 1;
        if (range.end.row - range.start.row == l) lines[l] = lines[l].substring(0, range.end.column);
      }

      return lines;
    };

    this.insertLines = function (row, lines) {
      console.warn("Use of document.insertLines is deprecated. Use the insertFullLines method instead.");
      return this.insertFullLines(row, lines);
    };

    this.removeLines = function (firstRow, lastRow) {
      console.warn("Use of document.removeLines is deprecated. Use the removeFullLines method instead.");
      return this.removeFullLines(firstRow, lastRow);
    };

    this.insertNewLine = function (position) {
      console.warn("Use of document.insertNewLine is deprecated. Use insertMergedLines(position, ['', '']) instead.");
      return this.insertMergedLines(position, ["", ""]);
    };

    this.insert = function (position, text) {
      if (this.getLength() <= 1) this.$detectNewLine(text);
      return this.insertMergedLines(position, this.$split(text));
    };

    this.insertInLine = function (position, text) {
      var start = this.clippedPos(position.row, position.column);
      var end = this.pos(position.row, position.column + text.length);
      this.applyDelta({
        start: start,
        end: end,
        action: "insert",
        lines: [text]
      }, true);
      return this.clonePos(end);
    };

    this.clippedPos = function (row, column) {
      var length = this.getLength();

      if (row === undefined) {
        row = length;
      } else if (row < 0) {
        row = 0;
      } else if (row >= length) {
        row = length - 1;
        column = undefined;
      }

      var line = this.getLine(row);
      if (column == undefined) column = line.length;
      column = Math.min(Math.max(column, 0), line.length);
      return {
        row: row,
        column: column
      };
    };

    this.clonePos = function (pos) {
      return {
        row: pos.row,
        column: pos.column
      };
    };

    this.pos = function (row, column) {
      return {
        row: row,
        column: column
      };
    };

    this.$clipPosition = function (position) {
      var length = this.getLength();

      if (position.row >= length) {
        position.row = Math.max(0, length - 1);
        position.column = this.getLine(length - 1).length;
      } else {
        position.row = Math.max(0, position.row);
        position.column = Math.min(Math.max(position.column, 0), this.getLine(position.row).length);
      }

      return position;
    };

    this.insertFullLines = function (row, lines) {
      row = Math.min(Math.max(row, 0), this.getLength());
      var column = 0;

      if (row < this.getLength()) {
        lines = lines.concat([""]);
        column = 0;
      } else {
        lines = [""].concat(lines);
        row--;
        column = this.$lines[row].length;
      }

      this.insertMergedLines({
        row: row,
        column: column
      }, lines);
    };

    this.insertMergedLines = function (position, lines) {
      var start = this.clippedPos(position.row, position.column);
      var end = {
        row: start.row + lines.length - 1,
        column: (lines.length == 1 ? start.column : 0) + lines[lines.length - 1].length
      };
      this.applyDelta({
        start: start,
        end: end,
        action: "insert",
        lines: lines
      });
      return this.clonePos(end);
    };

    this.remove = function (range) {
      var start = this.clippedPos(range.start.row, range.start.column);
      var end = this.clippedPos(range.end.row, range.end.column);
      this.applyDelta({
        start: start,
        end: end,
        action: "remove",
        lines: this.getLinesForRange({
          start: start,
          end: end
        })
      });
      return this.clonePos(start);
    };

    this.removeInLine = function (row, startColumn, endColumn) {
      var start = this.clippedPos(row, startColumn);
      var end = this.clippedPos(row, endColumn);
      this.applyDelta({
        start: start,
        end: end,
        action: "remove",
        lines: this.getLinesForRange({
          start: start,
          end: end
        })
      }, true);
      return this.clonePos(start);
    };

    this.removeFullLines = function (firstRow, lastRow) {
      firstRow = Math.min(Math.max(0, firstRow), this.getLength() - 1);
      lastRow = Math.min(Math.max(0, lastRow), this.getLength() - 1);
      var deleteFirstNewLine = lastRow == this.getLength() - 1 && firstRow > 0;
      var deleteLastNewLine = lastRow < this.getLength() - 1;
      var startRow = deleteFirstNewLine ? firstRow - 1 : firstRow;
      var startCol = deleteFirstNewLine ? this.getLine(startRow).length : 0;
      var endRow = deleteLastNewLine ? lastRow + 1 : lastRow;
      var endCol = deleteLastNewLine ? 0 : this.getLine(endRow).length;
      var range = new Range(startRow, startCol, endRow, endCol);
      var deletedLines = this.$lines.slice(firstRow, lastRow + 1);
      this.applyDelta({
        start: range.start,
        end: range.end,
        action: "remove",
        lines: this.getLinesForRange(range)
      });
      return deletedLines;
    };

    this.removeNewLine = function (row) {
      if (row < this.getLength() - 1 && row >= 0) {
        this.applyDelta({
          start: this.pos(row, this.getLine(row).length),
          end: this.pos(row + 1, 0),
          action: "remove",
          lines: ["", ""]
        });
      }
    };

    this.replace = function (range, text) {
      if (!(range instanceof Range)) range = Range.fromPoints(range.start, range.end);
      if (text.length === 0 && range.isEmpty()) return range.start;
      if (text == this.getTextRange(range)) return range.end;
      this.remove(range);
      var end;

      if (text) {
        end = this.insert(range.start, text);
      } else {
        end = range.start;
      }

      return end;
    };

    this.applyDeltas = function (deltas) {
      for (var i = 0; i < deltas.length; i++) {
        this.applyDelta(deltas[i]);
      }
    };

    this.revertDeltas = function (deltas) {
      for (var i = deltas.length - 1; i >= 0; i--) {
        this.revertDelta(deltas[i]);
      }
    };

    this.applyDelta = function (delta, doNotValidate) {
      var isInsert = delta.action == "insert";

      if (isInsert ? delta.lines.length <= 1 && !delta.lines[0] : !Range.comparePoints(delta.start, delta.end)) {
        return;
      }

      if (isInsert && delta.lines.length > 20000) {
        this.$splitAndapplyLargeDelta(delta, 20000);
      } else {
        applyDelta(this.$lines, delta, doNotValidate);

        this._signal("change", delta);
      }
    };

    this.$safeApplyDelta = function (delta) {
      var docLength = this.$lines.length;

      if (delta.action == "remove" && delta.start.row < docLength && delta.end.row < docLength || delta.action == "insert" && delta.start.row <= docLength) {
        this.applyDelta(delta);
      }
    };

    this.$splitAndapplyLargeDelta = function (delta, MAX) {
      var lines = delta.lines;
      var l = lines.length - MAX + 1;
      var row = delta.start.row;
      var column = delta.start.column;

      for (var from = 0, to = 0; from < l; from = to) {
        to += MAX - 1;
        var chunk = lines.slice(from, to);
        chunk.push("");
        this.applyDelta({
          start: this.pos(row + from, column),
          end: this.pos(row + to, column = 0),
          action: delta.action,
          lines: chunk
        }, true);
      }

      delta.lines = lines.slice(from);
      delta.start.row = row + from;
      delta.start.column = column;
      this.applyDelta(delta, true);
    };

    this.revertDelta = function (delta) {
      this.$safeApplyDelta({
        start: this.clonePos(delta.start),
        end: this.clonePos(delta.end),
        action: delta.action == "insert" ? "remove" : "insert",
        lines: delta.lines.slice()
      });
    };

    this.indexToPosition = function (index, startRow) {
      var lines = this.$lines || this.getAllLines();
      var newlineLength = this.getNewLineCharacter().length;

      for (var i = startRow || 0, l = lines.length; i < l; i++) {
        index -= lines[i].length + newlineLength;
        if (index < 0) return {
          row: i,
          column: index + lines[i].length + newlineLength
        };
      }

      return {
        row: l - 1,
        column: index + lines[l - 1].length + newlineLength
      };
    };

    this.positionToIndex = function (pos, startRow) {
      var lines = this.$lines || this.getAllLines();
      var newlineLength = this.getNewLineCharacter().length;
      var index = 0;
      var row = Math.min(pos.row, lines.length);

      for (var i = startRow || 0; i < row; ++i) {
        index += lines[i].length + newlineLength;
      }

      return index + pos.column;
    };
  }).call(Document.prototype);
  exports.Document = Document;
});
ace.define("ace/worker/mirror", [], function (require, exports, module) {
  "use strict";

  var Range = require("../range").Range;

  var Document = require("../document").Document;

  var lang = require("../lib/lang");

  var Mirror = exports.Mirror = function (sender) {
    this.sender = sender;
    var doc = this.doc = new Document("");
    var deferredUpdate = this.deferredUpdate = lang.delayedCall(this.onUpdate.bind(this));

    var _self = this;

    sender.on("change", function (e) {
      var data = e.data;

      if (data[0].start) {
        doc.applyDeltas(data);
      } else {
        for (var i = 0; i < data.length; i += 2) {
          if (Array.isArray(data[i + 1])) {
            var d = {
              action: "insert",
              start: data[i],
              lines: data[i + 1]
            };
          } else {
            var d = {
              action: "remove",
              start: data[i],
              end: data[i + 1]
            };
          }

          doc.applyDelta(d, true);
        }
      }

      if (_self.$timeout) return deferredUpdate.schedule(_self.$timeout);

      _self.onUpdate();
    });
  };

  (function () {
    this.$timeout = 500;

    this.setTimeout = function (timeout) {
      this.$timeout = timeout;
    };

    this.setValue = function (value) {
      this.doc.setValue(value);
      this.deferredUpdate.schedule(this.$timeout);
    };

    this.getValue = function (callbackId) {
      this.sender.callback(this.doc.getValue(), callbackId);
    };

    this.onUpdate = function () {};

    this.isPending = function () {
      return this.deferredUpdate.isPending();
    };
  }).call(Mirror.prototype);
});
ace.define("ace/mode/xml/sax", [], function (require, exports, module) {
  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) + "\xB7\u0300-\u036F\\ux203F-\u2040]");
  var tagNamePattern = new RegExp('^' + nameStartChar.source + nameChar.source + '*(?:\:' + nameStartChar.source + nameChar.source + '*)?$');
  var S_TAG = 0; //tag name offerring

  var S_ATTR = 1; //attr name offerring 

  var S_ATTR_S = 2; //attr name end and space offer

  var S_EQ = 3; //=space?

  var S_V = 4; //attr value(no quot value only)

  var S_E = 5; //attr value end and no space(quot end)

  var S_S = 6; //(attr value end || tag end ) && (space offer)

  var S_C = 7; //closed el<el />

  function XMLReader() {}

  XMLReader.prototype = {
    parse: function parse(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) {
      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
      var xt = source.substring(start, end).replace(/&#?\w+;/g, entityReplacer);
      locator && position(start);
      domBuilder.characters(xt, 0, end - start);
      start = end;
    }

    function position(start, m) {
      while (start >= endPos && (m = linePattern.exec(source))) {
        startPos = m.index;
        endPos = startPos + m[0].length;
        locator.lineNumber++;
      }

      locator.columnNumber = start - startPos + 1;
    }

    var startPos = 0;
    var endPos = 0;
    var linePattern = /.+(?:\r\n?|\n)|.*$/g;
    var locator = domBuilder.locator;
    var parseStack = [{
      currentNSMap: defaultNSMapCopy
    }];
    var closeMap = {};
    var start = 0;

    while (true) {
      var i = source.indexOf('<', start);

      if (i < 0) {
        if (!source.substr(start).match(/^\s*$/)) {
          var doc = domBuilder.document;
          var text = doc.createTextNode(source.substr(start));
          doc.appendChild(text);
          domBuilder.currentElement = text;
        }

        return;
      }

      if (i > start) {
        appendText(i);
      }

      switch (source.charAt(i + 1)) {
        case '/':
          var end = source.indexOf('>', i + 3);
          var tagName = source.substring(i + 2, end);
          var config;

          if (parseStack.length > 1) {
            config = parseStack.pop();
          } else {
            errorHandler.fatalError("end tag name not found for: " + tagName);
            break;
          }

          var localNSMap = config.localNSMap;

          if (config.tagName != tagName) {
            errorHandler.fatalError("end tag name: " + tagName + " does not match the current start tagName: " + config.tagName);
          }

          domBuilder.endElement(config.uri, config.localName, tagName);

          if (localNSMap) {
            for (var prefix in localNSMap) {
              domBuilder.endPrefixMapping(prefix);
            }
          }

          end++;
          break;

        case '?':
          // <?...?>
          locator && position(i);
          end = parseInstruction(source, i, domBuilder);
          break;

        case '!':
          // <!doctype,<![CDATA,<!--
          locator && position(i);
          end = parseDCC(source, i, domBuilder, errorHandler);
          break;

        default:
          try {
            locator && position(i);
            var el = new ElementAttributes();
            var end = parseElementStartPart(source, i, el, entityReplacer, errorHandler);
            var len = el.length;

            if (len && locator) {
              var backup = copyLocator(locator, {});

              for (var i = 0; i < len; i++) {
                var a = el[i];
                position(a.offset);
                a.offset = copyLocator(locator, {});
              }

              copyLocator(backup, locator);
            }

            if (!el.closed && fixSelfClosed(source, end, el.tagName, closeMap)) {
              el.closed = true;

              if (!entityMap.nbsp) {
                errorHandler.warning('unclosed xml attribute');
              }
            }

            appendElement(el, domBuilder, parseStack);

            if (el.uri === 'http://www.w3.org/1999/xhtml' && !el.closed) {
              end = parseHtmlSpecialContent(source, end, el.tagName, entityReplacer, domBuilder);
            } else {
              end++;
            }
          } catch (e) {
            errorHandler.error('element parse error: ' + e);
            end = -1;
          }

      }

      if (end < 0) {
        appendText(i + 1);
      } else {
        start = end;
      }
    }
  }

  function copyLocator(f, t) {
    t.lineNumber = f.lineNumber;
    t.columnNumber = f.columnNumber;
    return t;
  }

  function parseElementStartPart(source, start, el, entityReplacer, errorHandler) {
    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_S) {
            s = S_EQ;
          } else {
            throw new Error('attribute equal must after attrName');
          }

          break;

        case '\'':
        case '"':
          if (s === S_EQ) {
            //equal
            start = p + 1;
            p = source.indexOf(c, start);

            if (p > 0) {
              value = source.slice(start, p).replace(/&#?\w+;/g, entityReplacer);
              el.add(attrName, value, start - 1);
              s = S_E;
            } else {
              throw new Error('attribute value no end \'' + c + '\' match');
            }
          } else if (s == S_V) {
            value = source.slice(start, p).replace(/&#?\w+;/g, entityReplacer);
            el.add(attrName, value, start);
            errorHandler.warning('attribute "' + attrName + '" missed start quot(' + c + ')!!');
            start = p + 1;
            s = S_E;
          } else {
            throw new Error('attribute value must after "="');
          }

          break;

        case '/':
          switch (s) {
            case S_TAG:
              el.setTagName(source.slice(start, p));

            case S_E:
            case S_S:
            case S_C:
              s = S_C;
              el.closed = true;

            case S_V:
            case S_ATTR:
            case S_ATTR_S:
              break;

            default:
              throw new Error("attribute invalid close char('/')");
          }

          break;

        case '':
          //end document
          errorHandler.error('unexpected end of input');

        case '>':
          switch (s) {
            case S_TAG:
              el.setTagName(source.slice(start, p));

            case S_E:
            case S_S:
            case S_C:
              break;
            //normal

            case S_V: //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_S:
              if (s === S_ATTR_S) {
                value = attrName;
              }

              if (s == S_V) {
                errorHandler.warning('attribute "' + value + '" missed quot(")!!');
                el.add(attrName, value.replace(/&#?\w+;/g, entityReplacer), start);
              } else {
                errorHandler.warning('attribute "' + value + '" missed value!! "' + value + '" instead!!');
                el.add(value, value, start);
              }

              break;

            case S_EQ:
              throw new Error('attribute value missed!!');
          }

          return p;

        case "\x80":
          c = ' ';

        default:
          if (c <= ' ') {
            //space
            switch (s) {
              case S_TAG:
                el.setTagName(source.slice(start, p)); //tagName

                s = S_S;
                break;

              case S_ATTR:
                attrName = source.slice(start, p);
                s = S_ATTR_S;
                break;

              case S_V:
                var value = source.slice(start, p).replace(/&#?\w+;/g, entityReplacer);
                errorHandler.warning('attribute "' + value + '" missed quot(")!!');
                el.add(attrName, value, start);

              case S_E:
                s = S_S;
                break;
            }
          } else {
            //not space
            switch (s) {
              case S_ATTR_S:
                errorHandler.warning('attribute "' + attrName + '" missed value!! "' + attrName + '" instead!!');
                el.add(attrName, attrName, start);
                start = p;
                s = S_ATTR;
                break;

              case S_E:
                errorHandler.warning('attribute space is required"' + attrName + '"!!');

              case S_S:
                s = S_ATTR;
                start = p;
                break;

              case S_EQ:
                s = S_V;
                start = p;
                break;

              case S_C:
                throw new Error("elements closed character '/' and '>' must be connected to");
            }
          }

      }

      p++;
    }
  }

  function appendElement(el, domBuilder, parseStack) {
    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' && '';
      }

      a.localName = localName;

      if (nsPrefix !== false) {
        //hack!!
        if (localNSMap == null) {
          localNSMap = {};

          _copy(currentNSMap, currentNSMap = {});
        }

        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];
        }
      }
    }

    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;
    }

    var ns = el.uri = currentNSMap[prefix || ''];
    domBuilder.startElement(ns, localName, tagName, el);

    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);
    }
  }

  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)) {
          domBuilder.characters(text, 0, text.length);
          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) {
    var pos = closeMap[tagName];

    if (pos == null) {
      pos = closeMap[tagName] = source.lastIndexOf('</' + tagName + '>');
    }

    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);

          if (end > start) {
            domBuilder.comment(source, start + 4, end - start - 4);
            return end + 3;
          } else {
            errorHandler.error("Unclosed comment");
            return -1;
          }
        } else {
          return -1;
        }

      default:
        if (source.substr(start + 3, 6) == 'CDATA[') {
          var end = source.indexOf(']]>', start + 9);

          if (end > start) {
            domBuilder.startCDATA();
            domBuilder.characters(source, start + 9, end - start - 9);
            domBuilder.endCDATA();
            return end + 3;
          } else {
            errorHandler.error("Unclosed CDATA");
            return -1;
          }
        }

        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 = len > 3 && /^public$/i.test(matchs[2][0]) && matchs[3][0];
          var sysid = len > 4 && matchs[4][0];
          var lastMatch = matchs[len - 1];
          domBuilder.startDTD(name, pubid && pubid.replace(/^(['"])(.*?)\1$/, '$2'), sysid && sysid.replace(/^(['"])(.*?)\1$/, '$2'));
          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(source) {}

  ElementAttributes.prototype = {
    setTagName: function setTagName(tagName) {
      if (!tagNamePattern.test(tagName)) {
        throw new Error('invalid tagName:' + tagName);
      }

      this.tagName = tagName;
    },
    add: function add(qName, value, offset) {
      if (!tagNamePattern.test(qName)) {
        throw new Error('invalid attribute:' + qName);
      }

      this[this.length++] = {
        qName: qName,
        value: value,
        offset: offset
      };
    },
    length: 0,
    getLocalName: function getLocalName(i) {
      return this[i].localName;
    },
    getOffset: function getOffset(i) {
      return this[i].offset;
    },
    getQName: function getQName(i) {
      return this[i].qName;
    },
    getURI: function getURI(i) {
      return this[i].uri;
    },
    getValue: function getValue(i) {
      return this[i].value;
    }
  };

  function _set_proto_(thiz, parent) {
    thiz.__proto__ = parent;
    return thiz;
  }

  if (!(_set_proto_({}, _set_proto_.prototype) instanceof _set_proto_)) {
    _set_proto_ = function _set_proto_(thiz, parent) {
      function p() {}

      ;
      p.prototype = parent;
      p = new p();

      for (parent in thiz) {
        p[parent] = thiz[parent];
      }

      return p;
    };
  }

  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;
    }
  }

  return XMLReader;
});
ace.define("ace/mode/xml/dom", [], function (require, exports, module) {
  function copy(src, dest) {
    for (var p in src) {
      dest[p] = src[p];
    }
  }

  function _extends(Class, Super) {
    var t = function t() {};

    var pt = Class.prototype;

    if (Object.create) {
      var ppt = Object.create(Super.prototype);
      pt.__proto__ = ppt;
    }

    if (!(pt instanceof Super)) {
      t.prototype = Super.prototype;
      t = new t();
      copy(pt, t);
      Class.prototype = pt = t;
    }

    if (pt.constructor != Class) {
      if (typeof Class != 'function') {
        console.error("unknown Class:" + Class);
      }

      pt.constructor = Class;
    }
  }

  var htmlns = 'http://www.w3.org/1999/xhtml';
  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;
  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);
  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);

  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);

  function NodeList() {}

  ;
  NodeList.prototype = {
    length: 0,
    item: function item(index) {
      return this[index] || null;
    }
  };

  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);

      __set__(list, 'length', ls.length);

      copy(ls, list);
      list._inc = inc;
    }
  }

  LiveNodeList.prototype.item = function (i) {
    _updateLiveList(this);

    return this[i];
  };

  _extends(LiveNodeList, NodeList);

  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) {
    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 new DOMException(NOT_FOUND_ERR, new Error());
    }
  }

  NamedNodeMap.prototype = {
    length: 0,
    item: NodeList.prototype.item,
    getNamedItem: function getNamedItem(key) {
      var i = this.length;

      while (i--) {
        var attr = this[i];

        if (attr.nodeName == key) {
          return attr;
        }
      }
    },
    setNamedItem: function setNamedItem(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;
    },
    setNamedItemNS: function setNamedItemNS(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;
    },
    removeNamedItem: function removeNamedItem(key) {
      var attr = this.getNamedItem(key);

      _removeNamedNode(this._ownerElement, this, attr);

      return attr;
    },
    // raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
    removeNamedItemNS: function removeNamedItemNS(namespaceURI, localName) {
      var attr = this.getNamedItemNS(namespaceURI, localName);

      _removeNamedNode(this._ownerElement, this, attr);

      return attr;
    },
    getNamedItemNS: function getNamedItemNS(namespaceURI, localName) {
      var i = this.length;

      while (i--) {
        var node = this[i];

        if (node.localName == localName && node.namespaceURI == namespaceURI) {
          return node;
        }
      }

      return null;
    }
  };

  function DOMImplementation(
  /* Object */
  features) {
    this._features = {};

    if (features) {
      for (var feature in features) {
        this._features = features[feature];
      }
    }
  }

  ;
  DOMImplementation.prototype = {
    hasFeature: function hasFeature(
    /* string */
    feature,
    /* string */
    version) {
      var versions = this._features[feature.toLowerCase()];

      if (versions && (!version || version in versions)) {
        return true;
      } else {
        return false;
      }
    },
    createDocument: function createDocument(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;
    },
    createDocumentType: function createDocumentType(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;
      return node;
    }
  };

  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,
    insertBefore: function insertBefore(newChild, refChild) {
      //raises
      return _insertBefore(this, newChild, refChild);
    },
    replaceChild: function replaceChild(newChild, oldChild) {
      //raises
      this.insertBefore(newChild, oldChild);

      if (oldChild) {
        this.removeChild(oldChild);
      }
    },
    removeChild: function removeChild(oldChild) {
      return _removeChild(this, oldChild);
    },
    appendChild: function appendChild(newChild) {
      return this.insertBefore(newChild, null);
    },
    hasChildNodes: function hasChildNodes() {
      return this.firstChild != null;
    },
    cloneNode: function cloneNode(deep) {
      return _cloneNode(this.ownerDocument || this, this, deep);
    },
    normalize: function normalize() {
      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;
        }
      }
    },
    isSupported: function isSupported(feature, version) {
      return this.ownerDocument.implementation.hasFeature(feature, version);
    },
    hasAttributes: function hasAttributes() {
      return this.attributes.length > 0;
    },
    lookupPrefix: function lookupPrefix(namespaceURI) {
      var el = this;

      while (el) {
        var map = el._nsMap;

        if (map) {
          for (var n in map) {
            if (map[n] == namespaceURI) {
              return n;
            }
          }
        }

        el = el.nodeType == 2 ? el.ownerDocument : el.parentNode;
      }

      return null;
    },
    lookupNamespaceURI: function lookupNamespaceURI(prefix) {
      var el = this;

      while (el) {
        var map = el._nsMap;

        if (map) {
          if (prefix in map) {
            return map[prefix];
          }
        }

        el = el.nodeType == 2 ? el.ownerDocument : el.parentNode;
      }

      return null;
    },
    isDefaultNamespace: function isDefaultNamespace(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);

  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/') {
      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/') {
      delete el._nsMap[newAttr.prefix ? newAttr.localName : ''];
    }
  }

  function _onUpdateChild(doc, el, newChild) {
    if (doc && doc._inc) {
      doc._inc++;
      var cs = el.childNodes;

      if (newChild) {
        cs[cs.length++] = newChild;
      } else {
        var child = el.firstChild;
        var i = 0;

        while (child) {
          cs[i++] = child;
          child = child.nextSibling;
        }

        cs.length = i;
      }
    }
  }

  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;
  }

  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);

    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;
  }

  Document.prototype = {
    nodeName: '#document',
    nodeType: DOCUMENT_NODE,
    doctype: null,
    documentElement: null,
    _inc: 1,
    insertBefore: function insertBefore(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 == 1) {
        this.documentElement = newChild;
      }

      return _insertBefore(this, newChild, refChild), newChild.ownerDocument = this, newChild;
    },
    removeChild: function removeChild(oldChild) {
      if (this.documentElement == oldChild) {
        this.documentElement = null;
      }

      return _removeChild(this, oldChild);
    },
    importNode: function importNode(importedNode, deep) {
      return _importNode(this, importedNode, deep);
    },
    getElementById: function getElementById(id) {
      var rtv = null;

      _visitNode(this.documentElement, function (node) {
        if (node.nodeType == 1) {
          if (node.getAttribute('id') == id) {
            rtv = node;
            return true;
          }
        }
      });

      return rtv;
    },
    createElement: function createElement(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 createDocumentFragment() {
      var node = new DocumentFragment();
      node.ownerDocument = this;
      node.childNodes = new NodeList();
      return node;
    },
    createTextNode: function createTextNode(data) {
      var node = new Text();
      node.ownerDocument = this;
      node.appendData(data);
      return node;
    },
    createComment: function createComment(data) {
      var node = new Comment();
      node.ownerDocument = this;
      node.appendData(data);
      return node;
    },
    createCDATASection: function createCDATASection(data) {
      var node = new CDATASection();
      node.ownerDocument = this;
      node.appendData(data);
      return node;
    },
    createProcessingInstruction: function createProcessingInstruction(target, data) {
      var node = new ProcessingInstruction();
      node.ownerDocument = this;
      node.tagName = node.target = target;
      node.nodeValue = node.data = data;
      return node;
    },
    createAttribute: function createAttribute(name) {
      var node = new Attr();
      node.ownerDocument = this;
      node.name = name;
      node.nodeName = name;
      node.localName = name;
      node.specified = true;
      return node;
    },
    createEntityReference: function createEntityReference(name) {
      var node = new EntityReference();
      node.ownerDocument = this;
      node.nodeName = name;
      return node;
    },
    createElementNS: function createElementNS(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 {
        node.localName = qualifiedName;
      }

      attrs._ownerElement = node;
      return node;
    },
    createAttributeNS: function createAttributeNS(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 {
        node.localName = qualifiedName;
      }

      return node;
    }
  };

  _extends(Document, Node);

  function Element() {
    this._nsMap = {};
  }

  ;
  Element.prototype = {
    nodeType: ELEMENT_NODE,
    hasAttribute: function hasAttribute(name) {
      return this.getAttributeNode(name) != null;
    },
    getAttribute: function getAttribute(name) {
      var attr = this.getAttributeNode(name);
      return attr && attr.value || '';
    },
    getAttributeNode: function getAttributeNode(name) {
      return this.attributes.getNamedItem(name);
    },
    setAttribute: function setAttribute(name, value) {
      var attr = this.ownerDocument.createAttribute(name);
      attr.value = attr.nodeValue = "" + value;
      this.setAttributeNode(attr);
    },
    removeAttribute: function removeAttribute(name) {
      var attr = this.getAttributeNode(name);
      attr && this.removeAttributeNode(attr);
    },
    appendChild: function appendChild(newChild) {
      if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {
        return this.insertBefore(newChild, null);
      } else {
        return _appendSingleChild(this, newChild);
      }
    },
    setAttributeNode: function setAttributeNode(newAttr) {
      return this.attributes.setNamedItem(newAttr);
    },
    setAttributeNodeNS: function setAttributeNodeNS(newAttr) {
      return this.attributes.setNamedItemNS(newAttr);
    },
    removeAttributeNode: function removeAttributeNode(oldAttr) {
      return this.attributes.removeNamedItem(oldAttr.nodeName);
    },
    removeAttributeNS: function removeAttributeNS(namespaceURI, localName) {
      var old = this.getAttributeNodeNS(namespaceURI, localName);
      old && this.removeAttributeNode(old);
    },
    hasAttributeNS: function hasAttributeNS(namespaceURI, localName) {
      return this.getAttributeNodeNS(namespaceURI, localName) != null;
    },
    getAttributeNS: function getAttributeNS(namespaceURI, localName) {
      var attr = this.getAttributeNodeNS(namespaceURI, localName);
      return attr && attr.value || '';
    },
    setAttributeNS: function setAttributeNS(namespaceURI, qualifiedName, value) {
      var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
      attr.value = attr.nodeValue = "" + value;
      this.setAttributeNode(attr);
    },
    getAttributeNodeNS: function getAttributeNodeNS(namespaceURI, localName) {
      return this.attributes.getNamedItemNS(namespaceURI, localName);
    },
    getElementsByTagName: function getElementsByTagName(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 getElementsByTagNameNS(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 substringData(offset, count) {
      return this.data.substring(offset, offset + count);
    },
    appendData: function appendData(text) {
      text = this.data + text;
      this.nodeValue = this.data = text;
      this.length = text.length;
    },
    insertData: function insertData(offset, text) {
      this.replaceData(offset, 0, text);
    },
    appendChild: function appendChild(newChild) {
      throw new Error(ExceptionMessage[3]);
      return Node.prototype.appendChild.apply(this, arguments);
    },
    deleteData: function deleteData(offset, count) {
      this.replaceData(offset, count, "");
    },
    replaceData: function replaceData(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 splitText(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) {
    var buf = [];
    serializeToString(node, buf);
    return buf.join('');
  };

  Node.prototype.toString = function () {
    return XMLSerializer.prototype.serializeToString(this);
  };

  function serializeToString(node, buf) {
    switch (node.nodeType) {
      case ELEMENT_NODE:
        var attrs = node.attributes;
        var len = attrs.length;
        var child = node.firstChild;
        var nodeName = node.tagName;
        var isHTML = htmlns === node.namespaceURI;
        buf.push('<', nodeName);

        for (var i = 0; i < len; i++) {
          serializeToString(attrs.item(i), buf);
        }

        if (child || isHTML && !/^(?:meta|link|img|br|hr|input|button)$/i.test(nodeName)) {
          buf.push('>');

          if (isHTML && /^script$/i.test(nodeName)) {
            if (child) {
              buf.push(child.data);
            }
          } else {
            while (child) {
              serializeToString(child, buf);
              child = child.nextSibling;
            }
          }

          buf.push('</', nodeName, '>');
        } else {
          buf.push('/>');
        }

        return;

      case DOCUMENT_NODE:
      case DOCUMENT_FRAGMENT_NODE:
        var child = node.firstChild;

        while (child) {
          serializeToString(child, buf);
          child = child.nextSibling;
        }

        return;

      case ATTRIBUTE_NODE:
        return buf.push(' ', node.name, '="', node.value.replace(/[<&"]/g, _xmlEncoder), '"');

      case TEXT_NODE:
        return buf.push(node.data.replace(/[<&]/g, _xmlEncoder));

      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, ';');

      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;

      case DOCUMENT_FRAGMENT_NODE:
        break;

      case ATTRIBUTE_NODE:
        deep = true;
        break;
    }

    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;
  }

  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;
  }

  function getTextContent(node) {
    switch (node.nodeType) {
      case 1:
      case 11:
        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;
    }
  }

  try {
    if (Object.defineProperty) {
      Object.defineProperty(LiveNodeList.prototype, 'length', {
        get: function get() {
          _updateLiveList(this);

          return this.$$length;
        }
      });
      Object.defineProperty(Node.prototype, 'textContent', {
        get: function get() {
          return getTextContent(this);
        },
        set: function set(data) {
          switch (this.nodeType) {
            case 1:
            case 11:
              while (this.firstChild) {
                this.removeChild(this.firstChild);
              }

              if (data || String(data)) {
                this.appendChild(this.ownerDocument.createTextNode(data));
              }

              break;

            default:
              this.data = data;
              this.value = value;
              this.nodeValue = data;
          }
        }
      });

      __set__ = function __set__(object, key, value) {
        object['$$' + key] = value;
      };
    }
  } catch (e) {//ie8
  }

  return DOMImplementation;
});
ace.define("ace/mode/xml/dom-parser", [], function (require, exports, module) {
  'use strict';

  var XMLReader = require('./sax'),
      DOMImplementation = require('./dom');

  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 entityMap = {
      'lt': '<',
      'gt': '>',
      'amp': '&',
      'quot': '"',
      'apos': "'"
    };

    if (locator) {
      domBuilder.setDocumentLocator(locator);
    }

    sax.errorHandler = buildErrorHandler(errorHandler, domBuilder, locator);
    sax.domBuilder = options.domBuilder || domBuilder;

    if (/\/x?html?$/.test(mimeType)) {
      entityMap.nbsp = '\xa0';
      entityMap.copy = '\xa9';
      defaultNSMap[''] = 'http://www.w3.org/1999/xhtml';
    }

    if (source) {
      sax.parse(source, defaultNSMap, entityMap);
    } else {
      sax.errorHandler.error("invalid document source");
    }

    return domBuilder.document;
  };

  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) {
        if (isCallback) {
          fn = errorImpl.length == 2 ? function (msg) {
            errorImpl(key, msg);
          } : errorImpl;
        } else {
          var i = arguments.length;

          while (--i) {
            if (fn = errorImpl[arguments[i]]) {
              break;
            }
          }
        }
      }

      errorHandler[key] = fn && function (msg) {
        fn(msg + _locator(locator), msg, locator);
      } || function () {};
    }

    build('warning', 'warn');
    build('error', 'warn', 'warning');
    build('fatalError', 'warn', 'warning', 'error');
    return errorHandler;
  }

  function DOMHandler() {
    this.cdata = false;
  }

  function position(locator, node) {
    node.lineNumber = locator.lineNumber;
    node.columnNumber = locator.columnNumber;
  }

  DOMHandler.prototype = {
    startDocument: function startDocument() {
      this.document = new DOMImplementation().createDocument(null, null, null);

      if (this.locator) {
        this.document.documentURI = this.locator.systemId;
      }
    },
    startElement: function startElement(namespaceURI, localName, qName, attrs) {
      var doc = this.document;
      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);

        if (attr.getOffset) {
          position(attr.getOffset(1), attr);
        }

        attr.value = attr.nodeValue = value;
        el.setAttributeNode(attr);
      }
    },
    endElement: function endElement(namespaceURI, localName, qName) {
      var current = this.currentElement;
      var tagName = current.tagName;
      this.currentElement = current.parentNode;
    },
    startPrefixMapping: function startPrefixMapping(prefix, uri) {},
    endPrefixMapping: function endPrefixMapping(prefix) {},
    processingInstruction: function processingInstruction(target, data) {
      var ins = this.document.createProcessingInstruction(target, data);
      this.locator && position(this.locator, ins);
      appendElement(this, ins);
    },
    ignorableWhitespace: function ignorableWhitespace(ch, start, length) {},
    characters: function characters(chars, start, length) {
      chars = _toString.apply(this, arguments);

      if (this.currentElement && chars) {
        if (this.cdata) {
          var charNode = this.document.createCDATASection(chars);
          this.currentElement.appendChild(charNode);
        } else {
          var charNode = this.document.createTextNode(chars);
          this.currentElement.appendChild(charNode);
        }

        this.locator && position(this.locator, charNode);
      }
    },
    skippedEntity: function skippedEntity(name) {},
    endDocument: function endDocument() {
      this.document.normalize();
    },
    setDocumentLocator: function setDocumentLocator(locator) {
      if (this.locator = locator) {
        // && !('lineNumber' in locator)){
        locator.lineNumber = 0;
      }
    },
    comment: function comment(chars, start, length) {
      chars = _toString.apply(this, arguments);
      var comm = this.document.createComment(chars);
      this.locator && position(this.locator, comm);
      appendElement(this, comm);
    },
    startCDATA: function startCDATA() {
      this.cdata = true;
    },
    endCDATA: function endCDATA() {
      this.cdata = false;
    },
    startDTD: function startDTD(name, publicId, systemId) {
      var impl = this.document.implementation;

      if (impl && impl.createDocumentType) {
        var dt = impl.createDocumentType(name, publicId, systemId);
        this.locator && position(this.locator, dt);
        appendElement(this, dt);
      }
    },
    warning: function warning(error) {
      console.warn(error, _locator(this.locator));
    },
    error: function error(_error) {
      console.error(_error, _locator(this.locator));
    },
    fatalError: function fatalError(error) {
      console.error(error, _locator(this.locator));
      throw error;
    }
  };

  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;
    }
  }

  "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g, function (key) {
    DOMHandler.prototype[key] = function () {
      return null;
    };
  });

  function appendElement(hander, node) {
    if (!hander.currentElement) {
      hander.document.appendChild(node);
    } else {
      hander.currentElement.appendChild(node);
    }
  } //appendChild and setAttributeNS are preformance key


  return {
    DOMParser: DOMParser
  };
});
ace.define("ace/mode/xml_worker", [], function (require, exports, module) {
  "use strict";

  var oop = require("../lib/oop");

  var lang = require("../lib/lang");

  var Mirror = require("../worker/mirror").Mirror;

  var DOMParser = require("./xml/dom-parser").DOMParser;

  var Worker = exports.Worker = function (sender) {
    Mirror.call(this, sender);
    this.setTimeout(400);
    this.context = null;
  };

  oop.inherits(Worker, Mirror);
  (function () {
    this.setOptions = function (options) {
      this.context = options.context;
    };

    this.onUpdate = function () {
      var value = this.doc.getValue();
      if (!value) return;
      var parser = new DOMParser();
      var errors = [];
      parser.options.errorHandler = {
        fatalError: function fatalError(fullMsg, errorMsg, locator) {
          errors.push({
            row: locator.lineNumber,
            column: locator.columnNumber,
            text: errorMsg,
            type: "error"
          });
        },
        error: function error(fullMsg, errorMsg, locator) {
          errors.push({
            row: locator.lineNumber,
            column: locator.columnNumber,
            text: errorMsg,
            type: "error"
          });
        },
        warning: function warning(fullMsg, errorMsg, locator) {
          errors.push({
            row: locator.lineNumber,
            column: locator.columnNumber,
            text: errorMsg,
            type: "warning"
          });
        }
      };
      parser.parseFromString(value);
      this.sender.emit("error", errors);
    };
  }).call(Worker.prototype);
});
ace.define("ace/lib/es5-shim", [], function (require, exports, module) {
  function Empty() {}

  if (!Function.prototype.bind) {
    Function.prototype.bind = function bind(that) {
      // .length is 1
      var target = this;

      if (typeof target != "function") {
        throw new TypeError("Function.prototype.bind called on incompatible " + target);
      }

      var args = slice.call(arguments, 1); // for normal call

      var bound = function bound() {
        if (this instanceof bound) {
          var result = target.apply(this, args.concat(slice.call(arguments)));

          if (Object(result) === result) {
            return result;
          }

          return this;
        } else {
          return target.apply(that, args.concat(slice.call(arguments)));
        }
      };

      if (target.prototype) {
        Empty.prototype = target.prototype;
        bound.prototype = new Empty();
        Empty.prototype = null;
      }

      return bound;
    };
  }

  var call = Function.prototype.call;
  var prototypeOfArray = Array.prototype;
  var prototypeOfObject = Object.prototype;
  var slice = prototypeOfArray.slice;

  var _toString = call.bind(prototypeOfObject.toString);

  var owns = call.bind(prototypeOfObject.hasOwnProperty);
  var defineGetter;
  var defineSetter;
  var lookupGetter;
  var lookupSetter;
  var supportsAccessors;

  if (supportsAccessors = owns(prototypeOfObject, "__defineGetter__")) {
    defineGetter = call.bind(prototypeOfObject.__defineGetter__);
    defineSetter = call.bind(prototypeOfObject.__defineSetter__);
    lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
    lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
  }

  if ([1, 2].splice(0).length != 2) {
    if (function () {
      // test IE < 9 to splice bug - see issue #138
      function makeArray(l) {
        var a = new Array(l + 2);
        a[0] = a[1] = 0;
        return a;
      }

      var array = [],
          lengthBefore;
      array.splice.apply(array, makeArray(20));
      array.splice.apply(array, makeArray(26));
      lengthBefore = array.length; //46

      array.splice(5, 0, "XXX"); // add one element

      lengthBefore + 1 == array.length;

      if (lengthBefore + 1 == array.length) {
        return true; // has right splice implementation without bugs
      }
    }()) {
      //IE 6/7
      var array_splice = Array.prototype.splice;

      Array.prototype.splice = function (start, deleteCount) {
        if (!arguments.length) {
          return [];
        } else {
          return array_splice.apply(this, [start === void 0 ? 0 : start, deleteCount === void 0 ? this.length - start : deleteCount].concat(slice.call(arguments, 2)));
        }
      };
    } else {
      //IE8
      Array.prototype.splice = function (pos, removeCount) {
        var length = this.length;

        if (pos > 0) {
          if (pos > length) pos = length;
        } else if (pos == void 0) {
          pos = 0;
        } else if (pos < 0) {
          pos = Math.max(length + pos, 0);
        }

        if (!(pos + removeCount < length)) removeCount = length - pos;
        var removed = this.slice(pos, pos + removeCount);
        var insert = slice.call(arguments, 2);
        var add = insert.length;

        if (pos === length) {
          if (add) {
            this.push.apply(this, insert);
          }
        } else {
          var remove = Math.min(removeCount, length - pos);
          var tailOldPos = pos + remove;
          var tailNewPos = tailOldPos + add - remove;
          var tailCount = length - tailOldPos;
          var lengthAfterRemove = length - remove;

          if (tailNewPos < tailOldPos) {
            // case A
            for (var i = 0; i < tailCount; ++i) {
              this[tailNewPos + i] = this[tailOldPos + i];
            }
          } else if (tailNewPos > tailOldPos) {
            // case B
            for (i = tailCount; i--;) {
              this[tailNewPos + i] = this[tailOldPos + i];
            }
          } // else, add == remove (nothing to do)


          if (add && pos === lengthAfterRemove) {
            this.length = lengthAfterRemove; // truncate array

            this.push.apply(this, insert);
          } else {
            this.length = lengthAfterRemove + add; // reserves space

            for (i = 0; i < add; ++i) {
              this[pos + i] = insert[i];
            }
          }
        }

        return removed;
      };
    }
  }

  if (!Array.isArray) {
    Array.isArray = function isArray(obj) {
      return _toString(obj) == "[object Array]";
    };
  }

  var boxedString = Object("a"),
      splitString = boxedString[0] != "a" || !(0 in boxedString);

  if (!Array.prototype.forEach) {
    Array.prototype.forEach = function forEach(fun
    /*, thisp*/
    ) {
      var object = toObject(this),
          self = splitString && _toString(this) == "[object String]" ? this.split("") : object,
          thisp = arguments[1],
          i = -1,
          length = self.length >>> 0;

      if (_toString(fun) != "[object Function]") {
        throw new TypeError(); // TODO message
      }

      while (++i < length) {
        if (i in self) {
          fun.call(thisp, self[i], i, object);
        }
      }
    };
  }

  if (!Array.prototype.map) {
    Array.prototype.map = function map(fun
    /*, thisp*/
    ) {
      var object = toObject(this),
          self = splitString && _toString(this) == "[object String]" ? this.split("") : object,
          length = self.length >>> 0,
          result = Array(length),
          thisp = arguments[1];

      if (_toString(fun) != "[object Function]") {
        throw new TypeError(fun + " is not a function");
      }

      for (var i = 0; i < length; i++) {
        if (i in self) result[i] = fun.call(thisp, self[i], i, object);
      }

      return result;
    };
  }

  if (!Array.prototype.filter) {
    Array.prototype.filter = function filter(fun
    /*, thisp */
    ) {
      var object = toObject(this),
          self = splitString && _toString(this) == "[object String]" ? this.split("") : object,
          length = self.length >>> 0,
          result = [],
          value,
          thisp = arguments[1];

      if (_toString(fun) != "[object Function]") {
        throw new TypeError(fun + " is not a function");
      }

      for (var i = 0; i < length; i++) {
        if (i in self) {
          value = self[i];

          if (fun.call(thisp, value, i, object)) {
            result.push(value);
          }
        }
      }

      return result;
    };
  }

  if (!Array.prototype.every) {
    Array.prototype.every = function every(fun
    /*, thisp */
    ) {
      var object = toObject(this),
          self = splitString && _toString(this) == "[object String]" ? this.split("") : object,
          length = self.length >>> 0,
          thisp = arguments[1];

      if (_toString(fun) != "[object Function]") {
        throw new TypeError(fun + " is not a function");
      }

      for (var i = 0; i < length; i++) {
        if (i in self && !fun.call(thisp, self[i], i, object)) {
          return false;
        }
      }

      return true;
    };
  }

  if (!Array.prototype.some) {
    Array.prototype.some = function some(fun
    /*, thisp */
    ) {
      var object = toObject(this),
          self = splitString && _toString(this) == "[object String]" ? this.split("") : object,
          length = self.length >>> 0,
          thisp = arguments[1];

      if (_toString(fun) != "[object Function]") {
        throw new TypeError(fun + " is not a function");
      }

      for (var i = 0; i < length; i++) {
        if (i in self && fun.call(thisp, self[i], i, object)) {
          return true;
        }
      }

      return false;
    };
  }

  if (!Array.prototype.reduce) {
    Array.prototype.reduce = function reduce(fun
    /*, initial*/
    ) {
      var object = toObject(this),
          self = splitString && _toString(this) == "[object String]" ? this.split("") : object,
          length = self.length >>> 0;

      if (_toString(fun) != "[object Function]") {
        throw new TypeError(fun + " is not a function");
      }

      if (!length && arguments.length == 1) {
        throw new TypeError("reduce of empty array with no initial value");
      }

      var i = 0;
      var result;

      if (arguments.length >= 2) {
        result = arguments[1];
      } else {
        do {
          if (i in self) {
            result = self[i++];
            break;
          }

          if (++i >= length) {
            throw new TypeError("reduce of empty array with no initial value");
          }
        } while (true);
      }

      for (; i < length; i++) {
        if (i in self) {
          result = fun.call(void 0, result, self[i], i, object);
        }
      }

      return result;
    };
  }

  if (!Array.prototype.reduceRight) {
    Array.prototype.reduceRight = function reduceRight(fun
    /*, initial*/
    ) {
      var object = toObject(this),
          self = splitString && _toString(this) == "[object String]" ? this.split("") : object,
          length = self.length >>> 0;

      if (_toString(fun) != "[object Function]") {
        throw new TypeError(fun + " is not a function");
      }

      if (!length && arguments.length == 1) {
        throw new TypeError("reduceRight of empty array with no initial value");
      }

      var result,
          i = length - 1;

      if (arguments.length >= 2) {
        result = arguments[1];
      } else {
        do {
          if (i in self) {
            result = self[i--];
            break;
          }

          if (--i < 0) {
            throw new TypeError("reduceRight of empty array with no initial value");
          }
        } while (true);
      }

      do {
        if (i in this) {
          result = fun.call(void 0, result, self[i], i, object);
        }
      } while (i--);

      return result;
    };
  }

  if (!Array.prototype.indexOf || [0, 1].indexOf(1, 2) != -1) {
    Array.prototype.indexOf = function indexOf(sought
    /*, fromIndex */
    ) {
      var self = splitString && _toString(this) == "[object String]" ? this.split("") : toObject(this),
          length = self.length >>> 0;

      if (!length) {
        return -1;
      }

      var i = 0;

      if (arguments.length > 1) {
        i = toInteger(arguments[1]);
      }

      i = i >= 0 ? i : Math.max(0, length + i);

      for (; i < length; i++) {
        if (i in self && self[i] === sought) {
          return i;
        }
      }

      return -1;
    };
  }

  if (!Array.prototype.lastIndexOf || [0, 1].lastIndexOf(0, -3) != -1) {
    Array.prototype.lastIndexOf = function lastIndexOf(sought
    /*, fromIndex */
    ) {
      var self = splitString && _toString(this) == "[object String]" ? this.split("") : toObject(this),
          length = self.length >>> 0;

      if (!length) {
        return -1;
      }

      var i = length - 1;

      if (arguments.length > 1) {
        i = Math.min(i, toInteger(arguments[1]));
      }

      i = i >= 0 ? i : length - Math.abs(i);

      for (; i >= 0; i--) {
        if (i in self && sought === self[i]) {
          return i;
        }
      }

      return -1;
    };
  }

  if (!Object.getPrototypeOf) {
    Object.getPrototypeOf = function getPrototypeOf(object) {
      return object.__proto__ || (object.constructor ? object.constructor.prototype : prototypeOfObject);
    };
  }

  if (!Object.getOwnPropertyDescriptor) {
    var ERR_NON_OBJECT = "Object.getOwnPropertyDescriptor called on a " + "non-object: ";

    Object.getOwnPropertyDescriptor = function getOwnPropertyDescriptor(object, property) {
      if (typeof object != "object" && typeof object != "function" || object === null) throw new TypeError(ERR_NON_OBJECT + object);
      if (!owns(object, property)) return;
      var descriptor, getter, setter;
      descriptor = {
        enumerable: true,
        configurable: true
      };

      if (supportsAccessors) {
        var prototype = object.__proto__;
        object.__proto__ = prototypeOfObject;
        var getter = lookupGetter(object, property);
        var setter = lookupSetter(object, property);
        object.__proto__ = prototype;

        if (getter || setter) {
          if (getter) descriptor.get = getter;
          if (setter) descriptor.set = setter;
          return descriptor;
        }
      }

      descriptor.value = object[property];
      return descriptor;
    };
  }

  if (!Object.getOwnPropertyNames) {
    Object.getOwnPropertyNames = function getOwnPropertyNames(object) {
      return Object.keys(object);
    };
  }

  if (!Object.create) {
    var createEmpty;

    if (Object.prototype.__proto__ === null) {
      createEmpty = function createEmpty() {
        return {
          "__proto__": null
        };
      };
    } else {
      createEmpty = function createEmpty() {
        var empty = {};

        for (var i in empty) {
          empty[i] = null;
        }

        empty.constructor = empty.hasOwnProperty = empty.propertyIsEnumerable = empty.isPrototypeOf = empty.toLocaleString = empty.toString = empty.valueOf = empty.__proto__ = null;
        return empty;
      };
    }

    Object.create = function create(prototype, properties) {
      var object;

      if (prototype === null) {
        object = createEmpty();
      } else {
        if (typeof prototype != "object") throw new TypeError("typeof prototype[" + typeof prototype + "] != 'object'");

        var Type = function Type() {};

        Type.prototype = prototype;
        object = new Type();
        object.__proto__ = prototype;
      }

      if (properties !== void 0) Object.defineProperties(object, properties);
      return object;
    };
  }

  function doesDefinePropertyWork(object) {
    try {
      Object.defineProperty(object, "sentinel", {});
      return "sentinel" in object;
    } catch (exception) {}
  }

  if (Object.defineProperty) {
    var definePropertyWorksOnObject = doesDefinePropertyWork({});
    var definePropertyWorksOnDom = typeof document == "undefined" || doesDefinePropertyWork(document.createElement("div"));

    if (!definePropertyWorksOnObject || !definePropertyWorksOnDom) {
      var definePropertyFallback = Object.defineProperty;
    }
  }

  if (!Object.defineProperty || definePropertyFallback) {
    var ERR_NON_OBJECT_DESCRIPTOR = "Property description must be an object: ";
    var ERR_NON_OBJECT_TARGET = "Object.defineProperty called on non-object: ";
    var ERR_ACCESSORS_NOT_SUPPORTED = "getters & setters can not be defined " + "on this javascript engine";

    Object.defineProperty = function defineProperty(object, property, descriptor) {
      if (typeof object != "object" && typeof object != "function" || object === null) throw new TypeError(ERR_NON_OBJECT_TARGET + object);
      if (typeof descriptor != "object" && typeof descriptor != "function" || descriptor === null) throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);

      if (definePropertyFallback) {
        try {
          return definePropertyFallback.call(Object, object, property, descriptor);
        } catch (exception) {}
      }

      if (owns(descriptor, "value")) {
        if (supportsAccessors && (lookupGetter(object, property) || lookupSetter(object, property))) {
          var prototype = object.__proto__;
          object.__proto__ = prototypeOfObject;
          delete object[property];
          object[property] = descriptor.value;
          object.__proto__ = prototype;
        } else {
          object[property] = descriptor.value;
        }
      } else {
        if (!supportsAccessors) throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
        if (owns(descriptor, "get")) defineGetter(object, property, descriptor.get);
        if (owns(descriptor, "set")) defineSetter(object, property, descriptor.set);
      }

      return object;
    };
  }

  if (!Object.defineProperties) {
    Object.defineProperties = function defineProperties(object, properties) {
      for (var property in properties) {
        if (owns(properties, property)) Object.defineProperty(object, property, properties[property]);
      }

      return object;
    };
  }

  if (!Object.seal) {
    Object.seal = function seal(object) {
      return object;
    };
  }

  if (!Object.freeze) {
    Object.freeze = function freeze(object) {
      return object;
    };
  }

  try {
    Object.freeze(function () {});
  } catch (exception) {
    Object.freeze = function freeze(freezeObject) {
      return function freeze(object) {
        if (typeof object == "function") {
          return object;
        } else {
          return freezeObject(object);
        }
      };
    }(Object.freeze);
  }

  if (!Object.preventExtensions) {
    Object.preventExtensions = function preventExtensions(object) {
      return object;
    };
  }

  if (!Object.isSealed) {
    Object.isSealed = function isSealed(object) {
      return false;
    };
  }

  if (!Object.isFrozen) {
    Object.isFrozen = function isFrozen(object) {
      return false;
    };
  }

  if (!Object.isExtensible) {
    Object.isExtensible = function isExtensible(object) {
      if (Object(object) === object) {
        throw new TypeError(); // TODO message
      }

      var name = '';

      while (owns(object, name)) {
        name += '?';
      }

      object[name] = true;
      var returnValue = owns(object, name);
      delete object[name];
      return returnValue;
    };
  }

  if (!Object.keys) {
    var hasDontEnumBug = true,
        dontEnums = ["toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "constructor"],
        dontEnumsLength = dontEnums.length;

    for (var key in {
      "toString": null
    }) {
      hasDontEnumBug = false;
    }

    Object.keys = function keys(object) {
      if (typeof object != "object" && typeof object != "function" || object === null) {
        throw new TypeError("Object.keys called on a non-object");
      }

      var keys = [];

      for (var name in object) {
        if (owns(object, name)) {
          keys.push(name);
        }
      }

      if (hasDontEnumBug) {
        for (var i = 0, ii = dontEnumsLength; i < ii; i++) {
          var dontEnum = dontEnums[i];

          if (owns(object, dontEnum)) {
            keys.push(dontEnum);
          }
        }
      }

      return keys;
    };
  }

  if (!Date.now) {
    Date.now = function now() {
      return new Date().getTime();
    };
  }

  var ws = "\t\n\x0B\f\r \xA0\u1680\u2000\u2001\u2002\u2003" + "\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028" + "\u2029\uFEFF";

  if (!String.prototype.trim) {
    ws = "[" + ws + "]";
    var trimBeginRegexp = new RegExp("^" + ws + ws + "*"),
        trimEndRegexp = new RegExp(ws + ws + "*$");

    String.prototype.trim = function trim() {
      return String(this).replace(trimBeginRegexp, "").replace(trimEndRegexp, "");
    };
  }

  function toInteger(n) {
    n = +n;

    if (n !== n) {
      // isNaN
      n = 0;
    } else if (n !== 0 && n !== 1 / 0 && n !== -(1 / 0)) {
      n = (n > 0 || -1) * Math.floor(Math.abs(n));
    }

    return n;
  }

  function isPrimitive(input) {
    var type = typeof input;
    return input === null || type === "undefined" || type === "boolean" || type === "number" || type === "string";
  }

  function toPrimitive(input) {
    var val, valueOf, toString;

    if (isPrimitive(input)) {
      return input;
    }

    valueOf = input.valueOf;

    if (typeof valueOf === "function") {
      val = valueOf.call(input);

      if (isPrimitive(val)) {
        return val;
      }
    }

    toString = input.toString;

    if (typeof toString === "function") {
      val = toString.call(input);

      if (isPrimitive(val)) {
        return val;
      }
    }

    throw new TypeError();
  }

  var toObject = function toObject(o) {
    if (o == null) {
      // this matches both null and undefined
      throw new TypeError("can't convert " + o + " to object");
    }

    return Object(o);
  };
});