// ce-1.5.0.452 2410917ce1ad01bc914b32db5ce7ad1d5298485d
// Copyright 2013-2016 Evernote Corp. All rights reserved.
// http://www.evernote.com

var CLOSURE_NO_DEPS = true;
var COMPILED = false;
var goog = goog || {};
goog.global = this;
goog.global.CLOSURE_UNCOMPILED_DEFINES;
goog.global.CLOSURE_DEFINES;
goog.isDef = function(val) {
  return val !== void 0;
};
goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
  var parts = name.split(".");
  var cur = opt_objectToExportTo || goog.global;
  if (!(parts[0] in cur) && cur.execScript) {
    cur.execScript("var " + parts[0]);
  }
  for (var part;parts.length && (part = parts.shift());) {
    if (!parts.length && goog.isDef(opt_object)) {
      cur[part] = opt_object;
    } else {
      if (cur[part]) {
        cur = cur[part];
      } else {
        cur = cur[part] = {};
      }
    }
  }
};
goog.define = function(name, defaultValue) {
  var value = defaultValue;
  if (!COMPILED) {
    if (goog.global.CLOSURE_UNCOMPILED_DEFINES && Object.prototype.hasOwnProperty.call(goog.global.CLOSURE_UNCOMPILED_DEFINES, name)) {
      value = goog.global.CLOSURE_UNCOMPILED_DEFINES[name];
    } else {
      if (goog.global.CLOSURE_DEFINES && Object.prototype.hasOwnProperty.call(goog.global.CLOSURE_DEFINES, name)) {
        value = goog.global.CLOSURE_DEFINES[name];
      }
    }
  }
  goog.exportPath_(name, value);
};
goog.define("goog.DEBUG", true);
goog.define("goog.LOCALE", "en");
goog.define("goog.TRUSTED_SITE", true);
goog.define("goog.STRICT_MODE_COMPATIBLE", false);
goog.define("goog.DISALLOW_TEST_ONLY_CODE", COMPILED && !goog.DEBUG);
goog.define("goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING", false);
goog.provide = function(name) {
  if (goog.isInModuleLoader_()) {
    throw Error("goog.provide can not be used within a goog.module.");
  }
  if (!COMPILED) {
    if (goog.isProvided_(name)) {
      throw Error('Namespace "' + name + '" already declared.');
    }
  }
  goog.constructNamespace_(name);
};
goog.constructNamespace_ = function(name, opt_obj) {
  if (!COMPILED) {
    delete goog.implicitNamespaces_[name];
    var namespace = name;
    while (namespace = namespace.substring(0, namespace.lastIndexOf("."))) {
      if (goog.getObjectByName(namespace)) {
        break;
      }
      goog.implicitNamespaces_[namespace] = true;
    }
  }
  goog.exportPath_(name, opt_obj);
};
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
goog.module = function(name) {
  if (!goog.isString(name) || !name || name.search(goog.VALID_MODULE_RE_) == -1) {
    throw Error("Invalid module identifier");
  }
  if (!goog.isInModuleLoader_()) {
    throw Error("Module " + name + " has been loaded incorrectly.");
  }
  if (goog.moduleLoaderState_.moduleName) {
    throw Error("goog.module may only be called once per module.");
  }
  goog.moduleLoaderState_.moduleName = name;
  if (!COMPILED) {
    if (goog.isProvided_(name)) {
      throw Error('Namespace "' + name + '" already declared.');
    }
    delete goog.implicitNamespaces_[name];
  }
};
goog.module.get = function(name) {
  return goog.module.getInternal_(name);
};
goog.module.getInternal_ = function(name) {
  if (!COMPILED) {
    if (goog.isProvided_(name)) {
      return name in goog.loadedModules_ ? goog.loadedModules_[name] : goog.getObjectByName(name);
    } else {
      return null;
    }
  }
};
goog.moduleLoaderState_ = null;
goog.isInModuleLoader_ = function() {
  return goog.moduleLoaderState_ != null;
};
goog.module.declareLegacyNamespace = function() {
  if (!COMPILED && !goog.isInModuleLoader_()) {
    throw new Error("goog.module.declareLegacyNamespace must be called from " + "within a goog.module");
  }
  if (!COMPILED && !goog.moduleLoaderState_.moduleName) {
    throw Error("goog.module must be called prior to " + "goog.module.declareLegacyNamespace.");
  }
  goog.moduleLoaderState_.declareLegacyNamespace = true;
};
goog.setTestOnly = function(opt_message) {
  if (goog.DISALLOW_TEST_ONLY_CODE) {
    opt_message = opt_message || "";
    throw Error("Importing test-only code into non-debug environment" + (opt_message ? ": " + opt_message : "."));
  }
};
goog.forwardDeclare = function(name) {
};
goog.forwardDeclare("Document");
goog.forwardDeclare("HTMLScriptElement");
goog.forwardDeclare("XMLHttpRequest");
if (!COMPILED) {
  goog.isProvided_ = function(name) {
    return name in goog.loadedModules_ || !goog.implicitNamespaces_[name] && goog.isDefAndNotNull(goog.getObjectByName(name));
  };
  goog.implicitNamespaces_ = {"goog.module":true};
}
goog.getObjectByName = function(name, opt_obj) {
  var parts = name.split(".");
  var cur = opt_obj || goog.global;
  for (var part;part = parts.shift();) {
    if (goog.isDefAndNotNull(cur[part])) {
      cur = cur[part];
    } else {
      return null;
    }
  }
  return cur;
};
goog.globalize = function(obj, opt_global) {
  var global = opt_global || goog.global;
  for (var x in obj) {
    global[x] = obj[x];
  }
};
goog.addDependency = function(relPath, provides, requires, opt_loadFlags) {
  if (goog.DEPENDENCIES_ENABLED) {
    var provide, require;
    var path = relPath.replace(/\\/g, "/");
    var deps = goog.dependencies_;
    if (!opt_loadFlags || typeof opt_loadFlags === "boolean") {
      opt_loadFlags = opt_loadFlags ? {"module":"goog"} : {};
    }
    for (var i = 0;provide = provides[i];i++) {
      deps.nameToPath[provide] = path;
      deps.loadFlags[path] = opt_loadFlags;
    }
    for (var j = 0;require = requires[j];j++) {
      if (!(path in deps.requires)) {
        deps.requires[path] = {};
      }
      deps.requires[path][require] = true;
    }
  }
};
goog.define("goog.ENABLE_DEBUG_LOADER", true);
goog.logToConsole_ = function(msg) {
  if (goog.global.console) {
    goog.global.console["error"](msg);
  }
};
goog.require = function(name) {
  if (!COMPILED) {
    if (goog.ENABLE_DEBUG_LOADER && goog.IS_OLD_IE_) {
      goog.maybeProcessDeferredDep_(name);
    }
    if (goog.isProvided_(name)) {
      if (goog.isInModuleLoader_()) {
        return goog.module.getInternal_(name);
      } else {
        return null;
      }
    }
    if (goog.ENABLE_DEBUG_LOADER) {
      var path = goog.getPathFromDeps_(name);
      if (path) {
        goog.writeScripts_(path);
        return null;
      }
    }
    var errorMessage = "goog.require could not find: " + name;
    goog.logToConsole_(errorMessage);
    throw Error(errorMessage);
  }
};
goog.basePath = "";
goog.global.CLOSURE_BASE_PATH;
goog.global.CLOSURE_NO_DEPS;
goog.global.CLOSURE_IMPORT_SCRIPT;
goog.nullFunction = function() {
};
goog.abstractMethod = function() {
  throw Error("unimplemented abstract method");
};
goog.addSingletonGetter = function(ctor) {
  ctor.getInstance = function() {
    if (ctor.instance_) {
      return ctor.instance_;
    }
    if (goog.DEBUG) {
      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;
    }
    return ctor.instance_ = new ctor;
  };
};
goog.instantiatedSingletons_ = [];
goog.define("goog.LOAD_MODULE_USING_EVAL", true);
goog.define("goog.SEAL_MODULE_EXPORTS", goog.DEBUG);
goog.loadedModules_ = {};
goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;
goog.define("goog.TRANSPILE", "detect");
goog.define("goog.TRANSPILER", "transpile.js");
if (goog.DEPENDENCIES_ENABLED) {
  goog.dependencies_ = {loadFlags:{}, nameToPath:{}, requires:{}, visited:{}, written:{}, deferred:{}};
  goog.inHtmlDocument_ = function() {
    var doc = goog.global.document;
    return doc != null && "write" in doc;
  };
  goog.findBasePath_ = function() {
    if (goog.isDef(goog.global.CLOSURE_BASE_PATH)) {
      goog.basePath = goog.global.CLOSURE_BASE_PATH;
      return;
    } else {
      if (!goog.inHtmlDocument_()) {
        return;
      }
    }
    var doc = goog.global.document;
    var scripts = doc.getElementsByTagName("SCRIPT");
    for (var i = scripts.length - 1;i >= 0;--i) {
      var script = (scripts[i]);
      var src = script.src;
      var qmark = src.lastIndexOf("?");
      var l = qmark == -1 ? src.length : qmark;
      if (src.substr(l - 7, 7) == "base.js") {
        goog.basePath = src.substr(0, l - 7);
        return;
      }
    }
  };
  goog.importScript_ = function(src, opt_sourceText) {
    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT || goog.writeScriptTag_;
    if (importScript(src, opt_sourceText)) {
      goog.dependencies_.written[src] = true;
    }
  };
  goog.IS_OLD_IE_ = !!(!goog.global.atob && goog.global.document && goog.global.document.all);
  goog.importProcessedScript_ = function(src, isModule, needsTranspile) {
    var bootstrap = 'goog.retrieveAndExec_("' + src + '", ' + isModule + ", " + needsTranspile + ");";
    goog.importScript_("", bootstrap);
  };
  goog.queuedModules_ = [];
  goog.wrapModule_ = function(srcUrl, scriptText) {
    if (!goog.LOAD_MODULE_USING_EVAL || !goog.isDef(goog.global.JSON)) {
      return "" + "goog.loadModule(function(exports) {" + '"use strict";' + scriptText + "\n" + ";return exports" + "});" + "\n//# sourceURL=" + srcUrl + "\n";
    } else {
      return "" + "goog.loadModule(" + goog.global.JSON.stringify(scriptText + "\n//# sourceURL=" + srcUrl + "\n") + ");";
    }
  };
  goog.loadQueuedModules_ = function() {
    var count = goog.queuedModules_.length;
    if (count > 0) {
      var queue = goog.queuedModules_;
      goog.queuedModules_ = [];
      for (var i = 0;i < count;i++) {
        var path = queue[i];
        goog.maybeProcessDeferredPath_(path);
      }
    }
  };
  goog.maybeProcessDeferredDep_ = function(name) {
    if (goog.isDeferredModule_(name) && goog.allDepsAreAvailable_(name)) {
      var path = goog.getPathFromDeps_(name);
      goog.maybeProcessDeferredPath_(goog.basePath + path);
    }
  };
  goog.isDeferredModule_ = function(name) {
    var path = goog.getPathFromDeps_(name);
    var loadFlags = path && goog.dependencies_.loadFlags[path] || {};
    if (path && (loadFlags["module"] == "goog" || goog.needsTranspile_(loadFlags["lang"]))) {
      var abspath = goog.basePath + path;
      return abspath in goog.dependencies_.deferred;
    }
    return false;
  };
  goog.allDepsAreAvailable_ = function(name) {
    var path = goog.getPathFromDeps_(name);
    if (path && path in goog.dependencies_.requires) {
      for (var requireName in goog.dependencies_.requires[path]) {
        if (!goog.isProvided_(requireName) && !goog.isDeferredModule_(requireName)) {
          return false;
        }
      }
    }
    return true;
  };
  goog.maybeProcessDeferredPath_ = function(abspath) {
    if (abspath in goog.dependencies_.deferred) {
      var src = goog.dependencies_.deferred[abspath];
      delete goog.dependencies_.deferred[abspath];
      goog.globalEval(src);
    }
  };
  goog.loadModuleFromUrl = function(url) {
    goog.retrieveAndExec_(url, true, false);
  };
  goog.writeScriptSrcNode_ = function(src) {
    goog.global.document.write('<script type="text/javascript" src="' + src + '"></' + "script>");
  };
  goog.appendScriptSrcNode_ = function(src) {
    var doc = goog.global.document;
    var scriptEl = (doc.createElement("script"));
    scriptEl.type = "text/javascript";
    scriptEl.src = src;
    scriptEl.defer = false;
    scriptEl.async = false;
    doc.head.appendChild(scriptEl);
  };
  goog.writeScriptTag_ = function(src, opt_sourceText) {
    if (goog.inHtmlDocument_()) {
      var doc = goog.global.document;
      if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING && doc.readyState == "complete") {
        var isDeps = /\bdeps.js$/.test(src);
        if (isDeps) {
          return false;
        } else {
          throw Error('Cannot write "' + src + '" after document load');
        }
      }
      if (opt_sourceText === undefined) {
        if (!goog.IS_OLD_IE_) {
          if (goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {
            goog.appendScriptSrcNode_(src);
          } else {
            goog.writeScriptSrcNode_(src);
          }
        } else {
          var state = " onreadystatechange='goog.onScriptLoad_(this, " + ++goog.lastNonModuleScriptIndex_ + ")' ";
          doc.write('<script type="text/javascript" src="' + src + '"' + state + "></" + "script>");
        }
      } else {
        doc.write('<script type="text/javascript">' + opt_sourceText + "</" + "script>");
      }
      return true;
    } else {
      return false;
    }
  };
  goog.needsTranspile_ = function(lang) {
    if (goog.TRANSPILE == "always") {
      return true;
    } else {
      if (goog.TRANSPILE == "never") {
        return false;
      } else {
        if (!goog.transpiledLanguages_) {
          goog.transpiledLanguages_ = {"es5":true, "es6":true, "es6-impl":true};
          try {
            goog.transpiledLanguages_["es5"] = eval("[1,].length!=1");
            var es6implTest = "let a={};const X=class{constructor(){}x(z){return new Map([" + "...arguments]).get(z[0])==3}};return new X().x([a,3])";
            var es6fullTest = "class X{constructor(){if(new.target!=String)throw 1;this.x=42}}" + "let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof " + "String))throw 1;for(const a of[2,3]){if(a==2)continue;function " + "f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()" + "==3}";
            if (eval('(()=>{"use strict";' + es6implTest + "})()")) {
              goog.transpiledLanguages_["es6-impl"] = false;
            }
            if (eval('(()=>{"use strict";' + es6fullTest + "})()")) {
              goog.transpiledLanguages_["es6"] = false;
            }
          } catch (err) {
          }
        }
      }
    }
    return !!goog.transpiledLanguages_[lang];
  };
  goog.transpiledLanguages_ = null;
  goog.lastNonModuleScriptIndex_ = 0;
  goog.onScriptLoad_ = function(script, scriptIndex) {
    if (script.readyState == "complete" && goog.lastNonModuleScriptIndex_ == scriptIndex) {
      goog.loadQueuedModules_();
    }
    return true;
  };
  goog.writeScripts_ = function(pathToLoad) {
    var scripts = [];
    var seenScript = {};
    var deps = goog.dependencies_;
    function visitNode(path) {
      if (path in deps.written) {
        return;
      }
      if (path in deps.visited) {
        return;
      }
      deps.visited[path] = true;
      if (path in deps.requires) {
        for (var requireName in deps.requires[path]) {
          if (!goog.isProvided_(requireName)) {
            if (requireName in deps.nameToPath) {
              visitNode(deps.nameToPath[requireName]);
            } else {
              throw Error("Undefined nameToPath for " + requireName);
            }
          }
        }
      }
      if (!(path in seenScript)) {
        seenScript[path] = true;
        scripts.push(path);
      }
    }
    visitNode(pathToLoad);
    for (var i = 0;i < scripts.length;i++) {
      var path = scripts[i];
      goog.dependencies_.written[path] = true;
    }
    var moduleState = goog.moduleLoaderState_;
    goog.moduleLoaderState_ = null;
    for (var i = 0;i < scripts.length;i++) {
      var path = scripts[i];
      if (path) {
        var loadFlags = deps.loadFlags[path] || {};
        var needsTranspile = goog.needsTranspile_(loadFlags["lang"]);
        if (loadFlags["module"] == "goog" || needsTranspile) {
          goog.importProcessedScript_(goog.basePath + path, loadFlags["module"] == "goog", needsTranspile);
        } else {
          goog.importScript_(goog.basePath + path);
        }
      } else {
        goog.moduleLoaderState_ = moduleState;
        throw Error("Undefined script input");
      }
    }
    goog.moduleLoaderState_ = moduleState;
  };
  goog.getPathFromDeps_ = function(rule) {
    if (rule in goog.dependencies_.nameToPath) {
      return goog.dependencies_.nameToPath[rule];
    } else {
      return null;
    }
  };
  goog.findBasePath_();
  if (!goog.global.CLOSURE_NO_DEPS) {
    goog.importScript_(goog.basePath + "deps.js");
  }
}
goog.loadModule = function(moduleDef) {
  var previousState = goog.moduleLoaderState_;
  try {
    goog.moduleLoaderState_ = {moduleName:undefined, declareLegacyNamespace:false};
    var exports;
    if (goog.isFunction(moduleDef)) {
      exports = moduleDef.call(undefined, {});
    } else {
      if (goog.isString(moduleDef)) {
        exports = goog.loadModuleFromSource_.call(undefined, moduleDef);
      } else {
        throw Error("Invalid module definition");
      }
    }
    var moduleName = goog.moduleLoaderState_.moduleName;
    if (!goog.isString(moduleName) || !moduleName) {
      throw Error('Invalid module name "' + moduleName + '"');
    }
    if (goog.moduleLoaderState_.declareLegacyNamespace) {
      goog.constructNamespace_(moduleName, exports);
    } else {
      if (goog.SEAL_MODULE_EXPORTS && Object.seal) {
        Object.seal(exports);
      }
    }
    goog.loadedModules_[moduleName] = exports;
  } finally {
    goog.moduleLoaderState_ = previousState;
  }
};
goog.loadModuleFromSource_ = function() {
  var exports = {};
  eval(arguments[0]);
  return exports;
};
goog.normalizePath_ = function(path) {
  var components = path.split("/");
  var i = 0;
  while (i < components.length) {
    if (components[i] == ".") {
      components.splice(i, 1);
    } else {
      if (i && components[i] == ".." && components[i - 1] && components[i - 1] != "..") {
        components.splice(--i, 2);
      } else {
        i++;
      }
    }
  }
  return components.join("/");
};
goog.loadFileSync_ = function(src) {
  if (goog.global.CLOSURE_LOAD_FILE_SYNC) {
    return goog.global.CLOSURE_LOAD_FILE_SYNC(src);
  } else {
    try {
      var xhr = new goog.global["XMLHttpRequest"];
      xhr.open("get", src, false);
      xhr.send();
      return xhr.status == 0 || xhr.status == 200 ? xhr.responseText : null;
    } catch (err) {
      return null;
    }
  }
};
goog.retrieveAndExec_ = function(src, isModule, needsTranspile) {
  if (!COMPILED) {
    var originalPath = src;
    src = goog.normalizePath_(src);
    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT || goog.writeScriptTag_;
    var scriptText = goog.loadFileSync_(src);
    if (scriptText == null) {
      throw new Error('Load of "' + src + '" failed');
    }
    if (needsTranspile) {
      scriptText = goog.transpile_.call(goog.global, scriptText, src);
    }
    if (isModule) {
      scriptText = goog.wrapModule_(src, scriptText);
    } else {
      scriptText += "\n//# sourceURL=" + src;
    }
    var isOldIE = goog.IS_OLD_IE_;
    if (isOldIE) {
      goog.dependencies_.deferred[originalPath] = scriptText;
      goog.queuedModules_.push(originalPath);
    } else {
      importScript(src, scriptText);
    }
  }
};
goog.transpile_ = function(code, path) {
  var jscomp = goog.global["$jscomp"];
  if (!jscomp) {
    goog.global["$jscomp"] = jscomp = {};
  }
  var transpile = jscomp.transpile;
  if (!transpile) {
    var transpilerPath = goog.basePath + goog.TRANSPILER;
    var transpilerCode = goog.loadFileSync_(transpilerPath);
    if (transpilerCode) {
      eval(transpilerCode + "\n//# sourceURL=" + transpilerPath);
      jscomp = goog.global["$jscomp"];
      transpile = jscomp.transpile;
    }
  }
  if (!transpile) {
    var suffix = " requires transpilation but no transpiler was found.";
    transpile = jscomp.transpile = function(code, path) {
      goog.logToConsole_(path + suffix);
      return code;
    };
  }
  return transpile(code, path);
};
goog.typeOf = function(value) {
  var s = typeof value;
  if (s == "object") {
    if (value) {
      if (value instanceof Array) {
        return "array";
      } else {
        if (value instanceof Object) {
          return s;
        }
      }
      var className = Object.prototype.toString.call((value));
      if (className == "[object Window]") {
        return "object";
      }
      if (className == "[object Array]" || typeof value.length == "number" && typeof value.splice != "undefined" && typeof value.propertyIsEnumerable != "undefined" && !value.propertyIsEnumerable("splice")) {
        return "array";
      }
      if (className == "[object Function]" || typeof value.call != "undefined" && typeof value.propertyIsEnumerable != "undefined" && !value.propertyIsEnumerable("call")) {
        return "function";
      }
    } else {
      return "null";
    }
  } else {
    if (s == "function" && typeof value.call == "undefined") {
      return "object";
    }
  }
  return s;
};
goog.isNull = function(val) {
  return val === null;
};
goog.isDefAndNotNull = function(val) {
  return val != null;
};
goog.isArray = function(val) {
  return goog.typeOf(val) == "array";
};
goog.isArrayLike = function(val) {
  var type = goog.typeOf(val);
  return type == "array" || type == "object" && typeof val.length == "number";
};
goog.isDateLike = function(val) {
  return goog.isObject(val) && typeof val.getFullYear == "function";
};
goog.isString = function(val) {
  return typeof val == "string";
};
goog.isBoolean = function(val) {
  return typeof val == "boolean";
};
goog.isNumber = function(val) {
  return typeof val == "number";
};
goog.isFunction = function(val) {
  return goog.typeOf(val) == "function";
};
goog.isObject = function(val) {
  var type = typeof val;
  return type == "object" && val != null || type == "function";
};
goog.getUid = function(obj) {
  return obj[goog.UID_PROPERTY_] || (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
};
goog.hasUid = function(obj) {
  return !!obj[goog.UID_PROPERTY_];
};
goog.removeUid = function(obj) {
  if (obj !== null && "removeAttribute" in obj) {
    obj.removeAttribute(goog.UID_PROPERTY_);
  }
  try {
    delete obj[goog.UID_PROPERTY_];
  } catch (ex) {
  }
};
goog.UID_PROPERTY_ = "closure_uid_" + (Math.random() * 1E9 >>> 0);
goog.uidCounter_ = 0;
goog.getHashCode = goog.getUid;
goog.removeHashCode = goog.removeUid;
goog.cloneObject = function(obj) {
  var type = goog.typeOf(obj);
  if (type == "object" || type == "array") {
    if (obj.clone) {
      return obj.clone();
    }
    var clone = type == "array" ? [] : {};
    for (var key in obj) {
      clone[key] = goog.cloneObject(obj[key]);
    }
    return clone;
  }
  return obj;
};
goog.bindNative_ = function(fn, selfObj, var_args) {
  return (fn.call.apply(fn.bind, arguments));
};
goog.bindJs_ = function(fn, selfObj, var_args) {
  if (!fn) {
    throw new Error;
  }
  if (arguments.length > 2) {
    var boundArgs = Array.prototype.slice.call(arguments, 2);
    return function() {
      var newArgs = Array.prototype.slice.call(arguments);
      Array.prototype.unshift.apply(newArgs, boundArgs);
      return fn.apply(selfObj, newArgs);
    };
  } else {
    return function() {
      return fn.apply(selfObj, arguments);
    };
  }
};
goog.bind = function(fn, selfObj, var_args) {
  if (Function.prototype.bind && Function.prototype.bind.toString().indexOf("native code") != -1) {
    goog.bind = goog.bindNative_;
  } else {
    goog.bind = goog.bindJs_;
  }
  return goog.bind.apply(null, arguments);
};
goog.partial = function(fn, var_args) {
  var args = Array.prototype.slice.call(arguments, 1);
  return function() {
    var newArgs = args.slice();
    newArgs.push.apply(newArgs, arguments);
    return fn.apply(this, newArgs);
  };
};
goog.mixin = function(target, source) {
  for (var x in source) {
    target[x] = source[x];
  }
};
goog.now = goog.TRUSTED_SITE && Date.now || function() {
  return +new Date;
};
goog.globalEval = function(script) {
  if (goog.global.execScript) {
    goog.global.execScript(script, "JavaScript");
  } else {
    if (goog.global.eval) {
      if (goog.evalWorksForGlobals_ == null) {
        goog.global.eval("var _evalTest_ = 1;");
        if (typeof goog.global["_evalTest_"] != "undefined") {
          try {
            delete goog.global["_evalTest_"];
          } catch (ignore) {
          }
          goog.evalWorksForGlobals_ = true;
        } else {
          goog.evalWorksForGlobals_ = false;
        }
      }
      if (goog.evalWorksForGlobals_) {
        goog.global.eval(script);
      } else {
        var doc = goog.global.document;
        var scriptElt = (doc.createElement("SCRIPT"));
        scriptElt.type = "text/javascript";
        scriptElt.defer = false;
        scriptElt.appendChild(doc.createTextNode(script));
        doc.body.appendChild(scriptElt);
        doc.body.removeChild(scriptElt);
      }
    } else {
      throw Error("goog.globalEval not available");
    }
  }
};
goog.evalWorksForGlobals_ = null;
goog.cssNameMapping_;
goog.cssNameMappingStyle_;
goog.getCssName = function(className, opt_modifier) {
  var getMapping = function(cssName) {
    return goog.cssNameMapping_[cssName] || cssName;
  };
  var renameByParts = function(cssName) {
    var parts = cssName.split("-");
    var mapped = [];
    for (var i = 0;i < parts.length;i++) {
      mapped.push(getMapping(parts[i]));
    }
    return mapped.join("-");
  };
  var rename;
  if (goog.cssNameMapping_) {
    rename = goog.cssNameMappingStyle_ == "BY_WHOLE" ? getMapping : renameByParts;
  } else {
    rename = function(a) {
      return a;
    };
  }
  if (opt_modifier) {
    return className + "-" + rename(opt_modifier);
  } else {
    return rename(className);
  }
};
goog.setCssNameMapping = function(mapping, opt_style) {
  goog.cssNameMapping_ = mapping;
  goog.cssNameMappingStyle_ = opt_style;
};
goog.global.CLOSURE_CSS_NAME_MAPPING;
if (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {
  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;
}
goog.getMsg = function(str, opt_values) {
  if (opt_values) {
    str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
      return opt_values != null && key in opt_values ? opt_values[key] : match;
    });
  }
  return str;
};
goog.getMsgWithFallback = function(a, b) {
  return a;
};
goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
  goog.exportPath_(publicPath, object, opt_objectToExportTo);
};
goog.exportProperty = function(object, publicName, symbol) {
  object[publicName] = symbol;
};
goog.inherits = function(childCtor, parentCtor) {
  function tempCtor() {
  }
  tempCtor.prototype = parentCtor.prototype;
  childCtor.superClass_ = parentCtor.prototype;
  childCtor.prototype = new tempCtor;
  childCtor.prototype.constructor = childCtor;
  childCtor.base = function(me, methodName, var_args) {
    var args = new Array(arguments.length - 2);
    for (var i = 2;i < arguments.length;i++) {
      args[i - 2] = arguments[i];
    }
    return parentCtor.prototype[methodName].apply(me, args);
  };
};
goog.base = function(me, opt_methodName, var_args) {
  var caller = arguments.callee.caller;
  if (goog.STRICT_MODE_COMPATIBLE || goog.DEBUG && !caller) {
    throw Error("arguments.caller not defined.  goog.base() cannot be used " + "with strict mode code. See " + "http://www.ecma-international.org/ecma-262/5.1/#sec-C");
  }
  if (caller.superClass_) {
    var ctorArgs = new Array(arguments.length - 1);
    for (var i = 1;i < arguments.length;i++) {
      ctorArgs[i - 1] = arguments[i];
    }
    return caller.superClass_.constructor.apply(me, ctorArgs);
  }
  var args = new Array(arguments.length - 2);
  for (var i = 2;i < arguments.length;i++) {
    args[i - 2] = arguments[i];
  }
  var foundCaller = false;
  for (var ctor = me.constructor;ctor;ctor = ctor.superClass_ && ctor.superClass_.constructor) {
    if (ctor.prototype[opt_methodName] === caller) {
      foundCaller = true;
    } else {
      if (foundCaller) {
        return ctor.prototype[opt_methodName].apply(me, args);
      }
    }
  }
  if (me[opt_methodName] === caller) {
    return me.constructor.prototype[opt_methodName].apply(me, args);
  } else {
    throw Error("goog.base called from a method of one name " + "to a method of a different name");
  }
};
goog.scope = function(fn) {
  if (goog.isInModuleLoader_()) {
    throw Error("goog.scope is not supported within a goog.module.");
  }
  fn.call(goog.global);
};
if (!COMPILED) {
  goog.global["COMPILED"] = COMPILED;
}
goog.defineClass = function(superClass, def) {
  var constructor = def.constructor;
  var statics = def.statics;
  if (!constructor || constructor == Object.prototype.constructor) {
    constructor = function() {
      throw Error("cannot instantiate an interface (no constructor defined).");
    };
  }
  var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
  if (superClass) {
    goog.inherits(cls, superClass);
  }
  delete def.constructor;
  delete def.statics;
  goog.defineClass.applyProperties_(cls.prototype, def);
  if (statics != null) {
    if (statics instanceof Function) {
      statics(cls);
    } else {
      goog.defineClass.applyProperties_(cls, statics);
    }
  }
  return cls;
};
goog.defineClass.ClassDescriptor;
goog.define("goog.defineClass.SEAL_CLASS_INSTANCES", goog.DEBUG);
goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
  if (!goog.defineClass.SEAL_CLASS_INSTANCES) {
    return ctr;
  }
  var superclassSealable = !goog.defineClass.isUnsealable_(superClass);
  var wrappedCtr = function() {
    var instance = ctr.apply(this, arguments) || this;
    instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];
    if (this.constructor === wrappedCtr && superclassSealable && Object.seal instanceof Function) {
      Object.seal(instance);
    }
    return instance;
  };
  return wrappedCtr;
};
goog.defineClass.isUnsealable_ = function(ctr) {
  return ctr && ctr.prototype && ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];
};
goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = ["constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"];
goog.defineClass.applyProperties_ = function(target, source) {
  var key;
  for (key in source) {
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      target[key] = source[key];
    }
  }
  for (var i = 0;i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length;i++) {
    key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      target[key] = source[key];
    }
  }
};
goog.tagUnsealableClass = function(ctr) {
  if (!COMPILED && goog.defineClass.SEAL_CLASS_INSTANCES) {
    ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = true;
  }
};
goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = "goog_defineClass_legacy_unsealable";
goog.provide("goog.debug.Error");
goog.debug.Error = function(opt_msg) {
  if (Error.captureStackTrace) {
    Error.captureStackTrace(this, goog.debug.Error);
  } else {
    var stack = (new Error).stack;
    if (stack) {
      this.stack = stack;
    }
  }
  if (opt_msg) {
    this.message = String(opt_msg);
  }
  this.reportErrorToServer = true;
};
goog.inherits(goog.debug.Error, Error);
goog.debug.Error.prototype.name = "CustomError";
goog.provide("goog.dom.NodeType");
goog.dom.NodeType = {ELEMENT:1, ATTRIBUTE:2, TEXT:3, CDATA_SECTION:4, ENTITY_REFERENCE:5, ENTITY:6, PROCESSING_INSTRUCTION:7, COMMENT:8, DOCUMENT:9, DOCUMENT_TYPE:10, DOCUMENT_FRAGMENT:11, NOTATION:12};
goog.provide("goog.string");
goog.provide("goog.string.Unicode");
goog.define("goog.string.DETECT_DOUBLE_ESCAPING", false);
goog.define("goog.string.FORCE_NON_DOM_HTML_UNESCAPING", false);
goog.string.Unicode = {NBSP:"\u00a0"};
goog.string.startsWith = function(str, prefix) {
  return str.lastIndexOf(prefix, 0) == 0;
};
goog.string.endsWith = function(str, suffix) {
  var l = str.length - suffix.length;
  return l >= 0 && str.indexOf(suffix, l) == l;
};
goog.string.caseInsensitiveStartsWith = function(str, prefix) {
  return goog.string.caseInsensitiveCompare(prefix, str.substr(0, prefix.length)) == 0;
};
goog.string.caseInsensitiveEndsWith = function(str, suffix) {
  return goog.string.caseInsensitiveCompare(suffix, str.substr(str.length - suffix.length, suffix.length)) == 0;
};
goog.string.caseInsensitiveEquals = function(str1, str2) {
  return str1.toLowerCase() == str2.toLowerCase();
};
goog.string.subs = function(str, var_args) {
  var splitParts = str.split("%s");
  var returnString = "";
  var subsArguments = Array.prototype.slice.call(arguments, 1);
  while (subsArguments.length && splitParts.length > 1) {
    returnString += splitParts.shift() + subsArguments.shift();
  }
  return returnString + splitParts.join("%s");
};
goog.string.collapseWhitespace = function(str) {
  return str.replace(/[\s\xa0]+/g, " ").replace(/^\s+|\s+$/g, "");
};
goog.string.isEmptyOrWhitespace = function(str) {
  return /^[\s\xa0]*$/.test(str);
};
goog.string.isEmptyString = function(str) {
  return str.length == 0;
};
goog.string.isEmpty = goog.string.isEmptyOrWhitespace;
goog.string.isEmptyOrWhitespaceSafe = function(str) {
  return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(str));
};
goog.string.isEmptySafe = goog.string.isEmptyOrWhitespaceSafe;
goog.string.isBreakingWhitespace = function(str) {
  return !/[^\t\n\r ]/.test(str);
};
goog.string.isAlpha = function(str) {
  return !/[^a-zA-Z]/.test(str);
};
goog.string.isNumeric = function(str) {
  return !/[^0-9]/.test(str);
};
goog.string.isAlphaNumeric = function(str) {
  return !/[^a-zA-Z0-9]/.test(str);
};
goog.string.isSpace = function(ch) {
  return ch == " ";
};
goog.string.isUnicodeChar = function(ch) {
  return ch.length == 1 && ch >= " " && ch <= "~" || ch >= "\u0080" && ch <= "\ufffd";
};
goog.string.stripNewlines = function(str) {
  return str.replace(/(\r\n|\r|\n)+/g, " ");
};
goog.string.canonicalizeNewlines = function(str) {
  return str.replace(/(\r\n|\r|\n)/g, "\n");
};
goog.string.normalizeWhitespace = function(str) {
  return str.replace(/\xa0|\s/g, " ");
};
goog.string.normalizeSpaces = function(str) {
  return str.replace(/\xa0|[ \t]+/g, " ");
};
goog.string.collapseBreakingSpaces = function(str) {
  return str.replace(/[\t\r\n ]+/g, " ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, "");
};
goog.string.trim = goog.TRUSTED_SITE && String.prototype.trim ? function(str) {
  return str.trim();
} : function(str) {
  return str.replace(/^[\s\xa0]+|[\s\xa0]+$/g, "");
};
goog.string.trimLeft = function(str) {
  return str.replace(/^[\s\xa0]+/, "");
};
goog.string.trimRight = function(str) {
  return str.replace(/[\s\xa0]+$/, "");
};
goog.string.caseInsensitiveCompare = function(str1, str2) {
  var test1 = String(str1).toLowerCase();
  var test2 = String(str2).toLowerCase();
  if (test1 < test2) {
    return -1;
  } else {
    if (test1 == test2) {
      return 0;
    } else {
      return 1;
    }
  }
};
goog.string.numberAwareCompare_ = function(str1, str2, tokenizerRegExp) {
  if (str1 == str2) {
    return 0;
  }
  if (!str1) {
    return -1;
  }
  if (!str2) {
    return 1;
  }
  var tokens1 = str1.toLowerCase().match(tokenizerRegExp);
  var tokens2 = str2.toLowerCase().match(tokenizerRegExp);
  var count = Math.min(tokens1.length, tokens2.length);
  for (var i = 0;i < count;i++) {
    var a = tokens1[i];
    var b = tokens2[i];
    if (a != b) {
      var num1 = parseInt(a, 10);
      if (!isNaN(num1)) {
        var num2 = parseInt(b, 10);
        if (!isNaN(num2) && num1 - num2) {
          return num1 - num2;
        }
      }
      return a < b ? -1 : 1;
    }
  }
  if (tokens1.length != tokens2.length) {
    return tokens1.length - tokens2.length;
  }
  return str1 < str2 ? -1 : 1;
};
goog.string.intAwareCompare = function(str1, str2) {
  return goog.string.numberAwareCompare_(str1, str2, /\d+|\D+/g);
};
goog.string.floatAwareCompare = function(str1, str2) {
  return goog.string.numberAwareCompare_(str1, str2, /\d+|\.\d+|\D+/g);
};
goog.string.numerateCompare = goog.string.floatAwareCompare;
goog.string.urlEncode = function(str) {
  return encodeURIComponent(String(str));
};
goog.string.urlDecode = function(str) {
  return decodeURIComponent(str.replace(/\+/g, " "));
};
goog.string.newLineToBr = function(str, opt_xml) {
  return str.replace(/(\r\n|\r|\n)/g, opt_xml ? "<br />" : "<br>");
};
goog.string.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {
  if (opt_isLikelyToContainHtmlChars) {
    str = str.replace(goog.string.AMP_RE_, "&amp;").replace(goog.string.LT_RE_, "&lt;").replace(goog.string.GT_RE_, "&gt;").replace(goog.string.QUOT_RE_, "&quot;").replace(goog.string.SINGLE_QUOTE_RE_, "&#39;").replace(goog.string.NULL_RE_, "&#0;");
    if (goog.string.DETECT_DOUBLE_ESCAPING) {
      str = str.replace(goog.string.E_RE_, "&#101;");
    }
    return str;
  } else {
    if (!goog.string.ALL_RE_.test(str)) {
      return str;
    }
    if (str.indexOf("&") != -1) {
      str = str.replace(goog.string.AMP_RE_, "&amp;");
    }
    if (str.indexOf("<") != -1) {
      str = str.replace(goog.string.LT_RE_, "&lt;");
    }
    if (str.indexOf(">") != -1) {
      str = str.replace(goog.string.GT_RE_, "&gt;");
    }
    if (str.indexOf('"') != -1) {
      str = str.replace(goog.string.QUOT_RE_, "&quot;");
    }
    if (str.indexOf("'") != -1) {
      str = str.replace(goog.string.SINGLE_QUOTE_RE_, "&#39;");
    }
    if (str.indexOf("\x00") != -1) {
      str = str.replace(goog.string.NULL_RE_, "&#0;");
    }
    if (goog.string.DETECT_DOUBLE_ESCAPING && str.indexOf("e") != -1) {
      str = str.replace(goog.string.E_RE_, "&#101;");
    }
    return str;
  }
};
goog.string.AMP_RE_ = /&/g;
goog.string.LT_RE_ = /</g;
goog.string.GT_RE_ = />/g;
goog.string.QUOT_RE_ = /"/g;
goog.string.SINGLE_QUOTE_RE_ = /'/g;
goog.string.NULL_RE_ = /\x00/g;
goog.string.E_RE_ = /e/g;
goog.string.ALL_RE_ = goog.string.DETECT_DOUBLE_ESCAPING ? /[\x00&<>"'e]/ : /[\x00&<>"']/;
goog.string.unescapeEntities = function(str) {
  if (goog.string.contains(str, "&")) {
    if (!goog.string.FORCE_NON_DOM_HTML_UNESCAPING && "document" in goog.global) {
      return goog.string.unescapeEntitiesUsingDom_(str);
    } else {
      return goog.string.unescapePureXmlEntities_(str);
    }
  }
  return str;
};
goog.string.unescapeEntitiesWithDocument = function(str, document) {
  if (goog.string.contains(str, "&")) {
    return goog.string.unescapeEntitiesUsingDom_(str, document);
  }
  return str;
};
goog.string.unescapeEntitiesUsingDom_ = function(str, opt_document) {
  var seen = {"&amp;":"&", "&lt;":"<", "&gt;":">", "&quot;":'"'};
  var div;
  if (opt_document) {
    div = opt_document.createElement("div");
  } else {
    div = goog.global.document.createElement("div");
  }
  return str.replace(goog.string.HTML_ENTITY_PATTERN_, function(s, entity) {
    var value = seen[s];
    if (value) {
      return value;
    }
    if (entity.charAt(0) == "#") {
      var n = Number("0" + entity.substr(1));
      if (!isNaN(n)) {
        value = String.fromCharCode(n);
      }
    }
    if (!value) {
      div.innerHTML = s + " ";
      value = div.firstChild.nodeValue.slice(0, -1);
    }
    return seen[s] = value;
  });
};
goog.string.unescapePureXmlEntities_ = function(str) {
  return str.replace(/&([^;]+);/g, function(s, entity) {
    switch(entity) {
      case "amp":
        return "&";
      case "lt":
        return "<";
      case "gt":
        return ">";
      case "quot":
        return '"';
      default:
        if (entity.charAt(0) == "#") {
          var n = Number("0" + entity.substr(1));
          if (!isNaN(n)) {
            return String.fromCharCode(n);
          }
        }
        return s;
    }
  });
};
goog.string.HTML_ENTITY_PATTERN_ = /&([^;\s<&]+);?/g;
goog.string.whitespaceEscape = function(str, opt_xml) {
  return goog.string.newLineToBr(str.replace(/  /g, " &#160;"), opt_xml);
};
goog.string.preserveSpaces = function(str) {
  return str.replace(/(^|[\n ]) /g, "$1" + goog.string.Unicode.NBSP);
};
goog.string.stripQuotes = function(str, quoteChars) {
  var length = quoteChars.length;
  for (var i = 0;i < length;i++) {
    var quoteChar = length == 1 ? quoteChars : quoteChars.charAt(i);
    if (str.charAt(0) == quoteChar && str.charAt(str.length - 1) == quoteChar) {
      return str.substring(1, str.length - 1);
    }
  }
  return str;
};
goog.string.truncate = function(str, chars, opt_protectEscapedCharacters) {
  if (opt_protectEscapedCharacters) {
    str = goog.string.unescapeEntities(str);
  }
  if (str.length > chars) {
    str = str.substring(0, chars - 3) + "...";
  }
  if (opt_protectEscapedCharacters) {
    str = goog.string.htmlEscape(str);
  }
  return str;
};
goog.string.truncateMiddle = function(str, chars, opt_protectEscapedCharacters, opt_trailingChars) {
  if (opt_protectEscapedCharacters) {
    str = goog.string.unescapeEntities(str);
  }
  if (opt_trailingChars && str.length > chars) {
    if (opt_trailingChars > chars) {
      opt_trailingChars = chars;
    }
    var endPoint = str.length - opt_trailingChars;
    var startPoint = chars - opt_trailingChars;
    str = str.substring(0, startPoint) + "..." + str.substring(endPoint);
  } else {
    if (str.length > chars) {
      var half = Math.floor(chars / 2);
      var endPos = str.length - half;
      half += chars % 2;
      str = str.substring(0, half) + "..." + str.substring(endPos);
    }
  }
  if (opt_protectEscapedCharacters) {
    str = goog.string.htmlEscape(str);
  }
  return str;
};
goog.string.specialEscapeChars_ = {"\x00":"\\0", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t", "\x0B":"\\x0B", '"':'\\"', "\\":"\\\\", "<":"<"};
goog.string.jsEscapeCache_ = {"'":"\\'"};
goog.string.quote = function(s) {
  s = String(s);
  var sb = ['"'];
  for (var i = 0;i < s.length;i++) {
    var ch = s.charAt(i);
    var cc = ch.charCodeAt(0);
    sb[i + 1] = goog.string.specialEscapeChars_[ch] || (cc > 31 && cc < 127 ? ch : goog.string.escapeChar(ch));
  }
  sb.push('"');
  return sb.join("");
};
goog.string.escapeString = function(str) {
  var sb = [];
  for (var i = 0;i < str.length;i++) {
    sb[i] = goog.string.escapeChar(str.charAt(i));
  }
  return sb.join("");
};
goog.string.escapeChar = function(c) {
  if (c in goog.string.jsEscapeCache_) {
    return goog.string.jsEscapeCache_[c];
  }
  if (c in goog.string.specialEscapeChars_) {
    return goog.string.jsEscapeCache_[c] = goog.string.specialEscapeChars_[c];
  }
  var rv = c;
  var cc = c.charCodeAt(0);
  if (cc > 31 && cc < 127) {
    rv = c;
  } else {
    if (cc < 256) {
      rv = "\\x";
      if (cc < 16 || cc > 256) {
        rv += "0";
      }
    } else {
      rv = "\\u";
      if (cc < 4096) {
        rv += "0";
      }
    }
    rv += cc.toString(16).toUpperCase();
  }
  return goog.string.jsEscapeCache_[c] = rv;
};
goog.string.contains = function(str, subString) {
  return str.indexOf(subString) != -1;
};
goog.string.caseInsensitiveContains = function(str, subString) {
  return goog.string.contains(str.toLowerCase(), subString.toLowerCase());
};
goog.string.countOf = function(s, ss) {
  return s && ss ? s.split(ss).length - 1 : 0;
};
goog.string.removeAt = function(s, index, stringLength) {
  var resultStr = s;
  if (index >= 0 && index < s.length && stringLength > 0) {
    resultStr = s.substr(0, index) + s.substr(index + stringLength, s.length - index - stringLength);
  }
  return resultStr;
};
goog.string.remove = function(s, ss) {
  var re = new RegExp(goog.string.regExpEscape(ss), "");
  return s.replace(re, "");
};
goog.string.removeAll = function(s, ss) {
  var re = new RegExp(goog.string.regExpEscape(ss), "g");
  return s.replace(re, "");
};
goog.string.regExpEscape = function(s) {
  return String(s).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1").replace(/\x08/g, "\\x08");
};
goog.string.repeat = String.prototype.repeat ? function(string, length) {
  return string.repeat(length);
} : function(string, length) {
  return (new Array(length + 1)).join(string);
};
goog.string.padNumber = function(num, length, opt_precision) {
  var s = goog.isDef(opt_precision) ? num.toFixed(opt_precision) : String(num);
  var index = s.indexOf(".");
  if (index == -1) {
    index = s.length;
  }
  return goog.string.repeat("0", Math.max(0, length - index)) + s;
};
goog.string.makeSafe = function(obj) {
  return obj == null ? "" : String(obj);
};
goog.string.buildString = function(var_args) {
  return Array.prototype.join.call(arguments, "");
};
goog.string.getRandomString = function() {
  var x = 2147483648;
  return Math.floor(Math.random() * x).toString(36) + Math.abs(Math.floor(Math.random() * x) ^ goog.now()).toString(36);
};
goog.string.compareVersions = function(version1, version2) {
  var order = 0;
  var v1Subs = goog.string.trim(String(version1)).split(".");
  var v2Subs = goog.string.trim(String(version2)).split(".");
  var subCount = Math.max(v1Subs.length, v2Subs.length);
  for (var subIdx = 0;order == 0 && subIdx < subCount;subIdx++) {
    var v1Sub = v1Subs[subIdx] || "";
    var v2Sub = v2Subs[subIdx] || "";
    var v1CompParser = new RegExp("(\\d*)(\\D*)", "g");
    var v2CompParser = new RegExp("(\\d*)(\\D*)", "g");
    do {
      var v1Comp = v1CompParser.exec(v1Sub) || ["", "", ""];
      var v2Comp = v2CompParser.exec(v2Sub) || ["", "", ""];
      if (v1Comp[0].length == 0 && v2Comp[0].length == 0) {
        break;
      }
      var v1CompNum = v1Comp[1].length == 0 ? 0 : parseInt(v1Comp[1], 10);
      var v2CompNum = v2Comp[1].length == 0 ? 0 : parseInt(v2Comp[1], 10);
      order = goog.string.compareElements_(v1CompNum, v2CompNum) || goog.string.compareElements_(v1Comp[2].length == 0, v2Comp[2].length == 0) || goog.string.compareElements_(v1Comp[2], v2Comp[2]);
    } while (order == 0);
  }
  return order;
};
goog.string.compareElements_ = function(left, right) {
  if (left < right) {
    return -1;
  } else {
    if (left > right) {
      return 1;
    }
  }
  return 0;
};
goog.string.hashCode = function(str) {
  var result = 0;
  for (var i = 0;i < str.length;++i) {
    result = 31 * result + str.charCodeAt(i) >>> 0;
  }
  return result;
};
goog.string.uniqueStringCounter_ = Math.random() * 2147483648 | 0;
goog.string.createUniqueString = function() {
  return "goog_" + goog.string.uniqueStringCounter_++;
};
goog.string.toNumber = function(str) {
  var num = Number(str);
  if (num == 0 && goog.string.isEmptyOrWhitespace(str)) {
    return NaN;
  }
  return num;
};
goog.string.isLowerCamelCase = function(str) {
  return /^[a-z]+([A-Z][a-z]*)*$/.test(str);
};
goog.string.isUpperCamelCase = function(str) {
  return /^([A-Z][a-z]*)+$/.test(str);
};
goog.string.toCamelCase = function(str) {
  return String(str).replace(/\-([a-z])/g, function(all, match) {
    return match.toUpperCase();
  });
};
goog.string.toSelectorCase = function(str) {
  return String(str).replace(/([A-Z])/g, "-$1").toLowerCase();
};
goog.string.toTitleCase = function(str, opt_delimiters) {
  var delimiters = goog.isString(opt_delimiters) ? goog.string.regExpEscape(opt_delimiters) : "\\s";
  delimiters = delimiters ? "|[" + delimiters + "]+" : "";
  var regexp = new RegExp("(^" + delimiters + ")([a-z])", "g");
  return str.replace(regexp, function(all, p1, p2) {
    return p1 + p2.toUpperCase();
  });
};
goog.string.capitalize = function(str) {
  return String(str.charAt(0)).toUpperCase() + String(str.substr(1)).toLowerCase();
};
goog.string.parseInt = function(value) {
  if (isFinite(value)) {
    value = String(value);
  }
  if (goog.isString(value)) {
    return /^\s*-?0x/i.test(value) ? parseInt(value, 16) : parseInt(value, 10);
  }
  return NaN;
};
goog.string.splitLimit = function(str, separator, limit) {
  var parts = str.split(separator);
  var returnVal = [];
  while (limit > 0 && parts.length) {
    returnVal.push(parts.shift());
    limit--;
  }
  if (parts.length) {
    returnVal.push(parts.join(separator));
  }
  return returnVal;
};
goog.string.lastComponent = function(str, separators) {
  if (!separators) {
    return str;
  } else {
    if (typeof separators == "string") {
      separators = [separators];
    }
  }
  var lastSeparatorIndex = -1;
  for (var i = 0;i < separators.length;i++) {
    if (separators[i] == "") {
      continue;
    }
    var currentSeparatorIndex = str.lastIndexOf(separators[i]);
    if (currentSeparatorIndex > lastSeparatorIndex) {
      lastSeparatorIndex = currentSeparatorIndex;
    }
  }
  if (lastSeparatorIndex == -1) {
    return str;
  }
  return str.slice(lastSeparatorIndex + 1);
};
goog.string.editDistance = function(a, b) {
  var v0 = [];
  var v1 = [];
  if (a == b) {
    return 0;
  }
  if (!a.length || !b.length) {
    return Math.max(a.length, b.length);
  }
  for (var i = 0;i < b.length + 1;i++) {
    v0[i] = i;
  }
  for (var i = 0;i < a.length;i++) {
    v1[0] = i + 1;
    for (var j = 0;j < b.length;j++) {
      var cost = Number(a[i] != b[j]);
      v1[j + 1] = Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
    }
    for (var j = 0;j < v0.length;j++) {
      v0[j] = v1[j];
    }
  }
  return v1[b.length];
};
goog.provide("goog.asserts");
goog.provide("goog.asserts.AssertionError");
goog.require("goog.debug.Error");
goog.require("goog.dom.NodeType");
goog.require("goog.string");
goog.define("goog.asserts.ENABLE_ASSERTS", goog.DEBUG);
goog.asserts.AssertionError = function(messagePattern, messageArgs) {
  messageArgs.unshift(messagePattern);
  goog.debug.Error.call(this, goog.string.subs.apply(null, messageArgs));
  messageArgs.shift();
  this.messagePattern = messagePattern;
};
goog.inherits(goog.asserts.AssertionError, goog.debug.Error);
goog.asserts.AssertionError.prototype.name = "AssertionError";
goog.asserts.DEFAULT_ERROR_HANDLER = function(e) {
  throw e;
};
goog.asserts.errorHandler_ = goog.asserts.DEFAULT_ERROR_HANDLER;
goog.asserts.doAssertFailure_ = function(defaultMessage, defaultArgs, givenMessage, givenArgs) {
  var message = "Assertion failed";
  if (givenMessage) {
    message += ": " + givenMessage;
    var args = givenArgs;
  } else {
    if (defaultMessage) {
      message += ": " + defaultMessage;
      args = defaultArgs;
    }
  }
  var e = new goog.asserts.AssertionError("" + message, args || []);
  goog.asserts.errorHandler_(e);
};
goog.asserts.setErrorHandler = function(errorHandler) {
  if (goog.asserts.ENABLE_ASSERTS) {
    goog.asserts.errorHandler_ = errorHandler;
  }
};
goog.asserts.assert = function(condition, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !condition) {
    goog.asserts.doAssertFailure_("", null, opt_message, Array.prototype.slice.call(arguments, 2));
  }
  return condition;
};
goog.asserts.fail = function(opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS) {
    goog.asserts.errorHandler_(new goog.asserts.AssertionError("Failure" + (opt_message ? ": " + opt_message : ""), Array.prototype.slice.call(arguments, 1)));
  }
};
goog.asserts.assertNumber = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isNumber(value)) {
    goog.asserts.doAssertFailure_("Expected number but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
  }
  return (value);
};
goog.asserts.assertString = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isString(value)) {
    goog.asserts.doAssertFailure_("Expected string but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
  }
  return (value);
};
goog.asserts.assertFunction = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isFunction(value)) {
    goog.asserts.doAssertFailure_("Expected function but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
  }
  return (value);
};
goog.asserts.assertObject = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isObject(value)) {
    goog.asserts.doAssertFailure_("Expected object but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
  }
  return (value);
};
goog.asserts.assertArray = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isArray(value)) {
    goog.asserts.doAssertFailure_("Expected array but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
  }
  return (value);
};
goog.asserts.assertBoolean = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isBoolean(value)) {
    goog.asserts.doAssertFailure_("Expected boolean but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
  }
  return (value);
};
goog.asserts.assertElement = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && (!goog.isObject(value) || value.nodeType != goog.dom.NodeType.ELEMENT)) {
    goog.asserts.doAssertFailure_("Expected Element but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
  }
  return (value);
};
goog.asserts.assertInstanceof = function(value, type, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !(value instanceof type)) {
    goog.asserts.doAssertFailure_("Expected instanceof %s but got %s.", [goog.asserts.getType_(type), goog.asserts.getType_(value)], opt_message, Array.prototype.slice.call(arguments, 3));
  }
  return value;
};
goog.asserts.assertObjectPrototypeIsIntact = function() {
  for (var key in Object.prototype) {
    goog.asserts.fail(key + " should not be enumerable in Object.prototype.");
  }
};
goog.asserts.getType_ = function(value) {
  if (value instanceof Function) {
    return value.displayName || value.name || "unknown type name";
  } else {
    if (value instanceof Object) {
      return value.constructor.displayName || value.constructor.name || Object.prototype.toString.call(value);
    } else {
      return value === null ? "null" : typeof value;
    }
  }
};
goog.provide("goog.array");
goog.require("goog.asserts");
goog.define("goog.NATIVE_ARRAY_PROTOTYPES", goog.TRUSTED_SITE);
goog.define("goog.array.ASSUME_NATIVE_FUNCTIONS", false);
goog.array.peek = function(array) {
  return array[array.length - 1];
};
goog.array.last = goog.array.peek;
goog.array.indexOf = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.indexOf) ? function(arr, obj, opt_fromIndex) {
  goog.asserts.assert(arr.length != null);
  return Array.prototype.indexOf.call(arr, obj, opt_fromIndex);
} : function(arr, obj, opt_fromIndex) {
  var fromIndex = opt_fromIndex == null ? 0 : opt_fromIndex < 0 ? Math.max(0, arr.length + opt_fromIndex) : opt_fromIndex;
  if (goog.isString(arr)) {
    if (!goog.isString(obj) || obj.length != 1) {
      return -1;
    }
    return arr.indexOf(obj, fromIndex);
  }
  for (var i = fromIndex;i < arr.length;i++) {
    if (i in arr && arr[i] === obj) {
      return i;
    }
  }
  return -1;
};
goog.array.lastIndexOf = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.lastIndexOf) ? function(arr, obj, opt_fromIndex) {
  goog.asserts.assert(arr.length != null);
  var fromIndex = opt_fromIndex == null ? arr.length - 1 : opt_fromIndex;
  return Array.prototype.lastIndexOf.call(arr, obj, fromIndex);
} : function(arr, obj, opt_fromIndex) {
  var fromIndex = opt_fromIndex == null ? arr.length - 1 : opt_fromIndex;
  if (fromIndex < 0) {
    fromIndex = Math.max(0, arr.length + fromIndex);
  }
  if (goog.isString(arr)) {
    if (!goog.isString(obj) || obj.length != 1) {
      return -1;
    }
    return arr.lastIndexOf(obj, fromIndex);
  }
  for (var i = fromIndex;i >= 0;i--) {
    if (i in arr && arr[i] === obj) {
      return i;
    }
  }
  return -1;
};
goog.array.forEach = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.forEach) ? function(arr, f, opt_obj) {
  goog.asserts.assert(arr.length != null);
  Array.prototype.forEach.call(arr, f, opt_obj);
} : function(arr, f, opt_obj) {
  var l = arr.length;
  var arr2 = goog.isString(arr) ? arr.split("") : arr;
  for (var i = 0;i < l;i++) {
    if (i in arr2) {
      f.call((opt_obj), arr2[i], i, arr);
    }
  }
};
goog.array.forEachRight = function(arr, f, opt_obj) {
  var l = arr.length;
  var arr2 = goog.isString(arr) ? arr.split("") : arr;
  for (var i = l - 1;i >= 0;--i) {
    if (i in arr2) {
      f.call((opt_obj), arr2[i], i, arr);
    }
  }
};
goog.array.filter = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.filter) ? function(arr, f, opt_obj) {
  goog.asserts.assert(arr.length != null);
  return Array.prototype.filter.call(arr, f, opt_obj);
} : function(arr, f, opt_obj) {
  var l = arr.length;
  var res = [];
  var resLength = 0;
  var arr2 = goog.isString(arr) ? arr.split("") : arr;
  for (var i = 0;i < l;i++) {
    if (i in arr2) {
      var val = arr2[i];
      if (f.call((opt_obj), val, i, arr)) {
        res[resLength++] = val;
      }
    }
  }
  return res;
};
goog.array.map = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.map) ? function(arr, f, opt_obj) {
  goog.asserts.assert(arr.length != null);
  return Array.prototype.map.call(arr, f, opt_obj);
} : function(arr, f, opt_obj) {
  var l = arr.length;
  var res = new Array(l);
  var arr2 = goog.isString(arr) ? arr.split("") : arr;
  for (var i = 0;i < l;i++) {
    if (i in arr2) {
      res[i] = f.call((opt_obj), arr2[i], i, arr);
    }
  }
  return res;
};
goog.array.reduce = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.reduce) ? function(arr, f, val, opt_obj) {
  goog.asserts.assert(arr.length != null);
  if (opt_obj) {
    f = goog.bind(f, opt_obj);
  }
  return Array.prototype.reduce.call(arr, f, val);
} : function(arr, f, val, opt_obj) {
  var rval = val;
  goog.array.forEach(arr, function(val, index) {
    rval = f.call((opt_obj), rval, val, index, arr);
  });
  return rval;
};
goog.array.reduceRight = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.reduceRight) ? function(arr, f, val, opt_obj) {
  goog.asserts.assert(arr.length != null);
  goog.asserts.assert(f != null);
  if (opt_obj) {
    f = goog.bind(f, opt_obj);
  }
  return Array.prototype.reduceRight.call(arr, f, val);
} : function(arr, f, val, opt_obj) {
  var rval = val;
  goog.array.forEachRight(arr, function(val, index) {
    rval = f.call((opt_obj), rval, val, index, arr);
  });
  return rval;
};
goog.array.some = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.some) ? function(arr, f, opt_obj) {
  goog.asserts.assert(arr.length != null);
  return Array.prototype.some.call(arr, f, opt_obj);
} : function(arr, f, opt_obj) {
  var l = arr.length;
  var arr2 = goog.isString(arr) ? arr.split("") : arr;
  for (var i = 0;i < l;i++) {
    if (i in arr2 && f.call((opt_obj), arr2[i], i, arr)) {
      return true;
    }
  }
  return false;
};
goog.array.every = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.every) ? function(arr, f, opt_obj) {
  goog.asserts.assert(arr.length != null);
  return Array.prototype.every.call(arr, f, opt_obj);
} : function(arr, f, opt_obj) {
  var l = arr.length;
  var arr2 = goog.isString(arr) ? arr.split("") : arr;
  for (var i = 0;i < l;i++) {
    if (i in arr2 && !f.call((opt_obj), arr2[i], i, arr)) {
      return false;
    }
  }
  return true;
};
goog.array.count = function(arr, f, opt_obj) {
  var count = 0;
  goog.array.forEach(arr, function(element, index, arr) {
    if (f.call((opt_obj), element, index, arr)) {
      ++count;
    }
  }, opt_obj);
  return count;
};
goog.array.find = function(arr, f, opt_obj) {
  var i = goog.array.findIndex(arr, f, opt_obj);
  return i < 0 ? null : goog.isString(arr) ? arr.charAt(i) : arr[i];
};
goog.array.findIndex = function(arr, f, opt_obj) {
  var l = arr.length;
  var arr2 = goog.isString(arr) ? arr.split("") : arr;
  for (var i = 0;i < l;i++) {
    if (i in arr2 && f.call((opt_obj), arr2[i], i, arr)) {
      return i;
    }
  }
  return -1;
};
goog.array.findRight = function(arr, f, opt_obj) {
  var i = goog.array.findIndexRight(arr, f, opt_obj);
  return i < 0 ? null : goog.isString(arr) ? arr.charAt(i) : arr[i];
};
goog.array.findIndexRight = function(arr, f, opt_obj) {
  var l = arr.length;
  var arr2 = goog.isString(arr) ? arr.split("") : arr;
  for (var i = l - 1;i >= 0;i--) {
    if (i in arr2 && f.call((opt_obj), arr2[i], i, arr)) {
      return i;
    }
  }
  return -1;
};
goog.array.contains = function(arr, obj) {
  return goog.array.indexOf(arr, obj) >= 0;
};
goog.array.isEmpty = function(arr) {
  return arr.length == 0;
};
goog.array.clear = function(arr) {
  if (!goog.isArray(arr)) {
    for (var i = arr.length - 1;i >= 0;i--) {
      delete arr[i];
    }
  }
  arr.length = 0;
};
goog.array.insert = function(arr, obj) {
  if (!goog.array.contains(arr, obj)) {
    arr.push(obj);
  }
};
goog.array.insertAt = function(arr, obj, opt_i) {
  goog.array.splice(arr, opt_i, 0, obj);
};
goog.array.insertArrayAt = function(arr, elementsToAdd, opt_i) {
  goog.partial(goog.array.splice, arr, opt_i, 0).apply(null, elementsToAdd);
};
goog.array.insertBefore = function(arr, obj, opt_obj2) {
  var i;
  if (arguments.length == 2 || (i = goog.array.indexOf(arr, opt_obj2)) < 0) {
    arr.push(obj);
  } else {
    goog.array.insertAt(arr, obj, i);
  }
};
goog.array.remove = function(arr, obj) {
  var i = goog.array.indexOf(arr, obj);
  var rv;
  if (rv = i >= 0) {
    goog.array.removeAt(arr, i);
  }
  return rv;
};
goog.array.removeLast = function(arr, obj) {
  var i = goog.array.lastIndexOf(arr, obj);
  if (i >= 0) {
    goog.array.removeAt(arr, i);
    return true;
  }
  return false;
};
goog.array.removeAt = function(arr, i) {
  goog.asserts.assert(arr.length != null);
  return Array.prototype.splice.call(arr, i, 1).length == 1;
};
goog.array.removeIf = function(arr, f, opt_obj) {
  var i = goog.array.findIndex(arr, f, opt_obj);
  if (i >= 0) {
    goog.array.removeAt(arr, i);
    return true;
  }
  return false;
};
goog.array.removeAllIf = function(arr, f, opt_obj) {
  var removedCount = 0;
  goog.array.forEachRight(arr, function(val, index) {
    if (f.call((opt_obj), val, index, arr)) {
      if (goog.array.removeAt(arr, index)) {
        removedCount++;
      }
    }
  });
  return removedCount;
};
goog.array.concat = function(var_args) {
  return Array.prototype.concat.apply(Array.prototype, arguments);
};
goog.array.join = function(var_args) {
  return Array.prototype.concat.apply(Array.prototype, arguments);
};
goog.array.toArray = function(object) {
  var length = object.length;
  if (length > 0) {
    var rv = new Array(length);
    for (var i = 0;i < length;i++) {
      rv[i] = object[i];
    }
    return rv;
  }
  return [];
};
goog.array.clone = goog.array.toArray;
goog.array.extend = function(arr1, var_args) {
  for (var i = 1;i < arguments.length;i++) {
    var arr2 = arguments[i];
    if (goog.isArrayLike(arr2)) {
      var len1 = arr1.length || 0;
      var len2 = arr2.length || 0;
      arr1.length = len1 + len2;
      for (var j = 0;j < len2;j++) {
        arr1[len1 + j] = arr2[j];
      }
    } else {
      arr1.push(arr2);
    }
  }
};
goog.array.splice = function(arr, index, howMany, var_args) {
  goog.asserts.assert(arr.length != null);
  return Array.prototype.splice.apply(arr, goog.array.slice(arguments, 1));
};
goog.array.slice = function(arr, start, opt_end) {
  goog.asserts.assert(arr.length != null);
  if (arguments.length <= 2) {
    return Array.prototype.slice.call(arr, start);
  } else {
    return Array.prototype.slice.call(arr, start, opt_end);
  }
};
goog.array.removeDuplicates = function(arr, opt_rv, opt_hashFn) {
  var returnArray = opt_rv || arr;
  var defaultHashFn = function(item) {
    return goog.isObject(item) ? "o" + goog.getUid(item) : (typeof item).charAt(0) + item;
  };
  var hashFn = opt_hashFn || defaultHashFn;
  var seen = {}, cursorInsert = 0, cursorRead = 0;
  while (cursorRead < arr.length) {
    var current = arr[cursorRead++];
    var key = hashFn(current);
    if (!Object.prototype.hasOwnProperty.call(seen, key)) {
      seen[key] = true;
      returnArray[cursorInsert++] = current;
    }
  }
  returnArray.length = cursorInsert;
};
goog.array.binarySearch = function(arr, target, opt_compareFn) {
  return goog.array.binarySearch_(arr, opt_compareFn || goog.array.defaultCompare, false, target);
};
goog.array.binarySelect = function(arr, evaluator, opt_obj) {
  return goog.array.binarySearch_(arr, evaluator, true, undefined, opt_obj);
};
goog.array.binarySearch_ = function(arr, compareFn, isEvaluator, opt_target, opt_selfObj) {
  var left = 0;
  var right = arr.length;
  var found;
  while (left < right) {
    var middle = left + right >> 1;
    var compareResult;
    if (isEvaluator) {
      compareResult = compareFn.call(opt_selfObj, arr[middle], middle, arr);
    } else {
      compareResult = (compareFn)(opt_target, arr[middle]);
    }
    if (compareResult > 0) {
      left = middle + 1;
    } else {
      right = middle;
      found = !compareResult;
    }
  }
  return found ? left : ~left;
};
goog.array.sort = function(arr, opt_compareFn) {
  arr.sort(opt_compareFn || goog.array.defaultCompare);
};
goog.array.stableSort = function(arr, opt_compareFn) {
  var compArr = new Array(arr.length);
  for (var i = 0;i < arr.length;i++) {
    compArr[i] = {index:i, value:arr[i]};
  }
  var valueCompareFn = opt_compareFn || goog.array.defaultCompare;
  function stableCompareFn(obj1, obj2) {
    return valueCompareFn(obj1.value, obj2.value) || obj1.index - obj2.index;
  }
  goog.array.sort(compArr, stableCompareFn);
  for (var i = 0;i < arr.length;i++) {
    arr[i] = compArr[i].value;
  }
};
goog.array.sortByKey = function(arr, keyFn, opt_compareFn) {
  var keyCompareFn = opt_compareFn || goog.array.defaultCompare;
  goog.array.sort(arr, function(a, b) {
    return keyCompareFn(keyFn(a), keyFn(b));
  });
};
goog.array.sortObjectsByKey = function(arr, key, opt_compareFn) {
  goog.array.sortByKey(arr, function(obj) {
    return obj[key];
  }, opt_compareFn);
};
goog.array.isSorted = function(arr, opt_compareFn, opt_strict) {
  var compare = opt_compareFn || goog.array.defaultCompare;
  for (var i = 1;i < arr.length;i++) {
    var compareResult = compare(arr[i - 1], arr[i]);
    if (compareResult > 0 || compareResult == 0 && opt_strict) {
      return false;
    }
  }
  return true;
};
goog.array.equals = function(arr1, arr2, opt_equalsFn) {
  if (!goog.isArrayLike(arr1) || !goog.isArrayLike(arr2) || arr1.length != arr2.length) {
    return false;
  }
  var l = arr1.length;
  var equalsFn = opt_equalsFn || goog.array.defaultCompareEquality;
  for (var i = 0;i < l;i++) {
    if (!equalsFn(arr1[i], arr2[i])) {
      return false;
    }
  }
  return true;
};
goog.array.compare3 = function(arr1, arr2, opt_compareFn) {
  var compare = opt_compareFn || goog.array.defaultCompare;
  var l = Math.min(arr1.length, arr2.length);
  for (var i = 0;i < l;i++) {
    var result = compare(arr1[i], arr2[i]);
    if (result != 0) {
      return result;
    }
  }
  return goog.array.defaultCompare(arr1.length, arr2.length);
};
goog.array.defaultCompare = function(a, b) {
  return a > b ? 1 : a < b ? -1 : 0;
};
goog.array.inverseDefaultCompare = function(a, b) {
  return -goog.array.defaultCompare(a, b);
};
goog.array.defaultCompareEquality = function(a, b) {
  return a === b;
};
goog.array.binaryInsert = function(array, value, opt_compareFn) {
  var index = goog.array.binarySearch(array, value, opt_compareFn);
  if (index < 0) {
    goog.array.insertAt(array, value, -(index + 1));
    return true;
  }
  return false;
};
goog.array.binaryRemove = function(array, value, opt_compareFn) {
  var index = goog.array.binarySearch(array, value, opt_compareFn);
  return index >= 0 ? goog.array.removeAt(array, index) : false;
};
goog.array.bucket = function(array, sorter, opt_obj) {
  var buckets = {};
  for (var i = 0;i < array.length;i++) {
    var value = array[i];
    var key = sorter.call((opt_obj), value, i, array);
    if (goog.isDef(key)) {
      var bucket = buckets[key] || (buckets[key] = []);
      bucket.push(value);
    }
  }
  return buckets;
};
goog.array.toObject = function(arr, keyFunc, opt_obj) {
  var ret = {};
  goog.array.forEach(arr, function(element, index) {
    ret[keyFunc.call((opt_obj), element, index, arr)] = element;
  });
  return ret;
};
goog.array.range = function(startOrEnd, opt_end, opt_step) {
  var array = [];
  var start = 0;
  var end = startOrEnd;
  var step = opt_step || 1;
  if (opt_end !== undefined) {
    start = startOrEnd;
    end = opt_end;
  }
  if (step * (end - start) < 0) {
    return [];
  }
  if (step > 0) {
    for (var i = start;i < end;i += step) {
      array.push(i);
    }
  } else {
    for (var i = start;i > end;i += step) {
      array.push(i);
    }
  }
  return array;
};
goog.array.repeat = function(value, n) {
  var array = [];
  for (var i = 0;i < n;i++) {
    array[i] = value;
  }
  return array;
};
goog.array.flatten = function(var_args) {
  var CHUNK_SIZE = 8192;
  var result = [];
  for (var i = 0;i < arguments.length;i++) {
    var element = arguments[i];
    if (goog.isArray(element)) {
      for (var c = 0;c < element.length;c += CHUNK_SIZE) {
        var chunk = goog.array.slice(element, c, c + CHUNK_SIZE);
        var recurseResult = goog.array.flatten.apply(null, chunk);
        for (var r = 0;r < recurseResult.length;r++) {
          result.push(recurseResult[r]);
        }
      }
    } else {
      result.push(element);
    }
  }
  return result;
};
goog.array.rotate = function(array, n) {
  goog.asserts.assert(array.length != null);
  if (array.length) {
    n %= array.length;
    if (n > 0) {
      Array.prototype.unshift.apply(array, array.splice(-n, n));
    } else {
      if (n < 0) {
        Array.prototype.push.apply(array, array.splice(0, -n));
      }
    }
  }
  return array;
};
goog.array.moveItem = function(arr, fromIndex, toIndex) {
  goog.asserts.assert(fromIndex >= 0 && fromIndex < arr.length);
  goog.asserts.assert(toIndex >= 0 && toIndex < arr.length);
  var removedItems = Array.prototype.splice.call(arr, fromIndex, 1);
  Array.prototype.splice.call(arr, toIndex, 0, removedItems[0]);
};
goog.array.zip = function(var_args) {
  if (!arguments.length) {
    return [];
  }
  var result = [];
  var minLen = arguments[0].length;
  for (var i = 1;i < arguments.length;i++) {
    if (arguments[i].length < minLen) {
      minLen = arguments[i].length;
    }
  }
  for (var i = 0;i < minLen;i++) {
    var value = [];
    for (var j = 0;j < arguments.length;j++) {
      value.push(arguments[j][i]);
    }
    result.push(value);
  }
  return result;
};
goog.array.shuffle = function(arr, opt_randFn) {
  var randFn = opt_randFn || Math.random;
  for (var i = arr.length - 1;i > 0;i--) {
    var j = Math.floor(randFn() * (i + 1));
    var tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
  }
};
goog.array.copyByIndex = function(arr, index_arr) {
  var result = [];
  goog.array.forEach(index_arr, function(index) {
    result.push(arr[index]);
  });
  return result;
};
goog.array.concatMap = function(arr, f, opt_obj) {
  return goog.array.concat.apply([], goog.array.map(arr, f, opt_obj));
};
goog.provide("goog.dom.TagName");
goog.dom.TagName = {A:"A", ABBR:"ABBR", ACRONYM:"ACRONYM", ADDRESS:"ADDRESS", APPLET:"APPLET", AREA:"AREA", ARTICLE:"ARTICLE", ASIDE:"ASIDE", AUDIO:"AUDIO", B:"B", BASE:"BASE", BASEFONT:"BASEFONT", BDI:"BDI", BDO:"BDO", BIG:"BIG", BLOCKQUOTE:"BLOCKQUOTE", BODY:"BODY", BR:"BR", BUTTON:"BUTTON", CANVAS:"CANVAS", CAPTION:"CAPTION", CENTER:"CENTER", CITE:"CITE", CODE:"CODE", COL:"COL", COLGROUP:"COLGROUP", COMMAND:"COMMAND", DATA:"DATA", DATALIST:"DATALIST", DD:"DD", DEL:"DEL", DETAILS:"DETAILS", DFN:"DFN", 
DIALOG:"DIALOG", DIR:"DIR", DIV:"DIV", DL:"DL", DT:"DT", EM:"EM", EMBED:"EMBED", FIELDSET:"FIELDSET", FIGCAPTION:"FIGCAPTION", FIGURE:"FIGURE", FONT:"FONT", FOOTER:"FOOTER", FORM:"FORM", FRAME:"FRAME", FRAMESET:"FRAMESET", H1:"H1", H2:"H2", H3:"H3", H4:"H4", H5:"H5", H6:"H6", HEAD:"HEAD", HEADER:"HEADER", HGROUP:"HGROUP", HR:"HR", HTML:"HTML", I:"I", IFRAME:"IFRAME", IMG:"IMG", INPUT:"INPUT", INS:"INS", ISINDEX:"ISINDEX", KBD:"KBD", KEYGEN:"KEYGEN", LABEL:"LABEL", LEGEND:"LEGEND", LI:"LI", LINK:"LINK", 
MAP:"MAP", MARK:"MARK", MATH:"MATH", MENU:"MENU", META:"META", METER:"METER", NAV:"NAV", NOFRAMES:"NOFRAMES", NOSCRIPT:"NOSCRIPT", OBJECT:"OBJECT", OL:"OL", OPTGROUP:"OPTGROUP", OPTION:"OPTION", OUTPUT:"OUTPUT", P:"P", PARAM:"PARAM", PRE:"PRE", PROGRESS:"PROGRESS", Q:"Q", RP:"RP", RT:"RT", RUBY:"RUBY", S:"S", SAMP:"SAMP", SCRIPT:"SCRIPT", SECTION:"SECTION", SELECT:"SELECT", SMALL:"SMALL", SOURCE:"SOURCE", SPAN:"SPAN", STRIKE:"STRIKE", STRONG:"STRONG", STYLE:"STYLE", SUB:"SUB", SUMMARY:"SUMMARY", 
SUP:"SUP", SVG:"SVG", TABLE:"TABLE", TBODY:"TBODY", TD:"TD", TEMPLATE:"TEMPLATE", TEXTAREA:"TEXTAREA", TFOOT:"TFOOT", TH:"TH", THEAD:"THEAD", TIME:"TIME", TITLE:"TITLE", TR:"TR", TRACK:"TRACK", TT:"TT", U:"U", UL:"UL", VAR:"VAR", VIDEO:"VIDEO", WBR:"WBR"};
goog.provide("goog.object");
goog.object.is = function(v, v2) {
  if (v === v2) {
    return v !== 0 || 1 / v === 1 / (v2);
  }
  return v !== v && v2 !== v2;
};
goog.object.forEach = function(obj, f, opt_obj) {
  for (var key in obj) {
    f.call((opt_obj), obj[key], key, obj);
  }
};
goog.object.filter = function(obj, f, opt_obj) {
  var res = {};
  for (var key in obj) {
    if (f.call((opt_obj), obj[key], key, obj)) {
      res[key] = obj[key];
    }
  }
  return res;
};
goog.object.map = function(obj, f, opt_obj) {
  var res = {};
  for (var key in obj) {
    res[key] = f.call((opt_obj), obj[key], key, obj);
  }
  return res;
};
goog.object.some = function(obj, f, opt_obj) {
  for (var key in obj) {
    if (f.call((opt_obj), obj[key], key, obj)) {
      return true;
    }
  }
  return false;
};
goog.object.every = function(obj, f, opt_obj) {
  for (var key in obj) {
    if (!f.call((opt_obj), obj[key], key, obj)) {
      return false;
    }
  }
  return true;
};
goog.object.getCount = function(obj) {
  var rv = 0;
  for (var key in obj) {
    rv++;
  }
  return rv;
};
goog.object.getAnyKey = function(obj) {
  for (var key in obj) {
    return key;
  }
};
goog.object.getAnyValue = function(obj) {
  for (var key in obj) {
    return obj[key];
  }
};
goog.object.contains = function(obj, val) {
  return goog.object.containsValue(obj, val);
};
goog.object.getValues = function(obj) {
  var res = [];
  var i = 0;
  for (var key in obj) {
    res[i++] = obj[key];
  }
  return res;
};
goog.object.getKeys = function(obj) {
  var res = [];
  var i = 0;
  for (var key in obj) {
    res[i++] = key;
  }
  return res;
};
goog.object.getValueByKeys = function(obj, var_args) {
  var isArrayLike = goog.isArrayLike(var_args);
  var keys = isArrayLike ? var_args : arguments;
  for (var i = isArrayLike ? 0 : 1;i < keys.length;i++) {
    obj = obj[keys[i]];
    if (!goog.isDef(obj)) {
      break;
    }
  }
  return obj;
};
goog.object.containsKey = function(obj, key) {
  return obj !== null && key in obj;
};
goog.object.containsValue = function(obj, val) {
  for (var key in obj) {
    if (obj[key] == val) {
      return true;
    }
  }
  return false;
};
goog.object.findKey = function(obj, f, opt_this) {
  for (var key in obj) {
    if (f.call((opt_this), obj[key], key, obj)) {
      return key;
    }
  }
  return undefined;
};
goog.object.findValue = function(obj, f, opt_this) {
  var key = goog.object.findKey(obj, f, opt_this);
  return key && obj[key];
};
goog.object.isEmpty = function(obj) {
  for (var key in obj) {
    return false;
  }
  return true;
};
goog.object.clear = function(obj) {
  for (var i in obj) {
    delete obj[i];
  }
};
goog.object.remove = function(obj, key) {
  var rv;
  if (rv = key in (obj)) {
    delete obj[key];
  }
  return rv;
};
goog.object.add = function(obj, key, val) {
  if (obj !== null && key in obj) {
    throw Error('The object already contains the key "' + key + '"');
  }
  goog.object.set(obj, key, val);
};
goog.object.get = function(obj, key, opt_val) {
  if (obj !== null && key in obj) {
    return obj[key];
  }
  return opt_val;
};
goog.object.set = function(obj, key, value) {
  obj[key] = value;
};
goog.object.setIfUndefined = function(obj, key, value) {
  return key in (obj) ? obj[key] : obj[key] = value;
};
goog.object.setWithReturnValueIfNotSet = function(obj, key, f) {
  if (key in obj) {
    return obj[key];
  }
  var val = f();
  obj[key] = val;
  return val;
};
goog.object.equals = function(a, b) {
  for (var k in a) {
    if (!(k in b) || a[k] !== b[k]) {
      return false;
    }
  }
  for (var k in b) {
    if (!(k in a)) {
      return false;
    }
  }
  return true;
};
goog.object.clone = function(obj) {
  var res = {};
  for (var key in obj) {
    res[key] = obj[key];
  }
  return res;
};
goog.object.unsafeClone = function(obj) {
  var type = goog.typeOf(obj);
  if (type == "object" || type == "array") {
    if (goog.isFunction(obj.clone)) {
      return obj.clone();
    }
    var clone = type == "array" ? [] : {};
    for (var key in obj) {
      clone[key] = goog.object.unsafeClone(obj[key]);
    }
    return clone;
  }
  return obj;
};
goog.object.transpose = function(obj) {
  var transposed = {};
  for (var key in obj) {
    transposed[obj[key]] = key;
  }
  return transposed;
};
goog.object.PROTOTYPE_FIELDS_ = ["constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"];
goog.object.extend = function(target, var_args) {
  var key, source;
  for (var i = 1;i < arguments.length;i++) {
    source = arguments[i];
    for (key in source) {
      target[key] = source[key];
    }
    for (var j = 0;j < goog.object.PROTOTYPE_FIELDS_.length;j++) {
      key = goog.object.PROTOTYPE_FIELDS_[j];
      if (Object.prototype.hasOwnProperty.call(source, key)) {
        target[key] = source[key];
      }
    }
  }
};
goog.object.create = function(var_args) {
  var argLength = arguments.length;
  if (argLength == 1 && goog.isArray(arguments[0])) {
    return goog.object.create.apply(null, arguments[0]);
  }
  if (argLength % 2) {
    throw Error("Uneven number of arguments");
  }
  var rv = {};
  for (var i = 0;i < argLength;i += 2) {
    rv[arguments[i]] = arguments[i + 1];
  }
  return rv;
};
goog.object.createSet = function(var_args) {
  var argLength = arguments.length;
  if (argLength == 1 && goog.isArray(arguments[0])) {
    return goog.object.createSet.apply(null, arguments[0]);
  }
  var rv = {};
  for (var i = 0;i < argLength;i++) {
    rv[arguments[i]] = true;
  }
  return rv;
};
goog.object.createImmutableView = function(obj) {
  var result = obj;
  if (Object.isFrozen && !Object.isFrozen(obj)) {
    result = Object.create(obj);
    Object.freeze(result);
  }
  return result;
};
goog.object.isImmutableView = function(obj) {
  return !!Object.isFrozen && Object.isFrozen(obj);
};
goog.provide("goog.dom.tags");
goog.require("goog.object");
goog.dom.tags.VOID_TAGS_ = goog.object.createSet("area", "base", "br", "col", "command", "embed", "hr", "img", "input", "keygen", "link", "meta", "param", "source", "track", "wbr");
goog.dom.tags.isVoidTag = function(tagName) {
  return goog.dom.tags.VOID_TAGS_[tagName] === true;
};
goog.provide("goog.string.TypedString");
goog.string.TypedString = function() {
};
goog.string.TypedString.prototype.implementsGoogStringTypedString;
goog.string.TypedString.prototype.getTypedStringValue;
goog.provide("goog.string.Const");
goog.require("goog.asserts");
goog.require("goog.string.TypedString");
goog.string.Const = function() {
  this.stringConstValueWithSecurityContract__googStringSecurityPrivate_ = "";
  this.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_ = goog.string.Const.TYPE_MARKER_;
};
goog.string.Const.prototype.implementsGoogStringTypedString = true;
goog.string.Const.prototype.getTypedStringValue = function() {
  return this.stringConstValueWithSecurityContract__googStringSecurityPrivate_;
};
goog.string.Const.prototype.toString = function() {
  return "Const{" + this.stringConstValueWithSecurityContract__googStringSecurityPrivate_ + "}";
};
goog.string.Const.unwrap = function(stringConst) {
  if (stringConst instanceof goog.string.Const && stringConst.constructor === goog.string.Const && stringConst.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_ === goog.string.Const.TYPE_MARKER_) {
    return stringConst.stringConstValueWithSecurityContract__googStringSecurityPrivate_;
  } else {
    goog.asserts.fail("expected object of type Const, got '" + stringConst + "'");
    return "type_error:Const";
  }
};
goog.string.Const.from = function(s) {
  return goog.string.Const.create__googStringSecurityPrivate_(s);
};
goog.string.Const.TYPE_MARKER_ = {};
goog.string.Const.create__googStringSecurityPrivate_ = function(s) {
  var stringConst = new goog.string.Const;
  stringConst.stringConstValueWithSecurityContract__googStringSecurityPrivate_ = s;
  return stringConst;
};
goog.provide("goog.html.SafeStyle");
goog.require("goog.array");
goog.require("goog.asserts");
goog.require("goog.string");
goog.require("goog.string.Const");
goog.require("goog.string.TypedString");
goog.html.SafeStyle = function() {
  this.privateDoNotAccessOrElseSafeStyleWrappedValue_ = "";
  this.SAFE_STYLE_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
};
goog.html.SafeStyle.prototype.implementsGoogStringTypedString = true;
goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.SafeStyle.fromConstant = function(style) {
  var styleString = goog.string.Const.unwrap(style);
  if (styleString.length === 0) {
    return goog.html.SafeStyle.EMPTY;
  }
  goog.html.SafeStyle.checkStyle_(styleString);
  goog.asserts.assert(goog.string.endsWith(styleString, ";"), "Last character of style string is not ';': " + styleString);
  goog.asserts.assert(goog.string.contains(styleString, ":"), "Style string must contain at least one ':', to " + 'specify a "name: value" pair: ' + styleString);
  return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(styleString);
};
goog.html.SafeStyle.checkStyle_ = function(style) {
  goog.asserts.assert(!/[<>]/.test(style), "Forbidden characters in style string: " + style);
};
goog.html.SafeStyle.prototype.getTypedStringValue = function() {
  return this.privateDoNotAccessOrElseSafeStyleWrappedValue_;
};
if (goog.DEBUG) {
  goog.html.SafeStyle.prototype.toString = function() {
    return "SafeStyle{" + this.privateDoNotAccessOrElseSafeStyleWrappedValue_ + "}";
  };
}
goog.html.SafeStyle.unwrap = function(safeStyle) {
  if (safeStyle instanceof goog.html.SafeStyle && safeStyle.constructor === goog.html.SafeStyle && safeStyle.SAFE_STYLE_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ === goog.html.SafeStyle.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_) {
    return safeStyle.privateDoNotAccessOrElseSafeStyleWrappedValue_;
  } else {
    goog.asserts.fail("expected object of type SafeStyle, got '" + safeStyle + "' of type " + goog.typeOf(safeStyle));
    return "type_error:SafeStyle";
  }
};
goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse = function(style) {
  return (new goog.html.SafeStyle).initSecurityPrivateDoNotAccessOrElse_(style);
};
goog.html.SafeStyle.prototype.initSecurityPrivateDoNotAccessOrElse_ = function(style) {
  this.privateDoNotAccessOrElseSafeStyleWrappedValue_ = style;
  return this;
};
goog.html.SafeStyle.EMPTY = goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse("");
goog.html.SafeStyle.INNOCUOUS_STRING = "zClosurez";
goog.html.SafeStyle.PropertyMap;
goog.html.SafeStyle.create = function(map) {
  var style = "";
  for (var name in map) {
    if (!/^[-_a-zA-Z0-9]+$/.test(name)) {
      throw Error("Name allows only [-_a-zA-Z0-9], got: " + name);
    }
    var value = map[name];
    if (value == null) {
      continue;
    }
    if (value instanceof goog.string.Const) {
      value = goog.string.Const.unwrap(value);
      goog.asserts.assert(!/[{;}]/.test(value), "Value does not allow [{;}].");
    } else {
      if (!goog.html.SafeStyle.VALUE_RE_.test(value)) {
        goog.asserts.fail("String value allows only [-,.\"'%_!# a-zA-Z0-9], rgb() and " + "rgba(), got: " + value);
        value = goog.html.SafeStyle.INNOCUOUS_STRING;
      } else {
        if (!goog.html.SafeStyle.hasBalancedQuotes_(value)) {
          goog.asserts.fail("String value requires balanced quotes, got: " + value);
          value = goog.html.SafeStyle.INNOCUOUS_STRING;
        }
      }
    }
    style += name + ":" + value + ";";
  }
  if (!style) {
    return goog.html.SafeStyle.EMPTY;
  }
  goog.html.SafeStyle.checkStyle_(style);
  return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(style);
};
goog.html.SafeStyle.hasBalancedQuotes_ = function(value) {
  var outsideSingle = true;
  var outsideDouble = true;
  for (var i = 0;i < value.length;i++) {
    var c = value.charAt(i);
    if (c == "'" && outsideDouble) {
      outsideSingle = !outsideSingle;
    } else {
      if (c == '"' && outsideSingle) {
        outsideDouble = !outsideDouble;
      }
    }
  }
  return outsideSingle && outsideDouble;
};
goog.html.SafeStyle.VALUE_RE_ = /^([-,."'%_!# a-zA-Z0-9]+|(?:rgb|hsl)a?\([0-9.%, ]+\))$/;
goog.html.SafeStyle.concat = function(var_args) {
  var style = "";
  var addArgument = function(argument) {
    if (goog.isArray(argument)) {
      goog.array.forEach(argument, addArgument);
    } else {
      style += goog.html.SafeStyle.unwrap(argument);
    }
  };
  goog.array.forEach(arguments, addArgument);
  if (!style) {
    return goog.html.SafeStyle.EMPTY;
  }
  return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(style);
};
goog.provide("goog.html.SafeStyleSheet");
goog.require("goog.array");
goog.require("goog.asserts");
goog.require("goog.string");
goog.require("goog.string.Const");
goog.require("goog.string.TypedString");
goog.html.SafeStyleSheet = function() {
  this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_ = "";
  this.SAFE_STYLE_SHEET_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
};
goog.html.SafeStyleSheet.prototype.implementsGoogStringTypedString = true;
goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.SafeStyleSheet.concat = function(var_args) {
  var result = "";
  var addArgument = function(argument) {
    if (goog.isArray(argument)) {
      goog.array.forEach(argument, addArgument);
    } else {
      result += goog.html.SafeStyleSheet.unwrap(argument);
    }
  };
  goog.array.forEach(arguments, addArgument);
  return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(result);
};
goog.html.SafeStyleSheet.fromConstant = function(styleSheet) {
  var styleSheetString = goog.string.Const.unwrap(styleSheet);
  if (styleSheetString.length === 0) {
    return goog.html.SafeStyleSheet.EMPTY;
  }
  goog.asserts.assert(!goog.string.contains(styleSheetString, "<"), "Forbidden '<' character in style sheet string: " + styleSheetString);
  return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(styleSheetString);
};
goog.html.SafeStyleSheet.prototype.getTypedStringValue = function() {
  return this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_;
};
if (goog.DEBUG) {
  goog.html.SafeStyleSheet.prototype.toString = function() {
    return "SafeStyleSheet{" + this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_ + "}";
  };
}
goog.html.SafeStyleSheet.unwrap = function(safeStyleSheet) {
  if (safeStyleSheet instanceof goog.html.SafeStyleSheet && safeStyleSheet.constructor === goog.html.SafeStyleSheet && safeStyleSheet.SAFE_STYLE_SHEET_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ === goog.html.SafeStyleSheet.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_) {
    return safeStyleSheet.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_;
  } else {
    goog.asserts.fail("expected object of type SafeStyleSheet, got '" + safeStyleSheet + "' of type " + goog.typeOf(safeStyleSheet));
    return "type_error:SafeStyleSheet";
  }
};
goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse = function(styleSheet) {
  return (new goog.html.SafeStyleSheet).initSecurityPrivateDoNotAccessOrElse_(styleSheet);
};
goog.html.SafeStyleSheet.prototype.initSecurityPrivateDoNotAccessOrElse_ = function(styleSheet) {
  this.privateDoNotAccessOrElseSafeStyleSheetWrappedValue_ = styleSheet;
  return this;
};
goog.html.SafeStyleSheet.EMPTY = goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse("");
goog.provide("goog.fs.url");
goog.fs.url.createObjectUrl = function(blob) {
  return goog.fs.url.getUrlObject_().createObjectURL(blob);
};
goog.fs.url.revokeObjectUrl = function(url) {
  goog.fs.url.getUrlObject_().revokeObjectURL(url);
};
goog.fs.url.UrlObject_;
goog.fs.url.getUrlObject_ = function() {
  var urlObject = goog.fs.url.findUrlObject_();
  if (urlObject != null) {
    return urlObject;
  } else {
    throw Error("This browser doesn't seem to support blob URLs");
  }
};
goog.fs.url.findUrlObject_ = function() {
  if (goog.isDef(goog.global.URL) && goog.isDef(goog.global.URL.createObjectURL)) {
    return (goog.global.URL);
  } else {
    if (goog.isDef(goog.global.webkitURL) && goog.isDef(goog.global.webkitURL.createObjectURL)) {
      return (goog.global.webkitURL);
    } else {
      if (goog.isDef(goog.global.createObjectURL)) {
        return (goog.global);
      } else {
        return null;
      }
    }
  }
};
goog.fs.url.browserSupportsObjectUrls = function() {
  return goog.fs.url.findUrlObject_() != null;
};
goog.provide("goog.i18n.bidi");
goog.provide("goog.i18n.bidi.Dir");
goog.provide("goog.i18n.bidi.DirectionalString");
goog.provide("goog.i18n.bidi.Format");
goog.define("goog.i18n.bidi.FORCE_RTL", false);
goog.i18n.bidi.IS_RTL = goog.i18n.bidi.FORCE_RTL || (goog.LOCALE.substring(0, 2).toLowerCase() == "ar" || goog.LOCALE.substring(0, 2).toLowerCase() == "fa" || goog.LOCALE.substring(0, 2).toLowerCase() == "he" || goog.LOCALE.substring(0, 2).toLowerCase() == "iw" || goog.LOCALE.substring(0, 2).toLowerCase() == "ps" || goog.LOCALE.substring(0, 2).toLowerCase() == "sd" || goog.LOCALE.substring(0, 2).toLowerCase() == "ug" || goog.LOCALE.substring(0, 2).toLowerCase() == "ur" || goog.LOCALE.substring(0, 
2).toLowerCase() == "yi") && (goog.LOCALE.length == 2 || goog.LOCALE.substring(2, 3) == "-" || goog.LOCALE.substring(2, 3) == "_") || goog.LOCALE.length >= 3 && goog.LOCALE.substring(0, 3).toLowerCase() == "ckb" && (goog.LOCALE.length == 3 || goog.LOCALE.substring(3, 4) == "-" || goog.LOCALE.substring(3, 4) == "_");
goog.i18n.bidi.Format = {LRE:"\u202a", RLE:"\u202b", PDF:"\u202c", LRM:"\u200e", RLM:"\u200f"};
goog.i18n.bidi.Dir = {LTR:1, RTL:-1, NEUTRAL:0};
goog.i18n.bidi.RIGHT = "right";
goog.i18n.bidi.LEFT = "left";
goog.i18n.bidi.I18N_RIGHT = goog.i18n.bidi.IS_RTL ? goog.i18n.bidi.LEFT : goog.i18n.bidi.RIGHT;
goog.i18n.bidi.I18N_LEFT = goog.i18n.bidi.IS_RTL ? goog.i18n.bidi.RIGHT : goog.i18n.bidi.LEFT;
goog.i18n.bidi.toDir = function(givenDir, opt_noNeutral) {
  if (typeof givenDir == "number") {
    return givenDir > 0 ? goog.i18n.bidi.Dir.LTR : givenDir < 0 ? goog.i18n.bidi.Dir.RTL : opt_noNeutral ? null : goog.i18n.bidi.Dir.NEUTRAL;
  } else {
    if (givenDir == null) {
      return null;
    } else {
      return givenDir ? goog.i18n.bidi.Dir.RTL : goog.i18n.bidi.Dir.LTR;
    }
  }
};
goog.i18n.bidi.ltrChars_ = "A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0800-\u1fff" + "\u200e\u2c00-\ufb1c\ufe00-\ufe6f\ufefd-\uffff";
goog.i18n.bidi.rtlChars_ = "\u0591-\u06ef\u06fa-\u07ff\u200f\ufb1d-\ufdff\ufe70-\ufefc";
goog.i18n.bidi.htmlSkipReg_ = /<[^>]*>|&[^;]+;/g;
goog.i18n.bidi.stripHtmlIfNeeded_ = function(str, opt_isStripNeeded) {
  return opt_isStripNeeded ? str.replace(goog.i18n.bidi.htmlSkipReg_, "") : str;
};
goog.i18n.bidi.rtlCharReg_ = new RegExp("[" + goog.i18n.bidi.rtlChars_ + "]");
goog.i18n.bidi.ltrCharReg_ = new RegExp("[" + goog.i18n.bidi.ltrChars_ + "]");
goog.i18n.bidi.hasAnyRtl = function(str, opt_isHtml) {
  return goog.i18n.bidi.rtlCharReg_.test(goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml));
};
goog.i18n.bidi.hasRtlChar = goog.i18n.bidi.hasAnyRtl;
goog.i18n.bidi.hasAnyLtr = function(str, opt_isHtml) {
  return goog.i18n.bidi.ltrCharReg_.test(goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml));
};
goog.i18n.bidi.ltrRe_ = new RegExp("^[" + goog.i18n.bidi.ltrChars_ + "]");
goog.i18n.bidi.rtlRe_ = new RegExp("^[" + goog.i18n.bidi.rtlChars_ + "]");
goog.i18n.bidi.isRtlChar = function(str) {
  return goog.i18n.bidi.rtlRe_.test(str);
};
goog.i18n.bidi.isLtrChar = function(str) {
  return goog.i18n.bidi.ltrRe_.test(str);
};
goog.i18n.bidi.isNeutralChar = function(str) {
  return !goog.i18n.bidi.isLtrChar(str) && !goog.i18n.bidi.isRtlChar(str);
};
goog.i18n.bidi.ltrDirCheckRe_ = new RegExp("^[^" + goog.i18n.bidi.rtlChars_ + "]*[" + goog.i18n.bidi.ltrChars_ + "]");
goog.i18n.bidi.rtlDirCheckRe_ = new RegExp("^[^" + goog.i18n.bidi.ltrChars_ + "]*[" + goog.i18n.bidi.rtlChars_ + "]");
goog.i18n.bidi.startsWithRtl = function(str, opt_isHtml) {
  return goog.i18n.bidi.rtlDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml));
};
goog.i18n.bidi.isRtlText = goog.i18n.bidi.startsWithRtl;
goog.i18n.bidi.startsWithLtr = function(str, opt_isHtml) {
  return goog.i18n.bidi.ltrDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml));
};
goog.i18n.bidi.isLtrText = goog.i18n.bidi.startsWithLtr;
goog.i18n.bidi.isRequiredLtrRe_ = /^http:\/\/.*/;
goog.i18n.bidi.isNeutralText = function(str, opt_isHtml) {
  str = goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml);
  return goog.i18n.bidi.isRequiredLtrRe_.test(str) || !goog.i18n.bidi.hasAnyLtr(str) && !goog.i18n.bidi.hasAnyRtl(str);
};
goog.i18n.bidi.ltrExitDirCheckRe_ = new RegExp("[" + goog.i18n.bidi.ltrChars_ + "][^" + goog.i18n.bidi.rtlChars_ + "]*$");
goog.i18n.bidi.rtlExitDirCheckRe_ = new RegExp("[" + goog.i18n.bidi.rtlChars_ + "][^" + goog.i18n.bidi.ltrChars_ + "]*$");
goog.i18n.bidi.endsWithLtr = function(str, opt_isHtml) {
  return goog.i18n.bidi.ltrExitDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml));
};
goog.i18n.bidi.isLtrExitText = goog.i18n.bidi.endsWithLtr;
goog.i18n.bidi.endsWithRtl = function(str, opt_isHtml) {
  return goog.i18n.bidi.rtlExitDirCheckRe_.test(goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml));
};
goog.i18n.bidi.isRtlExitText = goog.i18n.bidi.endsWithRtl;
goog.i18n.bidi.rtlLocalesRe_ = new RegExp("^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|" + ".*[-_](Arab|Hebr|Thaa|Nkoo|Tfng))" + "(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)", "i");
goog.i18n.bidi.isRtlLanguage = function(lang) {
  return goog.i18n.bidi.rtlLocalesRe_.test(lang);
};
goog.i18n.bidi.bracketGuardTextRe_ = /(\(.*?\)+)|(\[.*?\]+)|(\{.*?\}+)|(<.*?>+)/g;
goog.i18n.bidi.guardBracketInText = function(s, opt_isRtlContext) {
  var useRtl = opt_isRtlContext === undefined ? goog.i18n.bidi.hasAnyRtl(s) : opt_isRtlContext;
  var mark = useRtl ? goog.i18n.bidi.Format.RLM : goog.i18n.bidi.Format.LRM;
  return s.replace(goog.i18n.bidi.bracketGuardTextRe_, mark + "$&" + mark);
};
goog.i18n.bidi.enforceRtlInHtml = function(html) {
  if (html.charAt(0) == "<") {
    return html.replace(/<\w+/, "$& dir=rtl");
  }
  return "\n<span dir=rtl>" + html + "</span>";
};
goog.i18n.bidi.enforceRtlInText = function(text) {
  return goog.i18n.bidi.Format.RLE + text + goog.i18n.bidi.Format.PDF;
};
goog.i18n.bidi.enforceLtrInHtml = function(html) {
  if (html.charAt(0) == "<") {
    return html.replace(/<\w+/, "$& dir=ltr");
  }
  return "\n<span dir=ltr>" + html + "</span>";
};
goog.i18n.bidi.enforceLtrInText = function(text) {
  return goog.i18n.bidi.Format.LRE + text + goog.i18n.bidi.Format.PDF;
};
goog.i18n.bidi.dimensionsRe_ = /:\s*([.\d][.\w]*)\s+([.\d][.\w]*)\s+([.\d][.\w]*)\s+([.\d][.\w]*)/g;
goog.i18n.bidi.leftRe_ = /left/gi;
goog.i18n.bidi.rightRe_ = /right/gi;
goog.i18n.bidi.tempRe_ = /%%%%/g;
goog.i18n.bidi.mirrorCSS = function(cssStr) {
  return cssStr.replace(goog.i18n.bidi.dimensionsRe_, ":$1 $4 $3 $2").replace(goog.i18n.bidi.leftRe_, "%%%%").replace(goog.i18n.bidi.rightRe_, goog.i18n.bidi.LEFT).replace(goog.i18n.bidi.tempRe_, goog.i18n.bidi.RIGHT);
};
goog.i18n.bidi.doubleQuoteSubstituteRe_ = /([\u0591-\u05f2])"/g;
goog.i18n.bidi.singleQuoteSubstituteRe_ = /([\u0591-\u05f2])'/g;
goog.i18n.bidi.normalizeHebrewQuote = function(str) {
  return str.replace(goog.i18n.bidi.doubleQuoteSubstituteRe_, "$1\u05f4").replace(goog.i18n.bidi.singleQuoteSubstituteRe_, "$1\u05f3");
};
goog.i18n.bidi.wordSeparatorRe_ = /\s+/;
goog.i18n.bidi.hasNumeralsRe_ = /[\d\u06f0-\u06f9]/;
goog.i18n.bidi.rtlDetectionThreshold_ = .4;
goog.i18n.bidi.estimateDirection = function(str, opt_isHtml) {
  var rtlCount = 0;
  var totalCount = 0;
  var hasWeaklyLtr = false;
  var tokens = goog.i18n.bidi.stripHtmlIfNeeded_(str, opt_isHtml).split(goog.i18n.bidi.wordSeparatorRe_);
  for (var i = 0;i < tokens.length;i++) {
    var token = tokens[i];
    if (goog.i18n.bidi.startsWithRtl(token)) {
      rtlCount++;
      totalCount++;
    } else {
      if (goog.i18n.bidi.isRequiredLtrRe_.test(token)) {
        hasWeaklyLtr = true;
      } else {
        if (goog.i18n.bidi.hasAnyLtr(token)) {
          totalCount++;
        } else {
          if (goog.i18n.bidi.hasNumeralsRe_.test(token)) {
            hasWeaklyLtr = true;
          }
        }
      }
    }
  }
  return totalCount == 0 ? hasWeaklyLtr ? goog.i18n.bidi.Dir.LTR : goog.i18n.bidi.Dir.NEUTRAL : rtlCount / totalCount > goog.i18n.bidi.rtlDetectionThreshold_ ? goog.i18n.bidi.Dir.RTL : goog.i18n.bidi.Dir.LTR;
};
goog.i18n.bidi.detectRtlDirectionality = function(str, opt_isHtml) {
  return goog.i18n.bidi.estimateDirection(str, opt_isHtml) == goog.i18n.bidi.Dir.RTL;
};
goog.i18n.bidi.setElementDirAndAlign = function(element, dir) {
  if (element) {
    dir = goog.i18n.bidi.toDir(dir);
    if (dir) {
      element.style.textAlign = dir == goog.i18n.bidi.Dir.RTL ? goog.i18n.bidi.RIGHT : goog.i18n.bidi.LEFT;
      element.dir = dir == goog.i18n.bidi.Dir.RTL ? "rtl" : "ltr";
    }
  }
};
goog.i18n.bidi.setElementDirByTextDirectionality = function(element, text) {
  switch(goog.i18n.bidi.estimateDirection(text)) {
    case goog.i18n.bidi.Dir.LTR:
      element.dir = "ltr";
      break;
    case goog.i18n.bidi.Dir.RTL:
      element.dir = "rtl";
      break;
    default:
      element.removeAttribute("dir");
  }
};
goog.i18n.bidi.DirectionalString = function() {
};
goog.i18n.bidi.DirectionalString.prototype.implementsGoogI18nBidiDirectionalString;
goog.i18n.bidi.DirectionalString.prototype.getDirection;
goog.provide("goog.html.SafeUrl");
goog.require("goog.asserts");
goog.require("goog.fs.url");
goog.require("goog.i18n.bidi.Dir");
goog.require("goog.i18n.bidi.DirectionalString");
goog.require("goog.string");
goog.require("goog.string.Const");
goog.require("goog.string.TypedString");
goog.html.SafeUrl = function() {
  this.privateDoNotAccessOrElseSafeHtmlWrappedValue_ = "";
  this.SAFE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
};
goog.html.SafeUrl.INNOCUOUS_STRING = "about:invalid#zClosurez";
goog.html.SafeUrl.prototype.implementsGoogStringTypedString = true;
goog.html.SafeUrl.prototype.getTypedStringValue = function() {
  return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_;
};
goog.html.SafeUrl.prototype.implementsGoogI18nBidiDirectionalString = true;
goog.html.SafeUrl.prototype.getDirection = function() {
  return goog.i18n.bidi.Dir.LTR;
};
if (goog.DEBUG) {
  goog.html.SafeUrl.prototype.toString = function() {
    return "SafeUrl{" + this.privateDoNotAccessOrElseSafeHtmlWrappedValue_ + "}";
  };
}
goog.html.SafeUrl.unwrap = function(safeUrl) {
  if (safeUrl instanceof goog.html.SafeUrl && safeUrl.constructor === goog.html.SafeUrl && safeUrl.SAFE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ === goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_) {
    return safeUrl.privateDoNotAccessOrElseSafeHtmlWrappedValue_;
  } else {
    goog.asserts.fail("expected object of type SafeUrl, got '" + safeUrl + "' of type " + goog.typeOf(safeUrl));
    return "type_error:SafeUrl";
  }
};
goog.html.SafeUrl.fromConstant = function(url) {
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(url));
};
goog.html.SAFE_MIME_TYPE_PATTERN_ = /^(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm))$/i;
goog.html.SafeUrl.fromBlob = function(blob) {
  var url = goog.html.SAFE_MIME_TYPE_PATTERN_.test(blob.type) ? goog.fs.url.createObjectUrl(blob) : goog.html.SafeUrl.INNOCUOUS_STRING;
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);
};
goog.html.DATA_URL_PATTERN_ = /^data:([^;,]*);base64,[a-z0-9+\/]+=*$/i;
goog.html.SafeUrl.fromDataUrl = function(dataUrl) {
  var match = dataUrl.match(goog.html.DATA_URL_PATTERN_);
  var valid = match && goog.html.SAFE_MIME_TYPE_PATTERN_.test(match[1]);
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(valid ? dataUrl : goog.html.SafeUrl.INNOCUOUS_STRING);
};
goog.html.SafeUrl.fromTelUrl = function(telUrl) {
  if (!goog.string.caseInsensitiveStartsWith(telUrl, "tel:")) {
    telUrl = goog.html.SafeUrl.INNOCUOUS_STRING;
  }
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(telUrl);
};
goog.html.SAFE_URL_PATTERN_ = /^(?:(?:https?|mailto|ftp):|[^&:/?#]*(?:[/?#]|$))/i;
goog.html.SafeUrl.sanitize = function(url) {
  if (url instanceof goog.html.SafeUrl) {
    return url;
  } else {
    if (url.implementsGoogStringTypedString) {
      url = url.getTypedStringValue();
    } else {
      url = String(url);
    }
  }
  if (!goog.html.SAFE_URL_PATTERN_.test(url)) {
    url = goog.html.SafeUrl.INNOCUOUS_STRING;
  }
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);
};
goog.html.SafeUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse = function(url) {
  var safeUrl = new goog.html.SafeUrl;
  safeUrl.privateDoNotAccessOrElseSafeHtmlWrappedValue_ = url;
  return safeUrl;
};
goog.html.SafeUrl.ABOUT_BLANK = goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse("about:blank");
goog.provide("goog.html.TrustedResourceUrl");
goog.require("goog.asserts");
goog.require("goog.i18n.bidi.Dir");
goog.require("goog.i18n.bidi.DirectionalString");
goog.require("goog.string.Const");
goog.require("goog.string.TypedString");
goog.html.TrustedResourceUrl = function() {
  this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_ = "";
  this.TRUSTED_RESOURCE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
};
goog.html.TrustedResourceUrl.prototype.implementsGoogStringTypedString = true;
goog.html.TrustedResourceUrl.prototype.getTypedStringValue = function() {
  return this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_;
};
goog.html.TrustedResourceUrl.prototype.implementsGoogI18nBidiDirectionalString = true;
goog.html.TrustedResourceUrl.prototype.getDirection = function() {
  return goog.i18n.bidi.Dir.LTR;
};
if (goog.DEBUG) {
  goog.html.TrustedResourceUrl.prototype.toString = function() {
    return "TrustedResourceUrl{" + this.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_ + "}";
  };
}
goog.html.TrustedResourceUrl.unwrap = function(trustedResourceUrl) {
  if (trustedResourceUrl instanceof goog.html.TrustedResourceUrl && trustedResourceUrl.constructor === goog.html.TrustedResourceUrl && trustedResourceUrl.TRUSTED_RESOURCE_URL_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ === goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_) {
    return trustedResourceUrl.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_;
  } else {
    goog.asserts.fail("expected object of type TrustedResourceUrl, got '" + trustedResourceUrl + "' of type " + goog.typeOf(trustedResourceUrl));
    return "type_error:TrustedResourceUrl";
  }
};
goog.html.TrustedResourceUrl.fromConstant = function(url) {
  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(goog.string.Const.unwrap(url));
};
goog.html.TrustedResourceUrl.fromConstants = function(parts) {
  var unwrapped = "";
  for (var i = 0;i < parts.length;i++) {
    unwrapped += goog.string.Const.unwrap(parts[i]);
  }
  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(unwrapped);
};
goog.html.TrustedResourceUrl.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse = function(url) {
  var trustedResourceUrl = new goog.html.TrustedResourceUrl;
  trustedResourceUrl.privateDoNotAccessOrElseTrustedResourceUrlWrappedValue_ = url;
  return trustedResourceUrl;
};
goog.provide("goog.labs.userAgent.util");
goog.require("goog.string");
goog.labs.userAgent.util.getNativeUserAgentString_ = function() {
  var navigator = goog.labs.userAgent.util.getNavigator_();
  if (navigator) {
    var userAgent = navigator.userAgent;
    if (userAgent) {
      return userAgent;
    }
  }
  return "";
};
goog.labs.userAgent.util.getNavigator_ = function() {
  return goog.global.navigator;
};
goog.labs.userAgent.util.userAgent_ = goog.labs.userAgent.util.getNativeUserAgentString_();
goog.labs.userAgent.util.setUserAgent = function(opt_userAgent) {
  goog.labs.userAgent.util.userAgent_ = opt_userAgent || goog.labs.userAgent.util.getNativeUserAgentString_();
};
goog.labs.userAgent.util.getUserAgent = function() {
  return goog.labs.userAgent.util.userAgent_;
};
goog.labs.userAgent.util.matchUserAgent = function(str) {
  var userAgent = goog.labs.userAgent.util.getUserAgent();
  return goog.string.contains(userAgent, str);
};
goog.labs.userAgent.util.matchUserAgentIgnoreCase = function(str) {
  var userAgent = goog.labs.userAgent.util.getUserAgent();
  return goog.string.caseInsensitiveContains(userAgent, str);
};
goog.labs.userAgent.util.extractVersionTuples = function(userAgent) {
  var versionRegExp = new RegExp("(\\w[\\w ]+)" + "/" + "([^\\s]+)" + "\\s*" + "(?:\\((.*?)\\))?", "g");
  var data = [];
  var match;
  while (match = versionRegExp.exec(userAgent)) {
    data.push([match[1], match[2], match[3] || undefined]);
  }
  return data;
};
goog.provide("goog.labs.userAgent.browser");
goog.require("goog.array");
goog.require("goog.labs.userAgent.util");
goog.require("goog.object");
goog.require("goog.string");
goog.labs.userAgent.browser.matchOpera_ = function() {
  return goog.labs.userAgent.util.matchUserAgent("Opera");
};
goog.labs.userAgent.browser.matchIE_ = function() {
  return goog.labs.userAgent.util.matchUserAgent("Trident") || goog.labs.userAgent.util.matchUserAgent("MSIE");
};
goog.labs.userAgent.browser.matchEdge_ = function() {
  return goog.labs.userAgent.util.matchUserAgent("Edge");
};
goog.labs.userAgent.browser.matchFirefox_ = function() {
  return goog.labs.userAgent.util.matchUserAgent("Firefox");
};
goog.labs.userAgent.browser.matchSafari_ = function() {
  return goog.labs.userAgent.util.matchUserAgent("Safari") && !(goog.labs.userAgent.browser.matchChrome_() || goog.labs.userAgent.browser.matchCoast_() || goog.labs.userAgent.browser.matchOpera_() || goog.labs.userAgent.browser.matchEdge_() || goog.labs.userAgent.browser.isSilk() || goog.labs.userAgent.util.matchUserAgent("Android"));
};
goog.labs.userAgent.browser.matchCoast_ = function() {
  return goog.labs.userAgent.util.matchUserAgent("Coast");
};
goog.labs.userAgent.browser.matchIosWebview_ = function() {
  return (goog.labs.userAgent.util.matchUserAgent("iPad") || goog.labs.userAgent.util.matchUserAgent("iPhone")) && !goog.labs.userAgent.browser.matchSafari_() && !goog.labs.userAgent.browser.matchChrome_() && !goog.labs.userAgent.browser.matchCoast_() && goog.labs.userAgent.util.matchUserAgent("AppleWebKit");
};
goog.labs.userAgent.browser.matchChrome_ = function() {
  return (goog.labs.userAgent.util.matchUserAgent("Chrome") || goog.labs.userAgent.util.matchUserAgent("CriOS")) && !goog.labs.userAgent.browser.matchEdge_();
};
goog.labs.userAgent.browser.matchAndroidBrowser_ = function() {
  return goog.labs.userAgent.util.matchUserAgent("Android") && !(goog.labs.userAgent.browser.isChrome() || goog.labs.userAgent.browser.isFirefox() || goog.labs.userAgent.browser.isOpera() || goog.labs.userAgent.browser.isSilk());
};
goog.labs.userAgent.browser.isOpera = goog.labs.userAgent.browser.matchOpera_;
goog.labs.userAgent.browser.isIE = goog.labs.userAgent.browser.matchIE_;
goog.labs.userAgent.browser.isEdge = goog.labs.userAgent.browser.matchEdge_;
goog.labs.userAgent.browser.isFirefox = goog.labs.userAgent.browser.matchFirefox_;
goog.labs.userAgent.browser.isSafari = goog.labs.userAgent.browser.matchSafari_;
goog.labs.userAgent.browser.isCoast = goog.labs.userAgent.browser.matchCoast_;
goog.labs.userAgent.browser.isIosWebview = goog.labs.userAgent.browser.matchIosWebview_;
goog.labs.userAgent.browser.isChrome = goog.labs.userAgent.browser.matchChrome_;
goog.labs.userAgent.browser.isAndroidBrowser = goog.labs.userAgent.browser.matchAndroidBrowser_;
goog.labs.userAgent.browser.isSilk = function() {
  return goog.labs.userAgent.util.matchUserAgent("Silk");
};
goog.labs.userAgent.browser.getVersion = function() {
  var userAgentString = goog.labs.userAgent.util.getUserAgent();
  if (goog.labs.userAgent.browser.isIE()) {
    return goog.labs.userAgent.browser.getIEVersion_(userAgentString);
  }
  var versionTuples = goog.labs.userAgent.util.extractVersionTuples(userAgentString);
  var versionMap = {};
  goog.array.forEach(versionTuples, function(tuple) {
    var key = tuple[0];
    var value = tuple[1];
    versionMap[key] = value;
  });
  var versionMapHasKey = goog.partial(goog.object.containsKey, versionMap);
  function lookUpValueWithKeys(keys) {
    var key = goog.array.find(keys, versionMapHasKey);
    return versionMap[key] || "";
  }
  if (goog.labs.userAgent.browser.isOpera()) {
    return lookUpValueWithKeys(["Version", "Opera"]);
  }
  if (goog.labs.userAgent.browser.isEdge()) {
    return lookUpValueWithKeys(["Edge"]);
  }
  if (goog.labs.userAgent.browser.isChrome()) {
    return lookUpValueWithKeys(["Chrome", "CriOS"]);
  }
  var tuple = versionTuples[2];
  return tuple && tuple[1] || "";
};
goog.labs.userAgent.browser.isVersionOrHigher = function(version) {
  return goog.string.compareVersions(goog.labs.userAgent.browser.getVersion(), version) >= 0;
};
goog.labs.userAgent.browser.getIEVersion_ = function(userAgent) {
  var rv = /rv: *([\d\.]*)/.exec(userAgent);
  if (rv && rv[1]) {
    return rv[1];
  }
  var version = "";
  var msie = /MSIE +([\d\.]+)/.exec(userAgent);
  if (msie && msie[1]) {
    var tridentVersion = /Trident\/(\d.\d)/.exec(userAgent);
    if (msie[1] == "7.0") {
      if (tridentVersion && tridentVersion[1]) {
        switch(tridentVersion[1]) {
          case "4.0":
            version = "8.0";
            break;
          case "5.0":
            version = "9.0";
            break;
          case "6.0":
            version = "10.0";
            break;
          case "7.0":
            version = "11.0";
            break;
        }
      } else {
        version = "7.0";
      }
    } else {
      version = msie[1];
    }
  }
  return version;
};
goog.provide("goog.html.SafeHtml");
goog.require("goog.array");
goog.require("goog.asserts");
goog.require("goog.dom.TagName");
goog.require("goog.dom.tags");
goog.require("goog.html.SafeStyle");
goog.require("goog.html.SafeStyleSheet");
goog.require("goog.html.SafeUrl");
goog.require("goog.html.TrustedResourceUrl");
goog.require("goog.i18n.bidi.Dir");
goog.require("goog.i18n.bidi.DirectionalString");
goog.require("goog.labs.userAgent.browser");
goog.require("goog.object");
goog.require("goog.string");
goog.require("goog.string.Const");
goog.require("goog.string.TypedString");
goog.html.SafeHtml = function() {
  this.privateDoNotAccessOrElseSafeHtmlWrappedValue_ = "";
  this.SAFE_HTML_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
  this.dir_ = null;
};
goog.html.SafeHtml.prototype.implementsGoogI18nBidiDirectionalString = true;
goog.html.SafeHtml.prototype.getDirection = function() {
  return this.dir_;
};
goog.html.SafeHtml.prototype.implementsGoogStringTypedString = true;
goog.html.SafeHtml.prototype.getTypedStringValue = function() {
  return this.privateDoNotAccessOrElseSafeHtmlWrappedValue_;
};
if (goog.DEBUG) {
  goog.html.SafeHtml.prototype.toString = function() {
    return "SafeHtml{" + this.privateDoNotAccessOrElseSafeHtmlWrappedValue_ + "}";
  };
}
goog.html.SafeHtml.unwrap = function(safeHtml) {
  if (safeHtml instanceof goog.html.SafeHtml && safeHtml.constructor === goog.html.SafeHtml && safeHtml.SAFE_HTML_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ === goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_) {
    return safeHtml.privateDoNotAccessOrElseSafeHtmlWrappedValue_;
  } else {
    goog.asserts.fail("expected object of type SafeHtml, got '" + safeHtml + "' of type " + goog.typeOf(safeHtml));
    return "type_error:SafeHtml";
  }
};
goog.html.SafeHtml.TextOrHtml_;
goog.html.SafeHtml.htmlEscape = function(textOrHtml) {
  if (textOrHtml instanceof goog.html.SafeHtml) {
    return textOrHtml;
  }
  var dir = null;
  if (textOrHtml.implementsGoogI18nBidiDirectionalString) {
    dir = textOrHtml.getDirection();
  }
  var textAsString;
  if (textOrHtml.implementsGoogStringTypedString) {
    textAsString = textOrHtml.getTypedStringValue();
  } else {
    textAsString = String(textOrHtml);
  }
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.htmlEscape(textAsString), dir);
};
goog.html.SafeHtml.htmlEscapePreservingNewlines = function(textOrHtml) {
  if (textOrHtml instanceof goog.html.SafeHtml) {
    return textOrHtml;
  }
  var html = goog.html.SafeHtml.htmlEscape(textOrHtml);
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.newLineToBr(goog.html.SafeHtml.unwrap(html)), html.getDirection());
};
goog.html.SafeHtml.htmlEscapePreservingNewlinesAndSpaces = function(textOrHtml) {
  if (textOrHtml instanceof goog.html.SafeHtml) {
    return textOrHtml;
  }
  var html = goog.html.SafeHtml.htmlEscape(textOrHtml);
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(goog.string.whitespaceEscape(goog.html.SafeHtml.unwrap(html)), html.getDirection());
};
goog.html.SafeHtml.from = goog.html.SafeHtml.htmlEscape;
goog.html.SafeHtml.VALID_NAMES_IN_TAG_ = /^[a-zA-Z0-9-]+$/;
goog.html.SafeHtml.URL_ATTRIBUTES_ = goog.object.createSet("action", "cite", "data", "formaction", "href", "manifest", "poster", "src");
goog.html.SafeHtml.NOT_ALLOWED_TAG_NAMES_ = goog.object.createSet(goog.dom.TagName.APPLET, goog.dom.TagName.BASE, goog.dom.TagName.EMBED, goog.dom.TagName.IFRAME, goog.dom.TagName.LINK, goog.dom.TagName.MATH, goog.dom.TagName.META, goog.dom.TagName.OBJECT, goog.dom.TagName.SCRIPT, goog.dom.TagName.STYLE, goog.dom.TagName.SVG, goog.dom.TagName.TEMPLATE);
goog.html.SafeHtml.AttributeValue;
goog.html.SafeHtml.create = function(tagName, opt_attributes, opt_content) {
  goog.html.SafeHtml.verifyTagName(tagName);
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse(tagName, opt_attributes, opt_content);
};
goog.html.SafeHtml.verifyTagName = function(tagName) {
  if (!goog.html.SafeHtml.VALID_NAMES_IN_TAG_.test(tagName)) {
    throw Error("Invalid tag name <" + tagName + ">.");
  }
  if (tagName.toUpperCase() in goog.html.SafeHtml.NOT_ALLOWED_TAG_NAMES_) {
    throw Error("Tag name <" + tagName + "> is not allowed for SafeHtml.");
  }
};
goog.html.SafeHtml.createIframe = function(opt_src, opt_srcdoc, opt_attributes, opt_content) {
  if (opt_src) {
    goog.html.TrustedResourceUrl.unwrap(opt_src);
  }
  var fixedAttributes = {};
  fixedAttributes["src"] = opt_src || null;
  fixedAttributes["srcdoc"] = opt_srcdoc && goog.html.SafeHtml.unwrap(opt_srcdoc);
  var defaultAttributes = {"sandbox":""};
  var attributes = goog.html.SafeHtml.combineAttributes(fixedAttributes, defaultAttributes, opt_attributes);
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe", attributes, opt_content);
};
goog.html.SafeHtml.createSandboxIframe = function(opt_src, opt_srcdoc, opt_attributes, opt_content) {
  if (!goog.html.SafeHtml.canUseSandboxIframe()) {
    throw new Error("The browser does not support sandboxed iframes.");
  }
  var fixedAttributes = {};
  if (opt_src) {
    fixedAttributes["src"] = goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(opt_src));
  } else {
    fixedAttributes["src"] = null;
  }
  fixedAttributes["srcdoc"] = opt_srcdoc || null;
  fixedAttributes["sandbox"] = "";
  var attributes = goog.html.SafeHtml.combineAttributes(fixedAttributes, {}, opt_attributes);
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("iframe", attributes, opt_content);
};
goog.html.SafeHtml.canUseSandboxIframe = function() {
  return goog.global["HTMLIFrameElement"] && "sandbox" in goog.global["HTMLIFrameElement"].prototype;
};
goog.html.SafeHtml.createScriptSrc = function(src, opt_attributes) {
  goog.html.TrustedResourceUrl.unwrap(src);
  var fixedAttributes = {"src":src};
  var defaultAttributes = {};
  var attributes = goog.html.SafeHtml.combineAttributes(fixedAttributes, defaultAttributes, opt_attributes);
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("script", attributes);
};
goog.html.SafeHtml.createStyle = function(styleSheet, opt_attributes) {
  var fixedAttributes = {"type":"text/css"};
  var defaultAttributes = {};
  var attributes = goog.html.SafeHtml.combineAttributes(fixedAttributes, defaultAttributes, opt_attributes);
  var content = "";
  styleSheet = goog.array.concat(styleSheet);
  for (var i = 0;i < styleSheet.length;i++) {
    content += goog.html.SafeStyleSheet.unwrap(styleSheet[i]);
  }
  var htmlContent = goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(content, goog.i18n.bidi.Dir.NEUTRAL);
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("style", attributes, htmlContent);
};
goog.html.SafeHtml.createMetaRefresh = function(url, opt_secs) {
  var unwrappedUrl = goog.html.SafeUrl.unwrap(goog.html.SafeUrl.sanitize(url));
  if (goog.labs.userAgent.browser.isIE() || goog.labs.userAgent.browser.isEdge()) {
    if (goog.string.contains(unwrappedUrl, ";")) {
      unwrappedUrl = "'" + unwrappedUrl.replace(/'/g, "%27") + "'";
    }
  }
  var attributes = {"http-equiv":"refresh", "content":(opt_secs || 0) + "; url=" + unwrappedUrl};
  return goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse("meta", attributes);
};
goog.html.SafeHtml.getAttrNameAndValue_ = function(tagName, name, value) {
  if (value instanceof goog.string.Const) {
    value = goog.string.Const.unwrap(value);
  } else {
    if (name.toLowerCase() == "style") {
      value = goog.html.SafeHtml.getStyleValue_(value);
    } else {
      if (/^on/i.test(name)) {
        throw Error('Attribute "' + name + '" requires goog.string.Const value, "' + value + '" given.');
      } else {
        if (name.toLowerCase() in goog.html.SafeHtml.URL_ATTRIBUTES_) {
          if (value instanceof goog.html.TrustedResourceUrl) {
            value = goog.html.TrustedResourceUrl.unwrap(value);
          } else {
            if (value instanceof goog.html.SafeUrl) {
              value = goog.html.SafeUrl.unwrap(value);
            } else {
              if (goog.isString(value)) {
                value = goog.html.SafeUrl.sanitize(value).getTypedStringValue();
              } else {
                throw Error('Attribute "' + name + '" on tag "' + tagName + '" requires goog.html.SafeUrl, goog.string.Const, or string,' + ' value "' + value + '" given.');
              }
            }
          }
        }
      }
    }
  }
  if (value.implementsGoogStringTypedString) {
    value = value.getTypedStringValue();
  }
  goog.asserts.assert(goog.isString(value) || goog.isNumber(value), "String or number value expected, got " + typeof value + " with value: " + value);
  return name + '="' + goog.string.htmlEscape(String(value)) + '"';
};
goog.html.SafeHtml.getStyleValue_ = function(value) {
  if (!goog.isObject(value)) {
    throw Error('The "style" attribute requires goog.html.SafeStyle or map ' + "of style properties, " + typeof value + " given: " + value);
  }
  if (!(value instanceof goog.html.SafeStyle)) {
    value = goog.html.SafeStyle.create(value);
  }
  return goog.html.SafeStyle.unwrap(value);
};
goog.html.SafeHtml.createWithDir = function(dir, tagName, opt_attributes, opt_content) {
  var html = goog.html.SafeHtml.create(tagName, opt_attributes, opt_content);
  html.dir_ = dir;
  return html;
};
goog.html.SafeHtml.concat = function(var_args) {
  var dir = goog.i18n.bidi.Dir.NEUTRAL;
  var content = "";
  var addArgument = function(argument) {
    if (goog.isArray(argument)) {
      goog.array.forEach(argument, addArgument);
    } else {
      var html = goog.html.SafeHtml.htmlEscape(argument);
      content += goog.html.SafeHtml.unwrap(html);
      var htmlDir = html.getDirection();
      if (dir == goog.i18n.bidi.Dir.NEUTRAL) {
        dir = htmlDir;
      } else {
        if (htmlDir != goog.i18n.bidi.Dir.NEUTRAL && dir != htmlDir) {
          dir = null;
        }
      }
    }
  };
  goog.array.forEach(arguments, addArgument);
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(content, dir);
};
goog.html.SafeHtml.concatWithDir = function(dir, var_args) {
  var html = goog.html.SafeHtml.concat(goog.array.slice(arguments, 1));
  html.dir_ = dir;
  return html;
};
goog.html.SafeHtml.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse = function(html, dir) {
  return (new goog.html.SafeHtml).initSecurityPrivateDoNotAccessOrElse_(html, dir);
};
goog.html.SafeHtml.prototype.initSecurityPrivateDoNotAccessOrElse_ = function(html, dir) {
  this.privateDoNotAccessOrElseSafeHtmlWrappedValue_ = html;
  this.dir_ = dir;
  return this;
};
goog.html.SafeHtml.createSafeHtmlTagSecurityPrivateDoNotAccessOrElse = function(tagName, opt_attributes, opt_content) {
  var dir = null;
  var result = "<" + tagName;
  result += goog.html.SafeHtml.stringifyAttributes(tagName, opt_attributes);
  var content = opt_content;
  if (!goog.isDefAndNotNull(content)) {
    content = [];
  } else {
    if (!goog.isArray(content)) {
      content = [content];
    }
  }
  if (goog.dom.tags.isVoidTag(tagName.toLowerCase())) {
    goog.asserts.assert(!content.length, "Void tag <" + tagName + "> does not allow content.");
    result += ">";
  } else {
    var html = goog.html.SafeHtml.concat(content);
    result += ">" + goog.html.SafeHtml.unwrap(html) + "</" + tagName + ">";
    dir = html.getDirection();
  }
  var dirAttribute = opt_attributes && opt_attributes["dir"];
  if (dirAttribute) {
    if (/^(ltr|rtl|auto)$/i.test(dirAttribute)) {
      dir = goog.i18n.bidi.Dir.NEUTRAL;
    } else {
      dir = null;
    }
  }
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(result, dir);
};
goog.html.SafeHtml.stringifyAttributes = function(tagName, opt_attributes) {
  var result = "";
  if (opt_attributes) {
    for (var name in opt_attributes) {
      if (!goog.html.SafeHtml.VALID_NAMES_IN_TAG_.test(name)) {
        throw Error('Invalid attribute name "' + name + '".');
      }
      var value = opt_attributes[name];
      if (!goog.isDefAndNotNull(value)) {
        continue;
      }
      result += " " + goog.html.SafeHtml.getAttrNameAndValue_(tagName, name, value);
    }
  }
  return result;
};
goog.html.SafeHtml.combineAttributes = function(fixedAttributes, defaultAttributes, opt_attributes) {
  var combinedAttributes = {};
  var name;
  for (name in fixedAttributes) {
    goog.asserts.assert(name.toLowerCase() == name, "Must be lower case");
    combinedAttributes[name] = fixedAttributes[name];
  }
  for (name in defaultAttributes) {
    goog.asserts.assert(name.toLowerCase() == name, "Must be lower case");
    combinedAttributes[name] = defaultAttributes[name];
  }
  for (name in opt_attributes) {
    var nameLower = name.toLowerCase();
    if (nameLower in fixedAttributes) {
      throw Error('Cannot override "' + nameLower + '" attribute, got "' + name + '" with value "' + opt_attributes[name] + '"');
    }
    if (nameLower in defaultAttributes) {
      delete combinedAttributes[nameLower];
    }
    combinedAttributes[name] = opt_attributes[name];
  }
  return combinedAttributes;
};
goog.html.SafeHtml.DOCTYPE_HTML = goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<!DOCTYPE html>", goog.i18n.bidi.Dir.NEUTRAL);
goog.html.SafeHtml.EMPTY = goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("", goog.i18n.bidi.Dir.NEUTRAL);
goog.html.SafeHtml.BR = goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse("<br>", goog.i18n.bidi.Dir.NEUTRAL);
goog.provide("goog.html.SafeScript");
goog.require("goog.asserts");
goog.require("goog.string.Const");
goog.require("goog.string.TypedString");
goog.html.SafeScript = function() {
  this.privateDoNotAccessOrElseSafeScriptWrappedValue_ = "";
  this.SAFE_SCRIPT_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_;
};
goog.html.SafeScript.prototype.implementsGoogStringTypedString = true;
goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ = {};
goog.html.SafeScript.fromConstant = function(script) {
  var scriptString = goog.string.Const.unwrap(script);
  if (scriptString.length === 0) {
    return goog.html.SafeScript.EMPTY;
  }
  return goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(scriptString);
};
goog.html.SafeScript.prototype.getTypedStringValue = function() {
  return this.privateDoNotAccessOrElseSafeScriptWrappedValue_;
};
if (goog.DEBUG) {
  goog.html.SafeScript.prototype.toString = function() {
    return "SafeScript{" + this.privateDoNotAccessOrElseSafeScriptWrappedValue_ + "}";
  };
}
goog.html.SafeScript.unwrap = function(safeScript) {
  if (safeScript instanceof goog.html.SafeScript && safeScript.constructor === goog.html.SafeScript && safeScript.SAFE_SCRIPT_TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_ === goog.html.SafeScript.TYPE_MARKER_GOOG_HTML_SECURITY_PRIVATE_) {
    return safeScript.privateDoNotAccessOrElseSafeScriptWrappedValue_;
  } else {
    goog.asserts.fail("expected object of type SafeScript, got '" + safeScript + "' of type " + goog.typeOf(safeScript));
    return "type_error:SafeScript";
  }
};
goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse = function(script) {
  return (new goog.html.SafeScript).initSecurityPrivateDoNotAccessOrElse_(script);
};
goog.html.SafeScript.prototype.initSecurityPrivateDoNotAccessOrElse_ = function(script) {
  this.privateDoNotAccessOrElseSafeScriptWrappedValue_ = script;
  return this;
};
goog.html.SafeScript.EMPTY = goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse("");
goog.provide("goog.html.uncheckedconversions");
goog.require("goog.asserts");
goog.require("goog.html.SafeHtml");
goog.require("goog.html.SafeScript");
goog.require("goog.html.SafeStyle");
goog.require("goog.html.SafeStyleSheet");
goog.require("goog.html.SafeUrl");
goog.require("goog.html.TrustedResourceUrl");
goog.require("goog.string");
goog.require("goog.string.Const");
goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract = function(justification, html, opt_dir) {
  goog.asserts.assertString(goog.string.Const.unwrap(justification), "must provide justification");
  goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)), "must provide non-empty justification");
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(html, opt_dir || null);
};
goog.html.uncheckedconversions.safeScriptFromStringKnownToSatisfyTypeContract = function(justification, script) {
  goog.asserts.assertString(goog.string.Const.unwrap(justification), "must provide justification");
  goog.asserts.assert(!goog.string.isEmpty(goog.string.Const.unwrap(justification)), "must provide non-empty justification");
  return goog.html.SafeScript.createSafeScriptSecurityPrivateDoNotAccessOrElse(script);
};
goog.html.uncheckedconversions.safeStyleFromStringKnownToSatisfyTypeContract = function(justification, style) {
  goog.asserts.assertString(goog.string.Const.unwrap(justification), "must provide justification");
  goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)), "must provide non-empty justification");
  return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(style);
};
goog.html.uncheckedconversions.safeStyleSheetFromStringKnownToSatisfyTypeContract = function(justification, styleSheet) {
  goog.asserts.assertString(goog.string.Const.unwrap(justification), "must provide justification");
  goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)), "must provide non-empty justification");
  return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(styleSheet);
};
goog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract = function(justification, url) {
  goog.asserts.assertString(goog.string.Const.unwrap(justification), "must provide justification");
  goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)), "must provide non-empty justification");
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);
};
goog.html.uncheckedconversions.trustedResourceUrlFromStringKnownToSatisfyTypeContract = function(justification, url) {
  goog.asserts.assertString(goog.string.Const.unwrap(justification), "must provide justification");
  goog.asserts.assert(!goog.string.isEmptyOrWhitespace(goog.string.Const.unwrap(justification)), "must provide non-empty justification");
  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(url);
};
goog.provide("goog.structs");
goog.require("goog.array");
goog.require("goog.object");
goog.structs.getCount = function(col) {
  if (col.getCount && typeof col.getCount == "function") {
    return col.getCount();
  }
  if (goog.isArrayLike(col) || goog.isString(col)) {
    return col.length;
  }
  return goog.object.getCount(col);
};
goog.structs.getValues = function(col) {
  if (col.getValues && typeof col.getValues == "function") {
    return col.getValues();
  }
  if (goog.isString(col)) {
    return col.split("");
  }
  if (goog.isArrayLike(col)) {
    var rv = [];
    var l = col.length;
    for (var i = 0;i < l;i++) {
      rv.push(col[i]);
    }
    return rv;
  }
  return goog.object.getValues(col);
};
goog.structs.getKeys = function(col) {
  if (col.getKeys && typeof col.getKeys == "function") {
    return col.getKeys();
  }
  if (col.getValues && typeof col.getValues == "function") {
    return undefined;
  }
  if (goog.isArrayLike(col) || goog.isString(col)) {
    var rv = [];
    var l = col.length;
    for (var i = 0;i < l;i++) {
      rv.push(i);
    }
    return rv;
  }
  return goog.object.getKeys(col);
};
goog.structs.contains = function(col, val) {
  if (col.contains && typeof col.contains == "function") {
    return col.contains(val);
  }
  if (col.containsValue && typeof col.containsValue == "function") {
    return col.containsValue(val);
  }
  if (goog.isArrayLike(col) || goog.isString(col)) {
    return goog.array.contains((col), val);
  }
  return goog.object.containsValue(col, val);
};
goog.structs.isEmpty = function(col) {
  if (col.isEmpty && typeof col.isEmpty == "function") {
    return col.isEmpty();
  }
  if (goog.isArrayLike(col) || goog.isString(col)) {
    return goog.array.isEmpty((col));
  }
  return goog.object.isEmpty(col);
};
goog.structs.clear = function(col) {
  if (col.clear && typeof col.clear == "function") {
    col.clear();
  } else {
    if (goog.isArrayLike(col)) {
      goog.array.clear((col));
    } else {
      goog.object.clear(col);
    }
  }
};
goog.structs.forEach = function(col, f, opt_obj) {
  if (col.forEach && typeof col.forEach == "function") {
    col.forEach(f, opt_obj);
  } else {
    if (goog.isArrayLike(col) || goog.isString(col)) {
      goog.array.forEach((col), f, opt_obj);
    } else {
      var keys = goog.structs.getKeys(col);
      var values = goog.structs.getValues(col);
      var l = values.length;
      for (var i = 0;i < l;i++) {
        f.call((opt_obj), values[i], keys && keys[i], col);
      }
    }
  }
};
goog.structs.filter = function(col, f, opt_obj) {
  if (typeof col.filter == "function") {
    return col.filter(f, opt_obj);
  }
  if (goog.isArrayLike(col) || goog.isString(col)) {
    return goog.array.filter((col), f, opt_obj);
  }
  var rv;
  var keys = goog.structs.getKeys(col);
  var values = goog.structs.getValues(col);
  var l = values.length;
  if (keys) {
    rv = {};
    for (var i = 0;i < l;i++) {
      if (f.call((opt_obj), values[i], keys[i], col)) {
        rv[keys[i]] = values[i];
      }
    }
  } else {
    rv = [];
    for (var i = 0;i < l;i++) {
      if (f.call(opt_obj, values[i], undefined, col)) {
        rv.push(values[i]);
      }
    }
  }
  return rv;
};
goog.structs.map = function(col, f, opt_obj) {
  if (typeof col.map == "function") {
    return col.map(f, opt_obj);
  }
  if (goog.isArrayLike(col) || goog.isString(col)) {
    return goog.array.map((col), f, opt_obj);
  }
  var rv;
  var keys = goog.structs.getKeys(col);
  var values = goog.structs.getValues(col);
  var l = values.length;
  if (keys) {
    rv = {};
    for (var i = 0;i < l;i++) {
      rv[keys[i]] = f.call((opt_obj), values[i], keys[i], col);
    }
  } else {
    rv = [];
    for (var i = 0;i < l;i++) {
      rv[i] = f.call((opt_obj), values[i], undefined, col);
    }
  }
  return rv;
};
goog.structs.some = function(col, f, opt_obj) {
  if (typeof col.some == "function") {
    return col.some(f, opt_obj);
  }
  if (goog.isArrayLike(col) || goog.isString(col)) {
    return goog.array.some((col), f, opt_obj);
  }
  var keys = goog.structs.getKeys(col);
  var values = goog.structs.getValues(col);
  var l = values.length;
  for (var i = 0;i < l;i++) {
    if (f.call((opt_obj), values[i], keys && keys[i], col)) {
      return true;
    }
  }
  return false;
};
goog.structs.every = function(col, f, opt_obj) {
  if (typeof col.every == "function") {
    return col.every(f, opt_obj);
  }
  if (goog.isArrayLike(col) || goog.isString(col)) {
    return goog.array.every((col), f, opt_obj);
  }
  var keys = goog.structs.getKeys(col);
  var values = goog.structs.getValues(col);
  var l = values.length;
  for (var i = 0;i < l;i++) {
    if (!f.call((opt_obj), values[i], keys && keys[i], col)) {
      return false;
    }
  }
  return true;
};
goog.provide("goog.structs.Collection");
goog.structs.Collection = function() {
};
goog.structs.Collection.prototype.add;
goog.structs.Collection.prototype.remove;
goog.structs.Collection.prototype.contains;
goog.structs.Collection.prototype.getCount;
goog.provide("goog.functions");
goog.functions.constant = function(retValue) {
  return function() {
    return retValue;
  };
};
goog.functions.FALSE = goog.functions.constant(false);
goog.functions.TRUE = goog.functions.constant(true);
goog.functions.NULL = goog.functions.constant(null);
goog.functions.identity = function(opt_returnValue, var_args) {
  return opt_returnValue;
};
goog.functions.error = function(message) {
  return function() {
    throw Error(message);
  };
};
goog.functions.fail = function(err) {
  return function() {
    throw err;
  };
};
goog.functions.lock = function(f, opt_numArgs) {
  opt_numArgs = opt_numArgs || 0;
  return function() {
    return f.apply(this, Array.prototype.slice.call(arguments, 0, opt_numArgs));
  };
};
goog.functions.nth = function(n) {
  return function() {
    return arguments[n];
  };
};
goog.functions.partialRight = function(fn, var_args) {
  var rightArgs = Array.prototype.slice.call(arguments, 1);
  return function() {
    var newArgs = Array.prototype.slice.call(arguments);
    newArgs.push.apply(newArgs, rightArgs);
    return fn.apply(this, newArgs);
  };
};
goog.functions.withReturnValue = function(f, retValue) {
  return goog.functions.sequence(f, goog.functions.constant(retValue));
};
goog.functions.equalTo = function(value, opt_useLooseComparison) {
  return function(other) {
    return opt_useLooseComparison ? value == other : value === other;
  };
};
goog.functions.compose = function(fn, var_args) {
  var functions = arguments;
  var length = functions.length;
  return function() {
    var result;
    if (length) {
      result = functions[length - 1].apply(this, arguments);
    }
    for (var i = length - 2;i >= 0;i--) {
      result = functions[i].call(this, result);
    }
    return result;
  };
};
goog.functions.sequence = function(var_args) {
  var functions = arguments;
  var length = functions.length;
  return function() {
    var result;
    for (var i = 0;i < length;i++) {
      result = functions[i].apply(this, arguments);
    }
    return result;
  };
};
goog.functions.and = function(var_args) {
  var functions = arguments;
  var length = functions.length;
  return function() {
    for (var i = 0;i < length;i++) {
      if (!functions[i].apply(this, arguments)) {
        return false;
      }
    }
    return true;
  };
};
goog.functions.or = function(var_args) {
  var functions = arguments;
  var length = functions.length;
  return function() {
    for (var i = 0;i < length;i++) {
      if (functions[i].apply(this, arguments)) {
        return true;
      }
    }
    return false;
  };
};
goog.functions.not = function(f) {
  return function() {
    return !f.apply(this, arguments);
  };
};
goog.functions.create = function(constructor, var_args) {
  var temp = function() {
  };
  temp.prototype = constructor.prototype;
  var obj = new temp;
  constructor.apply(obj, Array.prototype.slice.call(arguments, 1));
  return obj;
};
goog.define("goog.functions.CACHE_RETURN_VALUE", true);
goog.functions.cacheReturnValue = function(fn) {
  var called = false;
  var value;
  return function() {
    if (!goog.functions.CACHE_RETURN_VALUE) {
      return fn();
    }
    if (!called) {
      value = fn();
      called = true;
    }
    return value;
  };
};
goog.functions.once = function(f) {
  var inner = f;
  return function() {
    if (inner) {
      var tmp = inner;
      inner = null;
      tmp();
    }
  };
};
goog.functions.debounce = function(f, interval, opt_scope) {
  if (opt_scope) {
    f = goog.bind(f, opt_scope);
  }
  var timeout = null;
  return (function(var_args) {
    goog.global.clearTimeout(timeout);
    var args = arguments;
    timeout = goog.global.setTimeout(function() {
      f.apply(null, args);
    }, interval);
  });
};
goog.functions.throttle = function(f, interval, opt_scope) {
  if (opt_scope) {
    f = goog.bind(f, opt_scope);
  }
  var timeout = null;
  var shouldFire = false;
  var args = [];
  var handleTimeout = function() {
    timeout = null;
    if (shouldFire) {
      shouldFire = false;
      fire();
    }
  };
  var fire = function() {
    timeout = goog.global.setTimeout(handleTimeout, interval);
    f.apply(null, args);
  };
  return (function(var_args) {
    args = arguments;
    if (!timeout) {
      fire();
    } else {
      shouldFire = true;
    }
  });
};
goog.provide("goog.math");
goog.require("goog.array");
goog.require("goog.asserts");
goog.math.randomInt = function(a) {
  return Math.floor(Math.random() * a);
};
goog.math.uniformRandom = function(a, b) {
  return a + Math.random() * (b - a);
};
goog.math.clamp = function(value, min, max) {
  return Math.min(Math.max(value, min), max);
};
goog.math.modulo = function(a, b) {
  var r = a % b;
  return r * b < 0 ? r + b : r;
};
goog.math.lerp = function(a, b, x) {
  return a + x * (b - a);
};
goog.math.nearlyEquals = function(a, b, opt_tolerance) {
  return Math.abs(a - b) <= (opt_tolerance || 1E-6);
};
goog.math.standardAngle = function(angle) {
  return goog.math.modulo(angle, 360);
};
goog.math.standardAngleInRadians = function(angle) {
  return goog.math.modulo(angle, 2 * Math.PI);
};
goog.math.toRadians = function(angleDegrees) {
  return angleDegrees * Math.PI / 180;
};
goog.math.toDegrees = function(angleRadians) {
  return angleRadians * 180 / Math.PI;
};
goog.math.angleDx = function(degrees, radius) {
  return radius * Math.cos(goog.math.toRadians(degrees));
};
goog.math.angleDy = function(degrees, radius) {
  return radius * Math.sin(goog.math.toRadians(degrees));
};
goog.math.angle = function(x1, y1, x2, y2) {
  return goog.math.standardAngle(goog.math.toDegrees(Math.atan2(y2 - y1, x2 - x1)));
};
goog.math.angleDifference = function(startAngle, endAngle) {
  var d = goog.math.standardAngle(endAngle) - goog.math.standardAngle(startAngle);
  if (d > 180) {
    d = d - 360;
  } else {
    if (d <= -180) {
      d = 360 + d;
    }
  }
  return d;
};
goog.math.sign = Math.sign || function(x) {
  if (x > 0) {
    return 1;
  }
  if (x < 0) {
    return -1;
  }
  return x;
};
goog.math.longestCommonSubsequence = function(array1, array2, opt_compareFn, opt_collectorFn) {
  var compare = opt_compareFn || function(a, b) {
    return a == b;
  };
  var collect = opt_collectorFn || function(i1, i2) {
    return array1[i1];
  };
  var length1 = array1.length;
  var length2 = array2.length;
  var arr = [];
  for (var i = 0;i < length1 + 1;i++) {
    arr[i] = [];
    arr[i][0] = 0;
  }
  for (var j = 0;j < length2 + 1;j++) {
    arr[0][j] = 0;
  }
  for (i = 1;i <= length1;i++) {
    for (j = 1;j <= length2;j++) {
      if (compare(array1[i - 1], array2[j - 1])) {
        arr[i][j] = arr[i - 1][j - 1] + 1;
      } else {
        arr[i][j] = Math.max(arr[i - 1][j], arr[i][j - 1]);
      }
    }
  }
  var result = [];
  var i = length1, j = length2;
  while (i > 0 && j > 0) {
    if (compare(array1[i - 1], array2[j - 1])) {
      result.unshift(collect(i - 1, j - 1));
      i--;
      j--;
    } else {
      if (arr[i - 1][j] > arr[i][j - 1]) {
        i--;
      } else {
        j--;
      }
    }
  }
  return result;
};
goog.math.sum = function(var_args) {
  return (goog.array.reduce(arguments, function(sum, value) {
    return sum + value;
  }, 0));
};
goog.math.average = function(var_args) {
  return goog.math.sum.apply(null, arguments) / arguments.length;
};
goog.math.sampleVariance = function(var_args) {
  var sampleSize = arguments.length;
  if (sampleSize < 2) {
    return 0;
  }
  var mean = goog.math.average.apply(null, arguments);
  var variance = goog.math.sum.apply(null, goog.array.map(arguments, function(val) {
    return Math.pow(val - mean, 2);
  })) / (sampleSize - 1);
  return variance;
};
goog.math.standardDeviation = function(var_args) {
  return Math.sqrt(goog.math.sampleVariance.apply(null, arguments));
};
goog.math.isInt = function(num) {
  return isFinite(num) && num % 1 == 0;
};
goog.math.isFiniteNumber = function(num) {
  return isFinite(num) && !isNaN(num);
};
goog.math.isNegativeZero = function(num) {
  return num == 0 && 1 / num < 0;
};
goog.math.log10Floor = function(num) {
  if (num > 0) {
    var x = Math.round(Math.log(num) * Math.LOG10E);
    return x - (parseFloat("1e" + x) > num ? 1 : 0);
  }
  return num == 0 ? -Infinity : NaN;
};
goog.math.safeFloor = function(num, opt_epsilon) {
  goog.asserts.assert(!goog.isDef(opt_epsilon) || opt_epsilon > 0);
  return Math.floor(num + (opt_epsilon || 2E-15));
};
goog.math.safeCeil = function(num, opt_epsilon) {
  goog.asserts.assert(!goog.isDef(opt_epsilon) || opt_epsilon > 0);
  return Math.ceil(num - (opt_epsilon || 2E-15));
};
goog.provide("goog.iter");
goog.provide("goog.iter.Iterable");
goog.provide("goog.iter.Iterator");
goog.provide("goog.iter.StopIteration");
goog.require("goog.array");
goog.require("goog.asserts");
goog.require("goog.functions");
goog.require("goog.math");
goog.iter.Iterable;
goog.iter.StopIteration = "StopIteration" in goog.global ? goog.global["StopIteration"] : {message:"StopIteration", stack:""};
goog.iter.Iterator = function() {
};
goog.iter.Iterator.prototype.next = function() {
  throw goog.iter.StopIteration;
};
goog.iter.Iterator.prototype.__iterator__ = function(opt_keys) {
  return this;
};
goog.iter.toIterator = function(iterable) {
  if (iterable instanceof goog.iter.Iterator) {
    return iterable;
  }
  if (typeof iterable.__iterator__ == "function") {
    return iterable.__iterator__(false);
  }
  if (goog.isArrayLike(iterable)) {
    var i = 0;
    var newIter = new goog.iter.Iterator;
    newIter.next = function() {
      while (true) {
        if (i >= iterable.length) {
          throw goog.iter.StopIteration;
        }
        if (!(i in iterable)) {
          i++;
          continue;
        }
        return iterable[i++];
      }
    };
    return newIter;
  }
  throw Error("Not implemented");
};
goog.iter.forEach = function(iterable, f, opt_obj) {
  if (goog.isArrayLike(iterable)) {
    try {
      goog.array.forEach((iterable), f, opt_obj);
    } catch (ex) {
      if (ex !== goog.iter.StopIteration) {
        throw ex;
      }
    }
  } else {
    iterable = goog.iter.toIterator(iterable);
    try {
      while (true) {
        f.call(opt_obj, iterable.next(), undefined, iterable);
      }
    } catch (ex$0) {
      if (ex$0 !== goog.iter.StopIteration) {
        throw ex$0;
      }
    }
  }
};
goog.iter.filter = function(iterable, f, opt_obj) {
  var iterator = goog.iter.toIterator(iterable);
  var newIter = new goog.iter.Iterator;
  newIter.next = function() {
    while (true) {
      var val = iterator.next();
      if (f.call(opt_obj, val, undefined, iterator)) {
        return val;
      }
    }
  };
  return newIter;
};
goog.iter.filterFalse = function(iterable, f, opt_obj) {
  return goog.iter.filter(iterable, goog.functions.not(f), opt_obj);
};
goog.iter.range = function(startOrStop, opt_stop, opt_step) {
  var start = 0;
  var stop = startOrStop;
  var step = opt_step || 1;
  if (arguments.length > 1) {
    start = startOrStop;
    stop = opt_stop;
  }
  if (step == 0) {
    throw Error("Range step argument must not be zero");
  }
  var newIter = new goog.iter.Iterator;
  newIter.next = function() {
    if (step > 0 && start >= stop || step < 0 && start <= stop) {
      throw goog.iter.StopIteration;
    }
    var rv = start;
    start += step;
    return rv;
  };
  return newIter;
};
goog.iter.join = function(iterable, deliminator) {
  return goog.iter.toArray(iterable).join(deliminator);
};
goog.iter.map = function(iterable, f, opt_obj) {
  var iterator = goog.iter.toIterator(iterable);
  var newIter = new goog.iter.Iterator;
  newIter.next = function() {
    var val = iterator.next();
    return f.call(opt_obj, val, undefined, iterator);
  };
  return newIter;
};
goog.iter.reduce = function(iterable, f, val, opt_obj) {
  var rval = val;
  goog.iter.forEach(iterable, function(val) {
    rval = f.call(opt_obj, rval, val);
  });
  return rval;
};
goog.iter.some = function(iterable, f, opt_obj) {
  iterable = goog.iter.toIterator(iterable);
  try {
    while (true) {
      if (f.call(opt_obj, iterable.next(), undefined, iterable)) {
        return true;
      }
    }
  } catch (ex) {
    if (ex !== goog.iter.StopIteration) {
      throw ex;
    }
  }
  return false;
};
goog.iter.every = function(iterable, f, opt_obj) {
  iterable = goog.iter.toIterator(iterable);
  try {
    while (true) {
      if (!f.call(opt_obj, iterable.next(), undefined, iterable)) {
        return false;
      }
    }
  } catch (ex) {
    if (ex !== goog.iter.StopIteration) {
      throw ex;
    }
  }
  return true;
};
goog.iter.chain = function(var_args) {
  return goog.iter.chainFromIterable(arguments);
};
goog.iter.chainFromIterable = function(iterable) {
  var iterator = goog.iter.toIterator(iterable);
  var iter = new goog.iter.Iterator;
  var current = null;
  iter.next = function() {
    while (true) {
      if (current == null) {
        var it = iterator.next();
        current = goog.iter.toIterator(it);
      }
      try {
        return current.next();
      } catch (ex) {
        if (ex !== goog.iter.StopIteration) {
          throw ex;
        }
        current = null;
      }
    }
  };
  return iter;
};
goog.iter.dropWhile = function(iterable, f, opt_obj) {
  var iterator = goog.iter.toIterator(iterable);
  var newIter = new goog.iter.Iterator;
  var dropping = true;
  newIter.next = function() {
    while (true) {
      var val = iterator.next();
      if (dropping && f.call(opt_obj, val, undefined, iterator)) {
        continue;
      } else {
        dropping = false;
      }
      return val;
    }
  };
  return newIter;
};
goog.iter.takeWhile = function(iterable, f, opt_obj) {
  var iterator = goog.iter.toIterator(iterable);
  var iter = new goog.iter.Iterator;
  iter.next = function() {
    var val = iterator.next();
    if (f.call(opt_obj, val, undefined, iterator)) {
      return val;
    }
    throw goog.iter.StopIteration;
  };
  return iter;
};
goog.iter.toArray = function(iterable) {
  if (goog.isArrayLike(iterable)) {
    return goog.array.toArray((iterable));
  }
  iterable = goog.iter.toIterator(iterable);
  var array = [];
  goog.iter.forEach(iterable, function(val) {
    array.push(val);
  });
  return array;
};
goog.iter.equals = function(iterable1, iterable2, opt_equalsFn) {
  var fillValue = {};
  var pairs = goog.iter.zipLongest(fillValue, iterable1, iterable2);
  var equalsFn = opt_equalsFn || goog.array.defaultCompareEquality;
  return goog.iter.every(pairs, function(pair) {
    return equalsFn(pair[0], pair[1]);
  });
};
goog.iter.nextOrValue = function(iterable, defaultValue) {
  try {
    return goog.iter.toIterator(iterable).next();
  } catch (e) {
    if (e != goog.iter.StopIteration) {
      throw e;
    }
    return defaultValue;
  }
};
goog.iter.product = function(var_args) {
  var someArrayEmpty = goog.array.some(arguments, function(arr) {
    return !arr.length;
  });
  if (someArrayEmpty || !arguments.length) {
    return new goog.iter.Iterator;
  }
  var iter = new goog.iter.Iterator;
  var arrays = arguments;
  var indicies = goog.array.repeat(0, arrays.length);
  iter.next = function() {
    if (indicies) {
      var retVal = goog.array.map(indicies, function(valueIndex, arrayIndex) {
        return arrays[arrayIndex][valueIndex];
      });
      for (var i = indicies.length - 1;i >= 0;i--) {
        goog.asserts.assert(indicies);
        if (indicies[i] < arrays[i].length - 1) {
          indicies[i]++;
          break;
        }
        if (i == 0) {
          indicies = null;
          break;
        }
        indicies[i] = 0;
      }
      return retVal;
    }
    throw goog.iter.StopIteration;
  };
  return iter;
};
goog.iter.cycle = function(iterable) {
  var baseIterator = goog.iter.toIterator(iterable);
  var cache = [];
  var cacheIndex = 0;
  var iter = new goog.iter.Iterator;
  var useCache = false;
  iter.next = function() {
    var returnElement = null;
    if (!useCache) {
      try {
        returnElement = baseIterator.next();
        cache.push(returnElement);
        return returnElement;
      } catch (e) {
        if (e != goog.iter.StopIteration || goog.array.isEmpty(cache)) {
          throw e;
        }
        useCache = true;
      }
    }
    returnElement = cache[cacheIndex];
    cacheIndex = (cacheIndex + 1) % cache.length;
    return returnElement;
  };
  return iter;
};
goog.iter.count = function(opt_start, opt_step) {
  var counter = opt_start || 0;
  var step = goog.isDef(opt_step) ? opt_step : 1;
  var iter = new goog.iter.Iterator;
  iter.next = function() {
    var returnValue = counter;
    counter += step;
    return returnValue;
  };
  return iter;
};
goog.iter.repeat = function(value) {
  var iter = new goog.iter.Iterator;
  iter.next = goog.functions.constant(value);
  return iter;
};
goog.iter.accumulate = function(iterable) {
  var iterator = goog.iter.toIterator(iterable);
  var total = 0;
  var iter = new goog.iter.Iterator;
  iter.next = function() {
    total += iterator.next();
    return total;
  };
  return iter;
};
goog.iter.zip = function(var_args) {
  var args = arguments;
  var iter = new goog.iter.Iterator;
  if (args.length > 0) {
    var iterators = goog.array.map(args, goog.iter.toIterator);
    iter.next = function() {
      var arr = goog.array.map(iterators, function(it) {
        return it.next();
      });
      return arr;
    };
  }
  return iter;
};
goog.iter.zipLongest = function(fillValue, var_args) {
  var args = goog.array.slice(arguments, 1);
  var iter = new goog.iter.Iterator;
  if (args.length > 0) {
    var iterators = goog.array.map(args, goog.iter.toIterator);
    iter.next = function() {
      var iteratorsHaveValues = false;
      var arr = goog.array.map(iterators, function(it) {
        var returnValue;
        try {
          returnValue = it.next();
          iteratorsHaveValues = true;
        } catch (ex) {
          if (ex !== goog.iter.StopIteration) {
            throw ex;
          }
          returnValue = fillValue;
        }
        return returnValue;
      });
      if (!iteratorsHaveValues) {
        throw goog.iter.StopIteration;
      }
      return arr;
    };
  }
  return iter;
};
goog.iter.compress = function(iterable, selectors) {
  var selectorIterator = goog.iter.toIterator(selectors);
  return goog.iter.filter(iterable, function() {
    return !!selectorIterator.next();
  });
};
goog.iter.GroupByIterator_ = function(iterable, opt_keyFunc) {
  this.iterator = goog.iter.toIterator(iterable);
  this.keyFunc = opt_keyFunc || goog.functions.identity;
  this.targetKey;
  this.currentKey;
  this.currentValue;
};
goog.inherits(goog.iter.GroupByIterator_, goog.iter.Iterator);
goog.iter.GroupByIterator_.prototype.next = function() {
  while (this.currentKey == this.targetKey) {
    this.currentValue = this.iterator.next();
    this.currentKey = this.keyFunc(this.currentValue);
  }
  this.targetKey = this.currentKey;
  return [this.currentKey, this.groupItems_(this.targetKey)];
};
goog.iter.GroupByIterator_.prototype.groupItems_ = function(targetKey) {
  var arr = [];
  while (this.currentKey == targetKey) {
    arr.push(this.currentValue);
    try {
      this.currentValue = this.iterator.next();
    } catch (ex) {
      if (ex !== goog.iter.StopIteration) {
        throw ex;
      }
      break;
    }
    this.currentKey = this.keyFunc(this.currentValue);
  }
  return arr;
};
goog.iter.groupBy = function(iterable, opt_keyFunc) {
  return new goog.iter.GroupByIterator_(iterable, opt_keyFunc);
};
goog.iter.starMap = function(iterable, f, opt_obj) {
  var iterator = goog.iter.toIterator(iterable);
  var iter = new goog.iter.Iterator;
  iter.next = function() {
    var args = goog.iter.toArray(iterator.next());
    return f.apply(opt_obj, goog.array.concat(args, undefined, iterator));
  };
  return iter;
};
goog.iter.tee = function(iterable, opt_num) {
  var iterator = goog.iter.toIterator(iterable);
  var num = goog.isNumber(opt_num) ? opt_num : 2;
  var buffers = goog.array.map(goog.array.range(num), function() {
    return [];
  });
  var addNextIteratorValueToBuffers = function() {
    var val = iterator.next();
    goog.array.forEach(buffers, function(buffer) {
      buffer.push(val);
    });
  };
  var createIterator = function(buffer) {
    var iter = new goog.iter.Iterator;
    iter.next = function() {
      if (goog.array.isEmpty(buffer)) {
        addNextIteratorValueToBuffers();
      }
      goog.asserts.assert(!goog.array.isEmpty(buffer));
      return buffer.shift();
    };
    return iter;
  };
  return goog.array.map(buffers, createIterator);
};
goog.iter.enumerate = function(iterable, opt_start) {
  return goog.iter.zip(goog.iter.count(opt_start), iterable);
};
goog.iter.limit = function(iterable, limitSize) {
  goog.asserts.assert(goog.math.isInt(limitSize) && limitSize >= 0);
  var iterator = goog.iter.toIterator(iterable);
  var iter = new goog.iter.Iterator;
  var remaining = limitSize;
  iter.next = function() {
    if (remaining-- > 0) {
      return iterator.next();
    }
    throw goog.iter.StopIteration;
  };
  return iter;
};
goog.iter.consume = function(iterable, count) {
  goog.asserts.assert(goog.math.isInt(count) && count >= 0);
  var iterator = goog.iter.toIterator(iterable);
  while (count-- > 0) {
    goog.iter.nextOrValue(iterator, null);
  }
  return iterator;
};
goog.iter.slice = function(iterable, start, opt_end) {
  goog.asserts.assert(goog.math.isInt(start) && start >= 0);
  var iterator = goog.iter.consume(iterable, start);
  if (goog.isNumber(opt_end)) {
    goog.asserts.assert(goog.math.isInt(opt_end) && opt_end >= start);
    iterator = goog.iter.limit(iterator, opt_end - start);
  }
  return iterator;
};
goog.iter.hasDuplicates_ = function(arr) {
  var deduped = [];
  goog.array.removeDuplicates(arr, deduped);
  return arr.length != deduped.length;
};
goog.iter.permutations = function(iterable, opt_length) {
  var elements = goog.iter.toArray(iterable);
  var length = goog.isNumber(opt_length) ? opt_length : elements.length;
  var sets = goog.array.repeat(elements, length);
  var product = goog.iter.product.apply(undefined, sets);
  return goog.iter.filter(product, function(arr) {
    return !goog.iter.hasDuplicates_(arr);
  });
};
goog.iter.combinations = function(iterable, length) {
  var elements = goog.iter.toArray(iterable);
  var indexes = goog.iter.range(elements.length);
  var indexIterator = goog.iter.permutations(indexes, length);
  var sortedIndexIterator = goog.iter.filter(indexIterator, function(arr) {
    return goog.array.isSorted(arr);
  });
  var iter = new goog.iter.Iterator;
  function getIndexFromElements(index) {
    return elements[index];
  }
  iter.next = function() {
    return goog.array.map(sortedIndexIterator.next(), getIndexFromElements);
  };
  return iter;
};
goog.iter.combinationsWithReplacement = function(iterable, length) {
  var elements = goog.iter.toArray(iterable);
  var indexes = goog.array.range(elements.length);
  var sets = goog.array.repeat(indexes, length);
  var indexIterator = goog.iter.product.apply(undefined, sets);
  var sortedIndexIterator = goog.iter.filter(indexIterator, function(arr) {
    return goog.array.isSorted(arr);
  });
  var iter = new goog.iter.Iterator;
  function getIndexFromElements(index) {
    return elements[index];
  }
  iter.next = function() {
    return goog.array.map((sortedIndexIterator.next()), getIndexFromElements);
  };
  return iter;
};
goog.provide("goog.structs.Map");
goog.require("goog.iter.Iterator");
goog.require("goog.iter.StopIteration");
goog.require("goog.object");
goog.structs.Map = function(opt_map, var_args) {
  this.map_ = {};
  this.keys_ = [];
  this.count_ = 0;
  this.version_ = 0;
  var argLength = arguments.length;
  if (argLength > 1) {
    if (argLength % 2) {
      throw Error("Uneven number of arguments");
    }
    for (var i = 0;i < argLength;i += 2) {
      this.set(arguments[i], arguments[i + 1]);
    }
  } else {
    if (opt_map) {
      this.addAll((opt_map));
    }
  }
};
goog.structs.Map.prototype.getCount = function() {
  return this.count_;
};
goog.structs.Map.prototype.getValues = function() {
  this.cleanupKeysArray_();
  var rv = [];
  for (var i = 0;i < this.keys_.length;i++) {
    var key = this.keys_[i];
    rv.push(this.map_[key]);
  }
  return rv;
};
goog.structs.Map.prototype.getKeys = function() {
  this.cleanupKeysArray_();
  return (this.keys_.concat());
};
goog.structs.Map.prototype.containsKey = function(key) {
  return goog.structs.Map.hasKey_(this.map_, key);
};
goog.structs.Map.prototype.containsValue = function(val) {
  for (var i = 0;i < this.keys_.length;i++) {
    var key = this.keys_[i];
    if (goog.structs.Map.hasKey_(this.map_, key) && this.map_[key] == val) {
      return true;
    }
  }
  return false;
};
goog.structs.Map.prototype.equals = function(otherMap, opt_equalityFn) {
  if (this === otherMap) {
    return true;
  }
  if (this.count_ != otherMap.getCount()) {
    return false;
  }
  var equalityFn = opt_equalityFn || goog.structs.Map.defaultEquals;
  this.cleanupKeysArray_();
  for (var key, i = 0;key = this.keys_[i];i++) {
    if (!equalityFn(this.get(key), otherMap.get(key))) {
      return false;
    }
  }
  return true;
};
goog.structs.Map.defaultEquals = function(a, b) {
  return a === b;
};
goog.structs.Map.prototype.isEmpty = function() {
  return this.count_ == 0;
};
goog.structs.Map.prototype.clear = function() {
  this.map_ = {};
  this.keys_.length = 0;
  this.count_ = 0;
  this.version_ = 0;
};
goog.structs.Map.prototype.remove = function(key) {
  if (goog.structs.Map.hasKey_(this.map_, key)) {
    delete this.map_[key];
    this.count_--;
    this.version_++;
    if (this.keys_.length > 2 * this.count_) {
      this.cleanupKeysArray_();
    }
    return true;
  }
  return false;
};
goog.structs.Map.prototype.cleanupKeysArray_ = function() {
  if (this.count_ != this.keys_.length) {
    var srcIndex = 0;
    var destIndex = 0;
    while (srcIndex < this.keys_.length) {
      var key = this.keys_[srcIndex];
      if (goog.structs.Map.hasKey_(this.map_, key)) {
        this.keys_[destIndex++] = key;
      }
      srcIndex++;
    }
    this.keys_.length = destIndex;
  }
  if (this.count_ != this.keys_.length) {
    var seen = {};
    var srcIndex = 0;
    var destIndex = 0;
    while (srcIndex < this.keys_.length) {
      var key = this.keys_[srcIndex];
      if (!goog.structs.Map.hasKey_(seen, key)) {
        this.keys_[destIndex++] = key;
        seen[key] = 1;
      }
      srcIndex++;
    }
    this.keys_.length = destIndex;
  }
};
goog.structs.Map.prototype.get = function(key, opt_val) {
  if (goog.structs.Map.hasKey_(this.map_, key)) {
    return this.map_[key];
  }
  return opt_val;
};
goog.structs.Map.prototype.set = function(key, value) {
  if (!goog.structs.Map.hasKey_(this.map_, key)) {
    this.count_++;
    this.keys_.push((key));
    this.version_++;
  }
  this.map_[key] = value;
};
goog.structs.Map.prototype.addAll = function(map) {
  var keys, values;
  if (map instanceof goog.structs.Map) {
    keys = map.getKeys();
    values = map.getValues();
  } else {
    keys = goog.object.getKeys(map);
    values = goog.object.getValues(map);
  }
  for (var i = 0;i < keys.length;i++) {
    this.set(keys[i], values[i]);
  }
};
goog.structs.Map.prototype.forEach = function(f, opt_obj) {
  var keys = this.getKeys();
  for (var i = 0;i < keys.length;i++) {
    var key = keys[i];
    var value = this.get(key);
    f.call(opt_obj, value, key, this);
  }
};
goog.structs.Map.prototype.clone = function() {
  return new goog.structs.Map(this);
};
goog.structs.Map.prototype.transpose = function() {
  var transposed = new goog.structs.Map;
  for (var i = 0;i < this.keys_.length;i++) {
    var key = this.keys_[i];
    var value = this.map_[key];
    transposed.set(value, key);
  }
  return transposed;
};
goog.structs.Map.prototype.toObject = function() {
  this.cleanupKeysArray_();
  var obj = {};
  for (var i = 0;i < this.keys_.length;i++) {
    var key = this.keys_[i];
    obj[key] = this.map_[key];
  }
  return obj;
};
goog.structs.Map.prototype.getKeyIterator = function() {
  return this.__iterator__(true);
};
goog.structs.Map.prototype.getValueIterator = function() {
  return this.__iterator__(false);
};
goog.structs.Map.prototype.__iterator__ = function(opt_keys) {
  this.cleanupKeysArray_();
  var i = 0;
  var version = this.version_;
  var selfObj = this;
  var newIter = new goog.iter.Iterator;
  newIter.next = function() {
    if (version != selfObj.version_) {
      throw Error("The map has changed since the iterator was created");
    }
    if (i >= selfObj.keys_.length) {
      throw goog.iter.StopIteration;
    }
    var key = selfObj.keys_[i++];
    return opt_keys ? key : selfObj.map_[key];
  };
  return newIter;
};
goog.structs.Map.hasKey_ = function(obj, key) {
  return Object.prototype.hasOwnProperty.call(obj, key);
};
goog.provide("goog.structs.Set");
goog.require("goog.structs");
goog.require("goog.structs.Collection");
goog.require("goog.structs.Map");
goog.structs.Set = function(opt_values) {
  this.map_ = new goog.structs.Map;
  if (opt_values) {
    this.addAll(opt_values);
  }
};
goog.structs.Set.getKey_ = function(val) {
  var type = typeof val;
  if (type == "object" && val || type == "function") {
    return "o" + goog.getUid((val));
  } else {
    return type.substr(0, 1) + val;
  }
};
goog.structs.Set.prototype.getCount = function() {
  return this.map_.getCount();
};
goog.structs.Set.prototype.add = function(element) {
  this.map_.set(goog.structs.Set.getKey_(element), element);
};
goog.structs.Set.prototype.addAll = function(col) {
  var values = goog.structs.getValues(col);
  var l = values.length;
  for (var i = 0;i < l;i++) {
    this.add(values[i]);
  }
};
goog.structs.Set.prototype.removeAll = function(col) {
  var values = goog.structs.getValues(col);
  var l = values.length;
  for (var i = 0;i < l;i++) {
    this.remove(values[i]);
  }
};
goog.structs.Set.prototype.remove = function(element) {
  return this.map_.remove(goog.structs.Set.getKey_(element));
};
goog.structs.Set.prototype.clear = function() {
  this.map_.clear();
};
goog.structs.Set.prototype.isEmpty = function() {
  return this.map_.isEmpty();
};
goog.structs.Set.prototype.contains = function(element) {
  return this.map_.containsKey(goog.structs.Set.getKey_(element));
};
goog.structs.Set.prototype.containsAll = function(col) {
  return goog.structs.every(col, this.contains, this);
};
goog.structs.Set.prototype.intersection = function(col) {
  var result = new goog.structs.Set;
  var values = goog.structs.getValues(col);
  for (var i = 0;i < values.length;i++) {
    var value = values[i];
    if (this.contains(value)) {
      result.add(value);
    }
  }
  return result;
};
goog.structs.Set.prototype.difference = function(col) {
  var result = this.clone();
  result.removeAll(col);
  return result;
};
goog.structs.Set.prototype.getValues = function() {
  return this.map_.getValues();
};
goog.structs.Set.prototype.clone = function() {
  return new goog.structs.Set(this);
};
goog.structs.Set.prototype.equals = function(col) {
  return this.getCount() == goog.structs.getCount(col) && this.isSubsetOf(col);
};
goog.structs.Set.prototype.isSubsetOf = function(col) {
  var colCount = goog.structs.getCount(col);
  if (this.getCount() > colCount) {
    return false;
  }
  if (!(col instanceof goog.structs.Set) && colCount > 5) {
    col = new goog.structs.Set(col);
  }
  return goog.structs.every(this, function(value) {
    return goog.structs.contains(col, value);
  });
};
goog.structs.Set.prototype.__iterator__ = function(opt_keys) {
  return this.map_.__iterator__(false);
};
goog.provide("goog.labs.userAgent.engine");
goog.require("goog.array");
goog.require("goog.labs.userAgent.util");
goog.require("goog.string");
goog.labs.userAgent.engine.isPresto = function() {
  return goog.labs.userAgent.util.matchUserAgent("Presto");
};
goog.labs.userAgent.engine.isTrident = function() {
  return goog.labs.userAgent.util.matchUserAgent("Trident") || goog.labs.userAgent.util.matchUserAgent("MSIE");
};
goog.labs.userAgent.engine.isEdge = function() {
  return goog.labs.userAgent.util.matchUserAgent("Edge");
};
goog.labs.userAgent.engine.isWebKit = function() {
  return goog.labs.userAgent.util.matchUserAgentIgnoreCase("WebKit") && !goog.labs.userAgent.engine.isEdge();
};
goog.labs.userAgent.engine.isGecko = function() {
  return goog.labs.userAgent.util.matchUserAgent("Gecko") && !goog.labs.userAgent.engine.isWebKit() && !goog.labs.userAgent.engine.isTrident() && !goog.labs.userAgent.engine.isEdge();
};
goog.labs.userAgent.engine.getVersion = function() {
  var userAgentString = goog.labs.userAgent.util.getUserAgent();
  if (userAgentString) {
    var tuples = goog.labs.userAgent.util.extractVersionTuples(userAgentString);
    var engineTuple = goog.labs.userAgent.engine.getEngineTuple_(tuples);
    if (engineTuple) {
      if (engineTuple[0] == "Gecko") {
        return goog.labs.userAgent.engine.getVersionForKey_(tuples, "Firefox");
      }
      return engineTuple[1];
    }
    var browserTuple = tuples[0];
    var info;
    if (browserTuple && (info = browserTuple[2])) {
      var match = /Trident\/([^\s;]+)/.exec(info);
      if (match) {
        return match[1];
      }
    }
  }
  return "";
};
goog.labs.userAgent.engine.getEngineTuple_ = function(tuples) {
  if (!goog.labs.userAgent.engine.isEdge()) {
    return tuples[1];
  }
  for (var i = 0;i < tuples.length;i++) {
    var tuple = tuples[i];
    if (tuple[0] == "Edge") {
      return tuple;
    }
  }
};
goog.labs.userAgent.engine.isVersionOrHigher = function(version) {
  return goog.string.compareVersions(goog.labs.userAgent.engine.getVersion(), version) >= 0;
};
goog.labs.userAgent.engine.getVersionForKey_ = function(tuples, key) {
  var pair = goog.array.find(tuples, function(pair) {
    return key == pair[0];
  });
  return pair && pair[1] || "";
};
goog.provide("goog.labs.userAgent.platform");
goog.require("goog.labs.userAgent.util");
goog.require("goog.string");
goog.labs.userAgent.platform.isAndroid = function() {
  return goog.labs.userAgent.util.matchUserAgent("Android");
};
goog.labs.userAgent.platform.isIpod = function() {
  return goog.labs.userAgent.util.matchUserAgent("iPod");
};
goog.labs.userAgent.platform.isIphone = function() {
  return goog.labs.userAgent.util.matchUserAgent("iPhone") && !goog.labs.userAgent.util.matchUserAgent("iPod") && !goog.labs.userAgent.util.matchUserAgent("iPad");
};
goog.labs.userAgent.platform.isIpad = function() {
  return goog.labs.userAgent.util.matchUserAgent("iPad");
};
goog.labs.userAgent.platform.isIos = function() {
  return goog.labs.userAgent.platform.isIphone() || goog.labs.userAgent.platform.isIpad() || goog.labs.userAgent.platform.isIpod();
};
goog.labs.userAgent.platform.isMacintosh = function() {
  return goog.labs.userAgent.util.matchUserAgent("Macintosh");
};
goog.labs.userAgent.platform.isLinux = function() {
  return goog.labs.userAgent.util.matchUserAgent("Linux");
};
goog.labs.userAgent.platform.isWindows = function() {
  return goog.labs.userAgent.util.matchUserAgent("Windows");
};
goog.labs.userAgent.platform.isChromeOS = function() {
  return goog.labs.userAgent.util.matchUserAgent("CrOS");
};
goog.labs.userAgent.platform.getVersion = function() {
  var userAgentString = goog.labs.userAgent.util.getUserAgent();
  var version = "", re;
  if (goog.labs.userAgent.platform.isWindows()) {
    re = /Windows (?:NT|Phone) ([0-9.]+)/;
    var match = re.exec(userAgentString);
    if (match) {
      version = match[1];
    } else {
      version = "0.0";
    }
  } else {
    if (goog.labs.userAgent.platform.isIos()) {
      re = /(?:iPhone|iPod|iPad|CPU)\s+OS\s+(\S+)/;
      var match = re.exec(userAgentString);
      version = match && match[1].replace(/_/g, ".");
    } else {
      if (goog.labs.userAgent.platform.isMacintosh()) {
        re = /Mac OS X ([0-9_.]+)/;
        var match = re.exec(userAgentString);
        version = match ? match[1].replace(/_/g, ".") : "10";
      } else {
        if (goog.labs.userAgent.platform.isAndroid()) {
          re = /Android\s+([^\);]+)(\)|;)/;
          var match = re.exec(userAgentString);
          version = match && match[1];
        } else {
          if (goog.labs.userAgent.platform.isChromeOS()) {
            re = /(?:CrOS\s+(?:i686|x86_64)\s+([0-9.]+))/;
            var match = re.exec(userAgentString);
            version = match && match[1];
          }
        }
      }
    }
  }
  return version || "";
};
goog.labs.userAgent.platform.isVersionOrHigher = function(version) {
  return goog.string.compareVersions(goog.labs.userAgent.platform.getVersion(), version) >= 0;
};
goog.provide("goog.userAgent");
goog.require("goog.labs.userAgent.browser");
goog.require("goog.labs.userAgent.engine");
goog.require("goog.labs.userAgent.platform");
goog.require("goog.labs.userAgent.util");
goog.require("goog.string");
goog.define("goog.userAgent.ASSUME_IE", false);
goog.define("goog.userAgent.ASSUME_EDGE", false);
goog.define("goog.userAgent.ASSUME_GECKO", false);
goog.define("goog.userAgent.ASSUME_WEBKIT", false);
goog.define("goog.userAgent.ASSUME_MOBILE_WEBKIT", false);
goog.define("goog.userAgent.ASSUME_OPERA", false);
goog.define("goog.userAgent.ASSUME_ANY_VERSION", false);
goog.userAgent.BROWSER_KNOWN_ = goog.userAgent.ASSUME_IE || goog.userAgent.ASSUME_EDGE || goog.userAgent.ASSUME_GECKO || goog.userAgent.ASSUME_MOBILE_WEBKIT || goog.userAgent.ASSUME_WEBKIT || goog.userAgent.ASSUME_OPERA;
goog.userAgent.getUserAgentString = function() {
  return goog.labs.userAgent.util.getUserAgent();
};
goog.userAgent.getNavigator = function() {
  return goog.global["navigator"] || null;
};
goog.userAgent.OPERA = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_OPERA : goog.labs.userAgent.browser.isOpera();
goog.userAgent.IE = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_IE : goog.labs.userAgent.browser.isIE();
goog.userAgent.EDGE = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_EDGE : goog.labs.userAgent.engine.isEdge();
goog.userAgent.EDGE_OR_IE = goog.userAgent.EDGE || goog.userAgent.IE;
goog.userAgent.GECKO = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_GECKO : goog.labs.userAgent.engine.isGecko();
goog.userAgent.WEBKIT = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_WEBKIT || goog.userAgent.ASSUME_MOBILE_WEBKIT : goog.labs.userAgent.engine.isWebKit();
goog.userAgent.isMobile_ = function() {
  return goog.userAgent.WEBKIT && goog.labs.userAgent.util.matchUserAgent("Mobile");
};
goog.userAgent.MOBILE = goog.userAgent.ASSUME_MOBILE_WEBKIT || goog.userAgent.isMobile_();
goog.userAgent.SAFARI = goog.userAgent.WEBKIT;
goog.userAgent.determinePlatform_ = function() {
  var navigator = goog.userAgent.getNavigator();
  return navigator && navigator.platform || "";
};
goog.userAgent.PLATFORM = goog.userAgent.determinePlatform_();
goog.define("goog.userAgent.ASSUME_MAC", false);
goog.define("goog.userAgent.ASSUME_WINDOWS", false);
goog.define("goog.userAgent.ASSUME_LINUX", false);
goog.define("goog.userAgent.ASSUME_X11", false);
goog.define("goog.userAgent.ASSUME_ANDROID", false);
goog.define("goog.userAgent.ASSUME_IPHONE", false);
goog.define("goog.userAgent.ASSUME_IPAD", false);
goog.define("goog.userAgent.ASSUME_IPOD", false);
goog.userAgent.PLATFORM_KNOWN_ = goog.userAgent.ASSUME_MAC || goog.userAgent.ASSUME_WINDOWS || goog.userAgent.ASSUME_LINUX || goog.userAgent.ASSUME_X11 || goog.userAgent.ASSUME_ANDROID || goog.userAgent.ASSUME_IPHONE || goog.userAgent.ASSUME_IPAD || goog.userAgent.ASSUME_IPOD;
goog.userAgent.MAC = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_MAC : goog.labs.userAgent.platform.isMacintosh();
goog.userAgent.WINDOWS = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_WINDOWS : goog.labs.userAgent.platform.isWindows();
goog.userAgent.isLegacyLinux_ = function() {
  return goog.labs.userAgent.platform.isLinux() || goog.labs.userAgent.platform.isChromeOS();
};
goog.userAgent.LINUX = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_LINUX : goog.userAgent.isLegacyLinux_();
goog.userAgent.isX11_ = function() {
  var navigator = goog.userAgent.getNavigator();
  return !!navigator && goog.string.contains(navigator["appVersion"] || "", "X11");
};
goog.userAgent.X11 = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_X11 : goog.userAgent.isX11_();
goog.userAgent.ANDROID = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_ANDROID : goog.labs.userAgent.platform.isAndroid();
goog.userAgent.IPHONE = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPHONE : goog.labs.userAgent.platform.isIphone();
goog.userAgent.IPAD = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPAD : goog.labs.userAgent.platform.isIpad();
goog.userAgent.IPOD = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPOD : goog.labs.userAgent.platform.isIpod();
goog.userAgent.determineVersion_ = function() {
  var version = "";
  var arr = goog.userAgent.getVersionRegexResult_();
  if (arr) {
    version = arr ? arr[1] : "";
  }
  if (goog.userAgent.IE) {
    var docMode = goog.userAgent.getDocumentMode_();
    if (docMode != null && docMode > parseFloat(version)) {
      return String(docMode);
    }
  }
  return version;
};
goog.userAgent.getVersionRegexResult_ = function() {
  var userAgent = goog.userAgent.getUserAgentString();
  if (goog.userAgent.GECKO) {
    return /rv\:([^\);]+)(\)|;)/.exec(userAgent);
  }
  if (goog.userAgent.EDGE) {
    return /Edge\/([\d\.]+)/.exec(userAgent);
  }
  if (goog.userAgent.IE) {
    return /\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/.exec(userAgent);
  }
  if (goog.userAgent.WEBKIT) {
    return /WebKit\/(\S+)/.exec(userAgent);
  }
  if (goog.userAgent.OPERA) {
    return /(?:Version)[ \/]?(\S+)/.exec(userAgent);
  }
  return undefined;
};
goog.userAgent.getDocumentMode_ = function() {
  var doc = goog.global["document"];
  return doc ? doc["documentMode"] : undefined;
};
goog.userAgent.VERSION = goog.userAgent.determineVersion_();
goog.userAgent.compare = function(v1, v2) {
  return goog.string.compareVersions(v1, v2);
};
goog.userAgent.isVersionOrHigherCache_ = {};
goog.userAgent.isVersionOrHigher = function(version) {
  return goog.userAgent.ASSUME_ANY_VERSION || goog.userAgent.isVersionOrHigherCache_[version] || (goog.userAgent.isVersionOrHigherCache_[version] = goog.string.compareVersions(goog.userAgent.VERSION, version) >= 0);
};
goog.userAgent.isVersion = goog.userAgent.isVersionOrHigher;
goog.userAgent.isDocumentModeOrHigher = function(documentMode) {
  return Number(goog.userAgent.DOCUMENT_MODE) >= documentMode;
};
goog.userAgent.isDocumentMode = goog.userAgent.isDocumentModeOrHigher;
goog.userAgent.DOCUMENT_MODE = function() {
  var doc = goog.global["document"];
  var mode = goog.userAgent.getDocumentMode_();
  if (!doc || !goog.userAgent.IE) {
    return undefined;
  }
  return mode || (doc["compatMode"] == "CSS1Compat" ? parseInt(goog.userAgent.VERSION, 10) : 5);
}();
goog.provide("goog.debug");
goog.require("goog.array");
goog.require("goog.html.SafeHtml");
goog.require("goog.html.SafeUrl");
goog.require("goog.html.uncheckedconversions");
goog.require("goog.string.Const");
goog.require("goog.structs.Set");
goog.require("goog.userAgent");
goog.define("goog.debug.LOGGING_ENABLED", goog.DEBUG);
goog.define("goog.debug.FORCE_SLOPPY_STACKS", false);
goog.debug.catchErrors = function(logFunc, opt_cancel, opt_target) {
  var target = opt_target || goog.global;
  var oldErrorHandler = target.onerror;
  var retVal = !!opt_cancel;
  if (goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher("535.3")) {
    retVal = !retVal;
  }
  target.onerror = function(message, url, line, opt_col, opt_error) {
    if (oldErrorHandler) {
      oldErrorHandler(message, url, line, opt_col, opt_error);
    }
    logFunc({message:message, fileName:url, line:line, col:opt_col, error:opt_error});
    return retVal;
  };
};
goog.debug.expose = function(obj, opt_showFn) {
  if (typeof obj == "undefined") {
    return "undefined";
  }
  if (obj == null) {
    return "NULL";
  }
  var str = [];
  for (var x in obj) {
    if (!opt_showFn && goog.isFunction(obj[x])) {
      continue;
    }
    var s = x + " = ";
    try {
      s += obj[x];
    } catch (e) {
      s += "*** " + e + " ***";
    }
    str.push(s);
  }
  return str.join("\n");
};
goog.debug.deepExpose = function(obj, opt_showFn) {
  var str = [];
  var helper = function(obj, space, parentSeen) {
    var nestspace = space + "  ";
    var seen = new goog.structs.Set(parentSeen);
    var indentMultiline = function(str) {
      return str.replace(/\n/g, "\n" + space);
    };
    try {
      if (!goog.isDef(obj)) {
        str.push("undefined");
      } else {
        if (goog.isNull(obj)) {
          str.push("NULL");
        } else {
          if (goog.isString(obj)) {
            str.push('"' + indentMultiline(obj) + '"');
          } else {
            if (goog.isFunction(obj)) {
              str.push(indentMultiline(String(obj)));
            } else {
              if (goog.isObject(obj)) {
                if (seen.contains(obj)) {
                  str.push("*** reference loop detected ***");
                } else {
                  seen.add(obj);
                  str.push("{");
                  for (var x in obj) {
                    if (!opt_showFn && goog.isFunction(obj[x])) {
                      continue;
                    }
                    str.push("\n");
                    str.push(nestspace);
                    str.push(x + " = ");
                    helper(obj[x], nestspace, seen);
                  }
                  str.push("\n" + space + "}");
                }
              } else {
                str.push(obj);
              }
            }
          }
        }
      }
    } catch (e) {
      str.push("*** " + e + " ***");
    }
  };
  helper(obj, "", new goog.structs.Set);
  return str.join("");
};
goog.debug.exposeArray = function(arr) {
  var str = [];
  for (var i = 0;i < arr.length;i++) {
    if (goog.isArray(arr[i])) {
      str.push(goog.debug.exposeArray(arr[i]));
    } else {
      str.push(arr[i]);
    }
  }
  return "[ " + str.join(", ") + " ]";
};
goog.debug.exposeException = function(err, opt_fn) {
  var html = goog.debug.exposeExceptionAsHtml(err, opt_fn);
  return goog.html.SafeHtml.unwrap(html);
};
goog.debug.exposeExceptionAsHtml = function(err, opt_fn) {
  try {
    var e = goog.debug.normalizeErrorObject(err);
    var viewSourceUrl = goog.debug.createViewSourceUrl_(e.fileName);
    var error = goog.html.SafeHtml.concat(goog.html.SafeHtml.htmlEscapePreservingNewlinesAndSpaces("Message: " + e.message + "\nUrl: "), goog.html.SafeHtml.create("a", {href:viewSourceUrl, target:"_new"}, e.fileName), goog.html.SafeHtml.htmlEscapePreservingNewlinesAndSpaces("\nLine: " + e.lineNumber + "\n\nBrowser stack:\n" + e.stack + "-> " + "[end]\n\nJS stack traversal:\n" + goog.debug.getStacktrace(opt_fn) + "-> "));
    return error;
  } catch (e2) {
    return goog.html.SafeHtml.htmlEscapePreservingNewlinesAndSpaces("Exception trying to expose exception! You win, we lose. " + e2);
  }
};
goog.debug.createViewSourceUrl_ = function(opt_fileName) {
  if (!goog.isDefAndNotNull(opt_fileName)) {
    opt_fileName = "";
  }
  if (!/^https?:\/\//i.test(opt_fileName)) {
    return goog.html.SafeUrl.fromConstant(goog.string.Const.from("sanitizedviewsrc"));
  }
  var sanitizedFileName = goog.html.SafeUrl.sanitize(opt_fileName);
  return goog.html.uncheckedconversions.safeUrlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("view-source scheme plus HTTP/HTTPS URL"), "view-source:" + goog.html.SafeUrl.unwrap(sanitizedFileName));
};
goog.debug.normalizeErrorObject = function(err) {
  var href = goog.getObjectByName("window.location.href");
  if (goog.isString(err)) {
    return {"message":err, "name":"Unknown error", "lineNumber":"Not available", "fileName":href, "stack":"Not available"};
  }
  var lineNumber, fileName;
  var threwError = false;
  try {
    lineNumber = err.lineNumber || err.line || "Not available";
  } catch (e) {
    lineNumber = "Not available";
    threwError = true;
  }
  try {
    fileName = err.fileName || err.filename || err.sourceURL || goog.global["$googDebugFname"] || href;
  } catch (e$1) {
    fileName = "Not available";
    threwError = true;
  }
  if (threwError || !err.lineNumber || !err.fileName || !err.stack || !err.message || !err.name) {
    return {"message":err.message || "Not available", "name":err.name || "UnknownError", "lineNumber":lineNumber, "fileName":fileName, "stack":err.stack || "Not available"};
  }
  return (err);
};
goog.debug.enhanceError = function(err, opt_message) {
  var error;
  if (typeof err == "string") {
    error = Error(err);
    if (Error.captureStackTrace) {
      Error.captureStackTrace(error, goog.debug.enhanceError);
    }
  } else {
    error = err;
  }
  if (!error.stack) {
    error.stack = goog.debug.getStacktrace(goog.debug.enhanceError);
  }
  if (opt_message) {
    var x = 0;
    while (error["message" + x]) {
      ++x;
    }
    error["message" + x] = String(opt_message);
  }
  return error;
};
goog.debug.getStacktraceSimple = function(opt_depth) {
  if (!goog.debug.FORCE_SLOPPY_STACKS) {
    var stack = goog.debug.getNativeStackTrace_(goog.debug.getStacktraceSimple);
    if (stack) {
      return stack;
    }
  }
  var sb = [];
  var fn = arguments.callee.caller;
  var depth = 0;
  while (fn && (!opt_depth || depth < opt_depth)) {
    sb.push(goog.debug.getFunctionName(fn));
    sb.push("()\n");
    try {
      fn = fn.caller;
    } catch (e) {
      sb.push("[exception trying to get caller]\n");
      break;
    }
    depth++;
    if (depth >= goog.debug.MAX_STACK_DEPTH) {
      sb.push("[...long stack...]");
      break;
    }
  }
  if (opt_depth && depth >= opt_depth) {
    sb.push("[...reached max depth limit...]");
  } else {
    sb.push("[end]");
  }
  return sb.join("");
};
goog.debug.MAX_STACK_DEPTH = 50;
goog.debug.getNativeStackTrace_ = function(fn) {
  var tempErr = new Error;
  if (Error.captureStackTrace) {
    Error.captureStackTrace(tempErr, fn);
    return String(tempErr.stack);
  } else {
    try {
      throw tempErr;
    } catch (e) {
      tempErr = e;
    }
    var stack = tempErr.stack;
    if (stack) {
      return String(stack);
    }
  }
  return null;
};
goog.debug.getStacktrace = function(opt_fn) {
  var stack;
  if (!goog.debug.FORCE_SLOPPY_STACKS) {
    var contextFn = opt_fn || goog.debug.getStacktrace;
    stack = goog.debug.getNativeStackTrace_(contextFn);
  }
  if (!stack) {
    stack = goog.debug.getStacktraceHelper_(opt_fn || arguments.callee.caller, []);
  }
  return stack;
};
goog.debug.getStacktraceHelper_ = function(fn, visited) {
  var sb = [];
  if (goog.array.contains(visited, fn)) {
    sb.push("[...circular reference...]");
  } else {
    if (fn && visited.length < goog.debug.MAX_STACK_DEPTH) {
      sb.push(goog.debug.getFunctionName(fn) + "(");
      var args = fn.arguments;
      for (var i = 0;args && i < args.length;i++) {
        if (i > 0) {
          sb.push(", ");
        }
        var argDesc;
        var arg = args[i];
        switch(typeof arg) {
          case "object":
            argDesc = arg ? "object" : "null";
            break;
          case "string":
            argDesc = arg;
            break;
          case "number":
            argDesc = String(arg);
            break;
          case "boolean":
            argDesc = arg ? "true" : "false";
            break;
          case "function":
            argDesc = goog.debug.getFunctionName(arg);
            argDesc = argDesc ? argDesc : "[fn]";
            break;
          case "undefined":
          ;
          default:
            argDesc = typeof arg;
            break;
        }
        if (argDesc.length > 40) {
          argDesc = argDesc.substr(0, 40) + "...";
        }
        sb.push(argDesc);
      }
      visited.push(fn);
      sb.push(")\n");
      try {
        sb.push(goog.debug.getStacktraceHelper_(fn.caller, visited));
      } catch (e) {
        sb.push("[exception trying to get caller]\n");
      }
    } else {
      if (fn) {
        sb.push("[...long stack...]");
      } else {
        sb.push("[end]");
      }
    }
  }
  return sb.join("");
};
goog.debug.setFunctionResolver = function(resolver) {
  goog.debug.fnNameResolver_ = resolver;
};
goog.debug.getFunctionName = function(fn) {
  if (goog.debug.fnNameCache_[fn]) {
    return goog.debug.fnNameCache_[fn];
  }
  if (goog.debug.fnNameResolver_) {
    var name = goog.debug.fnNameResolver_(fn);
    if (name) {
      goog.debug.fnNameCache_[fn] = name;
      return name;
    }
  }
  var functionSource = String(fn);
  if (!goog.debug.fnNameCache_[functionSource]) {
    var matches = /function ([^\(]+)/.exec(functionSource);
    if (matches) {
      var method = matches[1];
      goog.debug.fnNameCache_[functionSource] = method;
    } else {
      goog.debug.fnNameCache_[functionSource] = "[Anonymous]";
    }
  }
  return goog.debug.fnNameCache_[functionSource];
};
goog.debug.makeWhitespaceVisible = function(string) {
  return string.replace(/ /g, "[_]").replace(/\f/g, "[f]").replace(/\n/g, "[n]\n").replace(/\r/g, "[r]").replace(/\t/g, "[t]");
};
goog.debug.runtimeType = function(value) {
  if (value instanceof Function) {
    return value.displayName || value.name || "unknown type name";
  } else {
    if (value instanceof Object) {
      return value.constructor.displayName || value.constructor.name || Object.prototype.toString.call(value);
    } else {
      return value === null ? "null" : typeof value;
    }
  }
};
goog.debug.fnNameCache_ = {};
goog.debug.fnNameResolver_;
goog.provide("goog.debug.LogRecord");
goog.debug.LogRecord = function(level, msg, loggerName, opt_time, opt_sequenceNumber) {
  this.reset(level, msg, loggerName, opt_time, opt_sequenceNumber);
};
goog.debug.LogRecord.prototype.time_;
goog.debug.LogRecord.prototype.level_;
goog.debug.LogRecord.prototype.msg_;
goog.debug.LogRecord.prototype.loggerName_;
goog.debug.LogRecord.prototype.sequenceNumber_ = 0;
goog.debug.LogRecord.prototype.exception_ = null;
goog.define("goog.debug.LogRecord.ENABLE_SEQUENCE_NUMBERS", true);
goog.debug.LogRecord.nextSequenceNumber_ = 0;
goog.debug.LogRecord.prototype.reset = function(level, msg, loggerName, opt_time, opt_sequenceNumber) {
  if (goog.debug.LogRecord.ENABLE_SEQUENCE_NUMBERS) {
    this.sequenceNumber_ = typeof opt_sequenceNumber == "number" ? opt_sequenceNumber : goog.debug.LogRecord.nextSequenceNumber_++;
  }
  this.time_ = opt_time || goog.now();
  this.level_ = level;
  this.msg_ = msg;
  this.loggerName_ = loggerName;
  delete this.exception_;
};
goog.debug.LogRecord.prototype.getLoggerName = function() {
  return this.loggerName_;
};
goog.debug.LogRecord.prototype.getException = function() {
  return this.exception_;
};
goog.debug.LogRecord.prototype.setException = function(exception) {
  this.exception_ = exception;
};
goog.debug.LogRecord.prototype.setLoggerName = function(loggerName) {
  this.loggerName_ = loggerName;
};
goog.debug.LogRecord.prototype.getLevel = function() {
  return this.level_;
};
goog.debug.LogRecord.prototype.setLevel = function(level) {
  this.level_ = level;
};
goog.debug.LogRecord.prototype.getMessage = function() {
  return this.msg_;
};
goog.debug.LogRecord.prototype.setMessage = function(msg) {
  this.msg_ = msg;
};
goog.debug.LogRecord.prototype.getMillis = function() {
  return this.time_;
};
goog.debug.LogRecord.prototype.setMillis = function(time) {
  this.time_ = time;
};
goog.debug.LogRecord.prototype.getSequenceNumber = function() {
  return this.sequenceNumber_;
};
goog.provide("goog.debug.LogBuffer");
goog.require("goog.asserts");
goog.require("goog.debug.LogRecord");
goog.debug.LogBuffer = function() {
  goog.asserts.assert(goog.debug.LogBuffer.isBufferingEnabled(), "Cannot use goog.debug.LogBuffer without defining " + "goog.debug.LogBuffer.CAPACITY.");
  this.clear();
};
goog.debug.LogBuffer.getInstance = function() {
  if (!goog.debug.LogBuffer.instance_) {
    goog.debug.LogBuffer.instance_ = new goog.debug.LogBuffer;
  }
  return goog.debug.LogBuffer.instance_;
};
goog.define("goog.debug.LogBuffer.CAPACITY", 0);
goog.debug.LogBuffer.prototype.buffer_;
goog.debug.LogBuffer.prototype.curIndex_;
goog.debug.LogBuffer.prototype.isFull_;
goog.debug.LogBuffer.prototype.addRecord = function(level, msg, loggerName) {
  var curIndex = (this.curIndex_ + 1) % goog.debug.LogBuffer.CAPACITY;
  this.curIndex_ = curIndex;
  if (this.isFull_) {
    var ret = this.buffer_[curIndex];
    ret.reset(level, msg, loggerName);
    return ret;
  }
  this.isFull_ = curIndex == goog.debug.LogBuffer.CAPACITY - 1;
  return this.buffer_[curIndex] = new goog.debug.LogRecord(level, msg, loggerName);
};
goog.debug.LogBuffer.isBufferingEnabled = function() {
  return goog.debug.LogBuffer.CAPACITY > 0;
};
goog.debug.LogBuffer.prototype.clear = function() {
  this.buffer_ = new Array(goog.debug.LogBuffer.CAPACITY);
  this.curIndex_ = -1;
  this.isFull_ = false;
};
goog.debug.LogBuffer.prototype.forEachRecord = function(func) {
  var buffer = this.buffer_;
  if (!buffer[0]) {
    return;
  }
  var curIndex = this.curIndex_;
  var i = this.isFull_ ? curIndex : -1;
  do {
    i = (i + 1) % goog.debug.LogBuffer.CAPACITY;
    func((buffer[i]));
  } while (i != curIndex);
};
goog.provide("goog.debug.LogManager");
goog.provide("goog.debug.Loggable");
goog.provide("goog.debug.Logger");
goog.provide("goog.debug.Logger.Level");
goog.require("goog.array");
goog.require("goog.asserts");
goog.require("goog.debug");
goog.require("goog.debug.LogBuffer");
goog.require("goog.debug.LogRecord");
goog.debug.Loggable;
goog.debug.Logger = function(name) {
  this.name_ = name;
  this.parent_ = null;
  this.level_ = null;
  this.children_ = null;
  this.handlers_ = null;
};
goog.debug.Logger.ROOT_LOGGER_NAME = "";
goog.define("goog.debug.Logger.ENABLE_HIERARCHY", true);
if (!goog.debug.Logger.ENABLE_HIERARCHY) {
  goog.debug.Logger.rootHandlers_ = [];
  goog.debug.Logger.rootLevel_;
}
goog.debug.Logger.Level = function(name, value) {
  this.name = name;
  this.value = value;
};
goog.debug.Logger.Level.prototype.toString = function() {
  return this.name;
};
goog.debug.Logger.Level.OFF = new goog.debug.Logger.Level("OFF", Infinity);
goog.debug.Logger.Level.SHOUT = new goog.debug.Logger.Level("SHOUT", 1200);
goog.debug.Logger.Level.SEVERE = new goog.debug.Logger.Level("SEVERE", 1E3);
goog.debug.Logger.Level.WARNING = new goog.debug.Logger.Level("WARNING", 900);
goog.debug.Logger.Level.INFO = new goog.debug.Logger.Level("INFO", 800);
goog.debug.Logger.Level.CONFIG = new goog.debug.Logger.Level("CONFIG", 700);
goog.debug.Logger.Level.FINE = new goog.debug.Logger.Level("FINE", 500);
goog.debug.Logger.Level.FINER = new goog.debug.Logger.Level("FINER", 400);
goog.debug.Logger.Level.FINEST = new goog.debug.Logger.Level("FINEST", 300);
goog.debug.Logger.Level.ALL = new goog.debug.Logger.Level("ALL", 0);
goog.debug.Logger.Level.PREDEFINED_LEVELS = [goog.debug.Logger.Level.OFF, goog.debug.Logger.Level.SHOUT, goog.debug.Logger.Level.SEVERE, goog.debug.Logger.Level.WARNING, goog.debug.Logger.Level.INFO, goog.debug.Logger.Level.CONFIG, goog.debug.Logger.Level.FINE, goog.debug.Logger.Level.FINER, goog.debug.Logger.Level.FINEST, goog.debug.Logger.Level.ALL];
goog.debug.Logger.Level.predefinedLevelsCache_ = null;
goog.debug.Logger.Level.createPredefinedLevelsCache_ = function() {
  goog.debug.Logger.Level.predefinedLevelsCache_ = {};
  for (var i = 0, level;level = goog.debug.Logger.Level.PREDEFINED_LEVELS[i];i++) {
    goog.debug.Logger.Level.predefinedLevelsCache_[level.value] = level;
    goog.debug.Logger.Level.predefinedLevelsCache_[level.name] = level;
  }
};
goog.debug.Logger.Level.getPredefinedLevel = function(name) {
  if (!goog.debug.Logger.Level.predefinedLevelsCache_) {
    goog.debug.Logger.Level.createPredefinedLevelsCache_();
  }
  return goog.debug.Logger.Level.predefinedLevelsCache_[name] || null;
};
goog.debug.Logger.Level.getPredefinedLevelByValue = function(value) {
  if (!goog.debug.Logger.Level.predefinedLevelsCache_) {
    goog.debug.Logger.Level.createPredefinedLevelsCache_();
  }
  if (value in (goog.debug.Logger.Level.predefinedLevelsCache_)) {
    return goog.debug.Logger.Level.predefinedLevelsCache_[value];
  }
  for (var i = 0;i < goog.debug.Logger.Level.PREDEFINED_LEVELS.length;++i) {
    var level = goog.debug.Logger.Level.PREDEFINED_LEVELS[i];
    if (level.value <= value) {
      return level;
    }
  }
  return null;
};
goog.debug.Logger.getLogger = function(name) {
  return goog.debug.LogManager.getLogger(name);
};
goog.debug.Logger.logToProfilers = function(msg) {
  if (goog.global["console"]) {
    if (goog.global["console"]["timeStamp"]) {
      goog.global["console"]["timeStamp"](msg);
    } else {
      if (goog.global["console"]["markTimeline"]) {
        goog.global["console"]["markTimeline"](msg);
      }
    }
  }
  if (goog.global["msWriteProfilerMark"]) {
    goog.global["msWriteProfilerMark"](msg);
  }
};
goog.debug.Logger.prototype.getName = function() {
  return this.name_;
};
goog.debug.Logger.prototype.addHandler = function(handler) {
  if (goog.debug.LOGGING_ENABLED) {
    if (goog.debug.Logger.ENABLE_HIERARCHY) {
      if (!this.handlers_) {
        this.handlers_ = [];
      }
      this.handlers_.push(handler);
    } else {
      goog.asserts.assert(!this.name_, "Cannot call addHandler on a non-root logger when " + "goog.debug.Logger.ENABLE_HIERARCHY is false.");
      goog.debug.Logger.rootHandlers_.push(handler);
    }
  }
};
goog.debug.Logger.prototype.removeHandler = function(handler) {
  if (goog.debug.LOGGING_ENABLED) {
    var handlers = goog.debug.Logger.ENABLE_HIERARCHY ? this.handlers_ : goog.debug.Logger.rootHandlers_;
    return !!handlers && goog.array.remove(handlers, handler);
  } else {
    return false;
  }
};
goog.debug.Logger.prototype.getParent = function() {
  return this.parent_;
};
goog.debug.Logger.prototype.getChildren = function() {
  if (!this.children_) {
    this.children_ = {};
  }
  return this.children_;
};
goog.debug.Logger.prototype.setLevel = function(level) {
  if (goog.debug.LOGGING_ENABLED) {
    if (goog.debug.Logger.ENABLE_HIERARCHY) {
      this.level_ = level;
    } else {
      goog.asserts.assert(!this.name_, "Cannot call setLevel() on a non-root logger when " + "goog.debug.Logger.ENABLE_HIERARCHY is false.");
      goog.debug.Logger.rootLevel_ = level;
    }
  }
};
goog.debug.Logger.prototype.getLevel = function() {
  return goog.debug.LOGGING_ENABLED ? this.level_ : goog.debug.Logger.Level.OFF;
};
goog.debug.Logger.prototype.getEffectiveLevel = function() {
  if (!goog.debug.LOGGING_ENABLED) {
    return goog.debug.Logger.Level.OFF;
  }
  if (!goog.debug.Logger.ENABLE_HIERARCHY) {
    return goog.debug.Logger.rootLevel_;
  }
  if (this.level_) {
    return this.level_;
  }
  if (this.parent_) {
    return this.parent_.getEffectiveLevel();
  }
  goog.asserts.fail("Root logger has no level set.");
  return null;
};
goog.debug.Logger.prototype.isLoggable = function(level) {
  return goog.debug.LOGGING_ENABLED && level.value >= this.getEffectiveLevel().value;
};
goog.debug.Logger.prototype.log = function(level, msg, opt_exception) {
  if (goog.debug.LOGGING_ENABLED && this.isLoggable(level)) {
    if (goog.isFunction(msg)) {
      msg = msg();
    }
    this.doLogRecord_(this.getLogRecord(level, msg, opt_exception));
  }
};
goog.debug.Logger.prototype.getLogRecord = function(level, msg, opt_exception) {
  if (goog.debug.LogBuffer.isBufferingEnabled()) {
    var logRecord = goog.debug.LogBuffer.getInstance().addRecord(level, msg, this.name_)
  } else {
    logRecord = new goog.debug.LogRecord(level, String(msg), this.name_);
  }
  if (opt_exception) {
    logRecord.setException(opt_exception);
  }
  return logRecord;
};
goog.debug.Logger.prototype.shout = function(msg, opt_exception) {
  if (goog.debug.LOGGING_ENABLED) {
    this.log(goog.debug.Logger.Level.SHOUT, msg, opt_exception);
  }
};
goog.debug.Logger.prototype.severe = function(msg, opt_exception) {
  if (goog.debug.LOGGING_ENABLED) {
    this.log(goog.debug.Logger.Level.SEVERE, msg, opt_exception);
  }
};
goog.debug.Logger.prototype.warning = function(msg, opt_exception) {
  if (goog.debug.LOGGING_ENABLED) {
    this.log(goog.debug.Logger.Level.WARNING, msg, opt_exception);
  }
};
goog.debug.Logger.prototype.info = function(msg, opt_exception) {
  if (goog.debug.LOGGING_ENABLED) {
    this.log(goog.debug.Logger.Level.INFO, msg, opt_exception);
  }
};
goog.debug.Logger.prototype.config = function(msg, opt_exception) {
  if (goog.debug.LOGGING_ENABLED) {
    this.log(goog.debug.Logger.Level.CONFIG, msg, opt_exception);
  }
};
goog.debug.Logger.prototype.fine = function(msg, opt_exception) {
  if (goog.debug.LOGGING_ENABLED) {
    this.log(goog.debug.Logger.Level.FINE, msg, opt_exception);
  }
};
goog.debug.Logger.prototype.finer = function(msg, opt_exception) {
  if (goog.debug.LOGGING_ENABLED) {
    this.log(goog.debug.Logger.Level.FINER, msg, opt_exception);
  }
};
goog.debug.Logger.prototype.finest = function(msg, opt_exception) {
  if (goog.debug.LOGGING_ENABLED) {
    this.log(goog.debug.Logger.Level.FINEST, msg, opt_exception);
  }
};
goog.debug.Logger.prototype.logRecord = function(logRecord) {
  if (goog.debug.LOGGING_ENABLED && this.isLoggable(logRecord.getLevel())) {
    this.doLogRecord_(logRecord);
  }
};
goog.debug.Logger.prototype.doLogRecord_ = function(logRecord) {
  goog.debug.Logger.logToProfilers("log:" + logRecord.getMessage());
  if (goog.debug.Logger.ENABLE_HIERARCHY) {
    var target = this;
    while (target) {
      target.callPublish_(logRecord);
      target = target.getParent();
    }
  } else {
    for (var i = 0, handler;handler = goog.debug.Logger.rootHandlers_[i++];) {
      handler(logRecord);
    }
  }
};
goog.debug.Logger.prototype.callPublish_ = function(logRecord) {
  if (this.handlers_) {
    for (var i = 0, handler;handler = this.handlers_[i];i++) {
      handler(logRecord);
    }
  }
};
goog.debug.Logger.prototype.setParent_ = function(parent) {
  this.parent_ = parent;
};
goog.debug.Logger.prototype.addChild_ = function(name, logger) {
  this.getChildren()[name] = logger;
};
goog.debug.LogManager = {};
goog.debug.LogManager.loggers_ = {};
goog.debug.LogManager.rootLogger_ = null;
goog.debug.LogManager.initialize = function() {
  if (!goog.debug.LogManager.rootLogger_) {
    goog.debug.LogManager.rootLogger_ = new goog.debug.Logger(goog.debug.Logger.ROOT_LOGGER_NAME);
    goog.debug.LogManager.loggers_[goog.debug.Logger.ROOT_LOGGER_NAME] = goog.debug.LogManager.rootLogger_;
    goog.debug.LogManager.rootLogger_.setLevel(goog.debug.Logger.Level.CONFIG);
  }
};
goog.debug.LogManager.getLoggers = function() {
  return goog.debug.LogManager.loggers_;
};
goog.debug.LogManager.getRoot = function() {
  goog.debug.LogManager.initialize();
  return (goog.debug.LogManager.rootLogger_);
};
goog.debug.LogManager.getLogger = function(name) {
  goog.debug.LogManager.initialize();
  var ret = goog.debug.LogManager.loggers_[name];
  return ret || goog.debug.LogManager.createLogger_(name);
};
goog.debug.LogManager.createFunctionForCatchErrors = function(opt_logger) {
  return function(info) {
    var logger = opt_logger || goog.debug.LogManager.getRoot();
    logger.severe("Error: " + info.message + " (" + info.fileName + " @ Line: " + info.line + ")");
  };
};
goog.debug.LogManager.createLogger_ = function(name) {
  var logger = new goog.debug.Logger(name);
  if (goog.debug.Logger.ENABLE_HIERARCHY) {
    var lastDotIndex = name.lastIndexOf(".");
    var parentName = name.substr(0, lastDotIndex);
    var leafName = name.substr(lastDotIndex + 1);
    var parentLogger = goog.debug.LogManager.getLogger(parentName);
    parentLogger.addChild_(leafName, logger);
    logger.setParent_(parentLogger);
  }
  goog.debug.LogManager.loggers_[name] = logger;
  return logger;
};
goog.provide("goog.editor.Command");
goog.editor.Command = {UNDO:"+undo", REDO:"+redo", LINK:"+link", FORMAT_BLOCK:"+formatBlock", INDENT:"+indent", OUTDENT:"+outdent", REMOVE_FORMAT:"+removeFormat", STRIKE_THROUGH:"+strikeThrough", HORIZONTAL_RULE:"+insertHorizontalRule", SUBSCRIPT:"+subscript", SUPERSCRIPT:"+superscript", UNDERLINE:"+underline", BOLD:"+bold", ITALIC:"+italic", FONT_SIZE:"+fontSize", FONT_FACE:"+fontName", FONT_COLOR:"+foreColor", EMOTICON:"+emoticon", EQUATION:"+equation", BACKGROUND_COLOR:"+backColor", ORDERED_LIST:"+insertOrderedList", 
UNORDERED_LIST:"+insertUnorderedList", TABLE:"+table", JUSTIFY_CENTER:"+justifyCenter", JUSTIFY_FULL:"+justifyFull", JUSTIFY_RIGHT:"+justifyRight", JUSTIFY_LEFT:"+justifyLeft", BLOCKQUOTE:"+BLOCKQUOTE", DIR_LTR:"ltr", DIR_RTL:"rtl", IMAGE:"image", EDIT_HTML:"editHtml", UPDATE_LINK_BUBBLE:"updateLinkBubble", DEFAULT_TAG:"+defaultTag", CLEAR_LOREM:"clearlorem", UPDATE_LOREM:"updatelorem", USING_LOREM:"usinglorem", MODAL_LINK_EDITOR:"link"};
goog.provide("goog.debug.EntryPointMonitor");
goog.provide("goog.debug.entryPointRegistry");
goog.require("goog.asserts");
goog.debug.EntryPointMonitor = function() {
};
goog.debug.EntryPointMonitor.prototype.wrap;
goog.debug.EntryPointMonitor.prototype.unwrap;
goog.debug.entryPointRegistry.refList_ = [];
goog.debug.entryPointRegistry.monitors_ = [];
goog.debug.entryPointRegistry.monitorsMayExist_ = false;
goog.debug.entryPointRegistry.register = function(callback) {
  goog.debug.entryPointRegistry.refList_[goog.debug.entryPointRegistry.refList_.length] = callback;
  if (goog.debug.entryPointRegistry.monitorsMayExist_) {
    var monitors = goog.debug.entryPointRegistry.monitors_;
    for (var i = 0;i < monitors.length;i++) {
      callback(goog.bind(monitors[i].wrap, monitors[i]));
    }
  }
};
goog.debug.entryPointRegistry.monitorAll = function(monitor) {
  goog.debug.entryPointRegistry.monitorsMayExist_ = true;
  var transformer = goog.bind(monitor.wrap, monitor);
  for (var i = 0;i < goog.debug.entryPointRegistry.refList_.length;i++) {
    goog.debug.entryPointRegistry.refList_[i](transformer);
  }
  goog.debug.entryPointRegistry.monitors_.push(monitor);
};
goog.debug.entryPointRegistry.unmonitorAllIfPossible = function(monitor) {
  var monitors = goog.debug.entryPointRegistry.monitors_;
  goog.asserts.assert(monitor == monitors[monitors.length - 1], "Only the most recent monitor can be unwrapped.");
  var transformer = goog.bind(monitor.unwrap, monitor);
  for (var i = 0;i < goog.debug.entryPointRegistry.refList_.length;i++) {
    goog.debug.entryPointRegistry.refList_[i](transformer);
  }
  monitors.length--;
};
goog.provide("goog.events.BrowserFeature");
goog.require("goog.userAgent");
goog.events.BrowserFeature = {HAS_W3C_BUTTON:!goog.userAgent.IE || goog.userAgent.isDocumentModeOrHigher(9), HAS_W3C_EVENT_SUPPORT:!goog.userAgent.IE || goog.userAgent.isDocumentModeOrHigher(9), SET_KEY_CODE_TO_PREVENT_DEFAULT:goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("9"), HAS_NAVIGATOR_ONLINE_PROPERTY:!goog.userAgent.WEBKIT || goog.userAgent.isVersionOrHigher("528"), HAS_HTML5_NETWORK_EVENT_SUPPORT:goog.userAgent.GECKO && goog.userAgent.isVersionOrHigher("1.9b") || goog.userAgent.IE && 
goog.userAgent.isVersionOrHigher("8") || goog.userAgent.OPERA && goog.userAgent.isVersionOrHigher("9.5") || goog.userAgent.WEBKIT && goog.userAgent.isVersionOrHigher("528"), HTML5_NETWORK_EVENTS_FIRE_ON_BODY:goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher("8") || goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("9"), TOUCH_ENABLED:"ontouchstart" in goog.global || !!(goog.global["document"] && document.documentElement && "ontouchstart" in document.documentElement) || !!(goog.global["navigator"] && 
goog.global["navigator"]["msMaxTouchPoints"])};
goog.provide("goog.disposable.IDisposable");
goog.disposable.IDisposable = function() {
};
goog.disposable.IDisposable.prototype.dispose = goog.abstractMethod;
goog.disposable.IDisposable.prototype.isDisposed = goog.abstractMethod;
goog.provide("goog.Disposable");
goog.provide("goog.dispose");
goog.provide("goog.disposeAll");
goog.require("goog.disposable.IDisposable");
goog.Disposable = function() {
  if (goog.Disposable.MONITORING_MODE != goog.Disposable.MonitoringMode.OFF) {
    if (goog.Disposable.INCLUDE_STACK_ON_CREATION) {
      this.creationStack = (new Error).stack;
    }
    goog.Disposable.instances_[goog.getUid(this)] = this;
  }
  this.disposed_ = this.disposed_;
  this.onDisposeCallbacks_ = this.onDisposeCallbacks_;
};
goog.Disposable.MonitoringMode = {OFF:0, PERMANENT:1, INTERACTIVE:2};
goog.define("goog.Disposable.MONITORING_MODE", 0);
goog.define("goog.Disposable.INCLUDE_STACK_ON_CREATION", true);
goog.Disposable.instances_ = {};
goog.Disposable.getUndisposedObjects = function() {
  var ret = [];
  for (var id in goog.Disposable.instances_) {
    if (goog.Disposable.instances_.hasOwnProperty(id)) {
      ret.push(goog.Disposable.instances_[Number(id)]);
    }
  }
  return ret;
};
goog.Disposable.clearUndisposedObjects = function() {
  goog.Disposable.instances_ = {};
};
goog.Disposable.prototype.disposed_ = false;
goog.Disposable.prototype.onDisposeCallbacks_;
goog.Disposable.prototype.creationStack;
goog.Disposable.prototype.isDisposed = function() {
  return this.disposed_;
};
goog.Disposable.prototype.getDisposed = goog.Disposable.prototype.isDisposed;
goog.Disposable.prototype.dispose = function() {
  if (!this.disposed_) {
    this.disposed_ = true;
    this.disposeInternal();
    if (goog.Disposable.MONITORING_MODE != goog.Disposable.MonitoringMode.OFF) {
      var uid = goog.getUid(this);
      if (goog.Disposable.MONITORING_MODE == goog.Disposable.MonitoringMode.PERMANENT && !goog.Disposable.instances_.hasOwnProperty(uid)) {
        throw Error(this + " did not call the goog.Disposable base " + "constructor or was disposed of after a clearUndisposedObjects " + "call");
      }
      delete goog.Disposable.instances_[uid];
    }
  }
};
goog.Disposable.prototype.registerDisposable = function(disposable) {
  this.addOnDisposeCallback(goog.partial(goog.dispose, disposable));
};
goog.Disposable.prototype.addOnDisposeCallback = function(callback, opt_scope) {
  if (this.disposed_) {
    goog.isDef(opt_scope) ? callback.call(opt_scope) : callback();
    return;
  }
  if (!this.onDisposeCallbacks_) {
    this.onDisposeCallbacks_ = [];
  }
  this.onDisposeCallbacks_.push(goog.isDef(opt_scope) ? goog.bind(callback, opt_scope) : callback);
};
goog.Disposable.prototype.disposeInternal = function() {
  if (this.onDisposeCallbacks_) {
    while (this.onDisposeCallbacks_.length) {
      this.onDisposeCallbacks_.shift()();
    }
  }
};
goog.Disposable.isDisposed = function(obj) {
  if (obj && typeof obj.isDisposed == "function") {
    return obj.isDisposed();
  }
  return false;
};
goog.dispose = function(obj) {
  if (obj && typeof obj.dispose == "function") {
    obj.dispose();
  }
};
goog.disposeAll = function(var_args) {
  for (var i = 0, len = arguments.length;i < len;++i) {
    var disposable = arguments[i];
    if (goog.isArrayLike(disposable)) {
      goog.disposeAll.apply(null, disposable);
    } else {
      goog.dispose(disposable);
    }
  }
};
goog.provide("goog.events.EventId");
goog.events.EventId = function(eventId) {
  this.id = eventId;
};
goog.events.EventId.prototype.toString = function() {
  return this.id;
};
goog.provide("goog.events.Event");
goog.provide("goog.events.EventLike");
goog.require("goog.Disposable");
goog.require("goog.events.EventId");
goog.events.EventLike;
goog.events.Event = function(type, opt_target) {
  this.type = type instanceof goog.events.EventId ? String(type) : type;
  this.target = opt_target;
  this.currentTarget = this.target;
  this.propagationStopped_ = false;
  this.defaultPrevented = false;
  this.returnValue_ = true;
};
goog.events.Event.prototype.stopPropagation = function() {
  this.propagationStopped_ = true;
};
goog.events.Event.prototype.preventDefault = function() {
  this.defaultPrevented = true;
  this.returnValue_ = false;
};
goog.events.Event.stopPropagation = function(e) {
  e.stopPropagation();
};
goog.events.Event.preventDefault = function(e) {
  e.preventDefault();
};
goog.provide("goog.events.EventType");
goog.require("goog.userAgent");
goog.events.getVendorPrefixedName_ = function(eventName) {
  return goog.userAgent.WEBKIT ? "webkit" + eventName : goog.userAgent.OPERA ? "o" + eventName.toLowerCase() : eventName.toLowerCase();
};
goog.events.EventType = {CLICK:"click", RIGHTCLICK:"rightclick", DBLCLICK:"dblclick", MOUSEDOWN:"mousedown", MOUSEUP:"mouseup", MOUSEOVER:"mouseover", MOUSEOUT:"mouseout", MOUSEMOVE:"mousemove", MOUSEENTER:"mouseenter", MOUSELEAVE:"mouseleave", SELECTSTART:"selectstart", WHEEL:"wheel", KEYPRESS:"keypress", KEYDOWN:"keydown", KEYUP:"keyup", BLUR:"blur", FOCUS:"focus", DEACTIVATE:"deactivate", FOCUSIN:goog.userAgent.IE ? "focusin" : "DOMFocusIn", FOCUSOUT:goog.userAgent.IE ? "focusout" : "DOMFocusOut", 
CHANGE:"change", RESET:"reset", SELECT:"select", SUBMIT:"submit", INPUT:"input", PROPERTYCHANGE:"propertychange", DRAGSTART:"dragstart", DRAG:"drag", DRAGENTER:"dragenter", DRAGOVER:"dragover", DRAGLEAVE:"dragleave", DROP:"drop", DRAGEND:"dragend", TOUCHSTART:"touchstart", TOUCHMOVE:"touchmove", TOUCHEND:"touchend", TOUCHCANCEL:"touchcancel", BEFOREUNLOAD:"beforeunload", CONSOLEMESSAGE:"consolemessage", CONTEXTMENU:"contextmenu", DOMCONTENTLOADED:"DOMContentLoaded", ERROR:"error", HELP:"help", LOAD:"load", 
LOSECAPTURE:"losecapture", ORIENTATIONCHANGE:"orientationchange", READYSTATECHANGE:"readystatechange", RESIZE:"resize", SCROLL:"scroll", UNLOAD:"unload", CANPLAY:"canplay", CANPLAYTHROUGH:"canplaythrough", DURATIONCHANGE:"durationchange", EMPTIED:"emptied", ENDED:"ended", LOADEDDATA:"loadeddata", LOADEDMETADATA:"loadedmetadata", PAUSE:"pause", PLAY:"play", PLAYING:"playing", RATECHANGE:"ratechange", SEEKED:"seeked", SEEKING:"seeking", STALLED:"stalled", SUSPEND:"suspend", TIMEUPDATE:"timeupdate", 
VOLUMECHANGE:"volumechange", WAITING:"waiting", HASHCHANGE:"hashchange", PAGEHIDE:"pagehide", PAGESHOW:"pageshow", POPSTATE:"popstate", COPY:"copy", PASTE:"paste", CUT:"cut", BEFORECOPY:"beforecopy", BEFORECUT:"beforecut", BEFOREPASTE:"beforepaste", ONLINE:"online", OFFLINE:"offline", MESSAGE:"message", CONNECT:"connect", ANIMATIONSTART:goog.events.getVendorPrefixedName_("AnimationStart"), ANIMATIONEND:goog.events.getVendorPrefixedName_("AnimationEnd"), ANIMATIONITERATION:goog.events.getVendorPrefixedName_("AnimationIteration"), 
TRANSITIONEND:goog.events.getVendorPrefixedName_("TransitionEnd"), POINTERDOWN:"pointerdown", POINTERUP:"pointerup", POINTERCANCEL:"pointercancel", POINTERMOVE:"pointermove", POINTEROVER:"pointerover", POINTEROUT:"pointerout", POINTERENTER:"pointerenter", POINTERLEAVE:"pointerleave", GOTPOINTERCAPTURE:"gotpointercapture", LOSTPOINTERCAPTURE:"lostpointercapture", MSGESTURECHANGE:"MSGestureChange", MSGESTUREEND:"MSGestureEnd", MSGESTUREHOLD:"MSGestureHold", MSGESTURESTART:"MSGestureStart", MSGESTURETAP:"MSGestureTap", 
MSGOTPOINTERCAPTURE:"MSGotPointerCapture", MSINERTIASTART:"MSInertiaStart", MSLOSTPOINTERCAPTURE:"MSLostPointerCapture", MSPOINTERCANCEL:"MSPointerCancel", MSPOINTERDOWN:"MSPointerDown", MSPOINTERENTER:"MSPointerEnter", MSPOINTERHOVER:"MSPointerHover", MSPOINTERLEAVE:"MSPointerLeave", MSPOINTERMOVE:"MSPointerMove", MSPOINTEROUT:"MSPointerOut", MSPOINTEROVER:"MSPointerOver", MSPOINTERUP:"MSPointerUp", TEXT:"text", TEXTINPUT:"textInput", COMPOSITIONSTART:"compositionstart", COMPOSITIONUPDATE:"compositionupdate", 
COMPOSITIONEND:"compositionend", EXIT:"exit", LOADABORT:"loadabort", LOADCOMMIT:"loadcommit", LOADREDIRECT:"loadredirect", LOADSTART:"loadstart", LOADSTOP:"loadstop", RESPONSIVE:"responsive", SIZECHANGED:"sizechanged", UNRESPONSIVE:"unresponsive", VISIBILITYCHANGE:"visibilitychange", STORAGE:"storage", DOMSUBTREEMODIFIED:"DOMSubtreeModified", DOMNODEINSERTED:"DOMNodeInserted", DOMNODEREMOVED:"DOMNodeRemoved", DOMNODEREMOVEDFROMDOCUMENT:"DOMNodeRemovedFromDocument", DOMNODEINSERTEDINTODOCUMENT:"DOMNodeInsertedIntoDocument", 
DOMATTRMODIFIED:"DOMAttrModified", DOMCHARACTERDATAMODIFIED:"DOMCharacterDataModified", BEFOREPRINT:"beforeprint", AFTERPRINT:"afterprint"};
goog.provide("goog.reflect");
goog.reflect.object = function(type, object) {
  return object;
};
goog.reflect.objectProperty = function(prop, object) {
  return prop;
};
goog.reflect.sinkValue = function(x) {
  goog.reflect.sinkValue[" "](x);
  return x;
};
goog.reflect.sinkValue[" "] = goog.nullFunction;
goog.reflect.canAccessProperty = function(obj, prop) {
  try {
    goog.reflect.sinkValue(obj[prop]);
    return true;
  } catch (e) {
  }
  return false;
};
goog.reflect.cache = function(cacheObj, key, valueFn, opt_keyFn) {
  var storedKey = opt_keyFn ? opt_keyFn(key) : key;
  if (Object.prototype.hasOwnProperty.call(cacheObj, storedKey)) {
    return cacheObj[storedKey];
  }
  return cacheObj[storedKey] = valueFn(key);
};
goog.provide("goog.events.BrowserEvent");
goog.provide("goog.events.BrowserEvent.MouseButton");
goog.require("goog.events.BrowserFeature");
goog.require("goog.events.Event");
goog.require("goog.events.EventType");
goog.require("goog.reflect");
goog.require("goog.userAgent");
goog.events.BrowserEvent = function(opt_e, opt_currentTarget) {
  goog.events.BrowserEvent.base(this, "constructor", opt_e ? opt_e.type : "");
  this.target = null;
  this.currentTarget = null;
  this.relatedTarget = null;
  this.offsetX = 0;
  this.offsetY = 0;
  this.clientX = 0;
  this.clientY = 0;
  this.screenX = 0;
  this.screenY = 0;
  this.button = 0;
  this.keyCode = 0;
  this.charCode = 0;
  this.ctrlKey = false;
  this.altKey = false;
  this.shiftKey = false;
  this.metaKey = false;
  this.state = null;
  this.platformModifierKey = false;
  this.event_ = null;
  if (opt_e) {
    this.init(opt_e, opt_currentTarget);
  }
};
goog.inherits(goog.events.BrowserEvent, goog.events.Event);
goog.events.BrowserEvent.MouseButton = {LEFT:0, MIDDLE:1, RIGHT:2};
goog.events.BrowserEvent.IEButtonMap = [1, 4, 2];
goog.events.BrowserEvent.prototype.init = function(e, opt_currentTarget) {
  var type = this.type = e.type;
  var relevantTouch = e.changedTouches ? e.changedTouches[0] : null;
  this.target = (e.target) || e.srcElement;
  this.currentTarget = (opt_currentTarget);
  var relatedTarget = (e.relatedTarget);
  if (relatedTarget) {
    if (goog.userAgent.GECKO) {
      if (!goog.reflect.canAccessProperty(relatedTarget, "nodeName")) {
        relatedTarget = null;
      }
    }
  } else {
    if (type == goog.events.EventType.MOUSEOVER) {
      relatedTarget = e.fromElement;
    } else {
      if (type == goog.events.EventType.MOUSEOUT) {
        relatedTarget = e.toElement;
      }
    }
  }
  this.relatedTarget = relatedTarget;
  if (!goog.isNull(relevantTouch)) {
    this.clientX = relevantTouch.clientX !== undefined ? relevantTouch.clientX : relevantTouch.pageX;
    this.clientY = relevantTouch.clientY !== undefined ? relevantTouch.clientY : relevantTouch.pageY;
    this.screenX = relevantTouch.screenX || 0;
    this.screenY = relevantTouch.screenY || 0;
  } else {
    this.offsetX = goog.userAgent.WEBKIT || e.offsetX !== undefined ? e.offsetX : e.layerX;
    this.offsetY = goog.userAgent.WEBKIT || e.offsetY !== undefined ? e.offsetY : e.layerY;
    this.clientX = e.clientX !== undefined ? e.clientX : e.pageX;
    this.clientY = e.clientY !== undefined ? e.clientY : e.pageY;
    this.screenX = e.screenX || 0;
    this.screenY = e.screenY || 0;
  }
  this.button = e.button;
  this.keyCode = e.keyCode || 0;
  this.charCode = e.charCode || (type == "keypress" ? e.keyCode : 0);
  this.ctrlKey = e.ctrlKey;
  this.altKey = e.altKey;
  this.shiftKey = e.shiftKey;
  this.metaKey = e.metaKey;
  this.platformModifierKey = goog.userAgent.MAC ? e.metaKey : e.ctrlKey;
  this.state = e.state;
  this.event_ = e;
  if (e.defaultPrevented) {
    this.preventDefault();
  }
};
goog.events.BrowserEvent.prototype.isButton = function(button) {
  if (!goog.events.BrowserFeature.HAS_W3C_BUTTON) {
    if (this.type == "click") {
      return button == goog.events.BrowserEvent.MouseButton.LEFT;
    } else {
      return !!(this.event_.button & goog.events.BrowserEvent.IEButtonMap[button]);
    }
  } else {
    return this.event_.button == button;
  }
};
goog.events.BrowserEvent.prototype.isMouseActionButton = function() {
  return this.isButton(goog.events.BrowserEvent.MouseButton.LEFT) && !(goog.userAgent.WEBKIT && goog.userAgent.MAC && this.ctrlKey);
};
goog.events.BrowserEvent.prototype.stopPropagation = function() {
  goog.events.BrowserEvent.superClass_.stopPropagation.call(this);
  if (this.event_.stopPropagation) {
    this.event_.stopPropagation();
  } else {
    this.event_.cancelBubble = true;
  }
};
goog.events.BrowserEvent.prototype.preventDefault = function() {
  goog.events.BrowserEvent.superClass_.preventDefault.call(this);
  var be = this.event_;
  if (!be.preventDefault) {
    be.returnValue = false;
    if (goog.events.BrowserFeature.SET_KEY_CODE_TO_PREVENT_DEFAULT) {
      try {
        var VK_F1 = 112;
        var VK_F12 = 123;
        if (be.ctrlKey || be.keyCode >= VK_F1 && be.keyCode <= VK_F12) {
          be.keyCode = -1;
        }
      } catch (ex) {
      }
    }
  } else {
    be.preventDefault();
  }
};
goog.events.BrowserEvent.prototype.getBrowserEvent = function() {
  return this.event_;
};
goog.provide("goog.events.Listenable");
goog.provide("goog.events.ListenableKey");
goog.require("goog.events.EventId");
goog.forwardDeclare("goog.events.EventLike");
goog.forwardDeclare("goog.events.EventTarget");
goog.events.Listenable = function() {
};
goog.events.Listenable.IMPLEMENTED_BY_PROP = "closure_listenable_" + (Math.random() * 1E6 | 0);
goog.events.Listenable.addImplementation = function(cls) {
  cls.prototype[goog.events.Listenable.IMPLEMENTED_BY_PROP] = true;
};
goog.events.Listenable.isImplementedBy = function(obj) {
  return !!(obj && obj[goog.events.Listenable.IMPLEMENTED_BY_PROP]);
};
goog.events.Listenable.prototype.listen;
goog.events.Listenable.prototype.listenOnce;
goog.events.Listenable.prototype.unlisten;
goog.events.Listenable.prototype.unlistenByKey;
goog.events.Listenable.prototype.dispatchEvent;
goog.events.Listenable.prototype.removeAllListeners;
goog.events.Listenable.prototype.getParentEventTarget;
goog.events.Listenable.prototype.fireListeners;
goog.events.Listenable.prototype.getListeners;
goog.events.Listenable.prototype.getListener;
goog.events.Listenable.prototype.hasListener;
goog.events.ListenableKey = function() {
};
goog.events.ListenableKey.counter_ = 0;
goog.events.ListenableKey.reserveKey = function() {
  return ++goog.events.ListenableKey.counter_;
};
goog.events.ListenableKey.prototype.src;
goog.events.ListenableKey.prototype.type;
goog.events.ListenableKey.prototype.listener;
goog.events.ListenableKey.prototype.capture;
goog.events.ListenableKey.prototype.handler;
goog.events.ListenableKey.prototype.key;
goog.provide("goog.events.Listener");
goog.require("goog.events.ListenableKey");
goog.events.Listener = function(listener, proxy, src, type, capture, opt_handler) {
  if (goog.events.Listener.ENABLE_MONITORING) {
    this.creationStack = (new Error).stack;
  }
  this.listener = listener;
  this.proxy = proxy;
  this.src = src;
  this.type = type;
  this.capture = !!capture;
  this.handler = opt_handler;
  this.key = goog.events.ListenableKey.reserveKey();
  this.callOnce = false;
  this.removed = false;
};
goog.define("goog.events.Listener.ENABLE_MONITORING", false);
goog.events.Listener.prototype.creationStack;
goog.events.Listener.prototype.markAsRemoved = function() {
  this.removed = true;
  this.listener = null;
  this.proxy = null;
  this.src = null;
  this.handler = null;
};
goog.provide("goog.events.ListenerMap");
goog.require("goog.array");
goog.require("goog.events.Listener");
goog.require("goog.object");
goog.events.ListenerMap = function(src) {
  this.src = src;
  this.listeners = {};
  this.typeCount_ = 0;
};
goog.events.ListenerMap.prototype.getTypeCount = function() {
  return this.typeCount_;
};
goog.events.ListenerMap.prototype.getListenerCount = function() {
  var count = 0;
  for (var type in this.listeners) {
    count += this.listeners[type].length;
  }
  return count;
};
goog.events.ListenerMap.prototype.add = function(type, listener, callOnce, opt_useCapture, opt_listenerScope) {
  var typeStr = type.toString();
  var listenerArray = this.listeners[typeStr];
  if (!listenerArray) {
    listenerArray = this.listeners[typeStr] = [];
    this.typeCount_++;
  }
  var listenerObj;
  var index = goog.events.ListenerMap.findListenerIndex_(listenerArray, listener, opt_useCapture, opt_listenerScope);
  if (index > -1) {
    listenerObj = listenerArray[index];
    if (!callOnce) {
      listenerObj.callOnce = false;
    }
  } else {
    listenerObj = new goog.events.Listener(listener, null, this.src, typeStr, !!opt_useCapture, opt_listenerScope);
    listenerObj.callOnce = callOnce;
    listenerArray.push(listenerObj);
  }
  return listenerObj;
};
goog.events.ListenerMap.prototype.remove = function(type, listener, opt_useCapture, opt_listenerScope) {
  var typeStr = type.toString();
  if (!(typeStr in this.listeners)) {
    return false;
  }
  var listenerArray = this.listeners[typeStr];
  var index = goog.events.ListenerMap.findListenerIndex_(listenerArray, listener, opt_useCapture, opt_listenerScope);
  if (index > -1) {
    var listenerObj = listenerArray[index];
    listenerObj.markAsRemoved();
    goog.array.removeAt(listenerArray, index);
    if (listenerArray.length == 0) {
      delete this.listeners[typeStr];
      this.typeCount_--;
    }
    return true;
  }
  return false;
};
goog.events.ListenerMap.prototype.removeByKey = function(listener) {
  var type = listener.type;
  if (!(type in this.listeners)) {
    return false;
  }
  var removed = goog.array.remove(this.listeners[type], listener);
  if (removed) {
    listener.markAsRemoved();
    if (this.listeners[type].length == 0) {
      delete this.listeners[type];
      this.typeCount_--;
    }
  }
  return removed;
};
goog.events.ListenerMap.prototype.removeAll = function(opt_type) {
  var typeStr = opt_type && opt_type.toString();
  var count = 0;
  for (var type in this.listeners) {
    if (!typeStr || type == typeStr) {
      var listenerArray = this.listeners[type];
      for (var i = 0;i < listenerArray.length;i++) {
        ++count;
        listenerArray[i].markAsRemoved();
      }
      delete this.listeners[type];
      this.typeCount_--;
    }
  }
  return count;
};
goog.events.ListenerMap.prototype.getListeners = function(type, capture) {
  var listenerArray = this.listeners[type.toString()];
  var rv = [];
  if (listenerArray) {
    for (var i = 0;i < listenerArray.length;++i) {
      var listenerObj = listenerArray[i];
      if (listenerObj.capture == capture) {
        rv.push(listenerObj);
      }
    }
  }
  return rv;
};
goog.events.ListenerMap.prototype.getListener = function(type, listener, capture, opt_listenerScope) {
  var listenerArray = this.listeners[type.toString()];
  var i = -1;
  if (listenerArray) {
    i = goog.events.ListenerMap.findListenerIndex_(listenerArray, listener, capture, opt_listenerScope);
  }
  return i > -1 ? listenerArray[i] : null;
};
goog.events.ListenerMap.prototype.hasListener = function(opt_type, opt_capture) {
  var hasType = goog.isDef(opt_type);
  var typeStr = hasType ? opt_type.toString() : "";
  var hasCapture = goog.isDef(opt_capture);
  return goog.object.some(this.listeners, function(listenerArray, type) {
    for (var i = 0;i < listenerArray.length;++i) {
      if ((!hasType || listenerArray[i].type == typeStr) && (!hasCapture || listenerArray[i].capture == opt_capture)) {
        return true;
      }
    }
    return false;
  });
};
goog.events.ListenerMap.findListenerIndex_ = function(listenerArray, listener, opt_useCapture, opt_listenerScope) {
  for (var i = 0;i < listenerArray.length;++i) {
    var listenerObj = listenerArray[i];
    if (!listenerObj.removed && listenerObj.listener == listener && listenerObj.capture == !!opt_useCapture && listenerObj.handler == opt_listenerScope) {
      return i;
    }
  }
  return -1;
};
goog.provide("goog.events");
goog.provide("goog.events.CaptureSimulationMode");
goog.provide("goog.events.Key");
goog.provide("goog.events.ListenableType");
goog.require("goog.asserts");
goog.require("goog.debug.entryPointRegistry");
goog.require("goog.events.BrowserEvent");
goog.require("goog.events.BrowserFeature");
goog.require("goog.events.Listenable");
goog.require("goog.events.ListenerMap");
goog.forwardDeclare("goog.debug.ErrorHandler");
goog.forwardDeclare("goog.events.EventWrapper");
goog.events.Key;
goog.events.ListenableType;
goog.events.LISTENER_MAP_PROP_ = "closure_lm_" + (Math.random() * 1E6 | 0);
goog.events.onString_ = "on";
goog.events.onStringMap_ = {};
goog.events.CaptureSimulationMode = {OFF_AND_FAIL:0, OFF_AND_SILENT:1, ON:2};
goog.define("goog.events.CAPTURE_SIMULATION_MODE", 2);
goog.events.listenerCountEstimate_ = 0;
goog.events.listen = function(src, type, listener, opt_capt, opt_handler) {
  if (goog.isArray(type)) {
    for (var i = 0;i < type.length;i++) {
      goog.events.listen(src, type[i], listener, opt_capt, opt_handler);
    }
    return null;
  }
  listener = goog.events.wrapListener(listener);
  if (goog.events.Listenable.isImplementedBy(src)) {
    return src.listen((type), listener, opt_capt, opt_handler);
  } else {
    return goog.events.listen_((src), (type), listener, false, opt_capt, opt_handler);
  }
};
goog.events.listen_ = function(src, type, listener, callOnce, opt_capt, opt_handler) {
  if (!type) {
    throw Error("Invalid event type");
  }
  var capture = !!opt_capt;
  if (capture && !goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT) {
    if (goog.events.CAPTURE_SIMULATION_MODE == goog.events.CaptureSimulationMode.OFF_AND_FAIL) {
      goog.asserts.fail("Can not register capture listener in IE8-.");
      return null;
    } else {
      if (goog.events.CAPTURE_SIMULATION_MODE == goog.events.CaptureSimulationMode.OFF_AND_SILENT) {
        return null;
      }
    }
  }
  var listenerMap = goog.events.getListenerMap_(src);
  if (!listenerMap) {
    src[goog.events.LISTENER_MAP_PROP_] = listenerMap = new goog.events.ListenerMap(src);
  }
  var listenerObj = listenerMap.add(type, listener, callOnce, opt_capt, opt_handler);
  if (listenerObj.proxy) {
    return listenerObj;
  }
  var proxy = goog.events.getProxy();
  listenerObj.proxy = proxy;
  proxy.src = src;
  proxy.listener = listenerObj;
  if (src.addEventListener) {
    src.addEventListener(type.toString(), proxy, capture);
  } else {
    if (src.attachEvent) {
      src.attachEvent(goog.events.getOnString_(type.toString()), proxy);
    } else {
      throw Error("addEventListener and attachEvent are unavailable.");
    }
  }
  goog.events.listenerCountEstimate_++;
  return listenerObj;
};
goog.events.getProxy = function() {
  var proxyCallbackFunction = goog.events.handleBrowserEvent_;
  var f = goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT ? function(eventObject) {
    return proxyCallbackFunction.call(f.src, f.listener, eventObject);
  } : function(eventObject) {
    var v = proxyCallbackFunction.call(f.src, f.listener, eventObject);
    if (!v) {
      return v;
    }
  };
  return f;
};
goog.events.listenOnce = function(src, type, listener, opt_capt, opt_handler) {
  if (goog.isArray(type)) {
    for (var i = 0;i < type.length;i++) {
      goog.events.listenOnce(src, type[i], listener, opt_capt, opt_handler);
    }
    return null;
  }
  listener = goog.events.wrapListener(listener);
  if (goog.events.Listenable.isImplementedBy(src)) {
    return src.listenOnce((type), listener, opt_capt, opt_handler);
  } else {
    return goog.events.listen_((src), (type), listener, true, opt_capt, opt_handler);
  }
};
goog.events.listenWithWrapper = function(src, wrapper, listener, opt_capt, opt_handler) {
  wrapper.listen(src, listener, opt_capt, opt_handler);
};
goog.events.unlisten = function(src, type, listener, opt_capt, opt_handler) {
  if (goog.isArray(type)) {
    for (var i = 0;i < type.length;i++) {
      goog.events.unlisten(src, type[i], listener, opt_capt, opt_handler);
    }
    return null;
  }
  listener = goog.events.wrapListener(listener);
  if (goog.events.Listenable.isImplementedBy(src)) {
    return src.unlisten((type), listener, opt_capt, opt_handler);
  }
  if (!src) {
    return false;
  }
  var capture = !!opt_capt;
  var listenerMap = goog.events.getListenerMap_((src));
  if (listenerMap) {
    var listenerObj = listenerMap.getListener((type), listener, capture, opt_handler);
    if (listenerObj) {
      return goog.events.unlistenByKey(listenerObj);
    }
  }
  return false;
};
goog.events.unlistenByKey = function(key) {
  if (goog.isNumber(key)) {
    return false;
  }
  var listener = key;
  if (!listener || listener.removed) {
    return false;
  }
  var src = listener.src;
  if (goog.events.Listenable.isImplementedBy(src)) {
    return (src).unlistenByKey(listener);
  }
  var type = listener.type;
  var proxy = listener.proxy;
  if (src.removeEventListener) {
    src.removeEventListener(type, proxy, listener.capture);
  } else {
    if (src.detachEvent) {
      src.detachEvent(goog.events.getOnString_(type), proxy);
    }
  }
  goog.events.listenerCountEstimate_--;
  var listenerMap = goog.events.getListenerMap_((src));
  if (listenerMap) {
    listenerMap.removeByKey(listener);
    if (listenerMap.getTypeCount() == 0) {
      listenerMap.src = null;
      src[goog.events.LISTENER_MAP_PROP_] = null;
    }
  } else {
    listener.markAsRemoved();
  }
  return true;
};
goog.events.unlistenWithWrapper = function(src, wrapper, listener, opt_capt, opt_handler) {
  wrapper.unlisten(src, listener, opt_capt, opt_handler);
};
goog.events.removeAll = function(obj, opt_type) {
  if (!obj) {
    return 0;
  }
  if (goog.events.Listenable.isImplementedBy(obj)) {
    return (obj).removeAllListeners(opt_type);
  }
  var listenerMap = goog.events.getListenerMap_((obj));
  if (!listenerMap) {
    return 0;
  }
  var count = 0;
  var typeStr = opt_type && opt_type.toString();
  for (var type in listenerMap.listeners) {
    if (!typeStr || type == typeStr) {
      var listeners = listenerMap.listeners[type].concat();
      for (var i = 0;i < listeners.length;++i) {
        if (goog.events.unlistenByKey(listeners[i])) {
          ++count;
        }
      }
    }
  }
  return count;
};
goog.events.getListeners = function(obj, type, capture) {
  if (goog.events.Listenable.isImplementedBy(obj)) {
    return (obj).getListeners(type, capture);
  } else {
    if (!obj) {
      return [];
    }
    var listenerMap = goog.events.getListenerMap_((obj));
    return listenerMap ? listenerMap.getListeners(type, capture) : [];
  }
};
goog.events.getListener = function(src, type, listener, opt_capt, opt_handler) {
  type = (type);
  listener = goog.events.wrapListener(listener);
  var capture = !!opt_capt;
  if (goog.events.Listenable.isImplementedBy(src)) {
    return src.getListener(type, listener, capture, opt_handler);
  }
  if (!src) {
    return null;
  }
  var listenerMap = goog.events.getListenerMap_((src));
  if (listenerMap) {
    return listenerMap.getListener(type, listener, capture, opt_handler);
  }
  return null;
};
goog.events.hasListener = function(obj, opt_type, opt_capture) {
  if (goog.events.Listenable.isImplementedBy(obj)) {
    return obj.hasListener(opt_type, opt_capture);
  }
  var listenerMap = goog.events.getListenerMap_((obj));
  return !!listenerMap && listenerMap.hasListener(opt_type, opt_capture);
};
goog.events.expose = function(e) {
  var str = [];
  for (var key in e) {
    if (e[key] && e[key].id) {
      str.push(key + " = " + e[key] + " (" + e[key].id + ")");
    } else {
      str.push(key + " = " + e[key]);
    }
  }
  return str.join("\n");
};
goog.events.getOnString_ = function(type) {
  if (type in goog.events.onStringMap_) {
    return goog.events.onStringMap_[type];
  }
  return goog.events.onStringMap_[type] = goog.events.onString_ + type;
};
goog.events.fireListeners = function(obj, type, capture, eventObject) {
  if (goog.events.Listenable.isImplementedBy(obj)) {
    return (obj).fireListeners(type, capture, eventObject);
  }
  return goog.events.fireListeners_(obj, type, capture, eventObject);
};
goog.events.fireListeners_ = function(obj, type, capture, eventObject) {
  var retval = true;
  var listenerMap = goog.events.getListenerMap_((obj));
  if (listenerMap) {
    var listenerArray = listenerMap.listeners[type.toString()];
    if (listenerArray) {
      listenerArray = listenerArray.concat();
      for (var i = 0;i < listenerArray.length;i++) {
        var listener = listenerArray[i];
        if (listener && listener.capture == capture && !listener.removed) {
          var result = goog.events.fireListener(listener, eventObject);
          retval = retval && result !== false;
        }
      }
    }
  }
  return retval;
};
goog.events.fireListener = function(listener, eventObject) {
  var listenerFn = listener.listener;
  var listenerHandler = listener.handler || listener.src;
  if (listener.callOnce) {
    goog.events.unlistenByKey(listener);
  }
  return listenerFn.call(listenerHandler, eventObject);
};
goog.events.getTotalListenerCount = function() {
  return goog.events.listenerCountEstimate_;
};
goog.events.dispatchEvent = function(src, e) {
  goog.asserts.assert(goog.events.Listenable.isImplementedBy(src), "Can not use goog.events.dispatchEvent with " + "non-goog.events.Listenable instance.");
  return src.dispatchEvent(e);
};
goog.events.protectBrowserEventEntryPoint = function(errorHandler) {
  goog.events.handleBrowserEvent_ = errorHandler.protectEntryPoint(goog.events.handleBrowserEvent_);
};
goog.events.handleBrowserEvent_ = function(listener, opt_evt) {
  if (listener.removed) {
    return true;
  }
  if (!goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT) {
    var ieEvent = opt_evt || (goog.getObjectByName("window.event"));
    var evt = new goog.events.BrowserEvent(ieEvent, this);
    var retval = true;
    if (goog.events.CAPTURE_SIMULATION_MODE == goog.events.CaptureSimulationMode.ON) {
      if (!goog.events.isMarkedIeEvent_(ieEvent)) {
        goog.events.markIeEvent_(ieEvent);
        var ancestors = [];
        for (var parent = evt.currentTarget;parent;parent = parent.parentNode) {
          ancestors.push(parent);
        }
        var type = listener.type;
        for (var i = ancestors.length - 1;!evt.propagationStopped_ && i >= 0;i--) {
          evt.currentTarget = ancestors[i];
          var result = goog.events.fireListeners_(ancestors[i], type, true, evt);
          retval = retval && result;
        }
        for (var i = 0;!evt.propagationStopped_ && i < ancestors.length;i++) {
          evt.currentTarget = ancestors[i];
          var result = goog.events.fireListeners_(ancestors[i], type, false, evt);
          retval = retval && result;
        }
      }
    } else {
      retval = goog.events.fireListener(listener, evt);
    }
    return retval;
  }
  return goog.events.fireListener(listener, new goog.events.BrowserEvent(opt_evt, this));
};
goog.events.markIeEvent_ = function(e) {
  var useReturnValue = false;
  if (e.keyCode == 0) {
    try {
      e.keyCode = -1;
      return;
    } catch (ex) {
      useReturnValue = true;
    }
  }
  if (useReturnValue || (e.returnValue) == undefined) {
    e.returnValue = true;
  }
};
goog.events.isMarkedIeEvent_ = function(e) {
  return e.keyCode < 0 || e.returnValue != undefined;
};
goog.events.uniqueIdCounter_ = 0;
goog.events.getUniqueId = function(identifier) {
  return identifier + "_" + goog.events.uniqueIdCounter_++;
};
goog.events.getListenerMap_ = function(src) {
  var listenerMap = src[goog.events.LISTENER_MAP_PROP_];
  return listenerMap instanceof goog.events.ListenerMap ? listenerMap : null;
};
goog.events.LISTENER_WRAPPER_PROP_ = "__closure_events_fn_" + (Math.random() * 1E9 >>> 0);
goog.events.wrapListener = function(listener) {
  goog.asserts.assert(listener, "Listener can not be null.");
  if (goog.isFunction(listener)) {
    return listener;
  }
  goog.asserts.assert(listener.handleEvent, "An object listener must have handleEvent method.");
  if (!listener[goog.events.LISTENER_WRAPPER_PROP_]) {
    listener[goog.events.LISTENER_WRAPPER_PROP_] = function(e) {
      return (listener).handleEvent(e);
    };
  }
  return listener[goog.events.LISTENER_WRAPPER_PROP_];
};
goog.debug.entryPointRegistry.register(function(transformer) {
  goog.events.handleBrowserEvent_ = transformer(goog.events.handleBrowserEvent_);
});
goog.provide("goog.dom.BrowserFeature");
goog.require("goog.userAgent");
goog.dom.BrowserFeature = {CAN_ADD_NAME_OR_TYPE_ATTRIBUTES:!goog.userAgent.IE || goog.userAgent.isDocumentModeOrHigher(9), CAN_USE_CHILDREN_ATTRIBUTE:!goog.userAgent.GECKO && !goog.userAgent.IE || goog.userAgent.IE && goog.userAgent.isDocumentModeOrHigher(9) || goog.userAgent.GECKO && goog.userAgent.isVersionOrHigher("1.9.1"), CAN_USE_INNER_TEXT:goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("9"), CAN_USE_PARENT_ELEMENT_PROPERTY:goog.userAgent.IE || goog.userAgent.OPERA || goog.userAgent.WEBKIT, 
INNER_HTML_NEEDS_SCOPED_ELEMENT:goog.userAgent.IE, LEGACY_IE_RANGES:goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9)};
goog.provide("goog.dom.safe");
goog.provide("goog.dom.safe.InsertAdjacentHtmlPosition");
goog.require("goog.asserts");
goog.require("goog.html.SafeHtml");
goog.require("goog.html.SafeUrl");
goog.require("goog.html.TrustedResourceUrl");
goog.require("goog.string");
goog.require("goog.string.Const");
goog.dom.safe.InsertAdjacentHtmlPosition = {AFTERBEGIN:"afterbegin", AFTEREND:"afterend", BEFOREBEGIN:"beforebegin", BEFOREEND:"beforeend"};
goog.dom.safe.insertAdjacentHtml = function(node, position, html) {
  node.insertAdjacentHTML(position, goog.html.SafeHtml.unwrap(html));
};
goog.dom.safe.setInnerHtml = function(elem, html) {
  elem.innerHTML = goog.html.SafeHtml.unwrap(html);
};
goog.dom.safe.setOuterHtml = function(elem, html) {
  elem.outerHTML = goog.html.SafeHtml.unwrap(html);
};
goog.dom.safe.documentWrite = function(doc, html) {
  doc.write(goog.html.SafeHtml.unwrap(html));
};
goog.dom.safe.setAnchorHref = function(anchor, url) {
  var safeUrl;
  if (url instanceof goog.html.SafeUrl) {
    safeUrl = url;
  } else {
    safeUrl = goog.html.SafeUrl.sanitize(url);
  }
  anchor.href = goog.html.SafeUrl.unwrap(safeUrl);
};
goog.dom.safe.setImageSrc = function(imageElement, url) {
  var safeUrl;
  if (url instanceof goog.html.SafeUrl) {
    safeUrl = url;
  } else {
    safeUrl = goog.html.SafeUrl.sanitize(url);
  }
  imageElement.src = goog.html.SafeUrl.unwrap(safeUrl);
};
goog.dom.safe.setEmbedSrc = function(embed, url) {
  embed.src = goog.html.TrustedResourceUrl.unwrap(url);
};
goog.dom.safe.setFrameSrc = function(frame, url) {
  frame.src = goog.html.TrustedResourceUrl.unwrap(url);
};
goog.dom.safe.setIframeSrc = function(iframe, url) {
  iframe.src = goog.html.TrustedResourceUrl.unwrap(url);
};
goog.dom.safe.setLinkHrefAndRel = function(link, url, rel) {
  link.rel = rel;
  if (goog.string.caseInsensitiveContains(rel, "stylesheet")) {
    goog.asserts.assert(url instanceof goog.html.TrustedResourceUrl, 'URL must be TrustedResourceUrl because "rel" contains "stylesheet"');
    link.href = goog.html.TrustedResourceUrl.unwrap(url);
  } else {
    if (url instanceof goog.html.TrustedResourceUrl) {
      link.href = goog.html.TrustedResourceUrl.unwrap(url);
    } else {
      if (url instanceof goog.html.SafeUrl) {
        link.href = goog.html.SafeUrl.unwrap(url);
      } else {
        link.href = goog.html.SafeUrl.sanitize(url).getTypedStringValue();
      }
    }
  }
};
goog.dom.safe.setObjectData = function(object, url) {
  object.data = goog.html.TrustedResourceUrl.unwrap(url);
};
goog.dom.safe.setScriptSrc = function(script, url) {
  script.src = goog.html.TrustedResourceUrl.unwrap(url);
};
goog.dom.safe.setLocationHref = function(loc, url) {
  var safeUrl;
  if (url instanceof goog.html.SafeUrl) {
    safeUrl = url;
  } else {
    safeUrl = goog.html.SafeUrl.sanitize(url);
  }
  loc.href = goog.html.SafeUrl.unwrap(safeUrl);
};
goog.dom.safe.openInWindow = function(url, opt_openerWin, opt_name, opt_specs, opt_replace) {
  var safeUrl;
  if (url instanceof goog.html.SafeUrl) {
    safeUrl = url;
  } else {
    safeUrl = goog.html.SafeUrl.sanitize(url);
  }
  var win = opt_openerWin || window;
  return win.open(goog.html.SafeUrl.unwrap(safeUrl), opt_name ? goog.string.Const.unwrap(opt_name) : "", opt_specs, opt_replace);
};
goog.provide("goog.math.Coordinate");
goog.require("goog.math");
goog.math.Coordinate = function(opt_x, opt_y) {
  this.x = goog.isDef(opt_x) ? opt_x : 0;
  this.y = goog.isDef(opt_y) ? opt_y : 0;
};
goog.math.Coordinate.prototype.clone = function() {
  return new goog.math.Coordinate(this.x, this.y);
};
if (goog.DEBUG) {
  goog.math.Coordinate.prototype.toString = function() {
    return "(" + this.x + ", " + this.y + ")";
  };
}
goog.math.Coordinate.equals = function(a, b) {
  if (a == b) {
    return true;
  }
  if (!a || !b) {
    return false;
  }
  return a.x == b.x && a.y == b.y;
};
goog.math.Coordinate.distance = function(a, b) {
  var dx = a.x - b.x;
  var dy = a.y - b.y;
  return Math.sqrt(dx * dx + dy * dy);
};
goog.math.Coordinate.magnitude = function(a) {
  return Math.sqrt(a.x * a.x + a.y * a.y);
};
goog.math.Coordinate.azimuth = function(a) {
  return goog.math.angle(0, 0, a.x, a.y);
};
goog.math.Coordinate.squaredDistance = function(a, b) {
  var dx = a.x - b.x;
  var dy = a.y - b.y;
  return dx * dx + dy * dy;
};
goog.math.Coordinate.difference = function(a, b) {
  return new goog.math.Coordinate(a.x - b.x, a.y - b.y);
};
goog.math.Coordinate.sum = function(a, b) {
  return new goog.math.Coordinate(a.x + b.x, a.y + b.y);
};
goog.math.Coordinate.prototype.ceil = function() {
  this.x = Math.ceil(this.x);
  this.y = Math.ceil(this.y);
  return this;
};
goog.math.Coordinate.prototype.floor = function() {
  this.x = Math.floor(this.x);
  this.y = Math.floor(this.y);
  return this;
};
goog.math.Coordinate.prototype.round = function() {
  this.x = Math.round(this.x);
  this.y = Math.round(this.y);
  return this;
};
goog.math.Coordinate.prototype.translate = function(tx, opt_ty) {
  if (tx instanceof goog.math.Coordinate) {
    this.x += tx.x;
    this.y += tx.y;
  } else {
    this.x += Number(tx);
    if (goog.isNumber(opt_ty)) {
      this.y += opt_ty;
    }
  }
  return this;
};
goog.math.Coordinate.prototype.scale = function(sx, opt_sy) {
  var sy = goog.isNumber(opt_sy) ? opt_sy : sx;
  this.x *= sx;
  this.y *= sy;
  return this;
};
goog.math.Coordinate.prototype.rotateRadians = function(radians, opt_center) {
  var center = opt_center || new goog.math.Coordinate(0, 0);
  var x = this.x;
  var y = this.y;
  var cos = Math.cos(radians);
  var sin = Math.sin(radians);
  this.x = (x - center.x) * cos - (y - center.y) * sin + center.x;
  this.y = (x - center.x) * sin + (y - center.y) * cos + center.y;
};
goog.math.Coordinate.prototype.rotateDegrees = function(degrees, opt_center) {
  this.rotateRadians(goog.math.toRadians(degrees), opt_center);
};
goog.provide("goog.math.Size");
goog.math.Size = function(width, height) {
  this.width = width;
  this.height = height;
};
goog.math.Size.equals = function(a, b) {
  if (a == b) {
    return true;
  }
  if (!a || !b) {
    return false;
  }
  return a.width == b.width && a.height == b.height;
};
goog.math.Size.prototype.clone = function() {
  return new goog.math.Size(this.width, this.height);
};
if (goog.DEBUG) {
  goog.math.Size.prototype.toString = function() {
    return "(" + this.width + " x " + this.height + ")";
  };
}
goog.math.Size.prototype.getLongest = function() {
  return Math.max(this.width, this.height);
};
goog.math.Size.prototype.getShortest = function() {
  return Math.min(this.width, this.height);
};
goog.math.Size.prototype.area = function() {
  return this.width * this.height;
};
goog.math.Size.prototype.perimeter = function() {
  return (this.width + this.height) * 2;
};
goog.math.Size.prototype.aspectRatio = function() {
  return this.width / this.height;
};
goog.math.Size.prototype.isEmpty = function() {
  return !this.area();
};
goog.math.Size.prototype.ceil = function() {
  this.width = Math.ceil(this.width);
  this.height = Math.ceil(this.height);
  return this;
};
goog.math.Size.prototype.fitsInside = function(target) {
  return this.width <= target.width && this.height <= target.height;
};
goog.math.Size.prototype.floor = function() {
  this.width = Math.floor(this.width);
  this.height = Math.floor(this.height);
  return this;
};
goog.math.Size.prototype.round = function() {
  this.width = Math.round(this.width);
  this.height = Math.round(this.height);
  return this;
};
goog.math.Size.prototype.scale = function(sx, opt_sy) {
  var sy = goog.isNumber(opt_sy) ? opt_sy : sx;
  this.width *= sx;
  this.height *= sy;
  return this;
};
goog.math.Size.prototype.scaleToCover = function(target) {
  var s = this.aspectRatio() <= target.aspectRatio() ? target.width / this.width : target.height / this.height;
  return this.scale(s);
};
goog.math.Size.prototype.scaleToFit = function(target) {
  var s = this.aspectRatio() > target.aspectRatio() ? target.width / this.width : target.height / this.height;
  return this.scale(s);
};
goog.provide("goog.dom");
goog.provide("goog.dom.Appendable");
goog.provide("goog.dom.DomHelper");
goog.require("goog.array");
goog.require("goog.asserts");
goog.require("goog.dom.BrowserFeature");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.TagName");
goog.require("goog.dom.safe");
goog.require("goog.html.SafeHtml");
goog.require("goog.html.uncheckedconversions");
goog.require("goog.math.Coordinate");
goog.require("goog.math.Size");
goog.require("goog.object");
goog.require("goog.string");
goog.require("goog.string.Unicode");
goog.require("goog.userAgent");
goog.forwardDeclare("goog.dom.TypedTagName");
goog.define("goog.dom.ASSUME_QUIRKS_MODE", false);
goog.define("goog.dom.ASSUME_STANDARDS_MODE", false);
goog.dom.COMPAT_MODE_KNOWN_ = goog.dom.ASSUME_QUIRKS_MODE || goog.dom.ASSUME_STANDARDS_MODE;
goog.dom.getDomHelper = function(opt_element) {
  return opt_element ? new goog.dom.DomHelper(goog.dom.getOwnerDocument(opt_element)) : goog.dom.defaultDomHelper_ || (goog.dom.defaultDomHelper_ = new goog.dom.DomHelper);
};
goog.dom.defaultDomHelper_;
goog.dom.getDocument = function() {
  return document;
};
goog.dom.getElement = function(element) {
  return goog.dom.getElementHelper_(document, element);
};
goog.dom.getElementHelper_ = function(doc, element) {
  return goog.isString(element) ? doc.getElementById(element) : element;
};
goog.dom.getRequiredElement = function(id) {
  return goog.dom.getRequiredElementHelper_(document, id);
};
goog.dom.getRequiredElementHelper_ = function(doc, id) {
  goog.asserts.assertString(id);
  var element = goog.dom.getElementHelper_(doc, id);
  element = goog.asserts.assertElement(element, "No element found with id: " + id);
  return element;
};
goog.dom.$ = goog.dom.getElement;
goog.dom.getElementsByTagNameAndClass = function(opt_tag, opt_class, opt_el) {
  return goog.dom.getElementsByTagNameAndClass_(document, opt_tag, opt_class, opt_el);
};
goog.dom.getElementsByClass = function(className, opt_el) {
  var parent = opt_el || document;
  if (goog.dom.canUseQuerySelector_(parent)) {
    return parent.querySelectorAll("." + className);
  }
  return goog.dom.getElementsByTagNameAndClass_(document, "*", className, opt_el);
};
goog.dom.getElementByClass = function(className, opt_el) {
  var parent = opt_el || document;
  var retVal = null;
  if (parent.getElementsByClassName) {
    retVal = parent.getElementsByClassName(className)[0];
  } else {
    if (goog.dom.canUseQuerySelector_(parent)) {
      retVal = parent.querySelector("." + className);
    } else {
      retVal = goog.dom.getElementsByTagNameAndClass_(document, "*", className, opt_el)[0];
    }
  }
  return retVal || null;
};
goog.dom.getRequiredElementByClass = function(className, opt_root) {
  var retValue = goog.dom.getElementByClass(className, opt_root);
  return goog.asserts.assert(retValue, "No element found with className: " + className);
};
goog.dom.canUseQuerySelector_ = function(parent) {
  return !!(parent.querySelectorAll && parent.querySelector);
};
goog.dom.getElementsByTagNameAndClass_ = function(doc, opt_tag, opt_class, opt_el) {
  var parent = opt_el || doc;
  var tagName = opt_tag && opt_tag != "*" ? opt_tag.toUpperCase() : "";
  if (goog.dom.canUseQuerySelector_(parent) && (tagName || opt_class)) {
    var query = tagName + (opt_class ? "." + opt_class : "");
    return parent.querySelectorAll(query);
  }
  if (opt_class && parent.getElementsByClassName) {
    var els = parent.getElementsByClassName(opt_class);
    if (tagName) {
      var arrayLike = {};
      var len = 0;
      for (var i = 0, el;el = els[i];i++) {
        if (tagName == el.nodeName) {
          arrayLike[len++] = el;
        }
      }
      arrayLike.length = len;
      return (arrayLike);
    } else {
      return els;
    }
  }
  var els = parent.getElementsByTagName(tagName || "*");
  if (opt_class) {
    var arrayLike = {};
    var len = 0;
    for (var i = 0, el;el = els[i];i++) {
      var className = el.className;
      if (typeof className.split == "function" && goog.array.contains(className.split(/\s+/), opt_class)) {
        arrayLike[len++] = el;
      }
    }
    arrayLike.length = len;
    return (arrayLike);
  } else {
    return els;
  }
};
goog.dom.$$ = goog.dom.getElementsByTagNameAndClass;
goog.dom.setProperties = function(element, properties) {
  goog.object.forEach(properties, function(val, key) {
    if (key == "style") {
      element.style.cssText = val;
    } else {
      if (key == "class") {
        element.className = val;
      } else {
        if (key == "for") {
          element.htmlFor = val;
        } else {
          if (goog.dom.DIRECT_ATTRIBUTE_MAP_.hasOwnProperty(key)) {
            element.setAttribute(goog.dom.DIRECT_ATTRIBUTE_MAP_[key], val);
          } else {
            if (goog.string.startsWith(key, "aria-") || goog.string.startsWith(key, "data-")) {
              element.setAttribute(key, val);
            } else {
              element[key] = val;
            }
          }
        }
      }
    }
  });
};
goog.dom.DIRECT_ATTRIBUTE_MAP_ = {"cellpadding":"cellPadding", "cellspacing":"cellSpacing", "colspan":"colSpan", "frameborder":"frameBorder", "height":"height", "maxlength":"maxLength", "nonce":"nonce", "role":"role", "rowspan":"rowSpan", "type":"type", "usemap":"useMap", "valign":"vAlign", "width":"width"};
goog.dom.getViewportSize = function(opt_window) {
  return goog.dom.getViewportSize_(opt_window || window);
};
goog.dom.getViewportSize_ = function(win) {
  var doc = win.document;
  var el = goog.dom.isCss1CompatMode_(doc) ? doc.documentElement : doc.body;
  return new goog.math.Size(el.clientWidth, el.clientHeight);
};
goog.dom.getDocumentHeight = function() {
  return goog.dom.getDocumentHeight_(window);
};
goog.dom.getDocumentHeightForWindow = function(win) {
  return goog.dom.getDocumentHeight_(win);
};
goog.dom.getDocumentHeight_ = function(win) {
  var doc = win.document;
  var height = 0;
  if (doc) {
    var body = doc.body;
    var docEl = (doc.documentElement);
    if (!(docEl && body)) {
      return 0;
    }
    var vh = goog.dom.getViewportSize_(win).height;
    if (goog.dom.isCss1CompatMode_(doc) && docEl.scrollHeight) {
      height = docEl.scrollHeight != vh ? docEl.scrollHeight : docEl.offsetHeight;
    } else {
      var sh = docEl.scrollHeight;
      var oh = docEl.offsetHeight;
      if (docEl.clientHeight != oh) {
        sh = body.scrollHeight;
        oh = body.offsetHeight;
      }
      if (sh > vh) {
        height = sh > oh ? sh : oh;
      } else {
        height = sh < oh ? sh : oh;
      }
    }
  }
  return height;
};
goog.dom.getPageScroll = function(opt_window) {
  var win = opt_window || goog.global || window;
  return goog.dom.getDomHelper(win.document).getDocumentScroll();
};
goog.dom.getDocumentScroll = function() {
  return goog.dom.getDocumentScroll_(document);
};
goog.dom.getDocumentScroll_ = function(doc) {
  var el = goog.dom.getDocumentScrollElement_(doc);
  var win = goog.dom.getWindow_(doc);
  if (goog.userAgent.IE && goog.userAgent.isVersionOrHigher("10") && win.pageYOffset != el.scrollTop) {
    return new goog.math.Coordinate(el.scrollLeft, el.scrollTop);
  }
  return new goog.math.Coordinate(win.pageXOffset || el.scrollLeft, win.pageYOffset || el.scrollTop);
};
goog.dom.getDocumentScrollElement = function() {
  return goog.dom.getDocumentScrollElement_(document);
};
goog.dom.getDocumentScrollElement_ = function(doc) {
  if (doc.scrollingElement) {
    return doc.scrollingElement;
  }
  if (!goog.userAgent.WEBKIT && goog.dom.isCss1CompatMode_(doc)) {
    return doc.documentElement;
  }
  return doc.body || doc.documentElement;
};
goog.dom.getWindow = function(opt_doc) {
  return opt_doc ? goog.dom.getWindow_(opt_doc) : window;
};
goog.dom.getWindow_ = function(doc) {
  return doc.parentWindow || doc.defaultView;
};
goog.dom.createDom = function(tagName, opt_properties, var_args) {
  return goog.dom.createDom_(document, arguments);
};
goog.dom.createUntypedDom = function(tagName, opt_attributes, var_args) {
  return goog.dom.createDom_(document, arguments);
};
goog.dom.createDom_ = function(doc, args) {
  var tagName = String(args[0]);
  var attributes = args[1];
  if (!goog.dom.BrowserFeature.CAN_ADD_NAME_OR_TYPE_ATTRIBUTES && attributes && (attributes.name || attributes.type)) {
    var tagNameArr = ["<", tagName];
    if (attributes.name) {
      tagNameArr.push(' name="', goog.string.htmlEscape(attributes.name), '"');
    }
    if (attributes.type) {
      tagNameArr.push(' type="', goog.string.htmlEscape(attributes.type), '"');
      var clone = {};
      goog.object.extend(clone, attributes);
      delete clone["type"];
      attributes = clone;
    }
    tagNameArr.push(">");
    tagName = tagNameArr.join("");
  }
  var element = doc.createElement(tagName);
  if (attributes) {
    if (goog.isString(attributes)) {
      element.className = attributes;
    } else {
      if (goog.isArray(attributes)) {
        element.className = attributes.join(" ");
      } else {
        goog.dom.setProperties(element, attributes);
      }
    }
  }
  if (args.length > 2) {
    goog.dom.append_(doc, element, args, 2);
  }
  return element;
};
goog.dom.append_ = function(doc, parent, args, startIndex) {
  function childHandler(child) {
    if (child) {
      parent.appendChild(goog.isString(child) ? doc.createTextNode(child) : child);
    }
  }
  for (var i = startIndex;i < args.length;i++) {
    var arg = args[i];
    if (goog.isArrayLike(arg) && !goog.dom.isNodeLike(arg)) {
      goog.array.forEach(goog.dom.isNodeList(arg) ? goog.array.toArray(arg) : arg, childHandler);
    } else {
      childHandler(arg);
    }
  }
};
goog.dom.$dom = goog.dom.createDom;
goog.dom.createElement = function(name) {
  return document.createElement(String(name));
};
goog.dom.createTextNode = function(content) {
  return document.createTextNode(String(content));
};
goog.dom.createTable = function(rows, columns, opt_fillWithNbsp) {
  return goog.dom.createTable_(document, rows, columns, !!opt_fillWithNbsp);
};
goog.dom.createTable_ = function(doc, rows, columns, fillWithNbsp) {
  var table = (doc.createElement(goog.dom.TagName.TABLE));
  var tbody = table.appendChild(doc.createElement(goog.dom.TagName.TBODY));
  for (var i = 0;i < rows;i++) {
    var tr = doc.createElement(goog.dom.TagName.TR);
    for (var j = 0;j < columns;j++) {
      var td = doc.createElement(goog.dom.TagName.TD);
      if (fillWithNbsp) {
        goog.dom.setTextContent(td, goog.string.Unicode.NBSP);
      }
      tr.appendChild(td);
    }
    tbody.appendChild(tr);
  }
  return table;
};
goog.dom.constHtmlToNode = function(var_args) {
  var stringArray = goog.array.map(arguments, goog.string.Const.unwrap);
  var safeHtml = goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Constant HTML string, that gets turned into a " + "Node later, so it will be automatically balanced."), stringArray.join(""));
  return goog.dom.safeHtmlToNode(safeHtml);
};
goog.dom.safeHtmlToNode = function(html) {
  return goog.dom.safeHtmlToNode_(document, html);
};
goog.dom.safeHtmlToNode_ = function(doc, html) {
  var tempDiv = doc.createElement(goog.dom.TagName.DIV);
  if (goog.dom.BrowserFeature.INNER_HTML_NEEDS_SCOPED_ELEMENT) {
    goog.dom.safe.setInnerHtml(tempDiv, goog.html.SafeHtml.concat(goog.html.SafeHtml.BR, html));
    tempDiv.removeChild(tempDiv.firstChild);
  } else {
    goog.dom.safe.setInnerHtml(tempDiv, html);
  }
  return goog.dom.childrenToNode_(doc, tempDiv);
};
goog.dom.childrenToNode_ = function(doc, tempDiv) {
  if (tempDiv.childNodes.length == 1) {
    return tempDiv.removeChild(tempDiv.firstChild);
  } else {
    var fragment = doc.createDocumentFragment();
    while (tempDiv.firstChild) {
      fragment.appendChild(tempDiv.firstChild);
    }
    return fragment;
  }
};
goog.dom.isCss1CompatMode = function() {
  return goog.dom.isCss1CompatMode_(document);
};
goog.dom.isCss1CompatMode_ = function(doc) {
  if (goog.dom.COMPAT_MODE_KNOWN_) {
    return goog.dom.ASSUME_STANDARDS_MODE;
  }
  return doc.compatMode == "CSS1Compat";
};
goog.dom.canHaveChildren = function(node) {
  if (node.nodeType != goog.dom.NodeType.ELEMENT) {
    return false;
  }
  switch((node).tagName) {
    case goog.dom.TagName.APPLET:
    ;
    case goog.dom.TagName.AREA:
    ;
    case goog.dom.TagName.BASE:
    ;
    case goog.dom.TagName.BR:
    ;
    case goog.dom.TagName.COL:
    ;
    case goog.dom.TagName.COMMAND:
    ;
    case goog.dom.TagName.EMBED:
    ;
    case goog.dom.TagName.FRAME:
    ;
    case goog.dom.TagName.HR:
    ;
    case goog.dom.TagName.IMG:
    ;
    case goog.dom.TagName.INPUT:
    ;
    case goog.dom.TagName.IFRAME:
    ;
    case goog.dom.TagName.ISINDEX:
    ;
    case goog.dom.TagName.KEYGEN:
    ;
    case goog.dom.TagName.LINK:
    ;
    case goog.dom.TagName.NOFRAMES:
    ;
    case goog.dom.TagName.NOSCRIPT:
    ;
    case goog.dom.TagName.META:
    ;
    case goog.dom.TagName.OBJECT:
    ;
    case goog.dom.TagName.PARAM:
    ;
    case goog.dom.TagName.SCRIPT:
    ;
    case goog.dom.TagName.SOURCE:
    ;
    case goog.dom.TagName.STYLE:
    ;
    case goog.dom.TagName.TRACK:
    ;
    case goog.dom.TagName.WBR:
      return false;
  }
  return true;
};
goog.dom.appendChild = function(parent, child) {
  parent.appendChild(child);
};
goog.dom.append = function(parent, var_args) {
  goog.dom.append_(goog.dom.getOwnerDocument(parent), parent, arguments, 1);
};
goog.dom.removeChildren = function(node) {
  var child;
  while (child = node.firstChild) {
    node.removeChild(child);
  }
};
goog.dom.insertSiblingBefore = function(newNode, refNode) {
  if (refNode.parentNode) {
    refNode.parentNode.insertBefore(newNode, refNode);
  }
};
goog.dom.insertSiblingAfter = function(newNode, refNode) {
  if (refNode.parentNode) {
    refNode.parentNode.insertBefore(newNode, refNode.nextSibling);
  }
};
goog.dom.insertChildAt = function(parent, child, index) {
  parent.insertBefore(child, parent.childNodes[index] || null);
};
goog.dom.removeNode = function(node) {
  return node && node.parentNode ? node.parentNode.removeChild(node) : null;
};
goog.dom.replaceNode = function(newNode, oldNode) {
  var parent = oldNode.parentNode;
  if (parent) {
    parent.replaceChild(newNode, oldNode);
  }
};
goog.dom.flattenElement = function(element) {
  var child, parent = element.parentNode;
  if (parent && parent.nodeType != goog.dom.NodeType.DOCUMENT_FRAGMENT) {
    if (element.removeNode) {
      return (element.removeNode(false));
    } else {
      while (child = element.firstChild) {
        parent.insertBefore(child, element);
      }
      return (goog.dom.removeNode(element));
    }
  }
};
goog.dom.getChildren = function(element) {
  if (goog.dom.BrowserFeature.CAN_USE_CHILDREN_ATTRIBUTE && element.children != undefined) {
    return element.children;
  }
  return goog.array.filter(element.childNodes, function(node) {
    return node.nodeType == goog.dom.NodeType.ELEMENT;
  });
};
goog.dom.getFirstElementChild = function(node) {
  if (goog.isDef(node.firstElementChild)) {
    return (node).firstElementChild;
  }
  return goog.dom.getNextElementNode_(node.firstChild, true);
};
goog.dom.getLastElementChild = function(node) {
  if (goog.isDef(node.lastElementChild)) {
    return (node).lastElementChild;
  }
  return goog.dom.getNextElementNode_(node.lastChild, false);
};
goog.dom.getNextElementSibling = function(node) {
  if (goog.isDef(node.nextElementSibling)) {
    return (node).nextElementSibling;
  }
  return goog.dom.getNextElementNode_(node.nextSibling, true);
};
goog.dom.getPreviousElementSibling = function(node) {
  if (goog.isDef(node.previousElementSibling)) {
    return (node).previousElementSibling;
  }
  return goog.dom.getNextElementNode_(node.previousSibling, false);
};
goog.dom.getNextElementNode_ = function(node, forward) {
  while (node && node.nodeType != goog.dom.NodeType.ELEMENT) {
    node = forward ? node.nextSibling : node.previousSibling;
  }
  return (node);
};
goog.dom.getNextNode = function(node) {
  if (!node) {
    return null;
  }
  if (node.firstChild) {
    return node.firstChild;
  }
  while (node && !node.nextSibling) {
    node = node.parentNode;
  }
  return node ? node.nextSibling : null;
};
goog.dom.getPreviousNode = function(node) {
  if (!node) {
    return null;
  }
  if (!node.previousSibling) {
    return node.parentNode;
  }
  node = node.previousSibling;
  while (node && node.lastChild) {
    node = node.lastChild;
  }
  return node;
};
goog.dom.isNodeLike = function(obj) {
  return goog.isObject(obj) && obj.nodeType > 0;
};
goog.dom.isElement = function(obj) {
  return goog.isObject(obj) && obj.nodeType == goog.dom.NodeType.ELEMENT;
};
goog.dom.isWindow = function(obj) {
  return goog.isObject(obj) && obj["window"] == obj;
};
goog.dom.getParentElement = function(element) {
  var parent;
  if (goog.dom.BrowserFeature.CAN_USE_PARENT_ELEMENT_PROPERTY) {
    var isIe9 = goog.userAgent.IE && goog.userAgent.isVersionOrHigher("9") && !goog.userAgent.isVersionOrHigher("10");
    if (!(isIe9 && goog.global["SVGElement"] && element instanceof goog.global["SVGElement"])) {
      parent = element.parentElement;
      if (parent) {
        return parent;
      }
    }
  }
  parent = element.parentNode;
  return goog.dom.isElement(parent) ? (parent) : null;
};
goog.dom.contains = function(parent, descendant) {
  if (!parent || !descendant) {
    return false;
  }
  if (parent.contains && descendant.nodeType == goog.dom.NodeType.ELEMENT) {
    return parent == descendant || parent.contains(descendant);
  }
  if (typeof parent.compareDocumentPosition != "undefined") {
    return parent == descendant || Boolean(parent.compareDocumentPosition(descendant) & 16);
  }
  while (descendant && parent != descendant) {
    descendant = descendant.parentNode;
  }
  return descendant == parent;
};
goog.dom.compareNodeOrder = function(node1, node2) {
  if (node1 == node2) {
    return 0;
  }
  if (node1.compareDocumentPosition) {
    return node1.compareDocumentPosition(node2) & 2 ? 1 : -1;
  }
  if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9)) {
    if (node1.nodeType == goog.dom.NodeType.DOCUMENT) {
      return -1;
    }
    if (node2.nodeType == goog.dom.NodeType.DOCUMENT) {
      return 1;
    }
  }
  if ("sourceIndex" in node1 || node1.parentNode && "sourceIndex" in node1.parentNode) {
    var isElement1 = node1.nodeType == goog.dom.NodeType.ELEMENT;
    var isElement2 = node2.nodeType == goog.dom.NodeType.ELEMENT;
    if (isElement1 && isElement2) {
      return node1.sourceIndex - node2.sourceIndex;
    } else {
      var parent1 = node1.parentNode;
      var parent2 = node2.parentNode;
      if (parent1 == parent2) {
        return goog.dom.compareSiblingOrder_(node1, node2);
      }
      if (!isElement1 && goog.dom.contains(parent1, node2)) {
        return -1 * goog.dom.compareParentsDescendantNodeIe_(node1, node2);
      }
      if (!isElement2 && goog.dom.contains(parent2, node1)) {
        return goog.dom.compareParentsDescendantNodeIe_(node2, node1);
      }
      return (isElement1 ? node1.sourceIndex : parent1.sourceIndex) - (isElement2 ? node2.sourceIndex : parent2.sourceIndex);
    }
  }
  var doc = goog.dom.getOwnerDocument(node1);
  var range1, range2;
  range1 = doc.createRange();
  range1.selectNode(node1);
  range1.collapse(true);
  range2 = doc.createRange();
  range2.selectNode(node2);
  range2.collapse(true);
  return range1.compareBoundaryPoints(goog.global["Range"].START_TO_END, range2);
};
goog.dom.compareParentsDescendantNodeIe_ = function(textNode, node) {
  var parent = textNode.parentNode;
  if (parent == node) {
    return -1;
  }
  var sibling = node;
  while (sibling.parentNode != parent) {
    sibling = sibling.parentNode;
  }
  return goog.dom.compareSiblingOrder_(sibling, textNode);
};
goog.dom.compareSiblingOrder_ = function(node1, node2) {
  var s = node2;
  while (s = s.previousSibling) {
    if (s == node1) {
      return -1;
    }
  }
  return 1;
};
goog.dom.findCommonAncestor = function(var_args) {
  var i, count = arguments.length;
  if (!count) {
    return null;
  } else {
    if (count == 1) {
      return arguments[0];
    }
  }
  var paths = [];
  var minLength = Infinity;
  for (i = 0;i < count;i++) {
    var ancestors = [];
    var node = arguments[i];
    while (node) {
      ancestors.unshift(node);
      node = node.parentNode;
    }
    paths.push(ancestors);
    minLength = Math.min(minLength, ancestors.length);
  }
  var output = null;
  for (i = 0;i < minLength;i++) {
    var first = paths[0][i];
    for (var j = 1;j < count;j++) {
      if (first != paths[j][i]) {
        return output;
      }
    }
    output = first;
  }
  return output;
};
goog.dom.getOwnerDocument = function(node) {
  goog.asserts.assert(node, "Node cannot be null or undefined.");
  return (node.nodeType == goog.dom.NodeType.DOCUMENT ? node : node.ownerDocument || node.document);
};
goog.dom.getFrameContentDocument = function(frame) {
  return frame.contentDocument || (frame).contentWindow.document;
};
goog.dom.getFrameContentWindow = function(frame) {
  try {
    return frame.contentWindow || (frame.contentDocument ? goog.dom.getWindow(frame.contentDocument) : null);
  } catch (e) {
  }
  return null;
};
goog.dom.setTextContent = function(node, text) {
  goog.asserts.assert(node != null, "goog.dom.setTextContent expects a non-null value for node");
  if ("textContent" in node) {
    node.textContent = text;
  } else {
    if (node.nodeType == goog.dom.NodeType.TEXT) {
      node.data = text;
    } else {
      if (node.firstChild && node.firstChild.nodeType == goog.dom.NodeType.TEXT) {
        while (node.lastChild != node.firstChild) {
          node.removeChild(node.lastChild);
        }
        node.firstChild.data = text;
      } else {
        goog.dom.removeChildren(node);
        var doc = goog.dom.getOwnerDocument(node);
        node.appendChild(doc.createTextNode(String(text)));
      }
    }
  }
};
goog.dom.getOuterHtml = function(element) {
  goog.asserts.assert(element !== null, "goog.dom.getOuterHtml expects a non-null value for element");
  if ("outerHTML" in element) {
    return element.outerHTML;
  } else {
    var doc = goog.dom.getOwnerDocument(element);
    var div = doc.createElement(goog.dom.TagName.DIV);
    div.appendChild(element.cloneNode(true));
    return div.innerHTML;
  }
};
goog.dom.findNode = function(root, p) {
  var rv = [];
  var found = goog.dom.findNodes_(root, p, rv, true);
  return found ? rv[0] : undefined;
};
goog.dom.findNodes = function(root, p) {
  var rv = [];
  goog.dom.findNodes_(root, p, rv, false);
  return rv;
};
goog.dom.findNodes_ = function(root, p, rv, findOne) {
  if (root != null) {
    var child = root.firstChild;
    while (child) {
      if (p(child)) {
        rv.push(child);
        if (findOne) {
          return true;
        }
      }
      if (goog.dom.findNodes_(child, p, rv, findOne)) {
        return true;
      }
      child = child.nextSibling;
    }
  }
  return false;
};
goog.dom.TAGS_TO_IGNORE_ = {"SCRIPT":1, "STYLE":1, "HEAD":1, "IFRAME":1, "OBJECT":1};
goog.dom.PREDEFINED_TAG_VALUES_ = {"IMG":" ", "BR":"\n"};
goog.dom.isFocusableTabIndex = function(element) {
  return goog.dom.hasSpecifiedTabIndex_(element) && goog.dom.isTabIndexFocusable_(element);
};
goog.dom.setFocusableTabIndex = function(element, enable) {
  if (enable) {
    element.tabIndex = 0;
  } else {
    element.tabIndex = -1;
    element.removeAttribute("tabIndex");
  }
};
goog.dom.isFocusable = function(element) {
  var focusable;
  if (goog.dom.nativelySupportsFocus_(element)) {
    focusable = !element.disabled && (!goog.dom.hasSpecifiedTabIndex_(element) || goog.dom.isTabIndexFocusable_(element));
  } else {
    focusable = goog.dom.isFocusableTabIndex(element);
  }
  return focusable && goog.userAgent.IE ? goog.dom.hasNonZeroBoundingRect_((element)) : focusable;
};
goog.dom.hasSpecifiedTabIndex_ = function(element) {
  var attrNode = element.getAttributeNode("tabindex");
  return goog.isDefAndNotNull(attrNode) && attrNode.specified;
};
goog.dom.isTabIndexFocusable_ = function(element) {
  var index = (element).tabIndex;
  return goog.isNumber(index) && index >= 0 && index < 32768;
};
goog.dom.nativelySupportsFocus_ = function(element) {
  return element.tagName == goog.dom.TagName.A || element.tagName == goog.dom.TagName.INPUT || element.tagName == goog.dom.TagName.TEXTAREA || element.tagName == goog.dom.TagName.SELECT || element.tagName == goog.dom.TagName.BUTTON;
};
goog.dom.hasNonZeroBoundingRect_ = function(element) {
  var rect;
  if (!goog.isFunction(element["getBoundingClientRect"]) || goog.userAgent.IE && element.parentElement == null) {
    rect = {"height":element.offsetHeight, "width":element.offsetWidth};
  } else {
    rect = element.getBoundingClientRect();
  }
  return goog.isDefAndNotNull(rect) && rect.height > 0 && rect.width > 0;
};
goog.dom.getTextContent = function(node) {
  var textContent;
  if (goog.dom.BrowserFeature.CAN_USE_INNER_TEXT && node !== null && "innerText" in node) {
    textContent = goog.string.canonicalizeNewlines(node.innerText);
  } else {
    var buf = [];
    goog.dom.getTextContent_(node, buf, true);
    textContent = buf.join("");
  }
  textContent = textContent.replace(/ \xAD /g, " ").replace(/\xAD/g, "");
  textContent = textContent.replace(/\u200B/g, "");
  if (!goog.dom.BrowserFeature.CAN_USE_INNER_TEXT) {
    textContent = textContent.replace(/ +/g, " ");
  }
  if (textContent != " ") {
    textContent = textContent.replace(/^\s*/, "");
  }
  return textContent;
};
goog.dom.getRawTextContent = function(node) {
  var buf = [];
  goog.dom.getTextContent_(node, buf, false);
  return buf.join("");
};
goog.dom.getTextContent_ = function(node, buf, normalizeWhitespace) {
  if (node.nodeName in goog.dom.TAGS_TO_IGNORE_) {
  } else {
    if (node.nodeType == goog.dom.NodeType.TEXT) {
      if (normalizeWhitespace) {
        buf.push(String(node.nodeValue).replace(/(\r\n|\r|\n)/g, ""));
      } else {
        buf.push(node.nodeValue);
      }
    } else {
      if (node.nodeName in goog.dom.PREDEFINED_TAG_VALUES_) {
        buf.push(goog.dom.PREDEFINED_TAG_VALUES_[node.nodeName]);
      } else {
        var child = node.firstChild;
        while (child) {
          goog.dom.getTextContent_(child, buf, normalizeWhitespace);
          child = child.nextSibling;
        }
      }
    }
  }
};
goog.dom.getNodeTextLength = function(node) {
  return goog.dom.getTextContent(node).length;
};
goog.dom.getNodeTextOffset = function(node, opt_offsetParent) {
  var root = opt_offsetParent || goog.dom.getOwnerDocument(node).body;
  var buf = [];
  while (node && node != root) {
    var cur = node;
    while (cur = cur.previousSibling) {
      buf.unshift(goog.dom.getTextContent(cur));
    }
    node = node.parentNode;
  }
  return goog.string.trimLeft(buf.join("")).replace(/ +/g, " ").length;
};
goog.dom.getNodeAtOffset = function(parent, offset, opt_result) {
  var stack = [parent], pos = 0, cur = null;
  while (stack.length > 0 && pos < offset) {
    cur = stack.pop();
    if (cur.nodeName in goog.dom.TAGS_TO_IGNORE_) {
    } else {
      if (cur.nodeType == goog.dom.NodeType.TEXT) {
        var text = cur.nodeValue.replace(/(\r\n|\r|\n)/g, "").replace(/ +/g, " ");
        pos += text.length;
      } else {
        if (cur.nodeName in goog.dom.PREDEFINED_TAG_VALUES_) {
          pos += goog.dom.PREDEFINED_TAG_VALUES_[cur.nodeName].length;
        } else {
          for (var i = cur.childNodes.length - 1;i >= 0;i--) {
            stack.push(cur.childNodes[i]);
          }
        }
      }
    }
  }
  if (goog.isObject(opt_result)) {
    opt_result.remainder = cur ? cur.nodeValue.length + offset - pos - 1 : 0;
    opt_result.node = cur;
  }
  return cur;
};
goog.dom.isNodeList = function(val) {
  if (val && typeof val.length == "number") {
    if (goog.isObject(val)) {
      return typeof val.item == "function" || typeof val.item == "string";
    } else {
      if (goog.isFunction(val)) {
        return typeof val.item == "function";
      }
    }
  }
  return false;
};
goog.dom.getAncestorByTagNameAndClass = function(element, opt_tag, opt_class, opt_maxSearchSteps) {
  if (!opt_tag && !opt_class) {
    return null;
  }
  var tagName = opt_tag ? opt_tag.toUpperCase() : null;
  return (goog.dom.getAncestor(element, function(node) {
    return (!tagName || node.nodeName == tagName) && (!opt_class || goog.isString(node.className) && goog.array.contains(node.className.split(/\s+/), opt_class));
  }, true, opt_maxSearchSteps));
};
goog.dom.getAncestorByClass = function(element, className, opt_maxSearchSteps) {
  return goog.dom.getAncestorByTagNameAndClass(element, null, className, opt_maxSearchSteps);
};
goog.dom.getAncestor = function(element, matcher, opt_includeNode, opt_maxSearchSteps) {
  if (!opt_includeNode) {
    element = element.parentNode;
  }
  var steps = 0;
  while (element && (opt_maxSearchSteps == null || steps <= opt_maxSearchSteps)) {
    goog.asserts.assert(element.name != "parentNode");
    if (matcher(element)) {
      return element;
    }
    element = element.parentNode;
    steps++;
  }
  return null;
};
goog.dom.getActiveElement = function(doc) {
  try {
    return doc && doc.activeElement;
  } catch (e) {
  }
  return null;
};
goog.dom.getPixelRatio = function() {
  var win = goog.dom.getWindow();
  if (goog.isDef(win.devicePixelRatio)) {
    return win.devicePixelRatio;
  } else {
    if (win.matchMedia) {
      return goog.dom.matchesPixelRatio_(.75) || goog.dom.matchesPixelRatio_(1.5) || goog.dom.matchesPixelRatio_(2) || goog.dom.matchesPixelRatio_(3) || 1;
    }
  }
  return 1;
};
goog.dom.matchesPixelRatio_ = function(pixelRatio) {
  var win = goog.dom.getWindow();
  var query = "(-webkit-min-device-pixel-ratio: " + pixelRatio + ")," + "(min--moz-device-pixel-ratio: " + pixelRatio + ")," + "(min-resolution: " + pixelRatio + "dppx)";
  return win.matchMedia(query).matches ? pixelRatio : 0;
};
goog.dom.DomHelper = function(opt_document) {
  this.document_ = opt_document || goog.global.document || document;
};
goog.dom.DomHelper.prototype.getDomHelper = goog.dom.getDomHelper;
goog.dom.DomHelper.prototype.setDocument = function(document) {
  this.document_ = document;
};
goog.dom.DomHelper.prototype.getDocument = function() {
  return this.document_;
};
goog.dom.DomHelper.prototype.getElement = function(element) {
  return goog.dom.getElementHelper_(this.document_, element);
};
goog.dom.DomHelper.prototype.getRequiredElement = function(id) {
  return goog.dom.getRequiredElementHelper_(this.document_, id);
};
goog.dom.DomHelper.prototype.$ = goog.dom.DomHelper.prototype.getElement;
goog.dom.DomHelper.prototype.getElementsByTagNameAndClass = function(opt_tag, opt_class, opt_el) {
  return goog.dom.getElementsByTagNameAndClass_(this.document_, opt_tag, opt_class, opt_el);
};
goog.dom.DomHelper.prototype.getElementsByClass = function(className, opt_el) {
  var doc = opt_el || this.document_;
  return goog.dom.getElementsByClass(className, doc);
};
goog.dom.DomHelper.prototype.getElementByClass = function(className, opt_el) {
  var doc = opt_el || this.document_;
  return goog.dom.getElementByClass(className, doc);
};
goog.dom.DomHelper.prototype.getRequiredElementByClass = function(className, opt_root) {
  var root = opt_root || this.document_;
  return goog.dom.getRequiredElementByClass(className, root);
};
goog.dom.DomHelper.prototype.$$ = goog.dom.DomHelper.prototype.getElementsByTagNameAndClass;
goog.dom.DomHelper.prototype.setProperties = goog.dom.setProperties;
goog.dom.DomHelper.prototype.getViewportSize = function(opt_window) {
  return goog.dom.getViewportSize(opt_window || this.getWindow());
};
goog.dom.DomHelper.prototype.getDocumentHeight = function() {
  return goog.dom.getDocumentHeight_(this.getWindow());
};
goog.dom.Appendable;
goog.dom.DomHelper.prototype.createDom = function(tagName, opt_attributes, var_args) {
  return goog.dom.createDom_(this.document_, arguments);
};
goog.dom.DomHelper.prototype.createUntypedDom = function(tagName, opt_attributes, var_args) {
  return goog.dom.createDom_(this.document_, arguments);
};
goog.dom.DomHelper.prototype.$dom = goog.dom.DomHelper.prototype.createDom;
goog.dom.DomHelper.prototype.createElement = function(name) {
  return this.document_.createElement(String(name));
};
goog.dom.DomHelper.prototype.createTextNode = function(content) {
  return this.document_.createTextNode(String(content));
};
goog.dom.DomHelper.prototype.createTable = function(rows, columns, opt_fillWithNbsp) {
  return goog.dom.createTable_(this.document_, rows, columns, !!opt_fillWithNbsp);
};
goog.dom.DomHelper.prototype.safeHtmlToNode = function(html) {
  return goog.dom.safeHtmlToNode_(this.document_, html);
};
goog.dom.DomHelper.prototype.isCss1CompatMode = function() {
  return goog.dom.isCss1CompatMode_(this.document_);
};
goog.dom.DomHelper.prototype.getWindow = function() {
  return goog.dom.getWindow_(this.document_);
};
goog.dom.DomHelper.prototype.getDocumentScrollElement = function() {
  return goog.dom.getDocumentScrollElement_(this.document_);
};
goog.dom.DomHelper.prototype.getDocumentScroll = function() {
  return goog.dom.getDocumentScroll_(this.document_);
};
goog.dom.DomHelper.prototype.getActiveElement = function(opt_doc) {
  return goog.dom.getActiveElement(opt_doc || this.document_);
};
goog.dom.DomHelper.prototype.appendChild = goog.dom.appendChild;
goog.dom.DomHelper.prototype.append = goog.dom.append;
goog.dom.DomHelper.prototype.canHaveChildren = goog.dom.canHaveChildren;
goog.dom.DomHelper.prototype.removeChildren = goog.dom.removeChildren;
goog.dom.DomHelper.prototype.insertSiblingBefore = goog.dom.insertSiblingBefore;
goog.dom.DomHelper.prototype.insertSiblingAfter = goog.dom.insertSiblingAfter;
goog.dom.DomHelper.prototype.insertChildAt = goog.dom.insertChildAt;
goog.dom.DomHelper.prototype.removeNode = goog.dom.removeNode;
goog.dom.DomHelper.prototype.replaceNode = goog.dom.replaceNode;
goog.dom.DomHelper.prototype.flattenElement = goog.dom.flattenElement;
goog.dom.DomHelper.prototype.getChildren = goog.dom.getChildren;
goog.dom.DomHelper.prototype.getFirstElementChild = goog.dom.getFirstElementChild;
goog.dom.DomHelper.prototype.getLastElementChild = goog.dom.getLastElementChild;
goog.dom.DomHelper.prototype.getNextElementSibling = goog.dom.getNextElementSibling;
goog.dom.DomHelper.prototype.getPreviousElementSibling = goog.dom.getPreviousElementSibling;
goog.dom.DomHelper.prototype.getNextNode = goog.dom.getNextNode;
goog.dom.DomHelper.prototype.getPreviousNode = goog.dom.getPreviousNode;
goog.dom.DomHelper.prototype.isNodeLike = goog.dom.isNodeLike;
goog.dom.DomHelper.prototype.isElement = goog.dom.isElement;
goog.dom.DomHelper.prototype.isWindow = goog.dom.isWindow;
goog.dom.DomHelper.prototype.getParentElement = goog.dom.getParentElement;
goog.dom.DomHelper.prototype.contains = goog.dom.contains;
goog.dom.DomHelper.prototype.compareNodeOrder = goog.dom.compareNodeOrder;
goog.dom.DomHelper.prototype.findCommonAncestor = goog.dom.findCommonAncestor;
goog.dom.DomHelper.prototype.getOwnerDocument = goog.dom.getOwnerDocument;
goog.dom.DomHelper.prototype.getFrameContentDocument = goog.dom.getFrameContentDocument;
goog.dom.DomHelper.prototype.getFrameContentWindow = goog.dom.getFrameContentWindow;
goog.dom.DomHelper.prototype.setTextContent = goog.dom.setTextContent;
goog.dom.DomHelper.prototype.getOuterHtml = goog.dom.getOuterHtml;
goog.dom.DomHelper.prototype.findNode = goog.dom.findNode;
goog.dom.DomHelper.prototype.findNodes = goog.dom.findNodes;
goog.dom.DomHelper.prototype.isFocusableTabIndex = goog.dom.isFocusableTabIndex;
goog.dom.DomHelper.prototype.setFocusableTabIndex = goog.dom.setFocusableTabIndex;
goog.dom.DomHelper.prototype.isFocusable = goog.dom.isFocusable;
goog.dom.DomHelper.prototype.getTextContent = goog.dom.getTextContent;
goog.dom.DomHelper.prototype.getNodeTextLength = goog.dom.getNodeTextLength;
goog.dom.DomHelper.prototype.getNodeTextOffset = goog.dom.getNodeTextOffset;
goog.dom.DomHelper.prototype.getNodeAtOffset = goog.dom.getNodeAtOffset;
goog.dom.DomHelper.prototype.isNodeList = goog.dom.isNodeList;
goog.dom.DomHelper.prototype.getAncestorByTagNameAndClass = goog.dom.getAncestorByTagNameAndClass;
goog.dom.DomHelper.prototype.getAncestorByClass = goog.dom.getAncestorByClass;
goog.dom.DomHelper.prototype.getAncestor = goog.dom.getAncestor;
goog.provide("uno.env");
goog.require("goog.userAgent");
(function() {
  var ua = goog.userAgent;
  var env = uno.env;
  env.getPlatform = function() {
    if (ua.MAC) {
      return "mac";
    } else {
      if (ua.WINDOWS) {
        return "win";
      } else {
        if (ua.ANDROID) {
          return "android";
        } else {
          if (ua.IPHONE || ua.IPAD) {
            return "ios";
          } else {
            return "web";
          }
        }
      }
    }
  };
})();
goog.provide("uno.api.cec");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("uno.env");
uno.api.cec = function() {
  var log = goog.debug.Logger.getLogger("uno.api.cec");
  var cec = {};
  cec.iframe = null;
  cec.iframeBody = null;
  cec.EN = null;
  cec.STATES = {NOT_RUNNING:"NOT_RUNNING", LOADING:"LOADING", RUNNING:"RUNNING"};
  var state = cec.STATES.NOT_RUNNING;
  cec.MODES = {OFF:"OFF", ONTOP:"ONTOP", BELOW:"BELOW", HIDDEN:"HIDDEN"};
  var mode = cec.MODES.OFF;
  var execCommandQueue = [];
  cec.setup = function(opt, setupDoneCallback) {
    cec.cleanup();
    state = cec.STATES.LOADING;
    if (opt.shared) {
      delete opt.shared;
    }
    if (opt.context) {
      opt.context.showPopup = false;
    }
    mode = cec.MODES.HIDDEN;
    if (opt.context != null || opt["context-upsell"] != null || opt["context-info"] != null) {
      mode = cec.MODES.BELOW;
    }
    if (opt.template != null) {
      mode = cec.MODES.ONTOP;
    }
    var iframeID = "common-editor-classic-iframe";
    var iframeStyle = "display: none; border: none;";
    var platform = uno.env.getPlatform();
    if (opt.env && opt.env.platform) {
      platform = opt.env.platform;
    }
    var bodyContent = "" + '<div class="en-note-container" id="container">' + '<div class="en-note">' + '<div id="en-note"></' + "div>" + "</" + "div>" + "</" + "div>" + '<div style="position:absolute; top: 0; left: 0; ' + 'width: 0; height: 0;" class="en-preload"></' + "div>" + '<link href="lib/common-editor-classic/dist/' + platform + "/en-" + platform + '-min.css" ' + 'rel="stylesheet" type="text/css" media="all" />';
    cec.iframe = goog.dom.createElement("iframe");
    cec.iframe.setAttribute("id", iframeID);
    cec.iframe.setAttribute("style", iframeStyle);
    cec.iframe.setAttribute("height", "100px");
    cec.iframe.onload = function() {
      cec.iframeBody = cec.iframe.contentWindow.document.body;
      cec.iframeBody.innerHTML = bodyContent;
      cec.iframeBody.style.backgroundColor = "white";
      applyMode(mode);
      handleWindowResize();
      window.addEventListener("resize", handleWindowResize);
      var cecScript = cec.iframe.contentWindow.document.createElement("script");
      cecScript.type = "text/javascript";
      cecScript.src = "lib/common-editor-classic/dist/" + platform + "/en-" + platform + "-min.js";
      cecScript.onload = function() {
        cec.EN = cec.iframe.contentWindow.EN;
        cec.EN.setup(opt);
        state = cec.STATES.RUNNING;
        if (setupDoneCallback != null) {
          setupDoneCallback();
        }
      };
      cec.iframeBody.appendChild(cecScript);
    };
    cec.iframe.src = "about:blank";
    document.body.appendChild(cec.iframe);
    return true;
  };
  cec.cleanup = function() {
    if (cec.iframe != null) {
      document.body.removeChild(cec.iframe);
      cec.iframe = null;
    }
    cec.iframeBody = null;
    cec.EN = null;
    state = cec.STATES.NOT_RUNNING;
    mode = cec.MODES.OFF;
    window.removeEventListener("resize", handleWindowResize);
    execCommandQueue = [];
  };
  var applyMode = function(mode) {
    if (cec.iframe == null) {
      log.warning("CEC couldn't find iframe?");
      return;
    }
    if (mode === cec.MODES.OFF || mode === cec.MODES.HIDDEN) {
      cec.iframe.style.display = "none";
    }
    if (mode === cec.MODES.ONTOP) {
      cec.iframe.style.display = "block";
      cec.iframe.style.position = "absolute";
      cec.iframe.style.top = "0px";
      cec.iframe.style.left = "0px";
    }
    if (mode === cec.MODES.BELOW) {
      cec.iframe.style.display = "block";
      cec.iframe.style.position = "static";
      cec.iframe.style.top = "auto";
      cec.iframe.style.left = "auto";
      [".en-shared", ".en-note"].forEach(function(q) {
        var elem = cec.iframeBody.querySelector(q);
        if (elem != null) {
          elem.style.display = "none";
        }
      });
    }
  };
  var handleWindowResize = function() {
    if (mode === cec.MODES.ONTOP) {
      cec.iframe.setAttribute("width", window.innerWidth);
      cec.iframe.setAttribute("height", window.innerHeight);
    }
    if (mode === cec.MODES.BELOW) {
      cec.iframe.setAttribute("width", document.documentElement.clientWidth - 20);
      cec.iframe.setAttribute("height", cec.iframeBody.offsetHeight + 20);
    }
  };
  cec.getMode = function() {
    return mode;
  };
  cec.getState = function() {
    return state;
  };
  cec.execCommand = function(command, value, options) {
    value = value ? value : null;
    options = options ? options : null;
    var execCommand = function(command, value, options) {
      log.info("CEC.execCommand: " + command);
      var result = cec.EN.execCommand(command, value, options);
      if (command.indexOf("context") >= 0) {
        handleWindowResize();
      }
      return result;
    };
    if (cec.getState() === cec.STATES.LOADING) {
      execCommandQueue.push([command, value, options]);
      log.warning("CEC queued execCommand " + command + " due to loading");
      return false;
    }
    if (cec.getState() !== cec.STATES.RUNNING) {
      log.error("CEC saw command " + command + " before CEC is ready!");
      return false;
    }
    for (var i = 0;i < execCommandQueue.length;i++) {
      var elem = execCommandQueue[i];
      execCommand(elem[0], elem[1], elem[2]);
      log.warning("CEC applied execCommand from queue: " + elem[0]);
    }
    execCommandQueue = [];
    return execCommand(command, value, options);
  };
  cec.queryCommandEnabled = function(command, options) {
    options = options ? options : null;
    log.info("CEC.queryCommandEnabled " + command + " " + options);
    return cec.EN.queryCommandEnabled(command, options);
  };
  cec.queryCommandValue = function(command, options) {
    options = options ? options : null;
    log.info("CEC.queryCommandValue " + command + " " + options);
    return cec.EN.queryCommandValue(command, options);
  };
  cec.queryCommandState = function(command, options) {
    options = options ? options : null;
    log.info("CEC.queryCommandState " + command + " " + options);
    return cec.EN.queryCommandState(command, options);
  };
  return cec;
}();
goog.provide("uno.api.celogger");
goog.require("goog.debug.Logger");
(function() {
  var celogger = uno && uno.api && uno.api.celogger || {};
  var log = goog && goog.debug && goog.debug.Logger.getLogger("uno.api.celogger") || {config:console.log.bind(console), info:console.log.bind(console)};
  celogger.wrap = function(EN) {
    celogger.EN = {setup:EN.setup.bind(EN), cleanup:EN.cleanup.bind(EN), execCommand:EN.execCommand.bind(EN), queryCommandEnabled:EN.queryCommandEnabled.bind(EN), queryCommandValue:EN.queryCommandValue.bind(EN), queryCommandState:EN.queryCommandState.bind(EN), notification:null};
    EN.setup = function(opt) {
      var obj = typeof opt === "string" ? JSON.parse(opt) : opt;
      log.config("EN.setup\n" + JSON.stringify(obj, null, 2));
      return celogger.EN.setup(opt);
    };
    EN.cleanup = function() {
      log.info("EN.cleanup");
      return celogger.EN.cleanup();
    };
    EN.execCommand = function(command, value, options) {
      logCommand("EN.execCommand", command, value, options);
      var result = celogger.EN.execCommand(command, value, options);
      log.info("execCommand returning: " + result + "\n");
      return result;
    };
    EN.queryCommandEnabled = function(command, options) {
      logCommand("EN.queryCommandEnabled", command, options);
      var result = celogger.EN.queryCommandEnabled(command, options);
      log.info("queryCommandEnabled returning: " + result + "\n");
      return result;
    };
    EN.queryCommandValue = function(command, options) {
      logCommand("EN.queryCommandValue", command, options);
      var result = celogger.EN.queryCommandValue(command, options);
      log.info("queryCommandValue returning: " + result + "\n");
      return result;
    };
    EN.queryCommandState = function(command, options) {
      logCommand("EN.queryCommandState", command, options);
      var result = celogger.EN.queryCommandState(command, options);
      log.info("queryCommandState returning: " + result + "\n");
      return result;
    };
    if (window.Evernote && Evernote.handleJavascriptEvent) {
      celogger.EN.notification = Evernote.handleJavascriptEvent.bind(Evernote);
      Evernote.handleJavascriptEvent = function(name, info) {
        log.info("NOTIFICATION : " + name + " : " + JSON.stringify(JSON.parse(info), null, 2));
        return celogger.EN.notification(name, info);
      };
    } else {
      if (window.evernoteClient && evernoteClient.postNotification) {
        celogger.EN.notification = evernoteClient.postNotification.bind(evernoteClient);
        evernoteClient.postNotification = function(name, info) {
          log.info("NOTIFICATION : " + name + " : " + JSON.stringify(JSON.parse(info), null, 2));
          return celogger.EN.notification(name, info);
        };
      } else {
        if (window.evernoteClient && evernoteClient.handleNotificationInfo) {
          celogger.EN.notification = evernoteClient.handleNotificationInfo.bind(evernoteClient);
          evernoteClient.postNotification = function(name, info) {
            log.info("NOTIFICATION : " + name + " : " + JSON.stringify(JSON.parse(info), null, 2));
            return celogger.EN.notification(name, info);
          };
        } else {
          if (EN.notification != null) {
            celogger.EN.notification = EN.notification;
            EN.notification = function(name, info) {
              log.info("NOTIFICATION : " + name + " : " + JSON.stringify(info, null, 2));
              return celogger.EN.notification(name, info);
            };
          }
        }
      }
    }
  };
  function logCommand(method, command, value, options) {
    var message = "COMMAND : " + method + "(" + command;
    if (value === undefined) {
      message += options === undefined ? "" : ", undefined, " + options;
    } else {
      if (value && typeof value === "object") {
        value = JSON.stringify(value, null, 2);
      }
      if (options && typeof options === "object") {
        options = JSON.stringify(options, null, 2);
      }
      message += ", " + value + (options === undefined ? "" : ", " + options);
    }
    message += ")";
    log.info(message);
  }
})();
goog.provide("uno.Auth");
goog.require("goog.debug.Logger");
(function() {
  var log = goog.debug.Logger.getLogger("uno.Auth");
  var Auth = uno.Auth = function(options) {
    this.router = options.router;
    this.providers = {};
  };
  Auth.ERROR_CODE_NO_AUTH = 2001;
  Auth.ERROR_CODE_INVALID_AUTH = 2002;
  Auth.ERROR_CODE_NETWORK_ERROR = 2003;
  Auth.ERROR_CODE_UNKNOWN = 2004;
  Auth.prototype.getTokenAsync = function(providerName, refresh, askUserForPermission) {
    var provider = this.providers[providerName] || this.addProvider(providerName);
    if (refresh) {
      provider.token = null;
    }
    if (provider.token) {
      return Promise.resolve(provider.token);
    }
    if (provider.request) {
      return provider.request;
    }
    provider.request = this.router.toHostAsync("requestAuth", {serviceName:provider.name, refresh:!!refresh, askUserForPermission:!!askUserForPermission}).then(function(response) {
      provider.request = null;
      provider.token = response.token;
      provider.lastRefreshed = response.lastRefreshed;
      provider.errorCode = response.errorCode;
      if (response.errorCode) {
        var err = new Error;
        err.provider = providerName;
        err.errorCode = response.errorCode;
        throw err;
      } else {
        return response.token;
      }
    })["catch"](function(error) {
      provider.request = null;
      provider.errorCode = error.errorCode;
      throw error;
    });
    return provider.request;
  };
  Auth.prototype.addProvider = function(name) {
    this.providers[name] = {name:name, request:null, token:null, errorCode:null, lastRefreshed:null};
    return this.providers[name];
  };
})();
goog.provide("uno.Cache");
goog.require("goog.debug.Logger");
(function() {
  var log = goog.debug.Logger.getLogger("uno.Cache");
  var Cache = uno.Cache = function(options) {
    this.router = options.router;
    this.diskEnabled = false;
    this.memCache = {};
  };
  Cache.prototype.readMem = function(key) {
    return this.memCache[key];
  };
  Cache.prototype.writeMem = function(key, value) {
    this.memCache[key] = value;
  };
  Cache.prototype.readDiskAsync = function(key) {
    if (this.diskEnabled) {
      return this.router.toHostAsync("getFromCache", {href:key}).then(function(data) {
        return data.data;
      });
    } else {
      return Promise.resolve();
    }
  };
  Cache.prototype.writeDisk = function(key, value) {
    if (this.diskEnabled) {
      this.router.toHostAsync("saveInCache", {href:key});
    }
  };
  Cache.prototype.write = function(key, value) {
    this.writeMem(key, value);
    this.writeDisk(key, value);
  };
})();
goog.provide("goog.dom.classes");
goog.require("goog.array");
goog.dom.classes.set = function(element, className) {
  element.className = className;
};
goog.dom.classes.get = function(element) {
  var className = element.className;
  return goog.isString(className) && className.match(/\S+/g) || [];
};
goog.dom.classes.add = function(element, var_args) {
  var classes = goog.dom.classes.get(element);
  var args = goog.array.slice(arguments, 1);
  var expectedCount = classes.length + args.length;
  goog.dom.classes.add_(classes, args);
  goog.dom.classes.set(element, classes.join(" "));
  return classes.length == expectedCount;
};
goog.dom.classes.remove = function(element, var_args) {
  var classes = goog.dom.classes.get(element);
  var args = goog.array.slice(arguments, 1);
  var newClasses = goog.dom.classes.getDifference_(classes, args);
  goog.dom.classes.set(element, newClasses.join(" "));
  return newClasses.length == classes.length - args.length;
};
goog.dom.classes.add_ = function(classes, args) {
  for (var i = 0;i < args.length;i++) {
    if (!goog.array.contains(classes, args[i])) {
      classes.push(args[i]);
    }
  }
};
goog.dom.classes.getDifference_ = function(arr1, arr2) {
  return goog.array.filter(arr1, function(item) {
    return !goog.array.contains(arr2, item);
  });
};
goog.dom.classes.swap = function(element, fromClass, toClass) {
  var classes = goog.dom.classes.get(element);
  var removed = false;
  for (var i = 0;i < classes.length;i++) {
    if (classes[i] == fromClass) {
      goog.array.splice(classes, i--, 1);
      removed = true;
    }
  }
  if (removed) {
    classes.push(toClass);
    goog.dom.classes.set(element, classes.join(" "));
  }
  return removed;
};
goog.dom.classes.addRemove = function(element, classesToRemove, classesToAdd) {
  var classes = goog.dom.classes.get(element);
  if (goog.isString(classesToRemove)) {
    goog.array.remove(classes, classesToRemove);
  } else {
    if (goog.isArray(classesToRemove)) {
      classes = goog.dom.classes.getDifference_(classes, classesToRemove);
    }
  }
  if (goog.isString(classesToAdd) && !goog.array.contains(classes, classesToAdd)) {
    classes.push(classesToAdd);
  } else {
    if (goog.isArray(classesToAdd)) {
      goog.dom.classes.add_(classes, classesToAdd);
    }
  }
  goog.dom.classes.set(element, classes.join(" "));
};
goog.dom.classes.has = function(element, className) {
  return goog.array.contains(goog.dom.classes.get(element), className);
};
goog.dom.classes.enable = function(element, className, enabled) {
  if (enabled) {
    goog.dom.classes.add(element, className);
  } else {
    goog.dom.classes.remove(element, className);
  }
};
goog.dom.classes.toggle = function(element, className) {
  var add = !goog.dom.classes.has(element, className);
  goog.dom.classes.enable(element, className, add);
  return add;
};
goog.provide("goog.log");
goog.provide("goog.log.Level");
goog.provide("goog.log.LogRecord");
goog.provide("goog.log.Logger");
goog.require("goog.debug");
goog.require("goog.debug.LogManager");
goog.require("goog.debug.LogRecord");
goog.require("goog.debug.Logger");
goog.define("goog.log.ENABLED", goog.debug.LOGGING_ENABLED);
goog.log.ROOT_LOGGER_NAME = goog.debug.Logger.ROOT_LOGGER_NAME;
goog.log.Logger = goog.debug.Logger;
goog.log.Level = goog.debug.Logger.Level;
goog.log.LogRecord = goog.debug.LogRecord;
goog.log.getLogger = function(name, opt_level) {
  if (goog.log.ENABLED) {
    var logger = goog.debug.LogManager.getLogger(name);
    if (opt_level && logger) {
      logger.setLevel(opt_level);
    }
    return logger;
  } else {
    return null;
  }
};
goog.log.addHandler = function(logger, handler) {
  if (goog.log.ENABLED && logger) {
    logger.addHandler(handler);
  }
};
goog.log.removeHandler = function(logger, handler) {
  if (goog.log.ENABLED && logger) {
    return logger.removeHandler(handler);
  } else {
    return false;
  }
};
goog.log.log = function(logger, level, msg, opt_exception) {
  if (goog.log.ENABLED && logger) {
    logger.log(level, msg, opt_exception);
  }
};
goog.log.error = function(logger, msg, opt_exception) {
  if (goog.log.ENABLED && logger) {
    logger.severe(msg, opt_exception);
  }
};
goog.log.warning = function(logger, msg, opt_exception) {
  if (goog.log.ENABLED && logger) {
    logger.warning(msg, opt_exception);
  }
};
goog.log.info = function(logger, msg, opt_exception) {
  if (goog.log.ENABLED && logger) {
    logger.info(msg, opt_exception);
  }
};
goog.log.fine = function(logger, msg, opt_exception) {
  if (goog.log.ENABLED && logger) {
    logger.fine(msg, opt_exception);
  }
};
goog.provide("goog.dom.SavedRange");
goog.require("goog.Disposable");
goog.require("goog.log");
goog.dom.SavedRange = function() {
  goog.Disposable.call(this);
};
goog.inherits(goog.dom.SavedRange, goog.Disposable);
goog.dom.SavedRange.logger_ = goog.log.getLogger("goog.dom.SavedRange");
goog.dom.SavedRange.prototype.restore = function(opt_stayAlive) {
  if (this.isDisposed()) {
    goog.log.error(goog.dom.SavedRange.logger_, "Disposed SavedRange objects cannot be restored.");
  }
  var range = this.restoreInternal();
  if (!opt_stayAlive) {
    this.dispose();
  }
  return range;
};
goog.dom.SavedRange.prototype.restoreInternal = goog.abstractMethod;
goog.provide("goog.dom.SavedCaretRange");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.SavedRange");
goog.require("goog.dom.TagName");
goog.require("goog.string");
goog.dom.SavedCaretRange = function(range) {
  goog.dom.SavedRange.call(this);
  this.startCaretId_ = goog.string.createUniqueString();
  this.endCaretId_ = goog.string.createUniqueString();
  this.reversed_ = range.isReversed();
  this.dom_ = goog.dom.getDomHelper(range.getDocument());
  range.surroundWithNodes(this.createCaret_(true), this.createCaret_(false));
};
goog.inherits(goog.dom.SavedCaretRange, goog.dom.SavedRange);
goog.dom.SavedCaretRange.prototype.toAbstractRange = function() {
  var range = null;
  var startCaret = this.getCaret(true);
  var endCaret = this.getCaret(false);
  if (startCaret && endCaret) {
    range = goog.dom.Range.createFromNodes(startCaret, 0, endCaret, 0);
  }
  return range;
};
goog.dom.SavedCaretRange.prototype.getCaret = function(start) {
  return this.dom_.getElement(start ? this.startCaretId_ : this.endCaretId_);
};
goog.dom.SavedCaretRange.prototype.removeCarets = function(opt_range) {
  goog.dom.removeNode(this.getCaret(true));
  goog.dom.removeNode(this.getCaret(false));
  return opt_range;
};
goog.dom.SavedCaretRange.prototype.setRestorationDocument = function(doc) {
  this.dom_.setDocument(doc);
};
goog.dom.SavedCaretRange.prototype.restoreInternal = function() {
  var range = null;
  var anchorCaret = this.getCaret(!this.reversed_);
  var focusCaret = this.getCaret(this.reversed_);
  if (anchorCaret && focusCaret) {
    var anchorNode = anchorCaret.parentNode;
    var anchorOffset = goog.array.indexOf(anchorNode.childNodes, anchorCaret);
    var focusNode = focusCaret.parentNode;
    var focusOffset = goog.array.indexOf(focusNode.childNodes, focusCaret);
    if (focusNode == anchorNode) {
      if (this.reversed_) {
        anchorOffset--;
      } else {
        focusOffset--;
      }
    }
    range = goog.dom.Range.createFromNodes(anchorNode, anchorOffset, focusNode, focusOffset);
    range = this.removeCarets(range);
    range.select();
  } else {
    this.removeCarets();
  }
  return range;
};
goog.dom.SavedCaretRange.prototype.disposeInternal = function() {
  this.removeCarets();
  this.dom_ = null;
};
goog.dom.SavedCaretRange.prototype.createCaret_ = function(start) {
  return this.dom_.createDom(goog.dom.TagName.SPAN, {"id":start ? this.startCaretId_ : this.endCaretId_});
};
goog.dom.SavedCaretRange.CARET_REGEX = /<span\s+id="?goog_\d+"?><\/span>/ig;
goog.dom.SavedCaretRange.htmlEqual = function(str1, str2) {
  return str1 == str2 || str1.replace(goog.dom.SavedCaretRange.CARET_REGEX, "") == str2.replace(goog.dom.SavedCaretRange.CARET_REGEX, "");
};
goog.provide("goog.dom.TagIterator");
goog.provide("goog.dom.TagWalkType");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.iter.Iterator");
goog.require("goog.iter.StopIteration");
goog.dom.TagWalkType = {START_TAG:1, OTHER:0, END_TAG:-1};
goog.dom.TagIterator = function(opt_node, opt_reversed, opt_unconstrained, opt_tagType, opt_depth) {
  this.reversed = !!opt_reversed;
  this.node = null;
  this.tagType = goog.dom.TagWalkType.OTHER;
  this.depth;
  this.started_ = false;
  this.constrained = !opt_unconstrained;
  if (opt_node) {
    this.setPosition(opt_node, opt_tagType);
  }
  this.depth = opt_depth != undefined ? opt_depth : this.tagType || 0;
  if (this.reversed) {
    this.depth *= -1;
  }
};
goog.inherits(goog.dom.TagIterator, goog.iter.Iterator);
goog.dom.TagIterator.prototype.setPosition = function(node, opt_tagType, opt_depth) {
  this.node = node;
  if (node) {
    if (goog.isNumber(opt_tagType)) {
      this.tagType = opt_tagType;
    } else {
      this.tagType = this.node.nodeType != goog.dom.NodeType.ELEMENT ? goog.dom.TagWalkType.OTHER : this.reversed ? goog.dom.TagWalkType.END_TAG : goog.dom.TagWalkType.START_TAG;
    }
  }
  if (goog.isNumber(opt_depth)) {
    this.depth = opt_depth;
  }
};
goog.dom.TagIterator.prototype.copyFrom = function(other) {
  this.node = other.node;
  this.tagType = other.tagType;
  this.depth = other.depth;
  this.reversed = other.reversed;
  this.constrained = other.constrained;
};
goog.dom.TagIterator.prototype.clone = function() {
  return new goog.dom.TagIterator(this.node, this.reversed, !this.constrained, this.tagType, this.depth);
};
goog.dom.TagIterator.prototype.skipTag = function() {
  var check = this.reversed ? goog.dom.TagWalkType.END_TAG : goog.dom.TagWalkType.START_TAG;
  if (this.tagType == check) {
    this.tagType = (check * -1);
    this.depth += this.tagType * (this.reversed ? -1 : 1);
  }
};
goog.dom.TagIterator.prototype.restartTag = function() {
  var check = this.reversed ? goog.dom.TagWalkType.START_TAG : goog.dom.TagWalkType.END_TAG;
  if (this.tagType == check) {
    this.tagType = (check * -1);
    this.depth += this.tagType * (this.reversed ? -1 : 1);
  }
};
goog.dom.TagIterator.prototype.next = function() {
  var node;
  if (this.started_) {
    if (!this.node || this.constrained && this.depth == 0) {
      throw goog.iter.StopIteration;
    }
    node = this.node;
    var startType = this.reversed ? goog.dom.TagWalkType.END_TAG : goog.dom.TagWalkType.START_TAG;
    if (this.tagType == startType) {
      var child = this.reversed ? node.lastChild : node.firstChild;
      if (child) {
        this.setPosition(child);
      } else {
        this.setPosition(node, (startType * -1));
      }
    } else {
      var sibling = this.reversed ? node.previousSibling : node.nextSibling;
      if (sibling) {
        this.setPosition(sibling);
      } else {
        this.setPosition(node.parentNode, (startType * -1));
      }
    }
    this.depth += this.tagType * (this.reversed ? -1 : 1);
  } else {
    this.started_ = true;
  }
  node = this.node;
  if (!this.node) {
    throw goog.iter.StopIteration;
  }
  return node;
};
goog.dom.TagIterator.prototype.isStarted = function() {
  return this.started_;
};
goog.dom.TagIterator.prototype.isStartTag = function() {
  return this.tagType == goog.dom.TagWalkType.START_TAG;
};
goog.dom.TagIterator.prototype.isEndTag = function() {
  return this.tagType == goog.dom.TagWalkType.END_TAG;
};
goog.dom.TagIterator.prototype.isNonElement = function() {
  return this.tagType == goog.dom.TagWalkType.OTHER;
};
goog.dom.TagIterator.prototype.equals = function(other) {
  return other.node == this.node && (!this.node || other.tagType == this.tagType);
};
goog.dom.TagIterator.prototype.splice = function(var_args) {
  var node = this.node;
  this.restartTag();
  this.reversed = !this.reversed;
  goog.dom.TagIterator.prototype.next.call(this);
  this.reversed = !this.reversed;
  var arr = goog.isArrayLike(arguments[0]) ? arguments[0] : arguments;
  for (var i = arr.length - 1;i >= 0;i--) {
    goog.dom.insertSiblingAfter(arr[i], node);
  }
  goog.dom.removeNode(node);
};
goog.provide("goog.dom.AbstractRange");
goog.provide("goog.dom.RangeIterator");
goog.provide("goog.dom.RangeType");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.SavedCaretRange");
goog.require("goog.dom.TagIterator");
goog.require("goog.userAgent");
goog.dom.RangeType = {TEXT:"text", CONTROL:"control", MULTI:"mutli"};
goog.dom.AbstractRange = function() {
};
goog.dom.AbstractRange.getBrowserSelectionForWindow = function(win) {
  if (win.getSelection) {
    return win.getSelection();
  } else {
    var doc = win.document;
    var sel = doc.selection;
    if (sel) {
      try {
        var range = sel.createRange();
        if (range.parentElement) {
          if (range.parentElement().document != doc) {
            return null;
          }
        } else {
          if (!range.length || (range).item(0).document != doc) {
            return null;
          }
        }
      } catch (e) {
        return null;
      }
      return sel;
    }
    return null;
  }
};
goog.dom.AbstractRange.isNativeControlRange = function(range) {
  return !!range && !!range.addElement;
};
goog.dom.AbstractRange.prototype.clone = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getType = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getBrowserRangeObject = goog.abstractMethod;
goog.dom.AbstractRange.prototype.setBrowserRangeObject = function(nativeRange) {
  return false;
};
goog.dom.AbstractRange.prototype.getTextRangeCount = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getTextRange = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getTextRanges = function() {
  var output = [];
  for (var i = 0, len = this.getTextRangeCount();i < len;i++) {
    output.push(this.getTextRange(i));
  }
  return output;
};
goog.dom.AbstractRange.prototype.getContainer = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getContainerElement = function() {
  var node = this.getContainer();
  return (node.nodeType == goog.dom.NodeType.ELEMENT ? node : node.parentNode);
};
goog.dom.AbstractRange.prototype.getStartNode = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getStartOffset = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getStartPosition = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getEndNode = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getEndOffset = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getEndPosition = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getAnchorNode = function() {
  return this.isReversed() ? this.getEndNode() : this.getStartNode();
};
goog.dom.AbstractRange.prototype.getAnchorOffset = function() {
  return this.isReversed() ? this.getEndOffset() : this.getStartOffset();
};
goog.dom.AbstractRange.prototype.getFocusNode = function() {
  return this.isReversed() ? this.getStartNode() : this.getEndNode();
};
goog.dom.AbstractRange.prototype.getFocusOffset = function() {
  return this.isReversed() ? this.getStartOffset() : this.getEndOffset();
};
goog.dom.AbstractRange.prototype.isReversed = function() {
  return false;
};
goog.dom.AbstractRange.prototype.getDocument = function() {
  return goog.dom.getOwnerDocument(goog.userAgent.IE ? this.getContainer() : this.getStartNode());
};
goog.dom.AbstractRange.prototype.getWindow = function() {
  return goog.dom.getWindow(this.getDocument());
};
goog.dom.AbstractRange.prototype.containsRange = goog.abstractMethod;
goog.dom.AbstractRange.prototype.containsNode = function(node, opt_allowPartial) {
  return this.containsRange(goog.dom.Range.createFromNodeContents(node), opt_allowPartial);
};
goog.dom.AbstractRange.prototype.isRangeInDocument = goog.abstractMethod;
goog.dom.AbstractRange.prototype.isCollapsed = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getText = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getHtmlFragment = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getValidHtml = goog.abstractMethod;
goog.dom.AbstractRange.prototype.getPastableHtml = goog.abstractMethod;
goog.dom.AbstractRange.prototype.__iterator__ = goog.abstractMethod;
goog.dom.AbstractRange.prototype.select = goog.abstractMethod;
goog.dom.AbstractRange.prototype.removeContents = goog.abstractMethod;
goog.dom.AbstractRange.prototype.insertNode = goog.abstractMethod;
goog.dom.AbstractRange.prototype.replaceContentsWithNode = function(node) {
  if (!this.isCollapsed()) {
    this.removeContents();
  }
  return this.insertNode(node, true);
};
goog.dom.AbstractRange.prototype.surroundWithNodes = goog.abstractMethod;
goog.dom.AbstractRange.prototype.saveUsingDom = goog.abstractMethod;
goog.dom.AbstractRange.prototype.saveUsingCarets = function() {
  return this.getStartNode() && this.getEndNode() ? new goog.dom.SavedCaretRange(this) : null;
};
goog.dom.AbstractRange.prototype.collapse = goog.abstractMethod;
goog.dom.RangeIterator = function(node, opt_reverse) {
  goog.dom.TagIterator.call(this, node, opt_reverse, true);
};
goog.inherits(goog.dom.RangeIterator, goog.dom.TagIterator);
goog.dom.RangeIterator.prototype.getStartTextOffset = goog.abstractMethod;
goog.dom.RangeIterator.prototype.getEndTextOffset = goog.abstractMethod;
goog.dom.RangeIterator.prototype.getStartNode = goog.abstractMethod;
goog.dom.RangeIterator.prototype.getEndNode = goog.abstractMethod;
goog.dom.RangeIterator.prototype.isLast = goog.abstractMethod;
goog.provide("goog.dom.AbstractMultiRange");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.AbstractRange");
goog.dom.AbstractMultiRange = function() {
};
goog.inherits(goog.dom.AbstractMultiRange, goog.dom.AbstractRange);
goog.dom.AbstractMultiRange.prototype.containsRange = function(otherRange, opt_allowPartial) {
  var ranges = this.getTextRanges();
  var otherRanges = otherRange.getTextRanges();
  var fn = opt_allowPartial ? goog.array.some : goog.array.every;
  return fn(otherRanges, function(otherRange) {
    return goog.array.some(ranges, function(range) {
      return range.containsRange(otherRange, opt_allowPartial);
    });
  });
};
goog.dom.AbstractMultiRange.prototype.insertNode = function(node, before) {
  if (before) {
    goog.dom.insertSiblingBefore(node, this.getStartNode());
  } else {
    goog.dom.insertSiblingAfter(node, this.getEndNode());
  }
  return node;
};
goog.dom.AbstractMultiRange.prototype.surroundWithNodes = function(startNode, endNode) {
  this.insertNode(startNode, true);
  this.insertNode(endNode, false);
};
goog.provide("goog.dom.TextRangeIterator");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.RangeIterator");
goog.require("goog.dom.TagName");
goog.require("goog.iter.StopIteration");
goog.dom.TextRangeIterator = function(startNode, startOffset, endNode, endOffset, opt_reverse) {
  this.startNode_ = null;
  this.endNode_ = null;
  this.startOffset_ = 0;
  this.endOffset_ = 0;
  var goNext;
  if (startNode) {
    this.startNode_ = startNode;
    this.startOffset_ = startOffset;
    this.endNode_ = endNode;
    this.endOffset_ = endOffset;
    if (startNode.nodeType == goog.dom.NodeType.ELEMENT && (startNode).tagName != goog.dom.TagName.BR) {
      var startChildren = startNode.childNodes;
      var candidate = startChildren[startOffset];
      if (candidate) {
        this.startNode_ = candidate;
        this.startOffset_ = 0;
      } else {
        if (startChildren.length) {
          this.startNode_ = (goog.array.peek(startChildren));
        }
        goNext = true;
      }
    }
    if (endNode.nodeType == goog.dom.NodeType.ELEMENT) {
      this.endNode_ = endNode.childNodes[endOffset];
      if (this.endNode_) {
        this.endOffset_ = 0;
      } else {
        this.endNode_ = endNode;
      }
    }
  }
  goog.dom.TextRangeIterator.base(this, "constructor", opt_reverse ? this.endNode_ : this.startNode_, opt_reverse);
  if (goNext) {
    try {
      this.next();
    } catch (e) {
      if (e != goog.iter.StopIteration) {
        throw e;
      }
    }
  }
};
goog.inherits(goog.dom.TextRangeIterator, goog.dom.RangeIterator);
goog.dom.TextRangeIterator.prototype.getStartTextOffset = function() {
  return this.node.nodeType != goog.dom.NodeType.TEXT ? -1 : this.node == this.startNode_ ? this.startOffset_ : 0;
};
goog.dom.TextRangeIterator.prototype.getEndTextOffset = function() {
  return this.node.nodeType != goog.dom.NodeType.TEXT ? -1 : this.node == this.endNode_ ? this.endOffset_ : this.node.nodeValue.length;
};
goog.dom.TextRangeIterator.prototype.getStartNode = function() {
  return this.startNode_;
};
goog.dom.TextRangeIterator.prototype.setStartNode = function(node) {
  if (!this.isStarted()) {
    this.setPosition(node);
  }
  this.startNode_ = node;
  this.startOffset_ = 0;
};
goog.dom.TextRangeIterator.prototype.getEndNode = function() {
  return this.endNode_;
};
goog.dom.TextRangeIterator.prototype.setEndNode = function(node) {
  this.endNode_ = node;
  this.endOffset_ = 0;
};
goog.dom.TextRangeIterator.prototype.isLast = function() {
  return this.isStarted() && this.node == this.endNode_ && (!this.endOffset_ || !this.isStartTag());
};
goog.dom.TextRangeIterator.prototype.next = function() {
  if (this.isLast()) {
    throw goog.iter.StopIteration;
  }
  return goog.dom.TextRangeIterator.superClass_.next.call(this);
};
goog.dom.TextRangeIterator.prototype.skipTag = function() {
  goog.dom.TextRangeIterator.superClass_.skipTag.apply(this);
  if (goog.dom.contains(this.node, this.endNode_)) {
    throw goog.iter.StopIteration;
  }
};
goog.dom.TextRangeIterator.prototype.copyFrom = function(other) {
  this.startNode_ = other.startNode_;
  this.endNode_ = other.endNode_;
  this.startOffset_ = other.startOffset_;
  this.endOffset_ = other.endOffset_;
  this.isReversed_ = other.isReversed_;
  goog.dom.TextRangeIterator.superClass_.copyFrom.call(this, other);
};
goog.dom.TextRangeIterator.prototype.clone = function() {
  var copy = new goog.dom.TextRangeIterator(this.startNode_, this.startOffset_, this.endNode_, this.endOffset_, this.isReversed_);
  copy.copyFrom(this);
  return copy;
};
goog.provide("goog.dom.RangeEndpoint");
goog.dom.RangeEndpoint = {START:1, END:0};
goog.provide("goog.string.StringBuffer");
goog.string.StringBuffer = function(opt_a1, var_args) {
  if (opt_a1 != null) {
    this.append.apply(this, arguments);
  }
};
goog.string.StringBuffer.prototype.buffer_ = "";
goog.string.StringBuffer.prototype.set = function(s) {
  this.buffer_ = "" + s;
};
goog.string.StringBuffer.prototype.append = function(a1, opt_a2, var_args) {
  this.buffer_ += String(a1);
  if (opt_a2 != null) {
    for (var i = 1;i < arguments.length;i++) {
      this.buffer_ += arguments[i];
    }
  }
  return this;
};
goog.string.StringBuffer.prototype.clear = function() {
  this.buffer_ = "";
};
goog.string.StringBuffer.prototype.getLength = function() {
  return this.buffer_.length;
};
goog.string.StringBuffer.prototype.toString = function() {
  return this.buffer_;
};
goog.provide("goog.dom.browserrange.AbstractRange");
goog.require("goog.array");
goog.require("goog.asserts");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.RangeEndpoint");
goog.require("goog.dom.TagName");
goog.require("goog.dom.TextRangeIterator");
goog.require("goog.iter");
goog.require("goog.math.Coordinate");
goog.require("goog.string");
goog.require("goog.string.StringBuffer");
goog.require("goog.userAgent");
goog.dom.browserrange.AbstractRange = function() {
};
goog.dom.browserrange.AbstractRange.prototype.clone = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.getBrowserRange = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.getContainer = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.getStartNode = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.getStartOffset = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.getStartPosition = function() {
  return this.getPosition_(true);
};
goog.dom.browserrange.AbstractRange.prototype.getEndNode = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.getEndOffset = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.getEndPosition = function() {
  return this.getPosition_(false);
};
goog.dom.browserrange.AbstractRange.prototype.getPosition_ = function(start) {
  goog.asserts.assert(this.range_.getClientRects, "Getting selection coordinates is not supported.");
  var rects = this.range_.getClientRects();
  if (rects.length) {
    var r = start ? rects[0] : goog.array.peek(rects);
    return new goog.math.Coordinate(start ? r.left : r.right, start ? r.top : r.bottom);
  }
  return null;
};
goog.dom.browserrange.AbstractRange.prototype.compareBrowserRangeEndpoints = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.containsRange = function(abstractRange, opt_allowPartial) {
  var checkPartial = opt_allowPartial && !abstractRange.isCollapsed();
  var range = abstractRange.getBrowserRange();
  var start = goog.dom.RangeEndpoint.START, end = goog.dom.RangeEndpoint.END;
  try {
    if (checkPartial) {
      return this.compareBrowserRangeEndpoints(range, end, start) >= 0 && this.compareBrowserRangeEndpoints(range, start, end) <= 0;
    } else {
      return this.compareBrowserRangeEndpoints(range, end, end) >= 0 && this.compareBrowserRangeEndpoints(range, start, start) <= 0;
    }
  } catch (e) {
    if (!goog.userAgent.IE) {
      throw e;
    }
    return false;
  }
};
goog.dom.browserrange.AbstractRange.prototype.containsNode = function(node, opt_allowPartial) {
  return this.containsRange(goog.dom.browserrange.createRangeFromNodeContents(node), opt_allowPartial);
};
goog.dom.browserrange.AbstractRange.prototype.isCollapsed = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.getText = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.getHtmlFragment = function() {
  var output = new goog.string.StringBuffer;
  goog.iter.forEach(this, function(node, ignore, it) {
    if (node.nodeType == goog.dom.NodeType.TEXT) {
      output.append(goog.string.htmlEscape(node.nodeValue.substring(it.getStartTextOffset(), it.getEndTextOffset())));
    } else {
      if (node.nodeType == goog.dom.NodeType.ELEMENT) {
        if (it.isEndTag()) {
          if (goog.dom.canHaveChildren(node)) {
            output.append("</" + node.tagName + ">");
          }
        } else {
          var shallow = node.cloneNode(false);
          var html = goog.dom.getOuterHtml(shallow);
          if (goog.userAgent.IE && node.tagName == goog.dom.TagName.LI) {
            output.append(html);
          } else {
            var index = html.lastIndexOf("<");
            output.append(index ? html.substr(0, index) : html);
          }
        }
      }
    }
  }, this);
  return output.toString();
};
goog.dom.browserrange.AbstractRange.prototype.getValidHtml = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.__iterator__ = function(opt_keys) {
  return new goog.dom.TextRangeIterator(this.getStartNode(), this.getStartOffset(), this.getEndNode(), this.getEndOffset());
};
goog.dom.browserrange.AbstractRange.prototype.select = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.removeContents = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.surroundContents = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.insertNode = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.surroundWithNodes = goog.abstractMethod;
goog.dom.browserrange.AbstractRange.prototype.collapse = goog.abstractMethod;
goog.provide("goog.dom.browserrange.W3cRange");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.RangeEndpoint");
goog.require("goog.dom.TagName");
goog.require("goog.dom.browserrange.AbstractRange");
goog.require("goog.string");
goog.require("goog.userAgent");
goog.dom.browserrange.W3cRange = function(range) {
  this.range_ = range;
};
goog.inherits(goog.dom.browserrange.W3cRange, goog.dom.browserrange.AbstractRange);
goog.dom.browserrange.W3cRange.getBrowserRangeForNode = function(node) {
  var nodeRange = goog.dom.getOwnerDocument(node).createRange();
  if (node.nodeType == goog.dom.NodeType.TEXT) {
    nodeRange.setStart(node, 0);
    nodeRange.setEnd(node, node.length);
  } else {
    if (!goog.dom.browserrange.canContainRangeEndpoint(node)) {
      var rangeParent = node.parentNode;
      var rangeStartOffset = goog.array.indexOf(rangeParent.childNodes, node);
      nodeRange.setStart(rangeParent, rangeStartOffset);
      nodeRange.setEnd(rangeParent, rangeStartOffset + 1);
    } else {
      var tempNode, leaf = node;
      while ((tempNode = leaf.firstChild) && goog.dom.browserrange.canContainRangeEndpoint(tempNode)) {
        leaf = tempNode;
      }
      nodeRange.setStart(leaf, 0);
      leaf = node;
      while ((tempNode = leaf.lastChild) && goog.dom.browserrange.canContainRangeEndpoint(tempNode)) {
        leaf = tempNode;
      }
      nodeRange.setEnd(leaf, leaf.nodeType == goog.dom.NodeType.ELEMENT ? leaf.childNodes.length : leaf.length);
    }
  }
  return nodeRange;
};
goog.dom.browserrange.W3cRange.getBrowserRangeForNodes = function(startNode, startOffset, endNode, endOffset) {
  var nodeRange = goog.dom.getOwnerDocument(startNode).createRange();
  nodeRange.setStart(startNode, startOffset);
  nodeRange.setEnd(endNode, endOffset);
  return nodeRange;
};
goog.dom.browserrange.W3cRange.createFromNodeContents = function(node) {
  return new goog.dom.browserrange.W3cRange(goog.dom.browserrange.W3cRange.getBrowserRangeForNode(node));
};
goog.dom.browserrange.W3cRange.createFromNodes = function(startNode, startOffset, endNode, endOffset) {
  return new goog.dom.browserrange.W3cRange(goog.dom.browserrange.W3cRange.getBrowserRangeForNodes(startNode, startOffset, endNode, endOffset));
};
goog.dom.browserrange.W3cRange.prototype.clone = function() {
  return new this.constructor(this.range_.cloneRange());
};
goog.dom.browserrange.W3cRange.prototype.getBrowserRange = function() {
  return this.range_;
};
goog.dom.browserrange.W3cRange.prototype.getContainer = function() {
  return this.range_.commonAncestorContainer;
};
goog.dom.browserrange.W3cRange.prototype.getStartNode = function() {
  return this.range_.startContainer;
};
goog.dom.browserrange.W3cRange.prototype.getStartOffset = function() {
  return this.range_.startOffset;
};
goog.dom.browserrange.W3cRange.prototype.getEndNode = function() {
  return this.range_.endContainer;
};
goog.dom.browserrange.W3cRange.prototype.getEndOffset = function() {
  return this.range_.endOffset;
};
goog.dom.browserrange.W3cRange.prototype.compareBrowserRangeEndpoints = function(range, thisEndpoint, otherEndpoint) {
  return this.range_.compareBoundaryPoints(otherEndpoint == goog.dom.RangeEndpoint.START ? thisEndpoint == goog.dom.RangeEndpoint.START ? goog.global["Range"].START_TO_START : goog.global["Range"].START_TO_END : thisEndpoint == goog.dom.RangeEndpoint.START ? goog.global["Range"].END_TO_START : goog.global["Range"].END_TO_END, (range));
};
goog.dom.browserrange.W3cRange.prototype.isCollapsed = function() {
  return this.range_.collapsed;
};
goog.dom.browserrange.W3cRange.prototype.getText = function() {
  return this.range_.toString();
};
goog.dom.browserrange.W3cRange.prototype.getValidHtml = function() {
  var div = goog.dom.getDomHelper(this.range_.startContainer).createDom(goog.dom.TagName.DIV);
  div.appendChild(this.range_.cloneContents());
  var result = div.innerHTML;
  if (goog.string.startsWith(result, "<") || !this.isCollapsed() && !goog.string.contains(result, "<")) {
    return result;
  }
  var container = this.getContainer();
  container = container.nodeType == goog.dom.NodeType.ELEMENT ? container : container.parentNode;
  var html = goog.dom.getOuterHtml((container.cloneNode(false)));
  return html.replace(">", ">" + result);
};
goog.dom.browserrange.W3cRange.prototype.select = function(reverse) {
  var win = goog.dom.getWindow(goog.dom.getOwnerDocument(this.getStartNode()));
  this.selectInternal(win.getSelection(), reverse);
};
goog.dom.browserrange.W3cRange.prototype.selectInternal = function(selection, reverse) {
  selection.removeAllRanges();
  selection.addRange(this.range_);
};
goog.dom.browserrange.W3cRange.prototype.removeContents = function() {
  var range = this.range_;
  range.extractContents();
  if (range.startContainer.hasChildNodes()) {
    var rangeStartContainer = range.startContainer.childNodes[range.startOffset];
    if (rangeStartContainer) {
      var rangePrevious = rangeStartContainer.previousSibling;
      if (goog.dom.getRawTextContent(rangeStartContainer) == "") {
        goog.dom.removeNode(rangeStartContainer);
      }
      if (rangePrevious && goog.dom.getRawTextContent(rangePrevious) == "") {
        goog.dom.removeNode(rangePrevious);
      }
    }
  }
  if (goog.userAgent.EDGE_OR_IE) {
    var startNode = this.getStartNode();
    var startOffset = this.getStartOffset();
    var endNode = this.getEndNode();
    var endOffset = this.getEndOffset();
    var sibling = startNode.nextSibling;
    if (startNode == endNode && startNode.parentNode && startNode.nodeType == goog.dom.NodeType.TEXT && sibling && sibling.nodeType == goog.dom.NodeType.TEXT) {
      startNode.nodeValue += sibling.nodeValue;
      goog.dom.removeNode(sibling);
      range.setStart(startNode, startOffset);
      range.setEnd(endNode, endOffset);
    }
  }
};
goog.dom.browserrange.W3cRange.prototype.surroundContents = function(element) {
  this.range_.surroundContents(element);
  return element;
};
goog.dom.browserrange.W3cRange.prototype.insertNode = function(node, before) {
  var range = this.range_.cloneRange();
  range.collapse(before);
  range.insertNode(node);
  range.detach();
  return node;
};
goog.dom.browserrange.W3cRange.prototype.surroundWithNodes = function(startNode, endNode) {
  var win = goog.dom.getWindow(goog.dom.getOwnerDocument(this.getStartNode()));
  var selectionRange = goog.dom.Range.createFromWindow(win);
  if (selectionRange) {
    var sNode = selectionRange.getStartNode();
    var eNode = selectionRange.getEndNode();
    var sOffset = selectionRange.getStartOffset();
    var eOffset = selectionRange.getEndOffset();
  }
  var clone1 = this.range_.cloneRange();
  var clone2 = this.range_.cloneRange();
  clone1.collapse(false);
  clone2.collapse(true);
  clone1.insertNode(endNode);
  clone2.insertNode(startNode);
  clone1.detach();
  clone2.detach();
  if (selectionRange) {
    var isInsertedNode = function(n) {
      return n == startNode || n == endNode;
    };
    if (sNode.nodeType == goog.dom.NodeType.TEXT) {
      while (sOffset > sNode.length) {
        sOffset -= sNode.length;
        do {
          sNode = sNode.nextSibling;
        } while (isInsertedNode(sNode));
      }
    }
    if (eNode.nodeType == goog.dom.NodeType.TEXT) {
      while (eOffset > eNode.length) {
        eOffset -= eNode.length;
        do {
          eNode = eNode.nextSibling;
        } while (isInsertedNode(eNode));
      }
    }
    goog.dom.Range.createFromNodes(sNode, (sOffset), eNode, (eOffset)).select();
  }
};
goog.dom.browserrange.W3cRange.prototype.collapse = function(toStart) {
  this.range_.collapse(toStart);
};
goog.provide("goog.dom.browserrange.GeckoRange");
goog.require("goog.dom.browserrange.W3cRange");
goog.dom.browserrange.GeckoRange = function(range) {
  goog.dom.browserrange.W3cRange.call(this, range);
};
goog.inherits(goog.dom.browserrange.GeckoRange, goog.dom.browserrange.W3cRange);
goog.dom.browserrange.GeckoRange.createFromNodeContents = function(node) {
  return new goog.dom.browserrange.GeckoRange(goog.dom.browserrange.W3cRange.getBrowserRangeForNode(node));
};
goog.dom.browserrange.GeckoRange.createFromNodes = function(startNode, startOffset, endNode, endOffset) {
  return new goog.dom.browserrange.GeckoRange(goog.dom.browserrange.W3cRange.getBrowserRangeForNodes(startNode, startOffset, endNode, endOffset));
};
goog.dom.browserrange.GeckoRange.prototype.selectInternal = function(selection, reversed) {
  if (!reversed || this.isCollapsed()) {
    goog.dom.browserrange.GeckoRange.base(this, "selectInternal", selection, reversed);
  } else {
    selection.collapse(this.getEndNode(), this.getEndOffset());
    selection.extend(this.getStartNode(), this.getStartOffset());
  }
};
goog.provide("goog.dom.browserrange.IeRange");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.RangeEndpoint");
goog.require("goog.dom.TagName");
goog.require("goog.dom.browserrange.AbstractRange");
goog.require("goog.log");
goog.require("goog.string");
goog.dom.browserrange.IeRange = function(range, doc) {
  this.parentNode_ = null;
  this.startNode_ = null;
  this.endNode_ = null;
  this.startOffset_ = -1;
  this.endOffset_ = -1;
  this.range_ = range;
  this.doc_ = doc;
};
goog.inherits(goog.dom.browserrange.IeRange, goog.dom.browserrange.AbstractRange);
goog.dom.browserrange.IeRange.logger_ = goog.log.getLogger("goog.dom.browserrange.IeRange");
goog.dom.browserrange.IeRange.getBrowserRangeForNode_ = function(node) {
  var nodeRange = goog.dom.getOwnerDocument(node).body.createTextRange();
  if (node.nodeType == goog.dom.NodeType.ELEMENT) {
    nodeRange.moveToElementText(node);
    if (goog.dom.browserrange.canContainRangeEndpoint(node) && !node.childNodes.length) {
      nodeRange.collapse(false);
    }
  } else {
    var offset = 0;
    var sibling = node;
    while (sibling = sibling.previousSibling) {
      var nodeType = sibling.nodeType;
      if (nodeType == goog.dom.NodeType.TEXT) {
        offset += sibling.length;
      } else {
        if (nodeType == goog.dom.NodeType.ELEMENT) {
          nodeRange.moveToElementText(sibling);
          break;
        }
      }
    }
    if (!sibling) {
      nodeRange.moveToElementText(node.parentNode);
    }
    nodeRange.collapse(!sibling);
    if (offset) {
      nodeRange.move("character", offset);
    }
    nodeRange.moveEnd("character", node.length);
  }
  return nodeRange;
};
goog.dom.browserrange.IeRange.getBrowserRangeForNodes_ = function(startNode, startOffset, endNode, endOffset) {
  var child, collapse = false;
  if (startNode.nodeType == goog.dom.NodeType.ELEMENT) {
    if (startOffset > startNode.childNodes.length) {
      goog.log.error(goog.dom.browserrange.IeRange.logger_, "Cannot have startOffset > startNode child count");
    }
    child = startNode.childNodes[startOffset];
    collapse = !child;
    startNode = child || startNode.lastChild || startNode;
    startOffset = 0;
  }
  var leftRange = goog.dom.browserrange.IeRange.getBrowserRangeForNode_(startNode);
  if (startOffset) {
    leftRange.move("character", startOffset);
  }
  if (startNode == endNode && startOffset == endOffset) {
    leftRange.collapse(true);
    return leftRange;
  }
  if (collapse) {
    leftRange.collapse(false);
  }
  collapse = false;
  if (endNode.nodeType == goog.dom.NodeType.ELEMENT) {
    if (endOffset > endNode.childNodes.length) {
      goog.log.error(goog.dom.browserrange.IeRange.logger_, "Cannot have endOffset > endNode child count");
    }
    child = endNode.childNodes[endOffset];
    endNode = child || endNode.lastChild || endNode;
    endOffset = 0;
    collapse = !child;
  }
  var rightRange = goog.dom.browserrange.IeRange.getBrowserRangeForNode_(endNode);
  rightRange.collapse(!collapse);
  if (endOffset) {
    rightRange.moveEnd("character", endOffset);
  }
  leftRange.setEndPoint("EndToEnd", rightRange);
  return leftRange;
};
goog.dom.browserrange.IeRange.createFromNodeContents = function(node) {
  var range = new goog.dom.browserrange.IeRange(goog.dom.browserrange.IeRange.getBrowserRangeForNode_(node), goog.dom.getOwnerDocument(node));
  if (!goog.dom.browserrange.canContainRangeEndpoint(node)) {
    range.startNode_ = range.endNode_ = range.parentNode_ = node.parentNode;
    range.startOffset_ = goog.array.indexOf(range.parentNode_.childNodes, node);
    range.endOffset_ = range.startOffset_ + 1;
  } else {
    var tempNode, leaf = node;
    while ((tempNode = leaf.firstChild) && goog.dom.browserrange.canContainRangeEndpoint(tempNode)) {
      leaf = tempNode;
    }
    range.startNode_ = leaf;
    range.startOffset_ = 0;
    leaf = node;
    while ((tempNode = leaf.lastChild) && goog.dom.browserrange.canContainRangeEndpoint(tempNode)) {
      leaf = tempNode;
    }
    range.endNode_ = leaf;
    range.endOffset_ = leaf.nodeType == goog.dom.NodeType.ELEMENT ? leaf.childNodes.length : leaf.length;
    range.parentNode_ = node;
  }
  return range;
};
goog.dom.browserrange.IeRange.createFromNodes = function(startNode, startOffset, endNode, endOffset) {
  var range = new goog.dom.browserrange.IeRange(goog.dom.browserrange.IeRange.getBrowserRangeForNodes_(startNode, startOffset, endNode, endOffset), goog.dom.getOwnerDocument(startNode));
  range.startNode_ = startNode;
  range.startOffset_ = startOffset;
  range.endNode_ = endNode;
  range.endOffset_ = endOffset;
  return range;
};
goog.dom.browserrange.IeRange.prototype.clone = function() {
  var range = new goog.dom.browserrange.IeRange(this.range_.duplicate(), this.doc_);
  range.parentNode_ = this.parentNode_;
  range.startNode_ = this.startNode_;
  range.endNode_ = this.endNode_;
  return range;
};
goog.dom.browserrange.IeRange.prototype.getBrowserRange = function() {
  return this.range_;
};
goog.dom.browserrange.IeRange.prototype.clearCachedValues_ = function() {
  this.parentNode_ = this.startNode_ = this.endNode_ = null;
  this.startOffset_ = this.endOffset_ = -1;
};
goog.dom.browserrange.IeRange.prototype.getContainer = function() {
  if (!this.parentNode_) {
    var selectText = this.range_.text;
    var range = this.range_.duplicate();
    var rightTrimmedSelectText = selectText.replace(/ +$/, "");
    var numSpacesAtEnd = selectText.length - rightTrimmedSelectText.length;
    if (numSpacesAtEnd) {
      range.moveEnd("character", -numSpacesAtEnd);
    }
    var parent = range.parentElement();
    var htmlText = range.htmlText;
    var htmlTextLen = goog.string.stripNewlines(htmlText).length;
    if (this.isCollapsed() && htmlTextLen > 0) {
      return this.parentNode_ = parent;
    }
    while (htmlTextLen > goog.string.stripNewlines(parent.outerHTML).length) {
      parent = parent.parentNode;
    }
    while (parent.childNodes.length == 1 && parent.innerText == goog.dom.browserrange.IeRange.getNodeText_(parent.firstChild)) {
      if (!goog.dom.browserrange.canContainRangeEndpoint(parent.firstChild)) {
        break;
      }
      parent = parent.firstChild;
    }
    if (selectText.length == 0) {
      parent = this.findDeepestContainer_(parent);
    }
    this.parentNode_ = parent;
  }
  return this.parentNode_;
};
goog.dom.browserrange.IeRange.prototype.findDeepestContainer_ = function(node) {
  var childNodes = node.childNodes;
  for (var i = 0, len = childNodes.length;i < len;i++) {
    var child = childNodes[i];
    if (goog.dom.browserrange.canContainRangeEndpoint(child)) {
      var childRange = goog.dom.browserrange.IeRange.getBrowserRangeForNode_(child);
      var start = goog.dom.RangeEndpoint.START;
      var end = goog.dom.RangeEndpoint.END;
      var isChildRangeErratic = childRange.htmlText != child.outerHTML;
      var isNativeInRangeErratic = this.isCollapsed() && isChildRangeErratic;
      var inChildRange = isNativeInRangeErratic ? this.compareBrowserRangeEndpoints(childRange, start, start) >= 0 && this.compareBrowserRangeEndpoints(childRange, start, end) <= 0 : this.range_.inRange(childRange);
      if (inChildRange) {
        return this.findDeepestContainer_(child);
      }
    }
  }
  return node;
};
goog.dom.browserrange.IeRange.prototype.getStartNode = function() {
  if (!this.startNode_) {
    this.startNode_ = this.getEndpointNode_(goog.dom.RangeEndpoint.START);
    if (this.isCollapsed()) {
      this.endNode_ = this.startNode_;
    }
  }
  return this.startNode_;
};
goog.dom.browserrange.IeRange.prototype.getStartOffset = function() {
  if (this.startOffset_ < 0) {
    this.startOffset_ = this.getOffset_(goog.dom.RangeEndpoint.START);
    if (this.isCollapsed()) {
      this.endOffset_ = this.startOffset_;
    }
  }
  return this.startOffset_;
};
goog.dom.browserrange.IeRange.prototype.getEndNode = function() {
  if (this.isCollapsed()) {
    return this.getStartNode();
  }
  if (!this.endNode_) {
    this.endNode_ = this.getEndpointNode_(goog.dom.RangeEndpoint.END);
  }
  return this.endNode_;
};
goog.dom.browserrange.IeRange.prototype.getEndOffset = function() {
  if (this.isCollapsed()) {
    return this.getStartOffset();
  }
  if (this.endOffset_ < 0) {
    this.endOffset_ = this.getOffset_(goog.dom.RangeEndpoint.END);
    if (this.isCollapsed()) {
      this.startOffset_ = this.endOffset_;
    }
  }
  return this.endOffset_;
};
goog.dom.browserrange.IeRange.prototype.compareBrowserRangeEndpoints = function(range, thisEndpoint, otherEndpoint) {
  return this.range_.compareEndPoints((thisEndpoint == goog.dom.RangeEndpoint.START ? "Start" : "End") + "To" + (otherEndpoint == goog.dom.RangeEndpoint.START ? "Start" : "End"), range);
};
goog.dom.browserrange.IeRange.prototype.getEndpointNode_ = function(endpoint, opt_node) {
  var node = opt_node || this.getContainer();
  if (!node || !node.firstChild) {
    return node;
  }
  var start = goog.dom.RangeEndpoint.START, end = goog.dom.RangeEndpoint.END;
  var isStartEndpoint = endpoint == start;
  for (var j = 0, length = node.childNodes.length;j < length;j++) {
    var i = isStartEndpoint ? j : length - j - 1;
    var child = node.childNodes[i];
    var childRange;
    try {
      childRange = goog.dom.browserrange.createRangeFromNodeContents(child);
    } catch (e) {
      continue;
    }
    var ieRange = childRange.getBrowserRange();
    if (this.isCollapsed()) {
      if (!goog.dom.browserrange.canContainRangeEndpoint(child)) {
        if (this.compareBrowserRangeEndpoints(ieRange, start, start) == 0) {
          this.startOffset_ = this.endOffset_ = i;
          return node;
        }
      } else {
        if (childRange.containsRange(this)) {
          return this.getEndpointNode_(endpoint, child);
        }
      }
    } else {
      if (this.containsRange(childRange)) {
        if (!goog.dom.browserrange.canContainRangeEndpoint(child)) {
          if (isStartEndpoint) {
            this.startOffset_ = i;
          } else {
            this.endOffset_ = i + 1;
          }
          return node;
        }
        return this.getEndpointNode_(endpoint, child);
      } else {
        if (this.compareBrowserRangeEndpoints(ieRange, start, end) < 0 && this.compareBrowserRangeEndpoints(ieRange, end, start) > 0) {
          return this.getEndpointNode_(endpoint, child);
        }
      }
    }
  }
  return node;
};
goog.dom.browserrange.IeRange.prototype.compareNodeEndpoints_ = function(node, thisEndpoint, otherEndpoint) {
  return this.range_.compareEndPoints((thisEndpoint == goog.dom.RangeEndpoint.START ? "Start" : "End") + "To" + (otherEndpoint == goog.dom.RangeEndpoint.START ? "Start" : "End"), goog.dom.browserrange.createRangeFromNodeContents(node).getBrowserRange());
};
goog.dom.browserrange.IeRange.prototype.getOffset_ = function(endpoint, opt_container) {
  var isStartEndpoint = endpoint == goog.dom.RangeEndpoint.START;
  var container = opt_container || (isStartEndpoint ? this.getStartNode() : this.getEndNode());
  if (container.nodeType == goog.dom.NodeType.ELEMENT) {
    var children = container.childNodes;
    var len = children.length;
    var edge = isStartEndpoint ? 0 : len - 1;
    var sign = isStartEndpoint ? 1 : -1;
    for (var i = edge;i >= 0 && i < len;i += sign) {
      var child = children[i];
      if (goog.dom.browserrange.canContainRangeEndpoint(child)) {
        continue;
      }
      var endPointCompare = this.compareNodeEndpoints_(child, endpoint, endpoint);
      if (endPointCompare == 0) {
        return isStartEndpoint ? i : i + 1;
      }
    }
    return i == -1 ? 0 : i;
  } else {
    var range = this.range_.duplicate();
    var nodeRange = goog.dom.browserrange.IeRange.getBrowserRangeForNode_(container);
    range.setEndPoint(isStartEndpoint ? "EndToEnd" : "StartToStart", nodeRange);
    var rangeLength = range.text.length;
    return isStartEndpoint ? container.length - rangeLength : rangeLength;
  }
};
goog.dom.browserrange.IeRange.getNodeText_ = function(node) {
  return node.nodeType == goog.dom.NodeType.TEXT ? node.nodeValue : node.innerText;
};
goog.dom.browserrange.IeRange.prototype.isRangeInDocument = function() {
  var range = this.doc_.body.createTextRange();
  range.moveToElementText(this.doc_.body);
  return this.containsRange(new goog.dom.browserrange.IeRange(range, this.doc_), true);
};
goog.dom.browserrange.IeRange.prototype.isCollapsed = function() {
  return this.range_.compareEndPoints("StartToEnd", this.range_) == 0;
};
goog.dom.browserrange.IeRange.prototype.getText = function() {
  return this.range_.text;
};
goog.dom.browserrange.IeRange.prototype.getValidHtml = function() {
  return this.range_.htmlText;
};
goog.dom.browserrange.IeRange.prototype.select = function(opt_reverse) {
  this.range_.select();
};
goog.dom.browserrange.IeRange.prototype.removeContents = function() {
  if (!this.isCollapsed() && this.range_.htmlText) {
    var startNode = this.getStartNode();
    var endNode = this.getEndNode();
    var oldText = this.range_.text;
    var clone = this.range_.duplicate();
    clone.moveStart("character", 1);
    clone.moveStart("character", -1);
    if (clone.text == oldText) {
      this.range_ = clone;
    }
    this.range_.text = "";
    this.clearCachedValues_();
    var newStartNode = this.getStartNode();
    var newStartOffset = this.getStartOffset();
    try {
      var sibling = startNode.nextSibling;
      if (startNode == endNode && startNode.parentNode && startNode.nodeType == goog.dom.NodeType.TEXT && sibling && sibling.nodeType == goog.dom.NodeType.TEXT) {
        startNode.nodeValue += sibling.nodeValue;
        goog.dom.removeNode(sibling);
        this.range_ = goog.dom.browserrange.IeRange.getBrowserRangeForNode_(newStartNode);
        this.range_.move("character", newStartOffset);
        this.clearCachedValues_();
      }
    } catch (e) {
    }
  }
};
goog.dom.browserrange.IeRange.getDomHelper_ = function(range) {
  return goog.dom.getDomHelper(range.parentElement());
};
goog.dom.browserrange.IeRange.pasteElement_ = function(range, element, opt_domHelper) {
  opt_domHelper = opt_domHelper || goog.dom.browserrange.IeRange.getDomHelper_(range);
  var id;
  var originalId = id = element.id;
  if (!id) {
    id = element.id = goog.string.createUniqueString();
  }
  range.pasteHTML(element.outerHTML);
  element = opt_domHelper.getElement(id);
  if (element) {
    if (!originalId) {
      element.removeAttribute("id");
    }
  }
  return element;
};
goog.dom.browserrange.IeRange.prototype.surroundContents = function(element) {
  goog.dom.removeNode(element);
  element.innerHTML = this.range_.htmlText;
  element = goog.dom.browserrange.IeRange.pasteElement_(this.range_, element);
  if (element) {
    this.range_.moveToElementText(element);
  }
  this.clearCachedValues_();
  return element;
};
goog.dom.browserrange.IeRange.insertNode_ = function(clone, node, before, opt_domHelper) {
  opt_domHelper = opt_domHelper || goog.dom.browserrange.IeRange.getDomHelper_(clone);
  var isNonElement;
  if (node.nodeType != goog.dom.NodeType.ELEMENT) {
    isNonElement = true;
    node = opt_domHelper.createDom(goog.dom.TagName.DIV, null, node);
  }
  clone.collapse(before);
  node = goog.dom.browserrange.IeRange.pasteElement_(clone, (node), opt_domHelper);
  if (isNonElement) {
    var newNonElement = node.firstChild;
    opt_domHelper.flattenElement(node);
    node = newNonElement;
  }
  return node;
};
goog.dom.browserrange.IeRange.prototype.insertNode = function(node, before) {
  var output = goog.dom.browserrange.IeRange.insertNode_(this.range_.duplicate(), node, before);
  this.clearCachedValues_();
  return output;
};
goog.dom.browserrange.IeRange.prototype.surroundWithNodes = function(startNode, endNode) {
  var clone1 = this.range_.duplicate();
  var clone2 = this.range_.duplicate();
  goog.dom.browserrange.IeRange.insertNode_(clone1, startNode, true);
  goog.dom.browserrange.IeRange.insertNode_(clone2, endNode, false);
  this.clearCachedValues_();
};
goog.dom.browserrange.IeRange.prototype.collapse = function(toStart) {
  this.range_.collapse(toStart);
  if (toStart) {
    this.endNode_ = this.startNode_;
    this.endOffset_ = this.startOffset_;
  } else {
    this.startNode_ = this.endNode_;
    this.startOffset_ = this.endOffset_;
  }
};
goog.provide("goog.dom.browserrange.OperaRange");
goog.require("goog.dom.browserrange.W3cRange");
goog.dom.browserrange.OperaRange = function(range) {
  goog.dom.browserrange.W3cRange.call(this, range);
};
goog.inherits(goog.dom.browserrange.OperaRange, goog.dom.browserrange.W3cRange);
goog.dom.browserrange.OperaRange.createFromNodeContents = function(node) {
  return new goog.dom.browserrange.OperaRange(goog.dom.browserrange.W3cRange.getBrowserRangeForNode(node));
};
goog.dom.browserrange.OperaRange.createFromNodes = function(startNode, startOffset, endNode, endOffset) {
  return new goog.dom.browserrange.OperaRange(goog.dom.browserrange.W3cRange.getBrowserRangeForNodes(startNode, startOffset, endNode, endOffset));
};
goog.dom.browserrange.OperaRange.prototype.selectInternal = function(selection, reversed) {
  selection.collapse(this.getStartNode(), this.getStartOffset());
  if (this.getEndNode() != this.getStartNode() || this.getEndOffset() != this.getStartOffset()) {
    selection.extend(this.getEndNode(), this.getEndOffset());
  }
  if (selection.rangeCount == 0) {
    selection.addRange(this.range_);
  }
};
goog.provide("goog.dom.browserrange.WebKitRange");
goog.require("goog.dom.RangeEndpoint");
goog.require("goog.dom.browserrange.W3cRange");
goog.require("goog.userAgent");
goog.dom.browserrange.WebKitRange = function(range) {
  goog.dom.browserrange.W3cRange.call(this, range);
};
goog.inherits(goog.dom.browserrange.WebKitRange, goog.dom.browserrange.W3cRange);
goog.dom.browserrange.WebKitRange.createFromNodeContents = function(node) {
  return new goog.dom.browserrange.WebKitRange(goog.dom.browserrange.W3cRange.getBrowserRangeForNode(node));
};
goog.dom.browserrange.WebKitRange.createFromNodes = function(startNode, startOffset, endNode, endOffset) {
  return new goog.dom.browserrange.WebKitRange(goog.dom.browserrange.W3cRange.getBrowserRangeForNodes(startNode, startOffset, endNode, endOffset));
};
goog.dom.browserrange.WebKitRange.prototype.compareBrowserRangeEndpoints = function(range, thisEndpoint, otherEndpoint) {
  if (goog.userAgent.isVersionOrHigher("528")) {
    return goog.dom.browserrange.WebKitRange.superClass_.compareBrowserRangeEndpoints.call(this, range, thisEndpoint, otherEndpoint);
  }
  return this.range_.compareBoundaryPoints(otherEndpoint == goog.dom.RangeEndpoint.START ? thisEndpoint == goog.dom.RangeEndpoint.START ? goog.global["Range"].START_TO_START : goog.global["Range"].END_TO_START : thisEndpoint == goog.dom.RangeEndpoint.START ? goog.global["Range"].START_TO_END : goog.global["Range"].END_TO_END, (range));
};
goog.dom.browserrange.WebKitRange.prototype.selectInternal = function(selection, reversed) {
  if (reversed) {
    selection.setBaseAndExtent(this.getEndNode(), this.getEndOffset(), this.getStartNode(), this.getStartOffset());
  } else {
    selection.setBaseAndExtent(this.getStartNode(), this.getStartOffset(), this.getEndNode(), this.getEndOffset());
  }
};
goog.provide("goog.dom.browserrange");
goog.provide("goog.dom.browserrange.Error");
goog.require("goog.dom");
goog.require("goog.dom.BrowserFeature");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.browserrange.GeckoRange");
goog.require("goog.dom.browserrange.IeRange");
goog.require("goog.dom.browserrange.OperaRange");
goog.require("goog.dom.browserrange.W3cRange");
goog.require("goog.dom.browserrange.WebKitRange");
goog.require("goog.userAgent");
goog.dom.browserrange.Error = {NOT_IMPLEMENTED:"Not Implemented"};
goog.dom.browserrange.createRange = function(range) {
  if (goog.dom.BrowserFeature.LEGACY_IE_RANGES) {
    return new goog.dom.browserrange.IeRange((range), goog.dom.getOwnerDocument(range.parentElement()));
  } else {
    if (goog.userAgent.WEBKIT) {
      return new goog.dom.browserrange.WebKitRange((range));
    } else {
      if (goog.userAgent.GECKO) {
        return new goog.dom.browserrange.GeckoRange((range));
      } else {
        if (goog.userAgent.OPERA) {
          return new goog.dom.browserrange.OperaRange((range));
        } else {
          return new goog.dom.browserrange.W3cRange((range));
        }
      }
    }
  }
};
goog.dom.browserrange.createRangeFromNodeContents = function(node) {
  if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9)) {
    return goog.dom.browserrange.IeRange.createFromNodeContents(node);
  } else {
    if (goog.userAgent.WEBKIT) {
      return goog.dom.browserrange.WebKitRange.createFromNodeContents(node);
    } else {
      if (goog.userAgent.GECKO) {
        return goog.dom.browserrange.GeckoRange.createFromNodeContents(node);
      } else {
        if (goog.userAgent.OPERA) {
          return goog.dom.browserrange.OperaRange.createFromNodeContents(node);
        } else {
          return goog.dom.browserrange.W3cRange.createFromNodeContents(node);
        }
      }
    }
  }
};
goog.dom.browserrange.createRangeFromNodes = function(startNode, startOffset, endNode, endOffset) {
  if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9)) {
    return goog.dom.browserrange.IeRange.createFromNodes(startNode, startOffset, endNode, endOffset);
  } else {
    if (goog.userAgent.WEBKIT) {
      return goog.dom.browserrange.WebKitRange.createFromNodes(startNode, startOffset, endNode, endOffset);
    } else {
      if (goog.userAgent.GECKO) {
        return goog.dom.browserrange.GeckoRange.createFromNodes(startNode, startOffset, endNode, endOffset);
      } else {
        if (goog.userAgent.OPERA) {
          return goog.dom.browserrange.OperaRange.createFromNodes(startNode, startOffset, endNode, endOffset);
        } else {
          return goog.dom.browserrange.W3cRange.createFromNodes(startNode, startOffset, endNode, endOffset);
        }
      }
    }
  }
};
goog.dom.browserrange.canContainRangeEndpoint = function(node) {
  return goog.dom.canHaveChildren(node) || node.nodeType == goog.dom.NodeType.TEXT;
};
goog.provide("goog.dom.TextRange");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.AbstractRange");
goog.require("goog.dom.RangeType");
goog.require("goog.dom.SavedRange");
goog.require("goog.dom.TagName");
goog.require("goog.dom.TextRangeIterator");
goog.require("goog.dom.browserrange");
goog.require("goog.string");
goog.require("goog.userAgent");
goog.dom.TextRange = function() {
  this.browserRangeWrapper_ = null;
  this.startNode_ = null;
  this.startOffset_ = null;
  this.endNode_ = null;
  this.endOffset_ = null;
  this.isReversed_ = false;
};
goog.inherits(goog.dom.TextRange, goog.dom.AbstractRange);
goog.dom.TextRange.createFromBrowserRange = function(range, opt_isReversed) {
  return goog.dom.TextRange.createFromBrowserRangeWrapper_(goog.dom.browserrange.createRange(range), opt_isReversed);
};
goog.dom.TextRange.createFromBrowserRangeWrapper_ = function(browserRange, opt_isReversed) {
  var range = new goog.dom.TextRange;
  range.browserRangeWrapper_ = browserRange;
  range.isReversed_ = !!opt_isReversed;
  return range;
};
goog.dom.TextRange.createFromNodeContents = function(node, opt_isReversed) {
  return goog.dom.TextRange.createFromBrowserRangeWrapper_(goog.dom.browserrange.createRangeFromNodeContents(node), opt_isReversed);
};
goog.dom.TextRange.createFromNodes = function(anchorNode, anchorOffset, focusNode, focusOffset) {
  var range = new goog.dom.TextRange;
  range.isReversed_ = goog.dom.Range.isReversed(anchorNode, anchorOffset, focusNode, focusOffset);
  if (goog.dom.isElement(anchorNode) && !goog.dom.canHaveChildren(anchorNode)) {
    var parent = anchorNode.parentNode;
    anchorOffset = goog.array.indexOf(parent.childNodes, anchorNode);
    anchorNode = parent;
  }
  if (goog.dom.isElement(focusNode) && !goog.dom.canHaveChildren(focusNode)) {
    var parent = focusNode.parentNode;
    focusOffset = goog.array.indexOf(parent.childNodes, focusNode);
    focusNode = parent;
  }
  if (range.isReversed_) {
    range.startNode_ = focusNode;
    range.startOffset_ = focusOffset;
    range.endNode_ = anchorNode;
    range.endOffset_ = anchorOffset;
  } else {
    range.startNode_ = anchorNode;
    range.startOffset_ = anchorOffset;
    range.endNode_ = focusNode;
    range.endOffset_ = focusOffset;
  }
  return range;
};
goog.dom.TextRange.prototype.clone = function() {
  var range = new goog.dom.TextRange;
  range.browserRangeWrapper_ = this.browserRangeWrapper_ && this.browserRangeWrapper_.clone();
  range.startNode_ = this.startNode_;
  range.startOffset_ = this.startOffset_;
  range.endNode_ = this.endNode_;
  range.endOffset_ = this.endOffset_;
  range.isReversed_ = this.isReversed_;
  return range;
};
goog.dom.TextRange.prototype.getType = function() {
  return goog.dom.RangeType.TEXT;
};
goog.dom.TextRange.prototype.getBrowserRangeObject = function() {
  return this.getBrowserRangeWrapper_().getBrowserRange();
};
goog.dom.TextRange.prototype.setBrowserRangeObject = function(nativeRange) {
  if (goog.dom.AbstractRange.isNativeControlRange(nativeRange)) {
    return false;
  }
  this.browserRangeWrapper_ = goog.dom.browserrange.createRange(nativeRange);
  this.clearCachedValues_();
  return true;
};
goog.dom.TextRange.prototype.clearCachedValues_ = function() {
  this.startNode_ = this.startOffset_ = this.endNode_ = this.endOffset_ = null;
};
goog.dom.TextRange.prototype.getTextRangeCount = function() {
  return 1;
};
goog.dom.TextRange.prototype.getTextRange = function(i) {
  return this;
};
goog.dom.TextRange.prototype.getBrowserRangeWrapper_ = function() {
  return this.browserRangeWrapper_ || (this.browserRangeWrapper_ = goog.dom.browserrange.createRangeFromNodes(this.getStartNode(), this.getStartOffset(), this.getEndNode(), this.getEndOffset()));
};
goog.dom.TextRange.prototype.getContainer = function() {
  return this.getBrowserRangeWrapper_().getContainer();
};
goog.dom.TextRange.prototype.getStartNode = function() {
  return this.startNode_ || (this.startNode_ = this.getBrowserRangeWrapper_().getStartNode());
};
goog.dom.TextRange.prototype.getStartOffset = function() {
  return this.startOffset_ != null ? this.startOffset_ : this.startOffset_ = this.getBrowserRangeWrapper_().getStartOffset();
};
goog.dom.TextRange.prototype.getStartPosition = function() {
  return this.getBrowserRangeWrapper_().getStartPosition();
};
goog.dom.TextRange.prototype.getEndNode = function() {
  return this.endNode_ || (this.endNode_ = this.getBrowserRangeWrapper_().getEndNode());
};
goog.dom.TextRange.prototype.getEndOffset = function() {
  return this.endOffset_ != null ? this.endOffset_ : this.endOffset_ = this.getBrowserRangeWrapper_().getEndOffset();
};
goog.dom.TextRange.prototype.getEndPosition = function() {
  return this.getBrowserRangeWrapper_().getEndPosition();
};
goog.dom.TextRange.prototype.moveToNodes = function(startNode, startOffset, endNode, endOffset, isReversed) {
  this.startNode_ = startNode;
  this.startOffset_ = startOffset;
  this.endNode_ = endNode;
  this.endOffset_ = endOffset;
  this.isReversed_ = isReversed;
  this.browserRangeWrapper_ = null;
};
goog.dom.TextRange.prototype.isReversed = function() {
  return this.isReversed_;
};
goog.dom.TextRange.prototype.containsRange = function(otherRange, opt_allowPartial) {
  var otherRangeType = otherRange.getType();
  if (otherRangeType == goog.dom.RangeType.TEXT) {
    return this.getBrowserRangeWrapper_().containsRange(otherRange.getBrowserRangeWrapper_(), opt_allowPartial);
  } else {
    if (otherRangeType == goog.dom.RangeType.CONTROL) {
      var elements = otherRange.getElements();
      var fn = opt_allowPartial ? goog.array.some : goog.array.every;
      return fn(elements, function(el) {
        return this.containsNode(el, opt_allowPartial);
      }, this);
    }
  }
  return false;
};
goog.dom.TextRange.isAttachedNode = function(node) {
  if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9)) {
    var returnValue = false;
    try {
      returnValue = node.parentNode;
    } catch (e) {
    }
    return !!returnValue;
  } else {
    return goog.dom.contains(node.ownerDocument.body, node);
  }
};
goog.dom.TextRange.prototype.isRangeInDocument = function() {
  return (!this.startNode_ || goog.dom.TextRange.isAttachedNode(this.startNode_)) && (!this.endNode_ || goog.dom.TextRange.isAttachedNode(this.endNode_)) && (!(goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9)) || this.getBrowserRangeWrapper_().isRangeInDocument());
};
goog.dom.TextRange.prototype.isCollapsed = function() {
  return this.getBrowserRangeWrapper_().isCollapsed();
};
goog.dom.TextRange.prototype.getText = function() {
  return this.getBrowserRangeWrapper_().getText();
};
goog.dom.TextRange.prototype.getHtmlFragment = function() {
  return this.getBrowserRangeWrapper_().getHtmlFragment();
};
goog.dom.TextRange.prototype.getValidHtml = function() {
  return this.getBrowserRangeWrapper_().getValidHtml();
};
goog.dom.TextRange.prototype.getPastableHtml = function() {
  var html = this.getValidHtml();
  if (html.match(/^\s*<td\b/i)) {
    html = "<table><tbody><tr>" + html + "</tr></tbody></table>";
  } else {
    if (html.match(/^\s*<tr\b/i)) {
      html = "<table><tbody>" + html + "</tbody></table>";
    } else {
      if (html.match(/^\s*<tbody\b/i)) {
        html = "<table>" + html + "</table>";
      } else {
        if (html.match(/^\s*<li\b/i)) {
          var container = (this.getContainer());
          var tagType = goog.dom.TagName.UL;
          while (container) {
            if (container.tagName == goog.dom.TagName.OL) {
              tagType = goog.dom.TagName.OL;
              break;
            } else {
              if (container.tagName == goog.dom.TagName.UL) {
                break;
              }
            }
            container = container.parentNode;
          }
          html = goog.string.buildString("<", tagType, ">", html, "</", tagType, ">");
        }
      }
    }
  }
  return html;
};
goog.dom.TextRange.prototype.__iterator__ = function(opt_keys) {
  return new goog.dom.TextRangeIterator(this.getStartNode(), this.getStartOffset(), this.getEndNode(), this.getEndOffset());
};
goog.dom.TextRange.prototype.select = function() {
  this.getBrowserRangeWrapper_().select(this.isReversed_);
};
goog.dom.TextRange.prototype.removeContents = function() {
  this.getBrowserRangeWrapper_().removeContents();
  this.clearCachedValues_();
};
goog.dom.TextRange.prototype.surroundContents = function(element) {
  var output = this.getBrowserRangeWrapper_().surroundContents(element);
  this.clearCachedValues_();
  return output;
};
goog.dom.TextRange.prototype.insertNode = function(node, before) {
  var output = this.getBrowserRangeWrapper_().insertNode(node, before);
  this.clearCachedValues_();
  return output;
};
goog.dom.TextRange.prototype.surroundWithNodes = function(startNode, endNode) {
  this.getBrowserRangeWrapper_().surroundWithNodes(startNode, endNode);
  this.clearCachedValues_();
};
goog.dom.TextRange.prototype.saveUsingDom = function() {
  return new goog.dom.DomSavedTextRange_(this);
};
goog.dom.TextRange.prototype.collapse = function(toAnchor) {
  var toStart = this.isReversed() ? !toAnchor : toAnchor;
  if (this.browserRangeWrapper_) {
    this.browserRangeWrapper_.collapse(toStart);
  }
  if (toStart) {
    this.endNode_ = this.startNode_;
    this.endOffset_ = this.startOffset_;
  } else {
    this.startNode_ = this.endNode_;
    this.startOffset_ = this.endOffset_;
  }
  this.isReversed_ = false;
};
goog.dom.DomSavedTextRange_ = function(range) {
  goog.dom.DomSavedTextRange_.base(this, "constructor");
  this.anchorNode_ = range.getAnchorNode();
  this.anchorOffset_ = range.getAnchorOffset();
  this.focusNode_ = range.getFocusNode();
  this.focusOffset_ = range.getFocusOffset();
};
goog.inherits(goog.dom.DomSavedTextRange_, goog.dom.SavedRange);
goog.dom.DomSavedTextRange_.prototype.restoreInternal = function() {
  return goog.dom.Range.createFromNodes(this.anchorNode_, this.anchorOffset_, this.focusNode_, this.focusOffset_);
};
goog.dom.DomSavedTextRange_.prototype.disposeInternal = function() {
  goog.dom.DomSavedTextRange_.superClass_.disposeInternal.call(this);
  this.anchorNode_ = null;
  this.focusNode_ = null;
};
goog.provide("goog.dom.ControlRange");
goog.provide("goog.dom.ControlRangeIterator");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.AbstractMultiRange");
goog.require("goog.dom.AbstractRange");
goog.require("goog.dom.RangeIterator");
goog.require("goog.dom.RangeType");
goog.require("goog.dom.SavedRange");
goog.require("goog.dom.TagWalkType");
goog.require("goog.dom.TextRange");
goog.require("goog.iter.StopIteration");
goog.require("goog.userAgent");
goog.dom.ControlRange = function() {
  this.range_ = null;
  this.elements_ = null;
  this.sortedElements_ = null;
};
goog.inherits(goog.dom.ControlRange, goog.dom.AbstractMultiRange);
goog.dom.ControlRange.createFromBrowserRange = function(controlRange) {
  var range = new goog.dom.ControlRange;
  range.range_ = controlRange;
  return range;
};
goog.dom.ControlRange.createFromElements = function(var_args) {
  var range = goog.dom.getOwnerDocument(arguments[0]).body.createControlRange();
  for (var i = 0, len = arguments.length;i < len;i++) {
    range.addElement(arguments[i]);
  }
  return goog.dom.ControlRange.createFromBrowserRange(range);
};
goog.dom.ControlRange.prototype.clearCachedValues_ = function() {
  this.elements_ = null;
  this.sortedElements_ = null;
};
goog.dom.ControlRange.prototype.clone = function() {
  return goog.dom.ControlRange.createFromElements.apply(this, this.getElements());
};
goog.dom.ControlRange.prototype.getType = function() {
  return goog.dom.RangeType.CONTROL;
};
goog.dom.ControlRange.prototype.getBrowserRangeObject = function() {
  return this.range_ || document.body.createControlRange();
};
goog.dom.ControlRange.prototype.setBrowserRangeObject = function(nativeRange) {
  if (!goog.dom.AbstractRange.isNativeControlRange(nativeRange)) {
    return false;
  }
  this.range_ = nativeRange;
  return true;
};
goog.dom.ControlRange.prototype.getTextRangeCount = function() {
  return this.range_ ? this.range_.length : 0;
};
goog.dom.ControlRange.prototype.getTextRange = function(i) {
  return goog.dom.TextRange.createFromNodeContents(this.range_.item(i));
};
goog.dom.ControlRange.prototype.getContainer = function() {
  return goog.dom.findCommonAncestor.apply(null, this.getElements());
};
goog.dom.ControlRange.prototype.getStartNode = function() {
  return this.getSortedElements()[0];
};
goog.dom.ControlRange.prototype.getStartOffset = function() {
  return 0;
};
goog.dom.ControlRange.prototype.getEndNode = function() {
  var sorted = this.getSortedElements();
  var startsLast = (goog.array.peek(sorted));
  return (goog.array.find(sorted, function(el) {
    return goog.dom.contains(el, startsLast);
  }));
};
goog.dom.ControlRange.prototype.getEndOffset = function() {
  return this.getEndNode().childNodes.length;
};
goog.dom.ControlRange.prototype.getElements = function() {
  if (!this.elements_) {
    this.elements_ = [];
    if (this.range_) {
      for (var i = 0;i < this.range_.length;i++) {
        this.elements_.push(this.range_.item(i));
      }
    }
  }
  return this.elements_;
};
goog.dom.ControlRange.prototype.getSortedElements = function() {
  if (!this.sortedElements_) {
    this.sortedElements_ = this.getElements().concat();
    this.sortedElements_.sort(function(a, b) {
      return a.sourceIndex - b.sourceIndex;
    });
  }
  return this.sortedElements_;
};
goog.dom.ControlRange.prototype.isRangeInDocument = function() {
  var returnValue = false;
  try {
    returnValue = goog.array.every(this.getElements(), function(element) {
      return goog.userAgent.IE ? !!element.parentNode : goog.dom.contains(element.ownerDocument.body, element);
    });
  } catch (e) {
  }
  return returnValue;
};
goog.dom.ControlRange.prototype.isCollapsed = function() {
  return !this.range_ || !this.range_.length;
};
goog.dom.ControlRange.prototype.getText = function() {
  return "";
};
goog.dom.ControlRange.prototype.getHtmlFragment = function() {
  return goog.array.map(this.getSortedElements(), goog.dom.getOuterHtml).join("");
};
goog.dom.ControlRange.prototype.getValidHtml = function() {
  return this.getHtmlFragment();
};
goog.dom.ControlRange.prototype.getPastableHtml = goog.dom.ControlRange.prototype.getValidHtml;
goog.dom.ControlRange.prototype.__iterator__ = function(opt_keys) {
  return new goog.dom.ControlRangeIterator(this);
};
goog.dom.ControlRange.prototype.select = function() {
  if (this.range_) {
    this.range_.select();
  }
};
goog.dom.ControlRange.prototype.removeContents = function() {
  if (this.range_) {
    var nodes = [];
    for (var i = 0, len = this.range_.length;i < len;i++) {
      nodes.push(this.range_.item(i));
    }
    goog.array.forEach(nodes, goog.dom.removeNode);
    this.collapse(false);
  }
};
goog.dom.ControlRange.prototype.replaceContentsWithNode = function(node) {
  var result = this.insertNode(node, true);
  if (!this.isCollapsed()) {
    this.removeContents();
  }
  return result;
};
goog.dom.ControlRange.prototype.saveUsingDom = function() {
  return new goog.dom.DomSavedControlRange_(this);
};
goog.dom.ControlRange.prototype.collapse = function(toAnchor) {
  this.range_ = null;
  this.clearCachedValues_();
};
goog.dom.DomSavedControlRange_ = function(range) {
  this.elements_ = range.getElements();
};
goog.inherits(goog.dom.DomSavedControlRange_, goog.dom.SavedRange);
goog.dom.DomSavedControlRange_.prototype.restoreInternal = function() {
  var doc = this.elements_.length ? goog.dom.getOwnerDocument(this.elements_[0]) : document;
  var controlRange = doc.body.createControlRange();
  for (var i = 0, len = this.elements_.length;i < len;i++) {
    controlRange.addElement(this.elements_[i]);
  }
  return goog.dom.ControlRange.createFromBrowserRange(controlRange);
};
goog.dom.DomSavedControlRange_.prototype.disposeInternal = function() {
  goog.dom.DomSavedControlRange_.superClass_.disposeInternal.call(this);
  delete this.elements_;
};
goog.dom.ControlRangeIterator = function(range) {
  this.startNode_ = null;
  this.endNode_ = null;
  this.elements_ = null;
  if (range) {
    this.elements_ = range.getSortedElements();
    this.startNode_ = this.elements_.shift();
    this.endNode_ = (goog.array.peek(this.elements_)) || this.startNode_;
  }
  goog.dom.ControlRangeIterator.base(this, "constructor", this.startNode_, false);
};
goog.inherits(goog.dom.ControlRangeIterator, goog.dom.RangeIterator);
goog.dom.ControlRangeIterator.prototype.getStartTextOffset = function() {
  return 0;
};
goog.dom.ControlRangeIterator.prototype.getEndTextOffset = function() {
  return 0;
};
goog.dom.ControlRangeIterator.prototype.getStartNode = function() {
  return this.startNode_;
};
goog.dom.ControlRangeIterator.prototype.getEndNode = function() {
  return this.endNode_;
};
goog.dom.ControlRangeIterator.prototype.isLast = function() {
  return !this.depth && !this.elements_.length;
};
goog.dom.ControlRangeIterator.prototype.next = function() {
  if (this.isLast()) {
    throw goog.iter.StopIteration;
  } else {
    if (!this.depth) {
      var el = this.elements_.shift();
      this.setPosition(el, goog.dom.TagWalkType.START_TAG, goog.dom.TagWalkType.START_TAG);
      return el;
    }
  }
  return goog.dom.ControlRangeIterator.superClass_.next.call(this);
};
goog.dom.ControlRangeIterator.prototype.copyFrom = function(other) {
  this.elements_ = other.elements_;
  this.startNode_ = other.startNode_;
  this.endNode_ = other.endNode_;
  goog.dom.ControlRangeIterator.superClass_.copyFrom.call(this, other);
};
goog.dom.ControlRangeIterator.prototype.clone = function() {
  var copy = new goog.dom.ControlRangeIterator(null);
  copy.copyFrom(this);
  return copy;
};
goog.provide("goog.dom.MultiRange");
goog.provide("goog.dom.MultiRangeIterator");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.AbstractMultiRange");
goog.require("goog.dom.AbstractRange");
goog.require("goog.dom.RangeIterator");
goog.require("goog.dom.RangeType");
goog.require("goog.dom.SavedRange");
goog.require("goog.dom.TextRange");
goog.require("goog.iter");
goog.require("goog.iter.StopIteration");
goog.require("goog.log");
goog.dom.MultiRange = function() {
  this.logger_ = goog.log.getLogger("goog.dom.MultiRange");
  this.browserRanges_ = [];
  this.ranges_ = [];
  this.sortedRanges_ = null;
  this.container_ = null;
};
goog.inherits(goog.dom.MultiRange, goog.dom.AbstractMultiRange);
goog.dom.MultiRange.createFromBrowserSelection = function(selection) {
  var range = new goog.dom.MultiRange;
  for (var i = 0, len = selection.rangeCount;i < len;i++) {
    range.browserRanges_.push(selection.getRangeAt(i));
  }
  return range;
};
goog.dom.MultiRange.createFromBrowserRanges = function(browserRanges) {
  var range = new goog.dom.MultiRange;
  range.browserRanges_ = goog.array.clone(browserRanges);
  return range;
};
goog.dom.MultiRange.createFromTextRanges = function(textRanges) {
  var range = new goog.dom.MultiRange;
  range.ranges_ = textRanges;
  range.browserRanges_ = goog.array.map(textRanges, function(range) {
    return range.getBrowserRangeObject();
  });
  return range;
};
goog.dom.MultiRange.prototype.clearCachedValues_ = function() {
  this.ranges_ = [];
  this.sortedRanges_ = null;
  this.container_ = null;
};
goog.dom.MultiRange.prototype.clone = function() {
  return goog.dom.MultiRange.createFromBrowserRanges(this.browserRanges_);
};
goog.dom.MultiRange.prototype.getType = function() {
  return goog.dom.RangeType.MULTI;
};
goog.dom.MultiRange.prototype.getBrowserRangeObject = function() {
  if (this.browserRanges_.length > 1) {
    goog.log.warning(this.logger_, "getBrowserRangeObject called on MultiRange with more than 1 range");
  }
  return this.browserRanges_[0];
};
goog.dom.MultiRange.prototype.setBrowserRangeObject = function(nativeRange) {
  return false;
};
goog.dom.MultiRange.prototype.getTextRangeCount = function() {
  return this.browserRanges_.length;
};
goog.dom.MultiRange.prototype.getTextRange = function(i) {
  if (!this.ranges_[i]) {
    this.ranges_[i] = goog.dom.TextRange.createFromBrowserRange(this.browserRanges_[i]);
  }
  return this.ranges_[i];
};
goog.dom.MultiRange.prototype.getContainer = function() {
  if (!this.container_) {
    var nodes = [];
    for (var i = 0, len = this.getTextRangeCount();i < len;i++) {
      nodes.push(this.getTextRange(i).getContainer());
    }
    this.container_ = goog.dom.findCommonAncestor.apply(null, nodes);
  }
  return this.container_;
};
goog.dom.MultiRange.prototype.getSortedRanges = function() {
  if (!this.sortedRanges_) {
    this.sortedRanges_ = this.getTextRanges();
    this.sortedRanges_.sort(function(a, b) {
      var aStartNode = a.getStartNode();
      var aStartOffset = a.getStartOffset();
      var bStartNode = b.getStartNode();
      var bStartOffset = b.getStartOffset();
      if (aStartNode == bStartNode && aStartOffset == bStartOffset) {
        return 0;
      }
      return goog.dom.Range.isReversed(aStartNode, aStartOffset, bStartNode, bStartOffset) ? 1 : -1;
    });
  }
  return this.sortedRanges_;
};
goog.dom.MultiRange.prototype.getStartNode = function() {
  return this.getSortedRanges()[0].getStartNode();
};
goog.dom.MultiRange.prototype.getStartOffset = function() {
  return this.getSortedRanges()[0].getStartOffset();
};
goog.dom.MultiRange.prototype.getEndNode = function() {
  return goog.array.peek(this.getSortedRanges()).getEndNode();
};
goog.dom.MultiRange.prototype.getEndOffset = function() {
  return goog.array.peek(this.getSortedRanges()).getEndOffset();
};
goog.dom.MultiRange.prototype.isRangeInDocument = function() {
  return goog.array.every(this.getTextRanges(), function(range) {
    return range.isRangeInDocument();
  });
};
goog.dom.MultiRange.prototype.isCollapsed = function() {
  return this.browserRanges_.length == 0 || this.browserRanges_.length == 1 && this.getTextRange(0).isCollapsed();
};
goog.dom.MultiRange.prototype.getText = function() {
  return goog.array.map(this.getTextRanges(), function(range) {
    return range.getText();
  }).join("");
};
goog.dom.MultiRange.prototype.getHtmlFragment = function() {
  return this.getValidHtml();
};
goog.dom.MultiRange.prototype.getValidHtml = function() {
  return goog.array.map(this.getTextRanges(), function(range) {
    return range.getValidHtml();
  }).join("");
};
goog.dom.MultiRange.prototype.getPastableHtml = function() {
  return this.getValidHtml();
};
goog.dom.MultiRange.prototype.__iterator__ = function(opt_keys) {
  return new goog.dom.MultiRangeIterator(this);
};
goog.dom.MultiRange.prototype.select = function() {
  var selection = goog.dom.AbstractRange.getBrowserSelectionForWindow(this.getWindow());
  selection.removeAllRanges();
  for (var i = 0, len = this.getTextRangeCount();i < len;i++) {
    selection.addRange(this.getTextRange(i).getBrowserRangeObject());
  }
};
goog.dom.MultiRange.prototype.removeContents = function() {
  goog.array.forEach(this.getTextRanges(), function(range) {
    range.removeContents();
  });
};
goog.dom.MultiRange.prototype.saveUsingDom = function() {
  return new goog.dom.DomSavedMultiRange_(this);
};
goog.dom.MultiRange.prototype.collapse = function(toAnchor) {
  if (!this.isCollapsed()) {
    var range = toAnchor ? this.getTextRange(0) : this.getTextRange(this.getTextRangeCount() - 1);
    this.clearCachedValues_();
    range.collapse(toAnchor);
    this.ranges_ = [range];
    this.sortedRanges_ = [range];
    this.browserRanges_ = [range.getBrowserRangeObject()];
  }
};
goog.dom.DomSavedMultiRange_ = function(range) {
  this.savedRanges_ = goog.array.map(range.getTextRanges(), function(range) {
    return range.saveUsingDom();
  });
};
goog.inherits(goog.dom.DomSavedMultiRange_, goog.dom.SavedRange);
goog.dom.DomSavedMultiRange_.prototype.restoreInternal = function() {
  var ranges = goog.array.map(this.savedRanges_, function(savedRange) {
    return savedRange.restore();
  });
  return goog.dom.MultiRange.createFromTextRanges(ranges);
};
goog.dom.DomSavedMultiRange_.prototype.disposeInternal = function() {
  goog.dom.DomSavedMultiRange_.superClass_.disposeInternal.call(this);
  goog.array.forEach(this.savedRanges_, function(savedRange) {
    savedRange.dispose();
  });
  delete this.savedRanges_;
};
goog.dom.MultiRangeIterator = function(range) {
  this.iterators_ = null;
  this.currentIdx_ = 0;
  if (range) {
    this.iterators_ = goog.array.map(range.getSortedRanges(), function(r) {
      return goog.iter.toIterator(r);
    });
  }
  goog.dom.MultiRangeIterator.base(this, "constructor", range ? this.getStartNode() : null, false);
};
goog.inherits(goog.dom.MultiRangeIterator, goog.dom.RangeIterator);
goog.dom.MultiRangeIterator.prototype.getStartTextOffset = function() {
  return this.iterators_[this.currentIdx_].getStartTextOffset();
};
goog.dom.MultiRangeIterator.prototype.getEndTextOffset = function() {
  return this.iterators_[this.currentIdx_].getEndTextOffset();
};
goog.dom.MultiRangeIterator.prototype.getStartNode = function() {
  return this.iterators_[0].getStartNode();
};
goog.dom.MultiRangeIterator.prototype.getEndNode = function() {
  return goog.array.peek(this.iterators_).getEndNode();
};
goog.dom.MultiRangeIterator.prototype.isLast = function() {
  return this.iterators_[this.currentIdx_].isLast();
};
goog.dom.MultiRangeIterator.prototype.next = function() {
  try {
    var it = this.iterators_[this.currentIdx_];
    var next = it.next();
    this.setPosition(it.node, it.tagType, it.depth);
    return next;
  } catch (ex) {
    if (ex !== goog.iter.StopIteration || this.iterators_.length - 1 == this.currentIdx_) {
      throw ex;
    } else {
      this.currentIdx_++;
      return this.next();
    }
  }
};
goog.dom.MultiRangeIterator.prototype.copyFrom = function(other) {
  this.iterators_ = goog.array.clone(other.iterators_);
  goog.dom.MultiRangeIterator.superClass_.copyFrom.call(this, other);
};
goog.dom.MultiRangeIterator.prototype.clone = function() {
  var copy = new goog.dom.MultiRangeIterator(null);
  copy.copyFrom(this);
  return copy;
};
goog.provide("goog.dom.Range");
goog.require("goog.dom");
goog.require("goog.dom.AbstractRange");
goog.require("goog.dom.BrowserFeature");
goog.require("goog.dom.ControlRange");
goog.require("goog.dom.MultiRange");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.TextRange");
goog.dom.Range.createFromWindow = function(opt_win) {
  var sel = goog.dom.AbstractRange.getBrowserSelectionForWindow(opt_win || window);
  return sel && goog.dom.Range.createFromBrowserSelection(sel);
};
goog.dom.Range.createFromBrowserSelection = function(selection) {
  var range;
  var isReversed = false;
  if (selection.createRange) {
    try {
      range = selection.createRange();
    } catch (e) {
      return null;
    }
  } else {
    if (selection.rangeCount) {
      if (selection.rangeCount > 1) {
        return goog.dom.MultiRange.createFromBrowserSelection((selection));
      } else {
        range = selection.getRangeAt(0);
        isReversed = goog.dom.Range.isReversed(selection.anchorNode, selection.anchorOffset, selection.focusNode, selection.focusOffset);
      }
    } else {
      return null;
    }
  }
  return goog.dom.Range.createFromBrowserRange(range, isReversed);
};
goog.dom.Range.createFromBrowserRange = function(range, opt_isReversed) {
  return goog.dom.AbstractRange.isNativeControlRange(range) ? goog.dom.ControlRange.createFromBrowserRange(range) : goog.dom.TextRange.createFromBrowserRange(range, opt_isReversed);
};
goog.dom.Range.createFromNodeContents = function(node, opt_isReversed) {
  return goog.dom.TextRange.createFromNodeContents(node, opt_isReversed);
};
goog.dom.Range.createCaret = function(node, offset) {
  return goog.dom.TextRange.createFromNodes(node, offset, node, offset);
};
goog.dom.Range.createFromNodes = function(anchorNode, anchorOffset, focusNode, focusOffset) {
  return goog.dom.TextRange.createFromNodes(anchorNode, anchorOffset, focusNode, focusOffset);
};
goog.dom.Range.clearSelection = function(opt_win) {
  var sel = goog.dom.AbstractRange.getBrowserSelectionForWindow(opt_win || window);
  if (!sel) {
    return;
  }
  if (sel.empty) {
    try {
      sel.empty();
    } catch (e) {
    }
  } else {
    try {
      sel.removeAllRanges();
    } catch (e$2) {
    }
  }
};
goog.dom.Range.hasSelection = function(opt_win) {
  var sel = goog.dom.AbstractRange.getBrowserSelectionForWindow(opt_win || window);
  return !!sel && (goog.dom.BrowserFeature.LEGACY_IE_RANGES ? sel.type != "None" : !!sel.rangeCount);
};
goog.dom.Range.isReversed = function(anchorNode, anchorOffset, focusNode, focusOffset) {
  if (anchorNode == focusNode) {
    return focusOffset < anchorOffset;
  }
  var child;
  if (anchorNode.nodeType == goog.dom.NodeType.ELEMENT && anchorOffset) {
    child = anchorNode.childNodes[anchorOffset];
    if (child) {
      anchorNode = child;
      anchorOffset = 0;
    } else {
      if (goog.dom.contains(anchorNode, focusNode)) {
        return true;
      }
    }
  }
  if (focusNode.nodeType == goog.dom.NodeType.ELEMENT && focusOffset) {
    child = focusNode.childNodes[focusOffset];
    if (child) {
      focusNode = child;
      focusOffset = 0;
    } else {
      if (goog.dom.contains(focusNode, anchorNode)) {
        return false;
      }
    }
  }
  return (goog.dom.compareNodeOrder(anchorNode, focusNode) || anchorOffset - focusOffset) > 0;
};
goog.provide("goog.a11y.aria.Role");
goog.a11y.aria.Role = {ALERT:"alert", ALERTDIALOG:"alertdialog", APPLICATION:"application", ARTICLE:"article", BANNER:"banner", BUTTON:"button", CHECKBOX:"checkbox", COLUMNHEADER:"columnheader", COMBOBOX:"combobox", COMPLEMENTARY:"complementary", CONTENTINFO:"contentinfo", DEFINITION:"definition", DIALOG:"dialog", DIRECTORY:"directory", DOCUMENT:"document", FORM:"form", GRID:"grid", GRIDCELL:"gridcell", GROUP:"group", HEADING:"heading", IMG:"img", LINK:"link", LIST:"list", LISTBOX:"listbox", LISTITEM:"listitem", 
LOG:"log", MAIN:"main", MARQUEE:"marquee", MATH:"math", MENU:"menu", MENUBAR:"menubar", MENU_ITEM:"menuitem", MENU_ITEM_CHECKBOX:"menuitemcheckbox", MENU_ITEM_RADIO:"menuitemradio", NAVIGATION:"navigation", NOTE:"note", OPTION:"option", PRESENTATION:"presentation", PROGRESSBAR:"progressbar", RADIO:"radio", RADIOGROUP:"radiogroup", REGION:"region", ROW:"row", ROWGROUP:"rowgroup", ROWHEADER:"rowheader", SCROLLBAR:"scrollbar", SEARCH:"search", SEPARATOR:"separator", SLIDER:"slider", SPINBUTTON:"spinbutton", 
STATUS:"status", TAB:"tab", TAB_LIST:"tablist", TAB_PANEL:"tabpanel", TEXTBOX:"textbox", TEXTINFO:"textinfo", TIMER:"timer", TOOLBAR:"toolbar", TOOLTIP:"tooltip", TREE:"tree", TREEGRID:"treegrid", TREEITEM:"treeitem"};
goog.provide("goog.a11y.aria.AutoCompleteValues");
goog.provide("goog.a11y.aria.CheckedValues");
goog.provide("goog.a11y.aria.DropEffectValues");
goog.provide("goog.a11y.aria.ExpandedValues");
goog.provide("goog.a11y.aria.GrabbedValues");
goog.provide("goog.a11y.aria.InvalidValues");
goog.provide("goog.a11y.aria.LivePriority");
goog.provide("goog.a11y.aria.OrientationValues");
goog.provide("goog.a11y.aria.PressedValues");
goog.provide("goog.a11y.aria.RelevantValues");
goog.provide("goog.a11y.aria.SelectedValues");
goog.provide("goog.a11y.aria.SortValues");
goog.provide("goog.a11y.aria.State");
goog.a11y.aria.State = {ACTIVEDESCENDANT:"activedescendant", ATOMIC:"atomic", AUTOCOMPLETE:"autocomplete", BUSY:"busy", CHECKED:"checked", CONTROLS:"controls", DESCRIBEDBY:"describedby", DISABLED:"disabled", DROPEFFECT:"dropeffect", EXPANDED:"expanded", FLOWTO:"flowto", GRABBED:"grabbed", HASPOPUP:"haspopup", HIDDEN:"hidden", INVALID:"invalid", LABEL:"label", LABELLEDBY:"labelledby", LEVEL:"level", LIVE:"live", MULTILINE:"multiline", MULTISELECTABLE:"multiselectable", ORIENTATION:"orientation", OWNS:"owns", 
POSINSET:"posinset", PRESSED:"pressed", READONLY:"readonly", RELEVANT:"relevant", REQUIRED:"required", SELECTED:"selected", SETSIZE:"setsize", SORT:"sort", VALUEMAX:"valuemax", VALUEMIN:"valuemin", VALUENOW:"valuenow", VALUETEXT:"valuetext"};
goog.a11y.aria.AutoCompleteValues = {INLINE:"inline", LIST:"list", BOTH:"both", NONE:"none"};
goog.a11y.aria.DropEffectValues = {COPY:"copy", MOVE:"move", LINK:"link", EXECUTE:"execute", POPUP:"popup", NONE:"none"};
goog.a11y.aria.LivePriority = {OFF:"off", POLITE:"polite", ASSERTIVE:"assertive"};
goog.a11y.aria.OrientationValues = {VERTICAL:"vertical", HORIZONTAL:"horizontal"};
goog.a11y.aria.RelevantValues = {ADDITIONS:"additions", REMOVALS:"removals", TEXT:"text", ALL:"all"};
goog.a11y.aria.SortValues = {ASCENDING:"ascending", DESCENDING:"descending", NONE:"none", OTHER:"other"};
goog.a11y.aria.CheckedValues = {TRUE:"true", FALSE:"false", MIXED:"mixed", UNDEFINED:"undefined"};
goog.a11y.aria.ExpandedValues = {TRUE:"true", FALSE:"false", UNDEFINED:"undefined"};
goog.a11y.aria.GrabbedValues = {TRUE:"true", FALSE:"false", UNDEFINED:"undefined"};
goog.a11y.aria.InvalidValues = {FALSE:"false", TRUE:"true", GRAMMAR:"grammar", SPELLING:"spelling"};
goog.a11y.aria.PressedValues = {TRUE:"true", FALSE:"false", MIXED:"mixed", UNDEFINED:"undefined"};
goog.a11y.aria.SelectedValues = {TRUE:"true", FALSE:"false", UNDEFINED:"undefined"};
goog.provide("goog.a11y.aria.datatables");
goog.require("goog.a11y.aria.State");
goog.require("goog.object");
goog.a11y.aria.DefaultStateValueMap_;
goog.a11y.aria.datatables.getDefaultValuesMap = function() {
  if (!goog.a11y.aria.DefaultStateValueMap_) {
    goog.a11y.aria.DefaultStateValueMap_ = goog.object.create(goog.a11y.aria.State.ATOMIC, false, goog.a11y.aria.State.AUTOCOMPLETE, "none", goog.a11y.aria.State.DROPEFFECT, "none", goog.a11y.aria.State.HASPOPUP, false, goog.a11y.aria.State.LIVE, "off", goog.a11y.aria.State.MULTILINE, false, goog.a11y.aria.State.MULTISELECTABLE, false, goog.a11y.aria.State.ORIENTATION, "vertical", goog.a11y.aria.State.READONLY, false, goog.a11y.aria.State.RELEVANT, "additions text", goog.a11y.aria.State.REQUIRED, 
    false, goog.a11y.aria.State.SORT, "none", goog.a11y.aria.State.BUSY, false, goog.a11y.aria.State.DISABLED, false, goog.a11y.aria.State.HIDDEN, false, goog.a11y.aria.State.INVALID, "false");
  }
  return goog.a11y.aria.DefaultStateValueMap_;
};
goog.provide("goog.a11y.aria");
goog.require("goog.a11y.aria.Role");
goog.require("goog.a11y.aria.State");
goog.require("goog.a11y.aria.datatables");
goog.require("goog.array");
goog.require("goog.asserts");
goog.require("goog.dom");
goog.require("goog.dom.TagName");
goog.require("goog.object");
goog.require("goog.string");
goog.a11y.aria.ARIA_PREFIX_ = "aria-";
goog.a11y.aria.ROLE_ATTRIBUTE_ = "role";
goog.a11y.aria.TAGS_WITH_ASSUMED_ROLES_ = [goog.dom.TagName.A, goog.dom.TagName.AREA, goog.dom.TagName.BUTTON, goog.dom.TagName.HEAD, goog.dom.TagName.INPUT, goog.dom.TagName.LINK, goog.dom.TagName.MENU, goog.dom.TagName.META, goog.dom.TagName.OPTGROUP, goog.dom.TagName.OPTION, goog.dom.TagName.PROGRESS, goog.dom.TagName.STYLE, goog.dom.TagName.SELECT, goog.dom.TagName.SOURCE, goog.dom.TagName.TEXTAREA, goog.dom.TagName.TITLE, goog.dom.TagName.TRACK];
goog.a11y.aria.CONTAINER_ROLES_ = [goog.a11y.aria.Role.COMBOBOX, goog.a11y.aria.Role.GRID, goog.a11y.aria.Role.GROUP, goog.a11y.aria.Role.LISTBOX, goog.a11y.aria.Role.MENU, goog.a11y.aria.Role.MENUBAR, goog.a11y.aria.Role.RADIOGROUP, goog.a11y.aria.Role.ROW, goog.a11y.aria.Role.ROWGROUP, goog.a11y.aria.Role.TAB_LIST, goog.a11y.aria.Role.TEXTBOX, goog.a11y.aria.Role.TOOLBAR, goog.a11y.aria.Role.TREE, goog.a11y.aria.Role.TREEGRID];
goog.a11y.aria.setRole = function(element, roleName) {
  if (!roleName) {
    goog.a11y.aria.removeRole(element);
  } else {
    if (goog.asserts.ENABLE_ASSERTS) {
      goog.asserts.assert(goog.object.containsValue(goog.a11y.aria.Role, roleName), "No such ARIA role " + roleName);
    }
    element.setAttribute(goog.a11y.aria.ROLE_ATTRIBUTE_, roleName);
  }
};
goog.a11y.aria.getRole = function(element) {
  var role = element.getAttribute(goog.a11y.aria.ROLE_ATTRIBUTE_);
  return (role) || null;
};
goog.a11y.aria.removeRole = function(element) {
  element.removeAttribute(goog.a11y.aria.ROLE_ATTRIBUTE_);
};
goog.a11y.aria.setState = function(element, stateName, value) {
  if (goog.isArray(value)) {
    value = value.join(" ");
  }
  var attrStateName = goog.a11y.aria.getAriaAttributeName_(stateName);
  if (value === "" || value == undefined) {
    var defaultValueMap = goog.a11y.aria.datatables.getDefaultValuesMap();
    if (stateName in defaultValueMap) {
      element.setAttribute(attrStateName, defaultValueMap[stateName]);
    } else {
      element.removeAttribute(attrStateName);
    }
  } else {
    element.setAttribute(attrStateName, value);
  }
};
goog.a11y.aria.toggleState = function(el, attr) {
  var val = goog.a11y.aria.getState(el, attr);
  if (!goog.string.isEmptyOrWhitespace(goog.string.makeSafe(val)) && !(val == "true" || val == "false")) {
    goog.a11y.aria.removeState(el, (attr));
    return;
  }
  goog.a11y.aria.setState(el, attr, val == "true" ? "false" : "true");
};
goog.a11y.aria.removeState = function(element, stateName) {
  element.removeAttribute(goog.a11y.aria.getAriaAttributeName_(stateName));
};
goog.a11y.aria.getState = function(element, stateName) {
  var attr = (element.getAttribute(goog.a11y.aria.getAriaAttributeName_(stateName)));
  var isNullOrUndefined = attr == null || attr == undefined;
  return isNullOrUndefined ? "" : String(attr);
};
goog.a11y.aria.getActiveDescendant = function(element) {
  var id = goog.a11y.aria.getState(element, goog.a11y.aria.State.ACTIVEDESCENDANT);
  return goog.dom.getOwnerDocument(element).getElementById(id);
};
goog.a11y.aria.setActiveDescendant = function(element, activeElement) {
  var id = "";
  if (activeElement) {
    id = activeElement.id;
    goog.asserts.assert(id, "The active element should have an id.");
  }
  goog.a11y.aria.setState(element, goog.a11y.aria.State.ACTIVEDESCENDANT, id);
};
goog.a11y.aria.getLabel = function(element) {
  return goog.a11y.aria.getState(element, goog.a11y.aria.State.LABEL);
};
goog.a11y.aria.setLabel = function(element, label) {
  goog.a11y.aria.setState(element, goog.a11y.aria.State.LABEL, label);
};
goog.a11y.aria.assertRoleIsSetInternalUtil = function(element, allowedRoles) {
  if (goog.array.contains(goog.a11y.aria.TAGS_WITH_ASSUMED_ROLES_, element.tagName)) {
    return;
  }
  var elementRole = (goog.a11y.aria.getRole(element));
  goog.asserts.assert(elementRole != null, "The element ARIA role cannot be null.");
  goog.asserts.assert(goog.array.contains(allowedRoles, elementRole), "Non existing or incorrect role set for element." + 'The role set is "' + elementRole + '". The role should be any of "' + allowedRoles + '". Check the ARIA specification for more details ' + "http://www.w3.org/TR/wai-aria/roles.");
};
goog.a11y.aria.getStateBoolean = function(element, stateName) {
  var attr = (element.getAttribute(goog.a11y.aria.getAriaAttributeName_(stateName)));
  goog.asserts.assert(goog.isBoolean(attr) || attr == null || attr == "true" || attr == "false");
  if (attr == null) {
    return attr;
  }
  return goog.isBoolean(attr) ? attr : attr == "true";
};
goog.a11y.aria.getStateNumber = function(element, stateName) {
  var attr = (element.getAttribute(goog.a11y.aria.getAriaAttributeName_(stateName)));
  goog.asserts.assert((attr == null || !isNaN(Number(attr))) && !goog.isBoolean(attr));
  return attr == null ? null : Number(attr);
};
goog.a11y.aria.getStateString = function(element, stateName) {
  var attr = element.getAttribute(goog.a11y.aria.getAriaAttributeName_(stateName));
  goog.asserts.assert((attr == null || goog.isString(attr)) && (attr == "" || isNaN(Number(attr))) && attr != "true" && attr != "false");
  return attr == null || attr == "" ? null : attr;
};
goog.a11y.aria.getStringArrayStateInternalUtil = function(element, stateName) {
  var attrValue = element.getAttribute(goog.a11y.aria.getAriaAttributeName_(stateName));
  return goog.a11y.aria.splitStringOnWhitespace_(attrValue);
};
goog.a11y.aria.hasState = function(element, stateName) {
  return element.hasAttribute(goog.a11y.aria.getAriaAttributeName_(stateName));
};
goog.a11y.aria.isContainerRole = function(element) {
  var role = goog.a11y.aria.getRole(element);
  return goog.array.contains(goog.a11y.aria.CONTAINER_ROLES_, role);
};
goog.a11y.aria.splitStringOnWhitespace_ = function(stringValue) {
  return stringValue ? stringValue.split(/\s+/) : [];
};
goog.a11y.aria.getAriaAttributeName_ = function(ariaName) {
  if (goog.asserts.ENABLE_ASSERTS) {
    goog.asserts.assert(ariaName, "ARIA attribute cannot be empty.");
    goog.asserts.assert(goog.object.containsValue(goog.a11y.aria.State, ariaName), "No such ARIA attribute " + ariaName);
  }
  return goog.a11y.aria.ARIA_PREFIX_ + ariaName;
};
goog.provide("goog.Thenable");
goog.Thenable = function() {
};
goog.Thenable.prototype.then = function(opt_onFulfilled, opt_onRejected, opt_context) {
};
goog.Thenable.IMPLEMENTED_BY_PROP = "$goog_Thenable";
goog.Thenable.addImplementation = function(ctor) {
  goog.exportProperty(ctor.prototype, "then", ctor.prototype.then);
  if (COMPILED) {
    ctor.prototype[goog.Thenable.IMPLEMENTED_BY_PROP] = true;
  } else {
    ctor.prototype.$goog_Thenable = true;
  }
};
goog.Thenable.isImplementedBy = function(object) {
  if (!object) {
    return false;
  }
  try {
    if (COMPILED) {
      return !!object[goog.Thenable.IMPLEMENTED_BY_PROP];
    }
    return !!object.$goog_Thenable;
  } catch (e) {
    return false;
  }
};
goog.provide("goog.async.FreeList");
goog.async.FreeList = goog.defineClass(null, {constructor:function(create, reset, limit) {
  this.limit_ = limit;
  this.create_ = create;
  this.reset_ = reset;
  this.occupants_ = 0;
  this.head_ = null;
}, get:function() {
  var item;
  if (this.occupants_ > 0) {
    this.occupants_--;
    item = this.head_;
    this.head_ = item.next;
    item.next = null;
  } else {
    item = this.create_();
  }
  return item;
}, put:function(item) {
  this.reset_(item);
  if (this.occupants_ < this.limit_) {
    this.occupants_++;
    item.next = this.head_;
    this.head_ = item;
  }
}, occupants:function() {
  return this.occupants_;
}});
goog.provide("goog.async.WorkItem");
goog.provide("goog.async.WorkQueue");
goog.require("goog.asserts");
goog.require("goog.async.FreeList");
goog.async.WorkQueue = function() {
  this.workHead_ = null;
  this.workTail_ = null;
};
goog.define("goog.async.WorkQueue.DEFAULT_MAX_UNUSED", 100);
goog.async.WorkQueue.freelist_ = new goog.async.FreeList(function() {
  return new goog.async.WorkItem;
}, function(item) {
  item.reset();
}, goog.async.WorkQueue.DEFAULT_MAX_UNUSED);
goog.async.WorkQueue.prototype.add = function(fn, scope) {
  var item = this.getUnusedItem_();
  item.set(fn, scope);
  if (this.workTail_) {
    this.workTail_.next = item;
    this.workTail_ = item;
  } else {
    goog.asserts.assert(!this.workHead_);
    this.workHead_ = item;
    this.workTail_ = item;
  }
};
goog.async.WorkQueue.prototype.remove = function() {
  var item = null;
  if (this.workHead_) {
    item = this.workHead_;
    this.workHead_ = this.workHead_.next;
    if (!this.workHead_) {
      this.workTail_ = null;
    }
    item.next = null;
  }
  return item;
};
goog.async.WorkQueue.prototype.returnUnused = function(item) {
  goog.async.WorkQueue.freelist_.put(item);
};
goog.async.WorkQueue.prototype.getUnusedItem_ = function() {
  return goog.async.WorkQueue.freelist_.get();
};
goog.async.WorkItem = function() {
  this.fn = null;
  this.scope = null;
  this.next = null;
};
goog.async.WorkItem.prototype.set = function(fn, scope) {
  this.fn = fn;
  this.scope = scope;
  this.next = null;
};
goog.async.WorkItem.prototype.reset = function() {
  this.fn = null;
  this.scope = null;
  this.next = null;
};
goog.provide("goog.async.nextTick");
goog.provide("goog.async.throwException");
goog.require("goog.debug.entryPointRegistry");
goog.require("goog.dom.TagName");
goog.require("goog.functions");
goog.require("goog.labs.userAgent.browser");
goog.require("goog.labs.userAgent.engine");
goog.async.throwException = function(exception) {
  goog.global.setTimeout(function() {
    throw exception;
  }, 0);
};
goog.async.nextTick = function(callback, opt_context, opt_useSetImmediate) {
  var cb = callback;
  if (opt_context) {
    cb = goog.bind(callback, opt_context);
  }
  cb = goog.async.nextTick.wrapCallback_(cb);
  if (goog.isFunction(goog.global.setImmediate) && (opt_useSetImmediate || goog.async.nextTick.useSetImmediate_())) {
    goog.global.setImmediate(cb);
    return;
  }
  if (!goog.async.nextTick.setImmediate_) {
    goog.async.nextTick.setImmediate_ = goog.async.nextTick.getSetImmediateEmulator_();
  }
  goog.async.nextTick.setImmediate_(cb);
};
goog.async.nextTick.useSetImmediate_ = function() {
  if (!goog.global.Window || !goog.global.Window.prototype) {
    return true;
  }
  if (goog.labs.userAgent.browser.isEdge() || goog.global.Window.prototype.setImmediate != goog.global.setImmediate) {
    return true;
  }
  return false;
};
goog.async.nextTick.setImmediate_;
goog.async.nextTick.getSetImmediateEmulator_ = function() {
  var Channel = goog.global["MessageChannel"];
  if (typeof Channel === "undefined" && typeof window !== "undefined" && window.postMessage && window.addEventListener && !goog.labs.userAgent.engine.isPresto()) {
    Channel = function() {
      var iframe = (document.createElement(goog.dom.TagName.IFRAME));
      iframe.style.display = "none";
      iframe.src = "";
      document.documentElement.appendChild(iframe);
      var win = iframe.contentWindow;
      var doc = win.document;
      doc.open();
      doc.write("");
      doc.close();
      var message = "callImmediate" + Math.random();
      var origin = win.location.protocol == "file:" ? "*" : win.location.protocol + "//" + win.location.host;
      var onmessage = goog.bind(function(e) {
        if (origin != "*" && e.origin != origin || e.data != message) {
          return;
        }
        this["port1"].onmessage();
      }, this);
      win.addEventListener("message", onmessage, false);
      this["port1"] = {};
      this["port2"] = {postMessage:function() {
        win.postMessage(message, origin);
      }};
    };
  }
  if (typeof Channel !== "undefined" && !goog.labs.userAgent.browser.isIE()) {
    var channel = new Channel;
    var head = {};
    var tail = head;
    channel["port1"].onmessage = function() {
      if (goog.isDef(head.next)) {
        head = head.next;
        var cb = head.cb;
        head.cb = null;
        cb();
      }
    };
    return function(cb) {
      tail.next = {cb:cb};
      tail = tail.next;
      channel["port2"].postMessage(0);
    };
  }
  if (typeof document !== "undefined" && "onreadystatechange" in document.createElement(goog.dom.TagName.SCRIPT)) {
    return function(cb) {
      var script = document.createElement(goog.dom.TagName.SCRIPT);
      script.onreadystatechange = function() {
        script.onreadystatechange = null;
        script.parentNode.removeChild(script);
        script = null;
        cb();
        cb = null;
      };
      document.documentElement.appendChild(script);
    };
  }
  return function(cb) {
    goog.global.setTimeout(cb, 0);
  };
};
goog.async.nextTick.wrapCallback_ = goog.functions.identity;
goog.debug.entryPointRegistry.register(function(transformer) {
  goog.async.nextTick.wrapCallback_ = transformer;
});
goog.provide("goog.async.run");
goog.require("goog.async.WorkQueue");
goog.require("goog.async.nextTick");
goog.require("goog.async.throwException");
goog.async.run = function(callback, opt_context) {
  if (!goog.async.run.schedule_) {
    goog.async.run.initializeRunner_();
  }
  if (!goog.async.run.workQueueScheduled_) {
    goog.async.run.schedule_();
    goog.async.run.workQueueScheduled_ = true;
  }
  goog.async.run.workQueue_.add(callback, opt_context);
};
goog.async.run.initializeRunner_ = function() {
  if (goog.global.Promise && goog.global.Promise.resolve) {
    var promise = goog.global.Promise.resolve(undefined);
    goog.async.run.schedule_ = function() {
      promise.then(goog.async.run.processWorkQueue);
    };
  } else {
    goog.async.run.schedule_ = function() {
      goog.async.nextTick(goog.async.run.processWorkQueue);
    };
  }
};
goog.async.run.forceNextTick = function(opt_realSetTimeout) {
  goog.async.run.schedule_ = function() {
    goog.async.nextTick(goog.async.run.processWorkQueue);
    if (opt_realSetTimeout) {
      opt_realSetTimeout(goog.async.run.processWorkQueue);
    }
  };
};
goog.async.run.schedule_;
goog.async.run.workQueueScheduled_ = false;
goog.async.run.workQueue_ = new goog.async.WorkQueue;
if (goog.DEBUG) {
  goog.async.run.resetQueue = function() {
    goog.async.run.workQueueScheduled_ = false;
    goog.async.run.workQueue_ = new goog.async.WorkQueue;
  };
}
goog.async.run.processWorkQueue = function() {
  var item = null;
  while (item = goog.async.run.workQueue_.remove()) {
    try {
      item.fn.call(item.scope);
    } catch (e) {
      goog.async.throwException(e);
    }
    goog.async.run.workQueue_.returnUnused(item);
  }
  goog.async.run.workQueueScheduled_ = false;
};
goog.provide("goog.promise.Resolver");
goog.promise.Resolver = function() {
};
goog.promise.Resolver.prototype.promise;
goog.promise.Resolver.prototype.resolve;
goog.promise.Resolver.prototype.reject;
goog.provide("goog.Promise");
goog.require("goog.Thenable");
goog.require("goog.asserts");
goog.require("goog.async.FreeList");
goog.require("goog.async.run");
goog.require("goog.async.throwException");
goog.require("goog.debug.Error");
goog.require("goog.promise.Resolver");
goog.Promise = function(resolver, opt_context) {
  this.state_ = goog.Promise.State_.PENDING;
  this.result_ = undefined;
  this.parent_ = null;
  this.callbackEntries_ = null;
  this.callbackEntriesTail_ = null;
  this.executing_ = false;
  if (goog.Promise.UNHANDLED_REJECTION_DELAY > 0) {
    this.unhandledRejectionId_ = 0;
  } else {
    if (goog.Promise.UNHANDLED_REJECTION_DELAY == 0) {
      this.hadUnhandledRejection_ = false;
    }
  }
  if (goog.Promise.LONG_STACK_TRACES) {
    this.stack_ = [];
    this.addStackTrace_(new Error("created"));
    this.currentStep_ = 0;
  }
  if (resolver != goog.nullFunction) {
    try {
      var self = this;
      resolver.call(opt_context, function(value) {
        self.resolve_(goog.Promise.State_.FULFILLED, value);
      }, function(reason) {
        if (goog.DEBUG && !(reason instanceof goog.Promise.CancellationError)) {
          try {
            if (reason instanceof Error) {
              throw reason;
            } else {
              throw new Error("Promise rejected.");
            }
          } catch (e) {
          }
        }
        self.resolve_(goog.Promise.State_.REJECTED, reason);
      });
    } catch (e) {
      this.resolve_(goog.Promise.State_.REJECTED, e);
    }
  }
};
goog.define("goog.Promise.LONG_STACK_TRACES", false);
goog.define("goog.Promise.UNHANDLED_REJECTION_DELAY", 0);
goog.Promise.State_ = {PENDING:0, BLOCKED:1, FULFILLED:2, REJECTED:3};
goog.Promise.CallbackEntry_ = function() {
  this.child = null;
  this.onFulfilled = null;
  this.onRejected = null;
  this.context = null;
  this.next = null;
  this.always = false;
};
goog.Promise.CallbackEntry_.prototype.reset = function() {
  this.child = null;
  this.onFulfilled = null;
  this.onRejected = null;
  this.context = null;
  this.always = false;
};
goog.define("goog.Promise.DEFAULT_MAX_UNUSED", 100);
goog.Promise.freelist_ = new goog.async.FreeList(function() {
  return new goog.Promise.CallbackEntry_;
}, function(item) {
  item.reset();
}, goog.Promise.DEFAULT_MAX_UNUSED);
goog.Promise.getCallbackEntry_ = function(onFulfilled, onRejected, context) {
  var entry = goog.Promise.freelist_.get();
  entry.onFulfilled = onFulfilled;
  entry.onRejected = onRejected;
  entry.context = context;
  return entry;
};
goog.Promise.returnEntry_ = function(entry) {
  goog.Promise.freelist_.put(entry);
};
goog.Promise.resolve = function(opt_value) {
  if (opt_value instanceof goog.Promise) {
    return opt_value;
  }
  var promise = new goog.Promise(goog.nullFunction);
  promise.resolve_(goog.Promise.State_.FULFILLED, opt_value);
  return promise;
};
goog.Promise.reject = function(opt_reason) {
  return new goog.Promise(function(resolve, reject) {
    reject(opt_reason);
  });
};
goog.Promise.resolveThen_ = function(value, onFulfilled, onRejected) {
  var isThenable = goog.Promise.maybeThen_(value, onFulfilled, onRejected, null);
  if (!isThenable) {
    goog.async.run(goog.partial(onFulfilled, value));
  }
};
goog.Promise.race = function(promises) {
  return new goog.Promise(function(resolve, reject) {
    if (!promises.length) {
      resolve(undefined);
    }
    for (var i = 0, promise;i < promises.length;i++) {
      promise = promises[i];
      goog.Promise.resolveThen_(promise, resolve, reject);
    }
  });
};
goog.Promise.all = function(promises) {
  return new goog.Promise(function(resolve, reject) {
    var toFulfill = promises.length;
    var values = [];
    if (!toFulfill) {
      resolve(values);
      return;
    }
    var onFulfill = function(index, value) {
      toFulfill--;
      values[index] = value;
      if (toFulfill == 0) {
        resolve(values);
      }
    };
    var onReject = function(reason) {
      reject(reason);
    };
    for (var i = 0, promise;i < promises.length;i++) {
      promise = promises[i];
      goog.Promise.resolveThen_(promise, goog.partial(onFulfill, i), onReject);
    }
  });
};
goog.Promise.allSettled = function(promises) {
  return new goog.Promise(function(resolve, reject) {
    var toSettle = promises.length;
    var results = [];
    if (!toSettle) {
      resolve(results);
      return;
    }
    var onSettled = function(index, fulfilled, result) {
      toSettle--;
      results[index] = fulfilled ? {fulfilled:true, value:result} : {fulfilled:false, reason:result};
      if (toSettle == 0) {
        resolve(results);
      }
    };
    for (var i = 0, promise;i < promises.length;i++) {
      promise = promises[i];
      goog.Promise.resolveThen_(promise, goog.partial(onSettled, i, true), goog.partial(onSettled, i, false));
    }
  });
};
goog.Promise.firstFulfilled = function(promises) {
  return new goog.Promise(function(resolve, reject) {
    var toReject = promises.length;
    var reasons = [];
    if (!toReject) {
      resolve(undefined);
      return;
    }
    var onFulfill = function(value) {
      resolve(value);
    };
    var onReject = function(index, reason) {
      toReject--;
      reasons[index] = reason;
      if (toReject == 0) {
        reject(reasons);
      }
    };
    for (var i = 0, promise;i < promises.length;i++) {
      promise = promises[i];
      goog.Promise.resolveThen_(promise, onFulfill, goog.partial(onReject, i));
    }
  });
};
goog.Promise.withResolver = function() {
  var resolve, reject;
  var promise = new goog.Promise(function(rs, rj) {
    resolve = rs;
    reject = rj;
  });
  return new goog.Promise.Resolver_(promise, resolve, reject);
};
goog.Promise.prototype.then = function(opt_onFulfilled, opt_onRejected, opt_context) {
  if (opt_onFulfilled != null) {
    goog.asserts.assertFunction(opt_onFulfilled, "opt_onFulfilled should be a function.");
  }
  if (opt_onRejected != null) {
    goog.asserts.assertFunction(opt_onRejected, "opt_onRejected should be a function. Did you pass opt_context " + "as the second argument instead of the third?");
  }
  if (goog.Promise.LONG_STACK_TRACES) {
    this.addStackTrace_(new Error("then"));
  }
  return this.addChildPromise_(goog.isFunction(opt_onFulfilled) ? opt_onFulfilled : null, goog.isFunction(opt_onRejected) ? opt_onRejected : null, opt_context);
};
goog.Thenable.addImplementation(goog.Promise);
goog.Promise.prototype.thenVoid = function(opt_onFulfilled, opt_onRejected, opt_context) {
  if (opt_onFulfilled != null) {
    goog.asserts.assertFunction(opt_onFulfilled, "opt_onFulfilled should be a function.");
  }
  if (opt_onRejected != null) {
    goog.asserts.assertFunction(opt_onRejected, "opt_onRejected should be a function. Did you pass opt_context " + "as the second argument instead of the third?");
  }
  if (goog.Promise.LONG_STACK_TRACES) {
    this.addStackTrace_(new Error("then"));
  }
  this.addCallbackEntry_(goog.Promise.getCallbackEntry_(opt_onFulfilled || goog.nullFunction, opt_onRejected || null, opt_context));
};
goog.Promise.prototype.thenAlways = function(onSettled, opt_context) {
  if (goog.Promise.LONG_STACK_TRACES) {
    this.addStackTrace_(new Error("thenAlways"));
  }
  var entry = goog.Promise.getCallbackEntry_(onSettled, onSettled, opt_context);
  entry.always = true;
  this.addCallbackEntry_(entry);
  return this;
};
goog.Promise.prototype.thenCatch = function(onRejected, opt_context) {
  if (goog.Promise.LONG_STACK_TRACES) {
    this.addStackTrace_(new Error("thenCatch"));
  }
  return this.addChildPromise_(null, onRejected, opt_context);
};
goog.Promise.prototype.cancel = function(opt_message) {
  if (this.state_ == goog.Promise.State_.PENDING) {
    goog.async.run(function() {
      var err = new goog.Promise.CancellationError(opt_message);
      this.cancelInternal_(err);
    }, this);
  }
};
goog.Promise.prototype.cancelInternal_ = function(err) {
  if (this.state_ == goog.Promise.State_.PENDING) {
    if (this.parent_) {
      this.parent_.cancelChild_(this, err);
      this.parent_ = null;
    } else {
      this.resolve_(goog.Promise.State_.REJECTED, err);
    }
  }
};
goog.Promise.prototype.cancelChild_ = function(childPromise, err) {
  if (!this.callbackEntries_) {
    return;
  }
  var childCount = 0;
  var childEntry = null;
  var beforeChildEntry = null;
  for (var entry = this.callbackEntries_;entry;entry = entry.next) {
    if (!entry.always) {
      childCount++;
      if (entry.child == childPromise) {
        childEntry = entry;
      }
      if (childEntry && childCount > 1) {
        break;
      }
    }
    if (!childEntry) {
      beforeChildEntry = entry;
    }
  }
  if (childEntry) {
    if (this.state_ == goog.Promise.State_.PENDING && childCount == 1) {
      this.cancelInternal_(err);
    } else {
      if (beforeChildEntry) {
        this.removeEntryAfter_(beforeChildEntry);
      } else {
        this.popEntry_();
      }
      this.executeCallback_(childEntry, goog.Promise.State_.REJECTED, err);
    }
  }
};
goog.Promise.prototype.addCallbackEntry_ = function(callbackEntry) {
  if (!this.hasEntry_() && (this.state_ == goog.Promise.State_.FULFILLED || this.state_ == goog.Promise.State_.REJECTED)) {
    this.scheduleCallbacks_();
  }
  this.queueEntry_(callbackEntry);
};
goog.Promise.prototype.addChildPromise_ = function(onFulfilled, onRejected, opt_context) {
  var callbackEntry = goog.Promise.getCallbackEntry_(null, null, null);
  callbackEntry.child = new goog.Promise(function(resolve, reject) {
    callbackEntry.onFulfilled = onFulfilled ? function(value) {
      try {
        var result = onFulfilled.call(opt_context, value);
        resolve(result);
      } catch (err) {
        reject(err);
      }
    } : resolve;
    callbackEntry.onRejected = onRejected ? function(reason) {
      try {
        var result = onRejected.call(opt_context, reason);
        if (!goog.isDef(result) && reason instanceof goog.Promise.CancellationError) {
          reject(reason);
        } else {
          resolve(result);
        }
      } catch (err) {
        reject(err);
      }
    } : reject;
  });
  callbackEntry.child.parent_ = this;
  this.addCallbackEntry_(callbackEntry);
  return callbackEntry.child;
};
goog.Promise.prototype.unblockAndFulfill_ = function(value) {
  goog.asserts.assert(this.state_ == goog.Promise.State_.BLOCKED);
  this.state_ = goog.Promise.State_.PENDING;
  this.resolve_(goog.Promise.State_.FULFILLED, value);
};
goog.Promise.prototype.unblockAndReject_ = function(reason) {
  goog.asserts.assert(this.state_ == goog.Promise.State_.BLOCKED);
  this.state_ = goog.Promise.State_.PENDING;
  this.resolve_(goog.Promise.State_.REJECTED, reason);
};
goog.Promise.prototype.resolve_ = function(state, x) {
  if (this.state_ != goog.Promise.State_.PENDING) {
    return;
  }
  if (this === x) {
    state = goog.Promise.State_.REJECTED;
    x = new TypeError("Promise cannot resolve to itself");
  }
  this.state_ = goog.Promise.State_.BLOCKED;
  var isThenable = goog.Promise.maybeThen_(x, this.unblockAndFulfill_, this.unblockAndReject_, this);
  if (isThenable) {
    return;
  }
  this.result_ = x;
  this.state_ = state;
  this.parent_ = null;
  this.scheduleCallbacks_();
  if (state == goog.Promise.State_.REJECTED && !(x instanceof goog.Promise.CancellationError)) {
    goog.Promise.addUnhandledRejection_(this, x);
  }
};
goog.Promise.maybeThen_ = function(value, onFulfilled, onRejected, context) {
  if (value instanceof goog.Promise) {
    value.thenVoid(onFulfilled, onRejected, context);
    return true;
  } else {
    if (goog.Thenable.isImplementedBy(value)) {
      value = (value);
      value.then(onFulfilled, onRejected, context);
      return true;
    } else {
      if (goog.isObject(value)) {
        try {
          var then = value["then"];
          if (goog.isFunction(then)) {
            goog.Promise.tryThen_(value, then, onFulfilled, onRejected, context);
            return true;
          }
        } catch (e) {
          onRejected.call(context, e);
          return true;
        }
      }
    }
  }
  return false;
};
goog.Promise.tryThen_ = function(thenable, then, onFulfilled, onRejected, context) {
  var called = false;
  var resolve = function(value) {
    if (!called) {
      called = true;
      onFulfilled.call(context, value);
    }
  };
  var reject = function(reason) {
    if (!called) {
      called = true;
      onRejected.call(context, reason);
    }
  };
  try {
    then.call(thenable, resolve, reject);
  } catch (e) {
    reject(e);
  }
};
goog.Promise.prototype.scheduleCallbacks_ = function() {
  if (!this.executing_) {
    this.executing_ = true;
    goog.async.run(this.executeCallbacks_, this);
  }
};
goog.Promise.prototype.hasEntry_ = function() {
  return !!this.callbackEntries_;
};
goog.Promise.prototype.queueEntry_ = function(entry) {
  goog.asserts.assert(entry.onFulfilled != null);
  if (this.callbackEntriesTail_) {
    this.callbackEntriesTail_.next = entry;
    this.callbackEntriesTail_ = entry;
  } else {
    this.callbackEntries_ = entry;
    this.callbackEntriesTail_ = entry;
  }
};
goog.Promise.prototype.popEntry_ = function() {
  var entry = null;
  if (this.callbackEntries_) {
    entry = this.callbackEntries_;
    this.callbackEntries_ = entry.next;
    entry.next = null;
  }
  if (!this.callbackEntries_) {
    this.callbackEntriesTail_ = null;
  }
  if (entry != null) {
    goog.asserts.assert(entry.onFulfilled != null);
  }
  return entry;
};
goog.Promise.prototype.removeEntryAfter_ = function(previous) {
  goog.asserts.assert(this.callbackEntries_);
  goog.asserts.assert(previous != null);
  if (previous.next == this.callbackEntriesTail_) {
    this.callbackEntriesTail_ = previous;
  }
  previous.next = previous.next.next;
};
goog.Promise.prototype.executeCallbacks_ = function() {
  var entry = null;
  while (entry = this.popEntry_()) {
    if (goog.Promise.LONG_STACK_TRACES) {
      this.currentStep_++;
    }
    this.executeCallback_(entry, this.state_, this.result_);
  }
  this.executing_ = false;
};
goog.Promise.prototype.executeCallback_ = function(callbackEntry, state, result) {
  if (state == goog.Promise.State_.REJECTED && callbackEntry.onRejected && !callbackEntry.always) {
    this.removeUnhandledRejection_();
  }
  if (callbackEntry.child) {
    callbackEntry.child.parent_ = null;
    goog.Promise.invokeCallback_(callbackEntry, state, result);
  } else {
    try {
      callbackEntry.always ? callbackEntry.onFulfilled.call(callbackEntry.context) : goog.Promise.invokeCallback_(callbackEntry, state, result);
    } catch (err) {
      goog.Promise.handleRejection_.call(null, err);
    }
  }
  goog.Promise.returnEntry_(callbackEntry);
};
goog.Promise.invokeCallback_ = function(callbackEntry, state, result) {
  if (state == goog.Promise.State_.FULFILLED) {
    callbackEntry.onFulfilled.call(callbackEntry.context, result);
  } else {
    if (callbackEntry.onRejected) {
      callbackEntry.onRejected.call(callbackEntry.context, result);
    }
  }
};
goog.Promise.prototype.addStackTrace_ = function(err) {
  if (goog.Promise.LONG_STACK_TRACES && goog.isString(err.stack)) {
    var trace = err.stack.split("\n", 4)[3];
    var message = err.message;
    message += Array(11 - message.length).join(" ");
    this.stack_.push(message + trace);
  }
};
goog.Promise.prototype.appendLongStack_ = function(err) {
  if (goog.Promise.LONG_STACK_TRACES && err && goog.isString(err.stack) && this.stack_.length) {
    var longTrace = ["Promise trace:"];
    for (var promise = this;promise;promise = promise.parent_) {
      for (var i = this.currentStep_;i >= 0;i--) {
        longTrace.push(promise.stack_[i]);
      }
      longTrace.push("Value: " + "[" + (promise.state_ == goog.Promise.State_.REJECTED ? "REJECTED" : "FULFILLED") + "] " + "<" + String(promise.result_) + ">");
    }
    err.stack += "\n\n" + longTrace.join("\n");
  }
};
goog.Promise.prototype.removeUnhandledRejection_ = function() {
  if (goog.Promise.UNHANDLED_REJECTION_DELAY > 0) {
    for (var p = this;p && p.unhandledRejectionId_;p = p.parent_) {
      goog.global.clearTimeout(p.unhandledRejectionId_);
      p.unhandledRejectionId_ = 0;
    }
  } else {
    if (goog.Promise.UNHANDLED_REJECTION_DELAY == 0) {
      for (var p = this;p && p.hadUnhandledRejection_;p = p.parent_) {
        p.hadUnhandledRejection_ = false;
      }
    }
  }
};
goog.Promise.addUnhandledRejection_ = function(promise, reason) {
  if (goog.Promise.UNHANDLED_REJECTION_DELAY > 0) {
    promise.unhandledRejectionId_ = goog.global.setTimeout(function() {
      promise.appendLongStack_(reason);
      goog.Promise.handleRejection_.call(null, reason);
    }, goog.Promise.UNHANDLED_REJECTION_DELAY);
  } else {
    if (goog.Promise.UNHANDLED_REJECTION_DELAY == 0) {
      promise.hadUnhandledRejection_ = true;
      goog.async.run(function() {
        if (promise.hadUnhandledRejection_) {
          promise.appendLongStack_(reason);
          goog.Promise.handleRejection_.call(null, reason);
        }
      });
    }
  }
};
goog.Promise.handleRejection_ = goog.async.throwException;
goog.Promise.setUnhandledRejectionHandler = function(handler) {
  goog.Promise.handleRejection_ = handler;
};
goog.Promise.CancellationError = function(opt_message) {
  goog.Promise.CancellationError.base(this, "constructor", opt_message);
};
goog.inherits(goog.Promise.CancellationError, goog.debug.Error);
goog.Promise.CancellationError.prototype.name = "cancel";
goog.Promise.Resolver_ = function(promise, resolve, reject) {
  this.promise = promise;
  this.resolve = resolve;
  this.reject = reject;
};
goog.provide("goog.events.EventTarget");
goog.require("goog.Disposable");
goog.require("goog.asserts");
goog.require("goog.events");
goog.require("goog.events.Event");
goog.require("goog.events.Listenable");
goog.require("goog.events.ListenerMap");
goog.require("goog.object");
goog.events.EventTarget = function() {
  goog.Disposable.call(this);
  this.eventTargetListeners_ = new goog.events.ListenerMap(this);
  this.actualEventTarget_ = this;
  this.parentEventTarget_ = null;
};
goog.inherits(goog.events.EventTarget, goog.Disposable);
goog.events.Listenable.addImplementation(goog.events.EventTarget);
goog.events.EventTarget.MAX_ANCESTORS_ = 1E3;
goog.events.EventTarget.prototype.getParentEventTarget = function() {
  return this.parentEventTarget_;
};
goog.events.EventTarget.prototype.setParentEventTarget = function(parent) {
  this.parentEventTarget_ = parent;
};
goog.events.EventTarget.prototype.addEventListener = function(type, handler, opt_capture, opt_handlerScope) {
  goog.events.listen(this, type, handler, opt_capture, opt_handlerScope);
};
goog.events.EventTarget.prototype.removeEventListener = function(type, handler, opt_capture, opt_handlerScope) {
  goog.events.unlisten(this, type, handler, opt_capture, opt_handlerScope);
};
goog.events.EventTarget.prototype.dispatchEvent = function(e) {
  this.assertInitialized_();
  var ancestorsTree, ancestor = this.getParentEventTarget();
  if (ancestor) {
    ancestorsTree = [];
    var ancestorCount = 1;
    for (;ancestor;ancestor = ancestor.getParentEventTarget()) {
      ancestorsTree.push(ancestor);
      goog.asserts.assert(++ancestorCount < goog.events.EventTarget.MAX_ANCESTORS_, "infinite loop");
    }
  }
  return goog.events.EventTarget.dispatchEventInternal_(this.actualEventTarget_, e, ancestorsTree);
};
goog.events.EventTarget.prototype.disposeInternal = function() {
  goog.events.EventTarget.superClass_.disposeInternal.call(this);
  this.removeAllListeners();
  this.parentEventTarget_ = null;
};
goog.events.EventTarget.prototype.listen = function(type, listener, opt_useCapture, opt_listenerScope) {
  this.assertInitialized_();
  return this.eventTargetListeners_.add(String(type), listener, false, opt_useCapture, opt_listenerScope);
};
goog.events.EventTarget.prototype.listenOnce = function(type, listener, opt_useCapture, opt_listenerScope) {
  return this.eventTargetListeners_.add(String(type), listener, true, opt_useCapture, opt_listenerScope);
};
goog.events.EventTarget.prototype.unlisten = function(type, listener, opt_useCapture, opt_listenerScope) {
  return this.eventTargetListeners_.remove(String(type), listener, opt_useCapture, opt_listenerScope);
};
goog.events.EventTarget.prototype.unlistenByKey = function(key) {
  return this.eventTargetListeners_.removeByKey(key);
};
goog.events.EventTarget.prototype.removeAllListeners = function(opt_type) {
  if (!this.eventTargetListeners_) {
    return 0;
  }
  return this.eventTargetListeners_.removeAll(opt_type);
};
goog.events.EventTarget.prototype.fireListeners = function(type, capture, eventObject) {
  var listenerArray = this.eventTargetListeners_.listeners[String(type)];
  if (!listenerArray) {
    return true;
  }
  listenerArray = listenerArray.concat();
  var rv = true;
  for (var i = 0;i < listenerArray.length;++i) {
    var listener = listenerArray[i];
    if (listener && !listener.removed && listener.capture == capture) {
      var listenerFn = listener.listener;
      var listenerHandler = listener.handler || listener.src;
      if (listener.callOnce) {
        this.unlistenByKey(listener);
      }
      rv = listenerFn.call(listenerHandler, eventObject) !== false && rv;
    }
  }
  return rv && eventObject.returnValue_ != false;
};
goog.events.EventTarget.prototype.getListeners = function(type, capture) {
  return this.eventTargetListeners_.getListeners(String(type), capture);
};
goog.events.EventTarget.prototype.getListener = function(type, listener, capture, opt_listenerScope) {
  return this.eventTargetListeners_.getListener(String(type), listener, capture, opt_listenerScope);
};
goog.events.EventTarget.prototype.hasListener = function(opt_type, opt_capture) {
  var id = goog.isDef(opt_type) ? String(opt_type) : undefined;
  return this.eventTargetListeners_.hasListener(id, opt_capture);
};
goog.events.EventTarget.prototype.setTargetForTesting = function(target) {
  this.actualEventTarget_ = target;
};
goog.events.EventTarget.prototype.assertInitialized_ = function() {
  goog.asserts.assert(this.eventTargetListeners_, "Event target is not initialized. Did you call the superclass " + "(goog.events.EventTarget) constructor?");
};
goog.events.EventTarget.dispatchEventInternal_ = function(target, e, opt_ancestorsTree) {
  var type = e.type || (e);
  if (goog.isString(e)) {
    e = new goog.events.Event(e, target);
  } else {
    if (!(e instanceof goog.events.Event)) {
      var oldEvent = e;
      e = new goog.events.Event(type, target);
      goog.object.extend(e, oldEvent);
    } else {
      e.target = e.target || target;
    }
  }
  var rv = true, currentTarget;
  if (opt_ancestorsTree) {
    for (var i = opt_ancestorsTree.length - 1;!e.propagationStopped_ && i >= 0;i--) {
      currentTarget = e.currentTarget = opt_ancestorsTree[i];
      rv = currentTarget.fireListeners(type, true, e) && rv;
    }
  }
  if (!e.propagationStopped_) {
    currentTarget = (e.currentTarget = target);
    rv = currentTarget.fireListeners(type, true, e) && rv;
    if (!e.propagationStopped_) {
      rv = currentTarget.fireListeners(type, false, e) && rv;
    }
  }
  if (opt_ancestorsTree) {
    for (i = 0;!e.propagationStopped_ && i < opt_ancestorsTree.length;i++) {
      currentTarget = e.currentTarget = opt_ancestorsTree[i];
      rv = currentTarget.fireListeners(type, false, e) && rv;
    }
  }
  return rv;
};
goog.provide("goog.Timer");
goog.require("goog.Promise");
goog.require("goog.events.EventTarget");
goog.Timer = function(opt_interval, opt_timerObject) {
  goog.events.EventTarget.call(this);
  this.interval_ = opt_interval || 1;
  this.timerObject_ = (opt_timerObject || goog.Timer.defaultTimerObject);
  this.boundTick_ = goog.bind(this.tick_, this);
  this.last_ = goog.now();
};
goog.inherits(goog.Timer, goog.events.EventTarget);
goog.Timer.MAX_TIMEOUT_ = 2147483647;
goog.Timer.INVALID_TIMEOUT_ID_ = -1;
goog.Timer.prototype.enabled = false;
goog.Timer.defaultTimerObject = goog.global;
goog.Timer.intervalScale = .8;
goog.Timer.prototype.timer_ = null;
goog.Timer.prototype.getInterval = function() {
  return this.interval_;
};
goog.Timer.prototype.setInterval = function(interval) {
  this.interval_ = interval;
  if (this.timer_ && this.enabled) {
    this.stop();
    this.start();
  } else {
    if (this.timer_) {
      this.stop();
    }
  }
};
goog.Timer.prototype.tick_ = function() {
  if (this.enabled) {
    var elapsed = goog.now() - this.last_;
    if (elapsed > 0 && elapsed < this.interval_ * goog.Timer.intervalScale) {
      this.timer_ = this.timerObject_.setTimeout(this.boundTick_, this.interval_ - elapsed);
      return;
    }
    if (this.timer_) {
      this.timerObject_.clearTimeout(this.timer_);
      this.timer_ = null;
    }
    this.dispatchTick();
    if (this.enabled) {
      this.timer_ = this.timerObject_.setTimeout(this.boundTick_, this.interval_);
      this.last_ = goog.now();
    }
  }
};
goog.Timer.prototype.dispatchTick = function() {
  this.dispatchEvent(goog.Timer.TICK);
};
goog.Timer.prototype.start = function() {
  this.enabled = true;
  if (!this.timer_) {
    this.timer_ = this.timerObject_.setTimeout(this.boundTick_, this.interval_);
    this.last_ = goog.now();
  }
};
goog.Timer.prototype.stop = function() {
  this.enabled = false;
  if (this.timer_) {
    this.timerObject_.clearTimeout(this.timer_);
    this.timer_ = null;
  }
};
goog.Timer.prototype.disposeInternal = function() {
  goog.Timer.superClass_.disposeInternal.call(this);
  this.stop();
  delete this.timerObject_;
};
goog.Timer.TICK = "tick";
goog.Timer.callOnce = function(listener, opt_delay, opt_handler) {
  if (goog.isFunction(listener)) {
    if (opt_handler) {
      listener = goog.bind(listener, opt_handler);
    }
  } else {
    if (listener && typeof listener.handleEvent == "function") {
      listener = goog.bind(listener.handleEvent, listener);
    } else {
      throw Error("Invalid listener argument");
    }
  }
  if (Number(opt_delay) > goog.Timer.MAX_TIMEOUT_) {
    return goog.Timer.INVALID_TIMEOUT_ID_;
  } else {
    return goog.Timer.defaultTimerObject.setTimeout(listener, opt_delay || 0);
  }
};
goog.Timer.clear = function(timerId) {
  goog.Timer.defaultTimerObject.clearTimeout(timerId);
};
goog.Timer.promise = function(delay, opt_result) {
  var timerKey = null;
  return (new goog.Promise(function(resolve, reject) {
    timerKey = goog.Timer.callOnce(function() {
      resolve(opt_result);
    }, delay);
    if (timerKey == goog.Timer.INVALID_TIMEOUT_ID_) {
      reject(new Error("Failed to schedule timer."));
    }
  })).thenCatch(function(error) {
    goog.Timer.clear(timerKey);
    throw error;
  });
};
goog.provide("goog.Delay");
goog.provide("goog.async.Delay");
goog.require("goog.Disposable");
goog.require("goog.Timer");
goog.async.Delay = function(listener, opt_interval, opt_handler) {
  goog.async.Delay.base(this, "constructor");
  this.listener_ = listener;
  this.interval_ = opt_interval || 0;
  this.handler_ = opt_handler;
  this.callback_ = goog.bind(this.doAction_, this);
};
goog.inherits(goog.async.Delay, goog.Disposable);
goog.Delay = goog.async.Delay;
goog.async.Delay.prototype.id_ = 0;
goog.async.Delay.prototype.disposeInternal = function() {
  goog.async.Delay.base(this, "disposeInternal");
  this.stop();
  delete this.listener_;
  delete this.handler_;
};
goog.async.Delay.prototype.start = function(opt_interval) {
  this.stop();
  this.id_ = goog.Timer.callOnce(this.callback_, goog.isDef(opt_interval) ? opt_interval : this.interval_);
};
goog.async.Delay.prototype.startIfNotActive = function(opt_interval) {
  if (!this.isActive()) {
    this.start(opt_interval);
  }
};
goog.async.Delay.prototype.stop = function() {
  if (this.isActive()) {
    goog.Timer.clear(this.id_);
  }
  this.id_ = 0;
};
goog.async.Delay.prototype.fire = function() {
  this.stop();
  this.doAction_();
};
goog.async.Delay.prototype.fireIfActive = function() {
  if (this.isActive()) {
    this.fire();
  }
};
goog.async.Delay.prototype.isActive = function() {
  return this.id_ != 0;
};
goog.async.Delay.prototype.doAction_ = function() {
  this.id_ = 0;
  if (this.listener_) {
    this.listener_.call(this.handler_);
  }
};
goog.provide("goog.dom.classlist");
goog.require("goog.array");
goog.define("goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST", false);
goog.dom.classlist.get = function(element) {
  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {
    return element.classList;
  }
  var className = element.className;
  return goog.isString(className) && className.match(/\S+/g) || [];
};
goog.dom.classlist.set = function(element, className) {
  element.className = className;
};
goog.dom.classlist.contains = function(element, className) {
  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {
    return element.classList.contains(className);
  }
  return goog.array.contains(goog.dom.classlist.get(element), className);
};
goog.dom.classlist.add = function(element, className) {
  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {
    element.classList.add(className);
    return;
  }
  if (!goog.dom.classlist.contains(element, className)) {
    element.className += element.className.length > 0 ? " " + className : className;
  }
};
goog.dom.classlist.addAll = function(element, classesToAdd) {
  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {
    goog.array.forEach(classesToAdd, function(className) {
      goog.dom.classlist.add(element, className);
    });
    return;
  }
  var classMap = {};
  goog.array.forEach(goog.dom.classlist.get(element), function(className) {
    classMap[className] = true;
  });
  goog.array.forEach(classesToAdd, function(className) {
    classMap[className] = true;
  });
  element.className = "";
  for (var className in classMap) {
    element.className += element.className.length > 0 ? " " + className : className;
  }
};
goog.dom.classlist.remove = function(element, className) {
  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {
    element.classList.remove(className);
    return;
  }
  if (goog.dom.classlist.contains(element, className)) {
    element.className = goog.array.filter(goog.dom.classlist.get(element), function(c) {
      return c != className;
    }).join(" ");
  }
};
goog.dom.classlist.removeAll = function(element, classesToRemove) {
  if (goog.dom.classlist.ALWAYS_USE_DOM_TOKEN_LIST || element.classList) {
    goog.array.forEach(classesToRemove, function(className) {
      goog.dom.classlist.remove(element, className);
    });
    return;
  }
  element.className = goog.array.filter(goog.dom.classlist.get(element), function(className) {
    return !goog.array.contains(classesToRemove, className);
  }).join(" ");
};
goog.dom.classlist.enable = function(element, className, enabled) {
  if (enabled) {
    goog.dom.classlist.add(element, className);
  } else {
    goog.dom.classlist.remove(element, className);
  }
};
goog.dom.classlist.enableAll = function(element, classesToEnable, enabled) {
  var f = enabled ? goog.dom.classlist.addAll : goog.dom.classlist.removeAll;
  f(element, classesToEnable);
};
goog.dom.classlist.swap = function(element, fromClass, toClass) {
  if (goog.dom.classlist.contains(element, fromClass)) {
    goog.dom.classlist.remove(element, fromClass);
    goog.dom.classlist.add(element, toClass);
    return true;
  }
  return false;
};
goog.dom.classlist.toggle = function(element, className) {
  var add = !goog.dom.classlist.contains(element, className);
  goog.dom.classlist.enable(element, className, add);
  return add;
};
goog.dom.classlist.addRemove = function(element, classToRemove, classToAdd) {
  goog.dom.classlist.remove(element, classToRemove);
  goog.dom.classlist.add(element, classToAdd);
};
goog.provide("goog.editor.defines");
goog.define("goog.editor.defines.USE_CONTENTEDITABLE_IN_FIREFOX_3", false);
goog.provide("goog.userAgent.product");
goog.require("goog.labs.userAgent.browser");
goog.require("goog.labs.userAgent.platform");
goog.require("goog.userAgent");
goog.define("goog.userAgent.product.ASSUME_FIREFOX", false);
goog.define("goog.userAgent.product.ASSUME_IPHONE", false);
goog.define("goog.userAgent.product.ASSUME_IPAD", false);
goog.define("goog.userAgent.product.ASSUME_ANDROID", false);
goog.define("goog.userAgent.product.ASSUME_CHROME", false);
goog.define("goog.userAgent.product.ASSUME_SAFARI", false);
goog.userAgent.product.PRODUCT_KNOWN_ = goog.userAgent.ASSUME_IE || goog.userAgent.ASSUME_EDGE || goog.userAgent.ASSUME_OPERA || goog.userAgent.product.ASSUME_FIREFOX || goog.userAgent.product.ASSUME_IPHONE || goog.userAgent.product.ASSUME_IPAD || goog.userAgent.product.ASSUME_ANDROID || goog.userAgent.product.ASSUME_CHROME || goog.userAgent.product.ASSUME_SAFARI;
goog.userAgent.product.OPERA = goog.userAgent.OPERA;
goog.userAgent.product.IE = goog.userAgent.IE;
goog.userAgent.product.EDGE = goog.userAgent.EDGE;
goog.userAgent.product.FIREFOX = goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_FIREFOX : goog.labs.userAgent.browser.isFirefox();
goog.userAgent.product.isIphoneOrIpod_ = function() {
  return goog.labs.userAgent.platform.isIphone() || goog.labs.userAgent.platform.isIpod();
};
goog.userAgent.product.IPHONE = goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_IPHONE : goog.userAgent.product.isIphoneOrIpod_();
goog.userAgent.product.IPAD = goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_IPAD : goog.labs.userAgent.platform.isIpad();
goog.userAgent.product.ANDROID = goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_ANDROID : goog.labs.userAgent.browser.isAndroidBrowser();
goog.userAgent.product.CHROME = goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_CHROME : goog.labs.userAgent.browser.isChrome();
goog.userAgent.product.isSafariDesktop_ = function() {
  return goog.labs.userAgent.browser.isSafari() && !goog.labs.userAgent.platform.isIos();
};
goog.userAgent.product.SAFARI = goog.userAgent.product.PRODUCT_KNOWN_ ? goog.userAgent.product.ASSUME_SAFARI : goog.userAgent.product.isSafariDesktop_();
goog.provide("goog.userAgent.product.isVersion");
goog.require("goog.labs.userAgent.platform");
goog.require("goog.string");
goog.require("goog.userAgent");
goog.require("goog.userAgent.product");
goog.userAgent.product.determineVersion_ = function() {
  if (goog.userAgent.product.FIREFOX) {
    return goog.userAgent.product.getFirstRegExpGroup_(/Firefox\/([0-9.]+)/);
  }
  if (goog.userAgent.product.IE || goog.userAgent.product.EDGE || goog.userAgent.product.OPERA) {
    return goog.userAgent.VERSION;
  }
  if (goog.userAgent.product.CHROME) {
    return goog.userAgent.product.getFirstRegExpGroup_(/Chrome\/([0-9.]+)/);
  }
  if (goog.userAgent.product.SAFARI && !goog.labs.userAgent.platform.isIos()) {
    return goog.userAgent.product.getFirstRegExpGroup_(/Version\/([0-9.]+)/);
  }
  if (goog.userAgent.product.IPHONE || goog.userAgent.product.IPAD) {
    var arr = goog.userAgent.product.execRegExp_(/Version\/(\S+).*Mobile\/(\S+)/);
    if (arr) {
      return arr[1] + "." + arr[2];
    }
  } else {
    if (goog.userAgent.product.ANDROID) {
      var version = goog.userAgent.product.getFirstRegExpGroup_(/Android\s+([0-9.]+)/);
      if (version) {
        return version;
      }
      return goog.userAgent.product.getFirstRegExpGroup_(/Version\/([0-9.]+)/);
    }
  }
  return "";
};
goog.userAgent.product.getFirstRegExpGroup_ = function(re) {
  var arr = goog.userAgent.product.execRegExp_(re);
  return arr ? arr[1] : "";
};
goog.userAgent.product.execRegExp_ = function(re) {
  return re.exec(goog.userAgent.getUserAgentString());
};
goog.userAgent.product.VERSION = goog.userAgent.product.determineVersion_();
goog.userAgent.product.isVersion = function(version) {
  return goog.string.compareVersions(goog.userAgent.product.VERSION, version) >= 0;
};
goog.provide("goog.editor.BrowserFeature");
goog.require("goog.editor.defines");
goog.require("goog.labs.userAgent.browser");
goog.require("goog.userAgent");
goog.require("goog.userAgent.product");
goog.require("goog.userAgent.product.isVersion");
goog.editor.BrowserFeature = {HAS_IE_RANGES:goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9), HAS_W3C_RANGES:goog.userAgent.GECKO || goog.userAgent.WEBKIT || goog.userAgent.OPERA || goog.userAgent.EDGE || goog.userAgent.IE && goog.userAgent.isDocumentModeOrHigher(9), HAS_CONTENT_EDITABLE:goog.userAgent.IE || goog.userAgent.WEBKIT || goog.userAgent.OPERA || goog.userAgent.EDGE || goog.editor.defines.USE_CONTENTEDITABLE_IN_FIREFOX_3 && goog.userAgent.GECKO && goog.userAgent.isVersionOrHigher("1.9"), 
USE_MUTATION_EVENTS:goog.userAgent.GECKO, HAS_DOM_SUBTREE_MODIFIED_EVENT:goog.userAgent.WEBKIT || goog.editor.defines.USE_CONTENTEDITABLE_IN_FIREFOX_3 && goog.userAgent.GECKO && goog.userAgent.isVersionOrHigher("1.9"), HAS_DOCUMENT_INDEPENDENT_NODES:goog.userAgent.GECKO, PUTS_CURSOR_BEFORE_FIRST_BLOCK_ELEMENT_ON_FOCUS:goog.userAgent.GECKO, CLEARS_SELECTION_WHEN_FOCUS_LEAVES:goog.userAgent.IE || goog.userAgent.WEBKIT || goog.userAgent.OPERA, HAS_UNSELECTABLE_STYLE:goog.userAgent.GECKO || goog.userAgent.WEBKIT, 
FORMAT_BLOCK_WORKS_FOR_BLOCKQUOTES:goog.userAgent.GECKO || goog.userAgent.WEBKIT || goog.userAgent.OPERA, CREATES_MULTIPLE_BLOCKQUOTES:goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher("534.16") || goog.userAgent.OPERA, WRAPS_BLOCKQUOTE_IN_DIVS:goog.userAgent.OPERA, PREFERS_READY_STATE_CHANGE_EVENT:goog.userAgent.IE, TAB_FIRES_KEYPRESS:!goog.userAgent.IE, NEEDS_99_WIDTH_IN_STANDARDS_MODE:goog.userAgent.IE, USE_DOCUMENT_FOR_KEY_EVENTS:goog.userAgent.GECKO && !goog.editor.defines.USE_CONTENTEDITABLE_IN_FIREFOX_3, 
SHOWS_CUSTOM_ATTRS_IN_INNER_HTML:goog.userAgent.IE, COLLAPSES_EMPTY_NODES:goog.userAgent.GECKO || goog.userAgent.WEBKIT || goog.userAgent.OPERA, CONVERT_TO_B_AND_I_TAGS:goog.userAgent.GECKO || goog.userAgent.OPERA, TABS_THROUGH_IMAGES:goog.userAgent.IE, UNESCAPES_URLS_WITHOUT_ASKING:goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("7.0"), HAS_STYLE_WITH_CSS:goog.userAgent.GECKO && goog.userAgent.isVersionOrHigher("1.8") || goog.userAgent.WEBKIT || goog.userAgent.OPERA, FOLLOWS_EDITABLE_LINKS:goog.userAgent.WEBKIT || 
goog.userAgent.IE && goog.userAgent.isVersionOrHigher("9"), HAS_ACTIVE_ELEMENT:goog.userAgent.IE || goog.userAgent.EDGE || goog.userAgent.OPERA || goog.userAgent.GECKO && goog.userAgent.isVersionOrHigher("1.9"), HAS_SET_CAPTURE:goog.userAgent.IE, EATS_EMPTY_BACKGROUND_COLOR:goog.userAgent.GECKO || goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher("527"), SUPPORTS_FOCUSIN:goog.userAgent.IE || goog.userAgent.OPERA, SELECTS_IMAGES_ON_CLICK:goog.userAgent.IE || goog.userAgent.OPERA, MOVES_STYLE_TO_HEAD:goog.userAgent.WEBKIT, 
COLLAPSES_SELECTION_ONMOUSEDOWN:false, CARET_INSIDE_SELECTION:goog.userAgent.OPERA, FOCUSES_EDITABLE_BODY_ON_HTML_CLICK:true, USES_KEYDOWN:goog.userAgent.IE || goog.userAgent.EDGE || goog.userAgent.WEBKIT && goog.userAgent.isVersionOrHigher("525"), ADDS_NBSPS_IN_REMOVE_FORMAT:goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher("531"), GETS_STUCK_IN_LINKS:goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher("528"), NORMALIZE_CORRUPTS_EMPTY_TEXT_NODES:goog.userAgent.GECKO && goog.userAgent.isVersionOrHigher("1.9") || 
goog.userAgent.IE || goog.userAgent.EDGE || goog.userAgent.OPERA || goog.userAgent.WEBKIT && goog.userAgent.isVersionOrHigher("531"), NORMALIZE_CORRUPTS_ALL_TEXT_NODES:goog.userAgent.IE, NESTS_SUBSCRIPT_SUPERSCRIPT:goog.userAgent.IE || goog.userAgent.EDGE || goog.userAgent.GECKO || goog.userAgent.OPERA, CAN_SELECT_EMPTY_ELEMENT:!goog.userAgent.IE && !goog.userAgent.WEBKIT, FORGETS_FORMATTING_WHEN_LISTIFYING:goog.userAgent.GECKO || goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher("526"), 
LEAVES_P_WHEN_REMOVING_LISTS:goog.userAgent.IE || goog.userAgent.OPERA, CAN_LISTIFY_BR:!goog.userAgent.IE && !goog.userAgent.OPERA, DOESNT_OVERRIDE_FONT_SIZE_IN_STYLE_ATTR:!goog.userAgent.WEBKIT && !goog.userAgent.EDGE, SUPPORTS_HTML5_FILE_DRAGGING:goog.userAgent.product.CHROME && goog.userAgent.product.isVersion("4") || goog.userAgent.product.SAFARI && goog.userAgent.isVersionOrHigher("533") || goog.userAgent.GECKO && goog.userAgent.isVersionOrHigher("2.0") || goog.userAgent.IE && goog.userAgent.isVersionOrHigher("10") || 
goog.userAgent.OPERA && goog.labs.userAgent.browser.isVersionOrHigher("15") || goog.userAgent.EDGE, SUPPORTS_OPERA_DEFAULTBLOCK_COMMAND:goog.userAgent.OPERA && goog.userAgent.isVersionOrHigher("11.10"), SUPPORTS_FILE_PASTING:goog.userAgent.product.CHROME && goog.userAgent.product.isVersion("12")};
goog.provide("goog.editor.Plugin");
goog.require("goog.events.EventTarget");
goog.require("goog.functions");
goog.require("goog.log");
goog.require("goog.object");
goog.require("goog.reflect");
goog.require("goog.userAgent");
goog.editor.Plugin = function() {
  goog.events.EventTarget.call(this);
  this.enabled_ = this.activeOnUneditableFields();
  this.fieldObject = null;
  this.autoDispose_ = true;
  this.logger = goog.log.getLogger("goog.editor.Plugin");
};
goog.inherits(goog.editor.Plugin, goog.events.EventTarget);
goog.editor.Plugin.prototype.getFieldDomHelper = function() {
  return this.getFieldObject() && this.getFieldObject().getEditableDomHelper();
};
goog.editor.Plugin.prototype.getFieldObject = function() {
  return this.fieldObject;
};
goog.editor.Plugin.prototype.setFieldObject = function(fieldObject) {
  this.fieldObject = fieldObject;
};
goog.editor.Plugin.prototype.registerFieldObject = function(fieldObject) {
  this.setFieldObject(fieldObject);
};
goog.editor.Plugin.prototype.unregisterFieldObject = function(fieldObj) {
  if (this.getFieldObject()) {
    this.disable(this.getFieldObject());
    this.setFieldObject(null);
  }
};
goog.editor.Plugin.prototype.enable = function(fieldObject) {
  if (this.getFieldObject() == fieldObject) {
    this.enabled_ = true;
  } else {
    goog.log.error(this.logger, "Trying to enable an unregistered field with " + "this plugin.");
  }
};
goog.editor.Plugin.prototype.disable = function(fieldObject) {
  if (this.getFieldObject() == fieldObject) {
    this.enabled_ = false;
  } else {
    goog.log.error(this.logger, "Trying to disable an unregistered field " + "with this plugin.");
  }
};
goog.editor.Plugin.prototype.isEnabled = function(fieldObject) {
  return this.getFieldObject() == fieldObject ? this.enabled_ : false;
};
goog.editor.Plugin.prototype.setAutoDispose = function(autoDispose) {
  this.autoDispose_ = autoDispose;
};
goog.editor.Plugin.prototype.isAutoDispose = function() {
  return this.autoDispose_;
};
goog.editor.Plugin.prototype.activeOnUneditableFields = goog.functions.FALSE;
goog.editor.Plugin.prototype.isSilentCommand = goog.functions.FALSE;
goog.editor.Plugin.prototype.disposeInternal = function() {
  if (this.getFieldObject()) {
    this.unregisterFieldObject(this.getFieldObject());
  }
  goog.editor.Plugin.superClass_.disposeInternal.call(this);
};
goog.editor.Plugin.prototype.getTrogClassId;
goog.editor.Plugin.Op = {KEYDOWN:1, KEYPRESS:2, KEYUP:3, SELECTION:4, SHORTCUT:5, EXEC_COMMAND:6, QUERY_COMMAND:7, PREPARE_CONTENTS_HTML:8, CLEAN_CONTENTS_HTML:10, CLEAN_CONTENTS_DOM:11};
goog.editor.Plugin.OPCODE = goog.object.transpose(goog.reflect.object(goog.editor.Plugin, {handleKeyDown:goog.editor.Plugin.Op.KEYDOWN, handleKeyPress:goog.editor.Plugin.Op.KEYPRESS, handleKeyUp:goog.editor.Plugin.Op.KEYUP, handleSelectionChange:goog.editor.Plugin.Op.SELECTION, handleKeyboardShortcut:goog.editor.Plugin.Op.SHORTCUT, execCommand:goog.editor.Plugin.Op.EXEC_COMMAND, queryCommandValue:goog.editor.Plugin.Op.QUERY_COMMAND, prepareContentsHtml:goog.editor.Plugin.Op.PREPARE_CONTENTS_HTML, 
cleanContentsHtml:goog.editor.Plugin.Op.CLEAN_CONTENTS_HTML, cleanContentsDom:goog.editor.Plugin.Op.CLEAN_CONTENTS_DOM}));
goog.editor.Plugin.IRREPRESSIBLE_OPS = goog.object.createSet(goog.editor.Plugin.Op.PREPARE_CONTENTS_HTML, goog.editor.Plugin.Op.CLEAN_CONTENTS_HTML, goog.editor.Plugin.Op.CLEAN_CONTENTS_DOM);
goog.editor.Plugin.prototype.handleKeyDown;
goog.editor.Plugin.prototype.handleKeyPress;
goog.editor.Plugin.prototype.handleKeyUp;
goog.editor.Plugin.prototype.handleSelectionChange;
goog.editor.Plugin.prototype.handleKeyboardShortcut;
goog.editor.Plugin.prototype.execCommand = function(command, var_args) {
  var silent = this.isSilentCommand(command);
  if (!silent) {
    if (goog.userAgent.GECKO) {
      this.getFieldObject().stopChangeEvents(true, true);
    }
    this.getFieldObject().dispatchBeforeChange();
  }
  try {
    var result = this.execCommandInternal.apply(this, arguments);
  } finally {
    if (!silent) {
      this.getFieldObject().dispatchChange();
      this.getFieldObject().dispatchSelectionChangeEvent();
    }
  }
  return result;
};
goog.editor.Plugin.prototype.execCommandInternal;
goog.editor.Plugin.prototype.queryCommandValue;
goog.editor.Plugin.prototype.prepareContentsHtml;
goog.editor.Plugin.prototype.cleanContentsDom;
goog.editor.Plugin.prototype.cleanContentsHtml;
goog.editor.Plugin.prototype.isSupportedCommand = function(command) {
  return false;
};
goog.editor.Plugin.prototype.saveScrollPosition = function() {
  if (this.getFieldObject() && goog.userAgent.EDGE) {
    var win = this.getFieldObject().getEditableDomHelper().getWindow();
    return win.scrollTo.bind(win, win.scrollX, win.scrollY);
  }
  return function() {
  };
};
goog.provide("goog.dom.vendor");
goog.require("goog.string");
goog.require("goog.userAgent");
goog.dom.vendor.getVendorJsPrefix = function() {
  if (goog.userAgent.WEBKIT) {
    return "Webkit";
  } else {
    if (goog.userAgent.GECKO) {
      return "Moz";
    } else {
      if (goog.userAgent.IE) {
        return "ms";
      } else {
        if (goog.userAgent.OPERA) {
          return "O";
        }
      }
    }
  }
  return null;
};
goog.dom.vendor.getVendorPrefix = function() {
  if (goog.userAgent.WEBKIT) {
    return "-webkit";
  } else {
    if (goog.userAgent.GECKO) {
      return "-moz";
    } else {
      if (goog.userAgent.IE) {
        return "-ms";
      } else {
        if (goog.userAgent.OPERA) {
          return "-o";
        }
      }
    }
  }
  return null;
};
goog.dom.vendor.getPrefixedPropertyName = function(propertyName, opt_object) {
  if (opt_object && propertyName in opt_object) {
    return propertyName;
  }
  var prefix = goog.dom.vendor.getVendorJsPrefix();
  if (prefix) {
    prefix = prefix.toLowerCase();
    var prefixedPropertyName = prefix + goog.string.toTitleCase(propertyName);
    return !goog.isDef(opt_object) || prefixedPropertyName in opt_object ? prefixedPropertyName : null;
  }
  return null;
};
goog.dom.vendor.getPrefixedEventType = function(eventType) {
  var prefix = goog.dom.vendor.getVendorJsPrefix() || "";
  return (prefix + eventType).toLowerCase();
};
goog.provide("goog.html.legacyconversions");
goog.require("goog.html.SafeHtml");
goog.require("goog.html.SafeStyle");
goog.require("goog.html.SafeStyleSheet");
goog.require("goog.html.SafeUrl");
goog.require("goog.html.TrustedResourceUrl");
goog.html.legacyconversions.safeHtmlFromString = function(html) {
  goog.html.legacyconversions.reportCallback_();
  return goog.html.SafeHtml.createSafeHtmlSecurityPrivateDoNotAccessOrElse(html, null);
};
goog.html.legacyconversions.safeStyleFromString = function(style) {
  goog.html.legacyconversions.reportCallback_();
  return goog.html.SafeStyle.createSafeStyleSecurityPrivateDoNotAccessOrElse(style);
};
goog.html.legacyconversions.safeStyleSheetFromString = function(styleSheet) {
  goog.html.legacyconversions.reportCallback_();
  return goog.html.SafeStyleSheet.createSafeStyleSheetSecurityPrivateDoNotAccessOrElse(styleSheet);
};
goog.html.legacyconversions.safeUrlFromString = function(url) {
  goog.html.legacyconversions.reportCallback_();
  return goog.html.SafeUrl.createSafeUrlSecurityPrivateDoNotAccessOrElse(url);
};
goog.html.legacyconversions.trustedResourceUrlFromString = function(url) {
  goog.html.legacyconversions.reportCallback_();
  return goog.html.TrustedResourceUrl.createTrustedResourceUrlSecurityPrivateDoNotAccessOrElse(url);
};
goog.html.legacyconversions.reportCallback_ = goog.nullFunction;
goog.html.legacyconversions.setReportCallback = function(callback) {
  goog.html.legacyconversions.reportCallback_ = callback;
};
goog.provide("goog.math.Box");
goog.require("goog.asserts");
goog.require("goog.math.Coordinate");
goog.math.Box = function(top, right, bottom, left) {
  this.top = top;
  this.right = right;
  this.bottom = bottom;
  this.left = left;
};
goog.math.Box.boundingBox = function(var_args) {
  var box = new goog.math.Box(arguments[0].y, arguments[0].x, arguments[0].y, arguments[0].x);
  for (var i = 1;i < arguments.length;i++) {
    box.expandToIncludeCoordinate(arguments[i]);
  }
  return box;
};
goog.math.Box.prototype.getWidth = function() {
  return this.right - this.left;
};
goog.math.Box.prototype.getHeight = function() {
  return this.bottom - this.top;
};
goog.math.Box.prototype.clone = function() {
  return new goog.math.Box(this.top, this.right, this.bottom, this.left);
};
if (goog.DEBUG) {
  goog.math.Box.prototype.toString = function() {
    return "(" + this.top + "t, " + this.right + "r, " + this.bottom + "b, " + this.left + "l)";
  };
}
goog.math.Box.prototype.contains = function(other) {
  return goog.math.Box.contains(this, other);
};
goog.math.Box.prototype.expand = function(top, opt_right, opt_bottom, opt_left) {
  if (goog.isObject(top)) {
    this.top -= top.top;
    this.right += top.right;
    this.bottom += top.bottom;
    this.left -= top.left;
  } else {
    this.top -= (top);
    this.right += Number(opt_right);
    this.bottom += Number(opt_bottom);
    this.left -= Number(opt_left);
  }
  return this;
};
goog.math.Box.prototype.expandToInclude = function(box) {
  this.left = Math.min(this.left, box.left);
  this.top = Math.min(this.top, box.top);
  this.right = Math.max(this.right, box.right);
  this.bottom = Math.max(this.bottom, box.bottom);
};
goog.math.Box.prototype.expandToIncludeCoordinate = function(coord) {
  this.top = Math.min(this.top, coord.y);
  this.right = Math.max(this.right, coord.x);
  this.bottom = Math.max(this.bottom, coord.y);
  this.left = Math.min(this.left, coord.x);
};
goog.math.Box.equals = function(a, b) {
  if (a == b) {
    return true;
  }
  if (!a || !b) {
    return false;
  }
  return a.top == b.top && a.right == b.right && a.bottom == b.bottom && a.left == b.left;
};
goog.math.Box.contains = function(box, other) {
  if (!box || !other) {
    return false;
  }
  if (other instanceof goog.math.Box) {
    return other.left >= box.left && other.right <= box.right && other.top >= box.top && other.bottom <= box.bottom;
  }
  return other.x >= box.left && other.x <= box.right && other.y >= box.top && other.y <= box.bottom;
};
goog.math.Box.relativePositionX = function(box, coord) {
  if (coord.x < box.left) {
    return coord.x - box.left;
  } else {
    if (coord.x > box.right) {
      return coord.x - box.right;
    }
  }
  return 0;
};
goog.math.Box.relativePositionY = function(box, coord) {
  if (coord.y < box.top) {
    return coord.y - box.top;
  } else {
    if (coord.y > box.bottom) {
      return coord.y - box.bottom;
    }
  }
  return 0;
};
goog.math.Box.distance = function(box, coord) {
  var x = goog.math.Box.relativePositionX(box, coord);
  var y = goog.math.Box.relativePositionY(box, coord);
  return Math.sqrt(x * x + y * y);
};
goog.math.Box.intersects = function(a, b) {
  return a.left <= b.right && b.left <= a.right && a.top <= b.bottom && b.top <= a.bottom;
};
goog.math.Box.intersectsWithPadding = function(a, b, padding) {
  return a.left <= b.right + padding && b.left <= a.right + padding && a.top <= b.bottom + padding && b.top <= a.bottom + padding;
};
goog.math.Box.prototype.ceil = function() {
  this.top = Math.ceil(this.top);
  this.right = Math.ceil(this.right);
  this.bottom = Math.ceil(this.bottom);
  this.left = Math.ceil(this.left);
  return this;
};
goog.math.Box.prototype.floor = function() {
  this.top = Math.floor(this.top);
  this.right = Math.floor(this.right);
  this.bottom = Math.floor(this.bottom);
  this.left = Math.floor(this.left);
  return this;
};
goog.math.Box.prototype.round = function() {
  this.top = Math.round(this.top);
  this.right = Math.round(this.right);
  this.bottom = Math.round(this.bottom);
  this.left = Math.round(this.left);
  return this;
};
goog.math.Box.prototype.translate = function(tx, opt_ty) {
  if (tx instanceof goog.math.Coordinate) {
    this.left += tx.x;
    this.right += tx.x;
    this.top += tx.y;
    this.bottom += tx.y;
  } else {
    goog.asserts.assertNumber(tx);
    this.left += tx;
    this.right += tx;
    if (goog.isNumber(opt_ty)) {
      this.top += opt_ty;
      this.bottom += opt_ty;
    }
  }
  return this;
};
goog.math.Box.prototype.scale = function(sx, opt_sy) {
  var sy = goog.isNumber(opt_sy) ? opt_sy : sx;
  this.left *= sx;
  this.right *= sx;
  this.top *= sy;
  this.bottom *= sy;
  return this;
};
goog.provide("goog.math.IRect");
goog.math.IRect = function() {
};
goog.math.IRect.prototype.left;
goog.math.IRect.prototype.top;
goog.math.IRect.prototype.width;
goog.math.IRect.prototype.height;
goog.provide("goog.math.Rect");
goog.require("goog.asserts");
goog.require("goog.math.Box");
goog.require("goog.math.Coordinate");
goog.require("goog.math.IRect");
goog.require("goog.math.Size");
goog.math.Rect = function(x, y, w, h) {
  this.left = x;
  this.top = y;
  this.width = w;
  this.height = h;
};
goog.math.Rect.prototype.clone = function() {
  return new goog.math.Rect(this.left, this.top, this.width, this.height);
};
goog.math.Rect.prototype.toBox = function() {
  var right = this.left + this.width;
  var bottom = this.top + this.height;
  return new goog.math.Box(this.top, right, bottom, this.left);
};
goog.math.Rect.createFromPositionAndSize = function(position, size) {
  return new goog.math.Rect(position.x, position.y, size.width, size.height);
};
goog.math.Rect.createFromBox = function(box) {
  return new goog.math.Rect(box.left, box.top, box.right - box.left, box.bottom - box.top);
};
if (goog.DEBUG) {
  goog.math.Rect.prototype.toString = function() {
    return "(" + this.left + ", " + this.top + " - " + this.width + "w x " + this.height + "h)";
  };
}
goog.math.Rect.equals = function(a, b) {
  if (a == b) {
    return true;
  }
  if (!a || !b) {
    return false;
  }
  return a.left == b.left && a.width == b.width && a.top == b.top && a.height == b.height;
};
goog.math.Rect.prototype.intersection = function(rect) {
  var x0 = Math.max(this.left, rect.left);
  var x1 = Math.min(this.left + this.width, rect.left + rect.width);
  if (x0 <= x1) {
    var y0 = Math.max(this.top, rect.top);
    var y1 = Math.min(this.top + this.height, rect.top + rect.height);
    if (y0 <= y1) {
      this.left = x0;
      this.top = y0;
      this.width = x1 - x0;
      this.height = y1 - y0;
      return true;
    }
  }
  return false;
};
goog.math.Rect.intersection = function(a, b) {
  var x0 = Math.max(a.left, b.left);
  var x1 = Math.min(a.left + a.width, b.left + b.width);
  if (x0 <= x1) {
    var y0 = Math.max(a.top, b.top);
    var y1 = Math.min(a.top + a.height, b.top + b.height);
    if (y0 <= y1) {
      return new goog.math.Rect(x0, y0, x1 - x0, y1 - y0);
    }
  }
  return null;
};
goog.math.Rect.intersects = function(a, b) {
  return a.left <= b.left + b.width && b.left <= a.left + a.width && a.top <= b.top + b.height && b.top <= a.top + a.height;
};
goog.math.Rect.prototype.intersects = function(rect) {
  return goog.math.Rect.intersects(this, rect);
};
goog.math.Rect.difference = function(a, b) {
  var intersection = goog.math.Rect.intersection(a, b);
  if (!intersection || !intersection.height || !intersection.width) {
    return [a.clone()];
  }
  var result = [];
  var top = a.top;
  var height = a.height;
  var ar = a.left + a.width;
  var ab = a.top + a.height;
  var br = b.left + b.width;
  var bb = b.top + b.height;
  if (b.top > a.top) {
    result.push(new goog.math.Rect(a.left, a.top, a.width, b.top - a.top));
    top = b.top;
    height -= b.top - a.top;
  }
  if (bb < ab) {
    result.push(new goog.math.Rect(a.left, bb, a.width, ab - bb));
    height = bb - top;
  }
  if (b.left > a.left) {
    result.push(new goog.math.Rect(a.left, top, b.left - a.left, height));
  }
  if (br < ar) {
    result.push(new goog.math.Rect(br, top, ar - br, height));
  }
  return result;
};
goog.math.Rect.prototype.difference = function(rect) {
  return goog.math.Rect.difference(this, rect);
};
goog.math.Rect.prototype.boundingRect = function(rect) {
  var right = Math.max(this.left + this.width, rect.left + rect.width);
  var bottom = Math.max(this.top + this.height, rect.top + rect.height);
  this.left = Math.min(this.left, rect.left);
  this.top = Math.min(this.top, rect.top);
  this.width = right - this.left;
  this.height = bottom - this.top;
};
goog.math.Rect.boundingRect = function(a, b) {
  if (!a || !b) {
    return null;
  }
  var newRect = new goog.math.Rect(a.left, a.top, a.width, a.height);
  newRect.boundingRect(b);
  return newRect;
};
goog.math.Rect.prototype.contains = function(another) {
  if (another instanceof goog.math.Coordinate) {
    return another.x >= this.left && another.x <= this.left + this.width && another.y >= this.top && another.y <= this.top + this.height;
  } else {
    return this.left <= another.left && this.left + this.width >= another.left + another.width && this.top <= another.top && this.top + this.height >= another.top + another.height;
  }
};
goog.math.Rect.prototype.squaredDistance = function(point) {
  var dx = point.x < this.left ? this.left - point.x : Math.max(point.x - (this.left + this.width), 0);
  var dy = point.y < this.top ? this.top - point.y : Math.max(point.y - (this.top + this.height), 0);
  return dx * dx + dy * dy;
};
goog.math.Rect.prototype.distance = function(point) {
  return Math.sqrt(this.squaredDistance(point));
};
goog.math.Rect.prototype.getSize = function() {
  return new goog.math.Size(this.width, this.height);
};
goog.math.Rect.prototype.getTopLeft = function() {
  return new goog.math.Coordinate(this.left, this.top);
};
goog.math.Rect.prototype.getCenter = function() {
  return new goog.math.Coordinate(this.left + this.width / 2, this.top + this.height / 2);
};
goog.math.Rect.prototype.getBottomRight = function() {
  return new goog.math.Coordinate(this.left + this.width, this.top + this.height);
};
goog.math.Rect.prototype.ceil = function() {
  this.left = Math.ceil(this.left);
  this.top = Math.ceil(this.top);
  this.width = Math.ceil(this.width);
  this.height = Math.ceil(this.height);
  return this;
};
goog.math.Rect.prototype.floor = function() {
  this.left = Math.floor(this.left);
  this.top = Math.floor(this.top);
  this.width = Math.floor(this.width);
  this.height = Math.floor(this.height);
  return this;
};
goog.math.Rect.prototype.round = function() {
  this.left = Math.round(this.left);
  this.top = Math.round(this.top);
  this.width = Math.round(this.width);
  this.height = Math.round(this.height);
  return this;
};
goog.math.Rect.prototype.translate = function(tx, opt_ty) {
  if (tx instanceof goog.math.Coordinate) {
    this.left += tx.x;
    this.top += tx.y;
  } else {
    this.left += goog.asserts.assertNumber(tx);
    if (goog.isNumber(opt_ty)) {
      this.top += opt_ty;
    }
  }
  return this;
};
goog.math.Rect.prototype.scale = function(sx, opt_sy) {
  var sy = goog.isNumber(opt_sy) ? opt_sy : sx;
  this.left *= sx;
  this.width *= sx;
  this.top *= sy;
  this.height *= sy;
  return this;
};
goog.provide("goog.style");
goog.require("goog.array");
goog.require("goog.asserts");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.TagName");
goog.require("goog.dom.vendor");
goog.require("goog.html.SafeStyleSheet");
goog.require("goog.html.legacyconversions");
goog.require("goog.math.Box");
goog.require("goog.math.Coordinate");
goog.require("goog.math.Rect");
goog.require("goog.math.Size");
goog.require("goog.object");
goog.require("goog.reflect");
goog.require("goog.string");
goog.require("goog.userAgent");
goog.forwardDeclare("goog.events.BrowserEvent");
goog.forwardDeclare("goog.events.Event");
goog.style.setStyle = function(element, style, opt_value) {
  if (goog.isString(style)) {
    goog.style.setStyle_(element, opt_value, style);
  } else {
    for (var key in style) {
      goog.style.setStyle_(element, style[key], key);
    }
  }
};
goog.style.setStyle_ = function(element, value, style) {
  var propertyName = goog.style.getVendorJsStyleName_(element, style);
  if (propertyName) {
    element.style[propertyName] = value;
  }
};
goog.style.styleNameCache_ = {};
goog.style.getVendorJsStyleName_ = function(element, style) {
  var propertyName = goog.style.styleNameCache_[style];
  if (!propertyName) {
    var camelStyle = goog.string.toCamelCase(style);
    propertyName = camelStyle;
    if (element.style[camelStyle] === undefined) {
      var prefixedStyle = goog.dom.vendor.getVendorJsPrefix() + goog.string.toTitleCase(camelStyle);
      if (element.style[prefixedStyle] !== undefined) {
        propertyName = prefixedStyle;
      }
    }
    goog.style.styleNameCache_[style] = propertyName;
  }
  return propertyName;
};
goog.style.getVendorStyleName_ = function(element, style) {
  var camelStyle = goog.string.toCamelCase(style);
  if (element.style[camelStyle] === undefined) {
    var prefixedStyle = goog.dom.vendor.getVendorJsPrefix() + goog.string.toTitleCase(camelStyle);
    if (element.style[prefixedStyle] !== undefined) {
      return goog.dom.vendor.getVendorPrefix() + "-" + style;
    }
  }
  return style;
};
goog.style.getStyle = function(element, property) {
  var styleValue = element.style[goog.string.toCamelCase(property)];
  if (typeof styleValue !== "undefined") {
    return styleValue;
  }
  return element.style[goog.style.getVendorJsStyleName_(element, property)] || "";
};
goog.style.getComputedStyle = function(element, property) {
  var doc = goog.dom.getOwnerDocument(element);
  if (doc.defaultView && doc.defaultView.getComputedStyle) {
    var styles = doc.defaultView.getComputedStyle(element, null);
    if (styles) {
      return styles[property] || styles.getPropertyValue(property) || "";
    }
  }
  return "";
};
goog.style.getCascadedStyle = function(element, style) {
  return element.currentStyle ? element.currentStyle[style] : null;
};
goog.style.getStyle_ = function(element, style) {
  return goog.style.getComputedStyle(element, style) || goog.style.getCascadedStyle(element, style) || element.style && element.style[style];
};
goog.style.getComputedBoxSizing = function(element) {
  return goog.style.getStyle_(element, "boxSizing") || goog.style.getStyle_(element, "MozBoxSizing") || goog.style.getStyle_(element, "WebkitBoxSizing") || null;
};
goog.style.getComputedPosition = function(element) {
  return goog.style.getStyle_(element, "position");
};
goog.style.getBackgroundColor = function(element) {
  return goog.style.getStyle_(element, "backgroundColor");
};
goog.style.getComputedOverflowX = function(element) {
  return goog.style.getStyle_(element, "overflowX");
};
goog.style.getComputedOverflowY = function(element) {
  return goog.style.getStyle_(element, "overflowY");
};
goog.style.getComputedZIndex = function(element) {
  return goog.style.getStyle_(element, "zIndex");
};
goog.style.getComputedTextAlign = function(element) {
  return goog.style.getStyle_(element, "textAlign");
};
goog.style.getComputedCursor = function(element) {
  return goog.style.getStyle_(element, "cursor");
};
goog.style.getComputedTransform = function(element) {
  var property = goog.style.getVendorStyleName_(element, "transform");
  return goog.style.getStyle_(element, property) || goog.style.getStyle_(element, "transform");
};
goog.style.setPosition = function(el, arg1, opt_arg2) {
  var x, y;
  if (arg1 instanceof goog.math.Coordinate) {
    x = arg1.x;
    y = arg1.y;
  } else {
    x = arg1;
    y = opt_arg2;
  }
  el.style.left = goog.style.getPixelStyleValue_((x), false);
  el.style.top = goog.style.getPixelStyleValue_((y), false);
};
goog.style.getPosition = function(element) {
  return new goog.math.Coordinate((element).offsetLeft, (element).offsetTop);
};
goog.style.getClientViewportElement = function(opt_node) {
  var doc;
  if (opt_node) {
    doc = goog.dom.getOwnerDocument(opt_node);
  } else {
    doc = goog.dom.getDocument();
  }
  if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9) && !goog.dom.getDomHelper(doc).isCss1CompatMode()) {
    return doc.body;
  }
  return doc.documentElement;
};
goog.style.getViewportPageOffset = function(doc) {
  var body = doc.body;
  var documentElement = doc.documentElement;
  var scrollLeft = body.scrollLeft || documentElement.scrollLeft;
  var scrollTop = body.scrollTop || documentElement.scrollTop;
  return new goog.math.Coordinate(scrollLeft, scrollTop);
};
goog.style.getBoundingClientRect_ = function(el) {
  var rect;
  try {
    rect = el.getBoundingClientRect();
  } catch (e) {
    return {"left":0, "top":0, "right":0, "bottom":0};
  }
  if (goog.userAgent.IE && el.ownerDocument.body) {
    var doc = el.ownerDocument;
    rect.left -= doc.documentElement.clientLeft + doc.body.clientLeft;
    rect.top -= doc.documentElement.clientTop + doc.body.clientTop;
  }
  return rect;
};
goog.style.getOffsetParent = function(element) {
  if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(8)) {
    goog.asserts.assert(element && "offsetParent" in element);
    return element.offsetParent;
  }
  var doc = goog.dom.getOwnerDocument(element);
  var positionStyle = goog.style.getStyle_(element, "position");
  var skipStatic = positionStyle == "fixed" || positionStyle == "absolute";
  for (var parent = element.parentNode;parent && parent != doc;parent = parent.parentNode) {
    if (parent.nodeType == goog.dom.NodeType.DOCUMENT_FRAGMENT && parent.host) {
      parent = parent.host;
    }
    positionStyle = goog.style.getStyle_((parent), "position");
    skipStatic = skipStatic && positionStyle == "static" && parent != doc.documentElement && parent != doc.body;
    if (!skipStatic && (parent.scrollWidth > parent.clientWidth || parent.scrollHeight > parent.clientHeight || positionStyle == "fixed" || positionStyle == "absolute" || positionStyle == "relative")) {
      return (parent);
    }
  }
  return null;
};
goog.style.getVisibleRectForElement = function(element) {
  var visibleRect = new goog.math.Box(0, Infinity, Infinity, 0);
  var dom = goog.dom.getDomHelper(element);
  var body = dom.getDocument().body;
  var documentElement = dom.getDocument().documentElement;
  var scrollEl = dom.getDocumentScrollElement();
  for (var el = element;el = goog.style.getOffsetParent(el);) {
    if ((!goog.userAgent.IE || el.clientWidth != 0) && (!goog.userAgent.WEBKIT || el.clientHeight != 0 || el != body) && (el != body && el != documentElement && goog.style.getStyle_(el, "overflow") != "visible")) {
      var pos = goog.style.getPageOffset(el);
      var client = goog.style.getClientLeftTop(el);
      pos.x += client.x;
      pos.y += client.y;
      visibleRect.top = Math.max(visibleRect.top, pos.y);
      visibleRect.right = Math.min(visibleRect.right, pos.x + el.clientWidth);
      visibleRect.bottom = Math.min(visibleRect.bottom, pos.y + el.clientHeight);
      visibleRect.left = Math.max(visibleRect.left, pos.x);
    }
  }
  var scrollX = scrollEl.scrollLeft, scrollY = scrollEl.scrollTop;
  visibleRect.left = Math.max(visibleRect.left, scrollX);
  visibleRect.top = Math.max(visibleRect.top, scrollY);
  var winSize = dom.getViewportSize();
  visibleRect.right = Math.min(visibleRect.right, scrollX + winSize.width);
  visibleRect.bottom = Math.min(visibleRect.bottom, scrollY + winSize.height);
  return visibleRect.top >= 0 && visibleRect.left >= 0 && visibleRect.bottom > visibleRect.top && visibleRect.right > visibleRect.left ? visibleRect : null;
};
goog.style.getContainerOffsetToScrollInto = function(element, opt_container, opt_center) {
  var container = opt_container || goog.dom.getDocumentScrollElement();
  var elementPos = goog.style.getPageOffset(element);
  var containerPos = goog.style.getPageOffset(container);
  var containerBorder = goog.style.getBorderBox(container);
  if (container == goog.dom.getDocumentScrollElement()) {
    var relX = elementPos.x - container.scrollLeft;
    var relY = elementPos.y - container.scrollTop;
    if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(10)) {
      relX += containerBorder.left;
      relY += containerBorder.top;
    }
  } else {
    var relX = elementPos.x - containerPos.x - containerBorder.left;
    var relY = elementPos.y - containerPos.y - containerBorder.top;
  }
  var elementSize = goog.style.getSizeWithDisplay_(element);
  var spaceX = container.clientWidth - elementSize.width;
  var spaceY = container.clientHeight - elementSize.height;
  var scrollLeft = container.scrollLeft;
  var scrollTop = container.scrollTop;
  if (opt_center) {
    scrollLeft += relX - spaceX / 2;
    scrollTop += relY - spaceY / 2;
  } else {
    scrollLeft += Math.min(relX, Math.max(relX - spaceX, 0));
    scrollTop += Math.min(relY, Math.max(relY - spaceY, 0));
  }
  return new goog.math.Coordinate(scrollLeft, scrollTop);
};
goog.style.scrollIntoContainerView = function(element, opt_container, opt_center) {
  var container = opt_container || goog.dom.getDocumentScrollElement();
  var offset = goog.style.getContainerOffsetToScrollInto(element, container, opt_center);
  container.scrollLeft = offset.x;
  container.scrollTop = offset.y;
};
goog.style.getClientLeftTop = function(el) {
  return new goog.math.Coordinate(el.clientLeft, el.clientTop);
};
goog.style.getPageOffset = function(el) {
  var doc = goog.dom.getOwnerDocument(el);
  goog.asserts.assertObject(el, "Parameter is required");
  var pos = new goog.math.Coordinate(0, 0);
  var viewportElement = goog.style.getClientViewportElement(doc);
  if (el == viewportElement) {
    return pos;
  }
  var box = goog.style.getBoundingClientRect_(el);
  var scrollCoord = goog.dom.getDomHelper(doc).getDocumentScroll();
  pos.x = box.left + scrollCoord.x;
  pos.y = box.top + scrollCoord.y;
  return pos;
};
goog.style.getPageOffsetLeft = function(el) {
  return goog.style.getPageOffset(el).x;
};
goog.style.getPageOffsetTop = function(el) {
  return goog.style.getPageOffset(el).y;
};
goog.style.getFramedPageOffset = function(el, relativeWin) {
  var position = new goog.math.Coordinate(0, 0);
  var currentWin = goog.dom.getWindow(goog.dom.getOwnerDocument(el));
  if (!goog.reflect.canAccessProperty(currentWin, "parent")) {
    return position;
  }
  var currentEl = el;
  do {
    var offset = currentWin == relativeWin ? goog.style.getPageOffset(currentEl) : goog.style.getClientPositionForElement_(goog.asserts.assert(currentEl));
    position.x += offset.x;
    position.y += offset.y;
  } while (currentWin && currentWin != relativeWin && currentWin != currentWin.parent && (currentEl = currentWin.frameElement) && (currentWin = currentWin.parent));
  return position;
};
goog.style.translateRectForAnotherFrame = function(rect, origBase, newBase) {
  if (origBase.getDocument() != newBase.getDocument()) {
    var body = origBase.getDocument().body;
    var pos = goog.style.getFramedPageOffset(body, newBase.getWindow());
    pos = goog.math.Coordinate.difference(pos, goog.style.getPageOffset(body));
    if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9) && !origBase.isCss1CompatMode()) {
      pos = goog.math.Coordinate.difference(pos, origBase.getDocumentScroll());
    }
    rect.left += pos.x;
    rect.top += pos.y;
  }
};
goog.style.getRelativePosition = function(a, b) {
  var ap = goog.style.getClientPosition(a);
  var bp = goog.style.getClientPosition(b);
  return new goog.math.Coordinate(ap.x - bp.x, ap.y - bp.y);
};
goog.style.getClientPositionForElement_ = function(el) {
  var box = goog.style.getBoundingClientRect_(el);
  return new goog.math.Coordinate(box.left, box.top);
};
goog.style.getClientPosition = function(el) {
  goog.asserts.assert(el);
  if (el.nodeType == goog.dom.NodeType.ELEMENT) {
    return goog.style.getClientPositionForElement_((el));
  } else {
    var targetEvent = el.changedTouches ? el.changedTouches[0] : el;
    return new goog.math.Coordinate(targetEvent.clientX, targetEvent.clientY);
  }
};
goog.style.setPageOffset = function(el, x, opt_y) {
  var cur = goog.style.getPageOffset(el);
  if (x instanceof goog.math.Coordinate) {
    opt_y = x.y;
    x = x.x;
  }
  var dx = goog.asserts.assertNumber(x) - cur.x;
  var dy = Number(opt_y) - cur.y;
  goog.style.setPosition(el, (el).offsetLeft + dx, (el).offsetTop + dy);
};
goog.style.setSize = function(element, w, opt_h) {
  var h;
  if (w instanceof goog.math.Size) {
    h = w.height;
    w = w.width;
  } else {
    if (opt_h == undefined) {
      throw Error("missing height argument");
    }
    h = opt_h;
  }
  goog.style.setWidth(element, (w));
  goog.style.setHeight(element, h);
};
goog.style.getPixelStyleValue_ = function(value, round) {
  if (typeof value == "number") {
    value = (round ? Math.round(value) : value) + "px";
  }
  return value;
};
goog.style.setHeight = function(element, height) {
  element.style.height = goog.style.getPixelStyleValue_(height, true);
};
goog.style.setWidth = function(element, width) {
  element.style.width = goog.style.getPixelStyleValue_(width, true);
};
goog.style.getSize = function(element) {
  return goog.style.evaluateWithTemporaryDisplay_(goog.style.getSizeWithDisplay_, (element));
};
goog.style.evaluateWithTemporaryDisplay_ = function(fn, element) {
  if (goog.style.getStyle_(element, "display") != "none") {
    return fn(element);
  }
  var style = element.style;
  var originalDisplay = style.display;
  var originalVisibility = style.visibility;
  var originalPosition = style.position;
  style.visibility = "hidden";
  style.position = "absolute";
  style.display = "inline";
  var retVal = fn(element);
  style.display = originalDisplay;
  style.position = originalPosition;
  style.visibility = originalVisibility;
  return retVal;
};
goog.style.getSizeWithDisplay_ = function(element) {
  var offsetWidth = (element).offsetWidth;
  var offsetHeight = (element).offsetHeight;
  var webkitOffsetsZero = goog.userAgent.WEBKIT && !offsetWidth && !offsetHeight;
  if ((!goog.isDef(offsetWidth) || webkitOffsetsZero) && element.getBoundingClientRect) {
    var clientRect = goog.style.getBoundingClientRect_(element);
    return new goog.math.Size(clientRect.right - clientRect.left, clientRect.bottom - clientRect.top);
  }
  return new goog.math.Size(offsetWidth, offsetHeight);
};
goog.style.getTransformedSize = function(element) {
  if (!element.getBoundingClientRect) {
    return null;
  }
  var clientRect = goog.style.evaluateWithTemporaryDisplay_(goog.style.getBoundingClientRect_, element);
  return new goog.math.Size(clientRect.right - clientRect.left, clientRect.bottom - clientRect.top);
};
goog.style.getBounds = function(element) {
  var o = goog.style.getPageOffset(element);
  var s = goog.style.getSize(element);
  return new goog.math.Rect(o.x, o.y, s.width, s.height);
};
goog.style.toCamelCase = function(selector) {
  return goog.string.toCamelCase(String(selector));
};
goog.style.toSelectorCase = function(selector) {
  return goog.string.toSelectorCase(selector);
};
goog.style.getOpacity = function(el) {
  goog.asserts.assert(el);
  var style = el.style;
  var result = "";
  if ("opacity" in style) {
    result = style.opacity;
  } else {
    if ("MozOpacity" in style) {
      result = style.MozOpacity;
    } else {
      if ("filter" in style) {
        var match = style.filter.match(/alpha\(opacity=([\d.]+)\)/);
        if (match) {
          result = String(match[1] / 100);
        }
      }
    }
  }
  return result == "" ? result : Number(result);
};
goog.style.setOpacity = function(el, alpha) {
  goog.asserts.assert(el);
  var style = el.style;
  if ("opacity" in style) {
    style.opacity = alpha;
  } else {
    if ("MozOpacity" in style) {
      style.MozOpacity = alpha;
    } else {
      if ("filter" in style) {
        if (alpha === "") {
          style.filter = "";
        } else {
          style.filter = "alpha(opacity=" + Number(alpha) * 100 + ")";
        }
      }
    }
  }
};
goog.style.setTransparentBackgroundImage = function(el, src) {
  var style = el.style;
  if (goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("8")) {
    style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(" + 'src="' + src + '", sizingMethod="crop")';
  } else {
    style.backgroundImage = "url(" + src + ")";
    style.backgroundPosition = "top left";
    style.backgroundRepeat = "no-repeat";
  }
};
goog.style.clearTransparentBackgroundImage = function(el) {
  var style = el.style;
  if ("filter" in style) {
    style.filter = "";
  } else {
    style.backgroundImage = "none";
  }
};
goog.style.showElement = function(el, display) {
  goog.style.setElementShown(el, display);
};
goog.style.setElementShown = function(el, isShown) {
  el.style.display = isShown ? "" : "none";
};
goog.style.isElementShown = function(el) {
  return el.style.display != "none";
};
goog.style.installStyles = function(stylesString, opt_node) {
  return goog.style.installSafeStyleSheet(goog.html.legacyconversions.safeStyleSheetFromString(stylesString), opt_node);
};
goog.style.installSafeStyleSheet = function(safeStyleSheet, opt_node) {
  var dh = goog.dom.getDomHelper(opt_node);
  var styleSheet = null;
  var doc = dh.getDocument();
  if (goog.userAgent.IE && doc.createStyleSheet) {
    styleSheet = doc.createStyleSheet();
    goog.style.setSafeStyleSheet(styleSheet, safeStyleSheet);
  } else {
    var head = dh.getElementsByTagNameAndClass(goog.dom.TagName.HEAD)[0];
    if (!head) {
      var body = dh.getElementsByTagNameAndClass(goog.dom.TagName.BODY)[0];
      head = dh.createDom(goog.dom.TagName.HEAD);
      body.parentNode.insertBefore(head, body);
    }
    styleSheet = dh.createDom(goog.dom.TagName.STYLE);
    goog.style.setSafeStyleSheet(styleSheet, safeStyleSheet);
    dh.appendChild(head, styleSheet);
  }
  return styleSheet;
};
goog.style.uninstallStyles = function(styleSheet) {
  var node = styleSheet.ownerNode || styleSheet.owningElement || (styleSheet);
  goog.dom.removeNode(node);
};
goog.style.setStyles = function(element, stylesString) {
  goog.style.setSafeStyleSheet((element), goog.html.legacyconversions.safeStyleSheetFromString(stylesString));
};
goog.style.setSafeStyleSheet = function(element, safeStyleSheet) {
  var stylesString = goog.html.SafeStyleSheet.unwrap(safeStyleSheet);
  if (goog.userAgent.IE && goog.isDef(element.cssText)) {
    element.cssText = stylesString;
  } else {
    element.innerHTML = stylesString;
  }
};
goog.style.setPreWrap = function(el) {
  var style = el.style;
  if (goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("8")) {
    style.whiteSpace = "pre";
    style.wordWrap = "break-word";
  } else {
    if (goog.userAgent.GECKO) {
      style.whiteSpace = "-moz-pre-wrap";
    } else {
      style.whiteSpace = "pre-wrap";
    }
  }
};
goog.style.setInlineBlock = function(el) {
  var style = el.style;
  style.position = "relative";
  if (goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("8")) {
    style.zoom = "1";
    style.display = "inline";
  } else {
    style.display = "inline-block";
  }
};
goog.style.isRightToLeft = function(el) {
  return "rtl" == goog.style.getStyle_(el, "direction");
};
goog.style.unselectableStyle_ = goog.userAgent.GECKO ? "MozUserSelect" : goog.userAgent.WEBKIT || goog.userAgent.EDGE ? "WebkitUserSelect" : null;
goog.style.isUnselectable = function(el) {
  if (goog.style.unselectableStyle_) {
    return el.style[goog.style.unselectableStyle_].toLowerCase() == "none";
  } else {
    if (goog.userAgent.IE || goog.userAgent.OPERA) {
      return el.getAttribute("unselectable") == "on";
    }
  }
  return false;
};
goog.style.setUnselectable = function(el, unselectable, opt_noRecurse) {
  var descendants = !opt_noRecurse ? el.getElementsByTagName("*") : null;
  var name = goog.style.unselectableStyle_;
  if (name) {
    var value = unselectable ? "none" : "";
    if (el.style) {
      el.style[name] = value;
    }
    if (descendants) {
      for (var i = 0, descendant;descendant = descendants[i];i++) {
        if (descendant.style) {
          descendant.style[name] = value;
        }
      }
    }
  } else {
    if (goog.userAgent.IE || goog.userAgent.OPERA) {
      var value = unselectable ? "on" : "";
      el.setAttribute("unselectable", value);
      if (descendants) {
        for (var i = 0, descendant;descendant = descendants[i];i++) {
          descendant.setAttribute("unselectable", value);
        }
      }
    }
  }
};
goog.style.getBorderBoxSize = function(element) {
  return new goog.math.Size((element).offsetWidth, (element).offsetHeight);
};
goog.style.setBorderBoxSize = function(element, size) {
  var doc = goog.dom.getOwnerDocument(element);
  var isCss1CompatMode = goog.dom.getDomHelper(doc).isCss1CompatMode();
  if (goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("10") && (!isCss1CompatMode || !goog.userAgent.isVersionOrHigher("8"))) {
    var style = element.style;
    if (isCss1CompatMode) {
      var paddingBox = goog.style.getPaddingBox(element);
      var borderBox = goog.style.getBorderBox(element);
      style.pixelWidth = size.width - borderBox.left - paddingBox.left - paddingBox.right - borderBox.right;
      style.pixelHeight = size.height - borderBox.top - paddingBox.top - paddingBox.bottom - borderBox.bottom;
    } else {
      style.pixelWidth = size.width;
      style.pixelHeight = size.height;
    }
  } else {
    goog.style.setBoxSizingSize_(element, size, "border-box");
  }
};
goog.style.getContentBoxSize = function(element) {
  var doc = goog.dom.getOwnerDocument(element);
  var ieCurrentStyle = goog.userAgent.IE && element.currentStyle;
  if (ieCurrentStyle && goog.dom.getDomHelper(doc).isCss1CompatMode() && ieCurrentStyle.width != "auto" && ieCurrentStyle.height != "auto" && !ieCurrentStyle.boxSizing) {
    var width = goog.style.getIePixelValue_(element, ieCurrentStyle.width, "width", "pixelWidth");
    var height = goog.style.getIePixelValue_(element, ieCurrentStyle.height, "height", "pixelHeight");
    return new goog.math.Size(width, height);
  } else {
    var borderBoxSize = goog.style.getBorderBoxSize(element);
    var paddingBox = goog.style.getPaddingBox(element);
    var borderBox = goog.style.getBorderBox(element);
    return new goog.math.Size(borderBoxSize.width - borderBox.left - paddingBox.left - paddingBox.right - borderBox.right, borderBoxSize.height - borderBox.top - paddingBox.top - paddingBox.bottom - borderBox.bottom);
  }
};
goog.style.setContentBoxSize = function(element, size) {
  var doc = goog.dom.getOwnerDocument(element);
  var isCss1CompatMode = goog.dom.getDomHelper(doc).isCss1CompatMode();
  if (goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("10") && (!isCss1CompatMode || !goog.userAgent.isVersionOrHigher("8"))) {
    var style = element.style;
    if (isCss1CompatMode) {
      style.pixelWidth = size.width;
      style.pixelHeight = size.height;
    } else {
      var paddingBox = goog.style.getPaddingBox(element);
      var borderBox = goog.style.getBorderBox(element);
      style.pixelWidth = size.width + borderBox.left + paddingBox.left + paddingBox.right + borderBox.right;
      style.pixelHeight = size.height + borderBox.top + paddingBox.top + paddingBox.bottom + borderBox.bottom;
    }
  } else {
    goog.style.setBoxSizingSize_(element, size, "content-box");
  }
};
goog.style.setBoxSizingSize_ = function(element, size, boxSizing) {
  var style = element.style;
  if (goog.userAgent.GECKO) {
    style.MozBoxSizing = boxSizing;
  } else {
    if (goog.userAgent.WEBKIT) {
      style.WebkitBoxSizing = boxSizing;
    } else {
      style.boxSizing = boxSizing;
    }
  }
  style.width = Math.max(size.width, 0) + "px";
  style.height = Math.max(size.height, 0) + "px";
};
goog.style.getIePixelValue_ = function(element, value, name, pixelName) {
  if (/^\d+px?$/.test(value)) {
    return parseInt(value, 10);
  } else {
    var oldStyleValue = element.style[name];
    var oldRuntimeValue = element.runtimeStyle[name];
    element.runtimeStyle[name] = element.currentStyle[name];
    element.style[name] = value;
    var pixelValue = element.style[pixelName];
    element.style[name] = oldStyleValue;
    element.runtimeStyle[name] = oldRuntimeValue;
    return pixelValue;
  }
};
goog.style.getIePixelDistance_ = function(element, propName) {
  var value = goog.style.getCascadedStyle(element, propName);
  return value ? goog.style.getIePixelValue_(element, value, "left", "pixelLeft") : 0;
};
goog.style.getBox_ = function(element, stylePrefix) {
  if (goog.userAgent.IE) {
    var left = goog.style.getIePixelDistance_(element, stylePrefix + "Left");
    var right = goog.style.getIePixelDistance_(element, stylePrefix + "Right");
    var top = goog.style.getIePixelDistance_(element, stylePrefix + "Top");
    var bottom = goog.style.getIePixelDistance_(element, stylePrefix + "Bottom");
    return new goog.math.Box(top, right, bottom, left);
  } else {
    var left = goog.style.getComputedStyle(element, stylePrefix + "Left");
    var right = goog.style.getComputedStyle(element, stylePrefix + "Right");
    var top = goog.style.getComputedStyle(element, stylePrefix + "Top");
    var bottom = goog.style.getComputedStyle(element, stylePrefix + "Bottom");
    return new goog.math.Box(parseFloat(top), parseFloat(right), parseFloat(bottom), parseFloat(left));
  }
};
goog.style.getPaddingBox = function(element) {
  return goog.style.getBox_(element, "padding");
};
goog.style.getMarginBox = function(element) {
  return goog.style.getBox_(element, "margin");
};
goog.style.ieBorderWidthKeywords_ = {"thin":2, "medium":4, "thick":6};
goog.style.getIePixelBorder_ = function(element, prop) {
  if (goog.style.getCascadedStyle(element, prop + "Style") == "none") {
    return 0;
  }
  var width = goog.style.getCascadedStyle(element, prop + "Width");
  if (width in goog.style.ieBorderWidthKeywords_) {
    return goog.style.ieBorderWidthKeywords_[width];
  }
  return goog.style.getIePixelValue_(element, width, "left", "pixelLeft");
};
goog.style.getBorderBox = function(element) {
  if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9)) {
    var left = goog.style.getIePixelBorder_(element, "borderLeft");
    var right = goog.style.getIePixelBorder_(element, "borderRight");
    var top = goog.style.getIePixelBorder_(element, "borderTop");
    var bottom = goog.style.getIePixelBorder_(element, "borderBottom");
    return new goog.math.Box(top, right, bottom, left);
  } else {
    var left = goog.style.getComputedStyle(element, "borderLeftWidth");
    var right = goog.style.getComputedStyle(element, "borderRightWidth");
    var top = goog.style.getComputedStyle(element, "borderTopWidth");
    var bottom = goog.style.getComputedStyle(element, "borderBottomWidth");
    return new goog.math.Box(parseFloat(top), parseFloat(right), parseFloat(bottom), parseFloat(left));
  }
};
goog.style.getFontFamily = function(el) {
  var doc = goog.dom.getOwnerDocument(el);
  var font = "";
  if (doc.body.createTextRange && goog.dom.contains(doc, el)) {
    var range = doc.body.createTextRange();
    range.moveToElementText(el);
    try {
      font = range.queryCommandValue("FontName");
    } catch (e) {
      font = "";
    }
  }
  if (!font) {
    font = goog.style.getStyle_(el, "fontFamily");
  }
  var fontsArray = font.split(",");
  if (fontsArray.length > 1) {
    font = fontsArray[0];
  }
  return goog.string.stripQuotes(font, "\"'");
};
goog.style.lengthUnitRegex_ = /[^\d]+$/;
goog.style.getLengthUnits = function(value) {
  var units = value.match(goog.style.lengthUnitRegex_);
  return units && units[0] || null;
};
goog.style.ABSOLUTE_CSS_LENGTH_UNITS_ = {"cm":1, "in":1, "mm":1, "pc":1, "pt":1};
goog.style.CONVERTIBLE_RELATIVE_CSS_UNITS_ = {"em":1, "ex":1};
goog.style.getFontSize = function(el) {
  var fontSize = goog.style.getStyle_(el, "fontSize");
  var sizeUnits = goog.style.getLengthUnits(fontSize);
  if (fontSize && "px" == sizeUnits) {
    return parseInt(fontSize, 10);
  }
  if (goog.userAgent.IE) {
    if (String(sizeUnits) in goog.style.ABSOLUTE_CSS_LENGTH_UNITS_) {
      return goog.style.getIePixelValue_(el, fontSize, "left", "pixelLeft");
    } else {
      if (el.parentNode && el.parentNode.nodeType == goog.dom.NodeType.ELEMENT && String(sizeUnits) in goog.style.CONVERTIBLE_RELATIVE_CSS_UNITS_) {
        var parentElement = (el.parentNode);
        var parentSize = goog.style.getStyle_(parentElement, "fontSize");
        return goog.style.getIePixelValue_(parentElement, fontSize == parentSize ? "1em" : fontSize, "left", "pixelLeft");
      }
    }
  }
  var sizeElement = goog.dom.createDom(goog.dom.TagName.SPAN, {"style":"visibility:hidden;position:absolute;" + "line-height:0;padding:0;margin:0;border:0;height:1em;"});
  goog.dom.appendChild(el, sizeElement);
  fontSize = sizeElement.offsetHeight;
  goog.dom.removeNode(sizeElement);
  return fontSize;
};
goog.style.parseStyleAttribute = function(value) {
  var result = {};
  goog.array.forEach(value.split(/\s*;\s*/), function(pair) {
    var keyValue = pair.match(/\s*([\w-]+)\s*\:(.+)/);
    if (keyValue) {
      var styleName = keyValue[1];
      var styleValue = goog.string.trim(keyValue[2]);
      result[goog.string.toCamelCase(styleName.toLowerCase())] = styleValue;
    }
  });
  return result;
};
goog.style.toStyleAttribute = function(obj) {
  var buffer = [];
  goog.object.forEach(obj, function(value, key) {
    buffer.push(goog.string.toSelectorCase(key), ":", value, ";");
  });
  return buffer.join("");
};
goog.style.setFloat = function(el, value) {
  el.style[goog.userAgent.IE ? "styleFloat" : "cssFloat"] = value;
};
goog.style.getFloat = function(el) {
  return el.style[goog.userAgent.IE ? "styleFloat" : "cssFloat"] || "";
};
goog.style.getScrollbarWidth = function(opt_className) {
  var outerDiv = goog.dom.createElement(goog.dom.TagName.DIV);
  if (opt_className) {
    outerDiv.className = opt_className;
  }
  outerDiv.style.cssText = "overflow:auto;" + "position:absolute;top:0;width:100px;height:100px";
  var innerDiv = goog.dom.createElement(goog.dom.TagName.DIV);
  goog.style.setSize(innerDiv, "200px", "200px");
  outerDiv.appendChild(innerDiv);
  goog.dom.appendChild(goog.dom.getDocument().body, outerDiv);
  var width = outerDiv.offsetWidth - outerDiv.clientWidth;
  goog.dom.removeNode(outerDiv);
  return width;
};
goog.style.MATRIX_TRANSLATION_REGEX_ = new RegExp("matrix\\([0-9\\.\\-]+, [0-9\\.\\-]+, " + "[0-9\\.\\-]+, [0-9\\.\\-]+, " + "([0-9\\.\\-]+)p?x?, ([0-9\\.\\-]+)p?x?\\)");
goog.style.getCssTranslation = function(element) {
  var transform = goog.style.getComputedTransform(element);
  if (!transform) {
    return new goog.math.Coordinate(0, 0);
  }
  var matches = transform.match(goog.style.MATRIX_TRANSLATION_REGEX_);
  if (!matches) {
    return new goog.math.Coordinate(0, 0);
  }
  return new goog.math.Coordinate(parseFloat(matches[1]), parseFloat(matches[2]));
};
goog.provide("goog.editor.icontent");
goog.provide("goog.editor.icontent.FieldFormatInfo");
goog.provide("goog.editor.icontent.FieldStyleInfo");
goog.require("goog.dom");
goog.require("goog.editor.BrowserFeature");
goog.require("goog.style");
goog.require("goog.userAgent");
goog.editor.icontent.FieldFormatInfo = function(fieldId, standards, blended, fixedHeight, opt_extraStyles) {
  this.fieldId_ = fieldId;
  this.standards_ = standards;
  this.blended_ = blended;
  this.fixedHeight_ = fixedHeight;
  this.extraStyles_ = opt_extraStyles || {};
};
goog.editor.icontent.FieldStyleInfo = function(wrapper, css) {
  this.wrapper_ = wrapper;
  this.css_ = css;
};
goog.editor.icontent.useStandardsModeIframes_ = false;
goog.editor.icontent.forceStandardsModeIframes = function() {
  goog.editor.icontent.useStandardsModeIframes_ = true;
};
goog.editor.icontent.getInitialIframeContent_ = function(info, bodyHtml, style) {
  var html = [];
  if (info.blended_ && info.standards_ || goog.editor.icontent.useStandardsModeIframes_) {
    html.push("<!DOCTYPE HTML>");
  }
  html.push('<html style="background:none transparent;min-width:0;');
  if (info.blended_) {
    html.push("height:", info.fixedHeight_ ? "100%" : "auto");
  }
  html.push('">');
  html.push("<head><style>");
  if (style && style.css_) {
    html.push(style.css_);
  }
  if (goog.userAgent.GECKO && info.standards_) {
    html.push(" img {-moz-force-broken-image-icon: 1;}");
  }
  html.push("</style></head>");
  html.push('<body g_editable="true" hidefocus="true" ');
  if (goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
    html.push("contentEditable ");
  }
  html.push('class="editable ');
  html.push('" id="', info.fieldId_, '" style="min-width:0;');
  if (goog.userAgent.GECKO && info.blended_) {
    html.push(";width:100%;border:0;margin:0;background:none transparent;", ";height:", info.standards_ ? "100%" : "auto");
    if (info.fixedHeight_) {
      html.push(";overflow:auto");
    } else {
      html.push(";overflow-y:hidden;overflow-x:auto");
    }
  }
  if (goog.userAgent.OPERA) {
    html.push(";outline:hidden");
  }
  for (var key in info.extraStyles_) {
    html.push(";" + key + ":" + info.extraStyles_[key]);
  }
  html.push('">', bodyHtml, "</body></html>");
  return html.join("");
};
goog.editor.icontent.writeNormalInitialBlendedIframe = function(info, bodyHtml, style, iframe) {
  if (info.blended_) {
    var field = style.wrapper_;
    var paddingBox = goog.style.getPaddingBox(field);
    if (paddingBox.top || paddingBox.left || paddingBox.right || paddingBox.bottom) {
      goog.style.setStyle(iframe, "margin", -paddingBox.top + "px " + -paddingBox.right + "px " + -paddingBox.bottom + "px " + -paddingBox.left + "px");
    }
  }
  goog.editor.icontent.writeNormalInitialIframe(info, bodyHtml, style, iframe);
};
goog.editor.icontent.writeNormalInitialIframe = function(info, bodyHtml, style, iframe) {
  var html = goog.editor.icontent.getInitialIframeContent_(info, bodyHtml, style);
  var doc = goog.dom.getFrameContentDocument(iframe);
  doc.open();
  doc.write(html);
  doc.close();
};
goog.editor.icontent.writeHttpsInitialIframe = function(info, doc, bodyHtml) {
  var body = doc.body;
  if (goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
    body.contentEditable = true;
  }
  body.className = "editable";
  body.setAttribute("g_editable", true);
  body.hideFocus = true;
  body.id = info.fieldId_;
  goog.style.setStyle(body, info.extraStyles_);
  body.innerHTML = bodyHtml;
};
goog.provide("goog.dom.iter.AncestorIterator");
goog.provide("goog.dom.iter.ChildIterator");
goog.provide("goog.dom.iter.SiblingIterator");
goog.require("goog.iter.Iterator");
goog.require("goog.iter.StopIteration");
goog.dom.iter.SiblingIterator = function(node, opt_includeNode, opt_reverse) {
  this.node_ = node;
  this.reverse_ = !!opt_reverse;
  if (node && !opt_includeNode) {
    this.next();
  }
};
goog.inherits(goog.dom.iter.SiblingIterator, goog.iter.Iterator);
goog.dom.iter.SiblingIterator.prototype.next = function() {
  var node = this.node_;
  if (!node) {
    throw goog.iter.StopIteration;
  }
  this.node_ = this.reverse_ ? node.previousSibling : node.nextSibling;
  return node;
};
goog.dom.iter.ChildIterator = function(element, opt_reverse, opt_startIndex) {
  if (!goog.isDef(opt_startIndex)) {
    opt_startIndex = opt_reverse && element.childNodes.length ? element.childNodes.length - 1 : 0;
  }
  goog.dom.iter.SiblingIterator.call(this, element.childNodes[opt_startIndex], true, opt_reverse);
};
goog.inherits(goog.dom.iter.ChildIterator, goog.dom.iter.SiblingIterator);
goog.dom.iter.AncestorIterator = function(node, opt_includeNode) {
  this.node_ = node;
  if (node && !opt_includeNode) {
    this.next();
  }
};
goog.inherits(goog.dom.iter.AncestorIterator, goog.iter.Iterator);
goog.dom.iter.AncestorIterator.prototype.next = function() {
  var node = this.node_;
  if (!node) {
    throw goog.iter.StopIteration;
  }
  this.node_ = node.parentNode;
  return node;
};
goog.provide("goog.editor.node");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.TagName");
goog.require("goog.dom.iter.ChildIterator");
goog.require("goog.dom.iter.SiblingIterator");
goog.require("goog.iter");
goog.require("goog.object");
goog.require("goog.string");
goog.require("goog.string.Unicode");
goog.require("goog.userAgent");
goog.editor.node.BLOCK_TAG_NAMES_ = goog.object.createSet(goog.dom.TagName.ADDRESS, goog.dom.TagName.ARTICLE, goog.dom.TagName.ASIDE, goog.dom.TagName.BLOCKQUOTE, goog.dom.TagName.BODY, goog.dom.TagName.CAPTION, goog.dom.TagName.CENTER, goog.dom.TagName.COL, goog.dom.TagName.COLGROUP, goog.dom.TagName.DETAILS, goog.dom.TagName.DIR, goog.dom.TagName.DIV, goog.dom.TagName.DL, goog.dom.TagName.DD, goog.dom.TagName.DT, goog.dom.TagName.FIELDSET, goog.dom.TagName.FIGCAPTION, goog.dom.TagName.FIGURE, goog.dom.TagName.FOOTER, 
goog.dom.TagName.FORM, goog.dom.TagName.H1, goog.dom.TagName.H2, goog.dom.TagName.H3, goog.dom.TagName.H4, goog.dom.TagName.H5, goog.dom.TagName.H6, goog.dom.TagName.HEADER, goog.dom.TagName.HGROUP, goog.dom.TagName.HR, goog.dom.TagName.ISINDEX, goog.dom.TagName.OL, goog.dom.TagName.LI, goog.dom.TagName.MAP, goog.dom.TagName.MENU, goog.dom.TagName.NAV, goog.dom.TagName.OPTGROUP, goog.dom.TagName.OPTION, goog.dom.TagName.P, goog.dom.TagName.PRE, goog.dom.TagName.SECTION, goog.dom.TagName.SUMMARY, 
goog.dom.TagName.TABLE, goog.dom.TagName.TBODY, goog.dom.TagName.TD, goog.dom.TagName.TFOOT, goog.dom.TagName.TH, goog.dom.TagName.THEAD, goog.dom.TagName.TR, goog.dom.TagName.UL);
goog.editor.node.NON_EMPTY_TAGS_ = goog.object.createSet(goog.dom.TagName.IMG, goog.dom.TagName.IFRAME, goog.dom.TagName.EMBED);
goog.editor.node.isStandardsMode = function(node) {
  return goog.dom.getDomHelper(node).isCss1CompatMode();
};
goog.editor.node.getRightMostLeaf = function(parent) {
  var temp;
  while (temp = goog.editor.node.getLastChild(parent)) {
    parent = temp;
  }
  return parent;
};
goog.editor.node.getLeftMostLeaf = function(parent) {
  var temp;
  while (temp = goog.editor.node.getFirstChild(parent)) {
    parent = temp;
  }
  return parent;
};
goog.editor.node.getFirstChild = function(parent) {
  return goog.editor.node.getChildHelper_(parent, false);
};
goog.editor.node.getLastChild = function(parent) {
  return goog.editor.node.getChildHelper_(parent, true);
};
goog.editor.node.getPreviousSibling = function(sibling) {
  return (goog.editor.node.getFirstValue_(goog.iter.filter(new goog.dom.iter.SiblingIterator(sibling, false, true), goog.editor.node.isImportant)));
};
goog.editor.node.getNextSibling = function(sibling) {
  return (goog.editor.node.getFirstValue_(goog.iter.filter(new goog.dom.iter.SiblingIterator(sibling), goog.editor.node.isImportant)));
};
goog.editor.node.getChildHelper_ = function(parent, isReversed) {
  return !parent || parent.nodeType != goog.dom.NodeType.ELEMENT ? null : (goog.editor.node.getFirstValue_(goog.iter.filter(new goog.dom.iter.ChildIterator((parent), isReversed), goog.editor.node.isImportant)));
};
goog.editor.node.getFirstValue_ = function(iterator) {
  try {
    return iterator.next();
  } catch (e) {
    return null;
  }
};
goog.editor.node.isImportant = function(node) {
  return node.nodeType == goog.dom.NodeType.ELEMENT || node.nodeType == goog.dom.NodeType.TEXT && !goog.editor.node.isAllNonNbspWhiteSpace(node);
};
goog.editor.node.isAllNonNbspWhiteSpace = function(textNode) {
  return goog.string.isBreakingWhitespace(textNode.nodeValue);
};
goog.editor.node.isEmpty = function(node, opt_prohibitSingleNbsp) {
  var nodeData = goog.dom.getRawTextContent(node);
  if (node.getElementsByTagName) {
    node = (node);
    for (var tag in goog.editor.node.NON_EMPTY_TAGS_) {
      if (node.tagName == tag || node.getElementsByTagName(tag).length > 0) {
        return false;
      }
    }
  }
  return !opt_prohibitSingleNbsp && nodeData == goog.string.Unicode.NBSP || goog.string.isBreakingWhitespace(nodeData);
};
goog.editor.node.getLength = function(node) {
  return node.length || node.childNodes.length;
};
goog.editor.node.findInChildren = function(parent, hasProperty) {
  for (var i = 0, len = parent.childNodes.length;i < len;i++) {
    if (hasProperty(parent.childNodes[i])) {
      return i;
    }
  }
  return null;
};
goog.editor.node.findHighestMatchingAncestor = function(node, hasProperty) {
  var parent = node.parentNode;
  var ancestor = null;
  while (parent && hasProperty(parent)) {
    ancestor = parent;
    parent = parent.parentNode;
  }
  return ancestor;
};
goog.editor.node.isBlockTag = function(node) {
  return !!goog.editor.node.BLOCK_TAG_NAMES_[(node).tagName];
};
goog.editor.node.skipEmptyTextNodes = function(node) {
  while (node && node.nodeType == goog.dom.NodeType.TEXT && !node.nodeValue) {
    node = node.nextSibling;
  }
  return node;
};
goog.editor.node.isEditableContainer = function(element) {
  return element.getAttribute && element.getAttribute("g_editable") == "true";
};
goog.editor.node.isEditable = function(node) {
  return !!goog.dom.getAncestor(node, goog.editor.node.isEditableContainer);
};
goog.editor.node.findTopMostEditableAncestor = function(node, criteria) {
  var targetNode = null;
  while (node && !goog.editor.node.isEditableContainer(node)) {
    if (criteria(node)) {
      targetNode = node;
    }
    node = node.parentNode;
  }
  return targetNode;
};
goog.editor.node.splitDomTreeAt = function(currentNode, opt_secondHalf, opt_root) {
  var parent;
  while (currentNode != opt_root && (parent = currentNode.parentNode)) {
    opt_secondHalf = goog.editor.node.getSecondHalfOfNode_(parent, currentNode, opt_secondHalf);
    currentNode = parent;
  }
  return (opt_secondHalf);
};
goog.editor.node.getSecondHalfOfNode_ = function(node, startNode, firstChild) {
  var secondHalf = (node.cloneNode(false));
  while (startNode.nextSibling) {
    goog.dom.appendChild(secondHalf, startNode.nextSibling);
  }
  if (firstChild) {
    secondHalf.insertBefore(firstChild, secondHalf.firstChild);
  }
  return secondHalf;
};
goog.editor.node.transferChildren = function(newNode, oldNode) {
  goog.dom.append(newNode, oldNode.childNodes);
};
goog.editor.node.replaceInnerHtml = function(node, html) {
  if (goog.userAgent.IE) {
    goog.dom.removeChildren(node);
  }
  node.innerHTML = html;
};
goog.provide("goog.editor.style");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.TagName");
goog.require("goog.editor.BrowserFeature");
goog.require("goog.events.EventType");
goog.require("goog.object");
goog.require("goog.style");
goog.require("goog.userAgent");
goog.editor.style.getComputedOrCascadedStyle_ = function(node, stylePropertyName) {
  if (node.nodeType != goog.dom.NodeType.ELEMENT) {
    return null;
  }
  return goog.userAgent.IE ? goog.style.getCascadedStyle((node), stylePropertyName) : goog.style.getComputedStyle((node), stylePropertyName);
};
goog.editor.style.isDisplayBlock = function(node) {
  return goog.editor.style.getComputedOrCascadedStyle_(node, "display") == "block";
};
goog.editor.style.isContainer = function(element) {
  var nodeName = element && element.nodeName;
  return !!(element && (goog.editor.style.isDisplayBlock(element) || nodeName == goog.dom.TagName.TD || nodeName == goog.dom.TagName.TABLE || nodeName == goog.dom.TagName.LI));
};
goog.editor.style.getContainer = function(node) {
  return (goog.dom.getAncestor(node, goog.editor.style.isContainer, true));
};
goog.editor.style.SELECTABLE_INPUT_TYPES_ = goog.object.createSet("text", "file", "url");
goog.editor.style.cancelMouseDownHelper_ = function(e) {
  var targetTagName = e.target.tagName;
  if (targetTagName != goog.dom.TagName.TEXTAREA && targetTagName != goog.dom.TagName.INPUT) {
    e.preventDefault();
  }
};
goog.editor.style.makeUnselectable = function(element, eventHandler) {
  if (goog.editor.BrowserFeature.HAS_UNSELECTABLE_STYLE) {
    eventHandler.listen(element, goog.events.EventType.MOUSEDOWN, goog.editor.style.cancelMouseDownHelper_, true);
  }
  goog.style.setUnselectable(element, true);
  var inputs = element.getElementsByTagName(goog.dom.TagName.INPUT);
  for (var i = 0, len = inputs.length;i < len;i++) {
    var input = inputs[i];
    if (input.type in goog.editor.style.SELECTABLE_INPUT_TYPES_) {
      goog.editor.style.makeSelectable(input);
    }
  }
  goog.array.forEach(element.getElementsByTagName(goog.dom.TagName.TEXTAREA), goog.editor.style.makeSelectable);
};
goog.editor.style.makeSelectable = function(element) {
  goog.style.setUnselectable(element, false);
  if (goog.editor.BrowserFeature.HAS_UNSELECTABLE_STYLE) {
    var child = element;
    var current = (element.parentNode);
    while (current && current.tagName != goog.dom.TagName.HTML) {
      if (goog.style.isUnselectable(current)) {
        goog.style.setUnselectable(current, false, true);
        for (var i = 0, len = current.childNodes.length;i < len;i++) {
          var node = current.childNodes[i];
          if (node != child && node.nodeType == goog.dom.NodeType.ELEMENT) {
            goog.style.setUnselectable((current.childNodes[i]), true);
          }
        }
      }
      child = current;
      current = (current.parentNode);
    }
  }
};
goog.provide("goog.editor.range");
goog.provide("goog.editor.range.Point");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.Range");
goog.require("goog.dom.RangeEndpoint");
goog.require("goog.dom.SavedCaretRange");
goog.require("goog.editor.node");
goog.require("goog.editor.style");
goog.require("goog.iter");
goog.require("goog.userAgent");
goog.editor.range.narrow = function(range, el) {
  var startContainer = range.getStartNode();
  var endContainer = range.getEndNode();
  if (startContainer && endContainer) {
    var isElement = function(node) {
      return node == el;
    };
    var hasStart = goog.dom.getAncestor(startContainer, isElement, true);
    var hasEnd = goog.dom.getAncestor(endContainer, isElement, true);
    if (hasStart && hasEnd) {
      return range.clone();
    } else {
      if (hasStart) {
        var leaf = goog.editor.node.getRightMostLeaf(el);
        return goog.dom.Range.createFromNodes(range.getStartNode(), range.getStartOffset(), leaf, goog.editor.node.getLength(leaf));
      } else {
        if (hasEnd) {
          return goog.dom.Range.createFromNodes(goog.editor.node.getLeftMostLeaf(el), 0, range.getEndNode(), range.getEndOffset());
        }
      }
    }
  }
  return null;
};
goog.editor.range.expand = function(range, opt_stopNode) {
  var expandedRange = goog.editor.range.expandEndPointToContainer_(range, goog.dom.RangeEndpoint.START, opt_stopNode);
  expandedRange = goog.editor.range.expandEndPointToContainer_(expandedRange, goog.dom.RangeEndpoint.END, opt_stopNode);
  var startNode = expandedRange.getStartNode();
  var endNode = expandedRange.getEndNode();
  var startOffset = expandedRange.getStartOffset();
  var endOffset = expandedRange.getEndOffset();
  if (startNode == endNode) {
    while (endNode != opt_stopNode && startOffset == 0 && endOffset == goog.editor.node.getLength(endNode)) {
      var parentNode = endNode.parentNode;
      startOffset = goog.array.indexOf(parentNode.childNodes, endNode);
      endOffset = startOffset + 1;
      endNode = parentNode;
    }
    startNode = endNode;
  }
  return goog.dom.Range.createFromNodes(startNode, startOffset, endNode, endOffset);
};
goog.editor.range.expandEndPointToContainer_ = function(range, endpoint, opt_stopNode) {
  var expandStart = endpoint == goog.dom.RangeEndpoint.START;
  var node = expandStart ? range.getStartNode() : range.getEndNode();
  var offset = expandStart ? range.getStartOffset() : range.getEndOffset();
  var container = range.getContainerElement();
  while (node != container && node != opt_stopNode) {
    if (expandStart && offset != 0 || !expandStart && offset != goog.editor.node.getLength(node)) {
      break;
    }
    var parentNode = node.parentNode;
    var index = goog.array.indexOf(parentNode.childNodes, node);
    offset = expandStart ? index : index + 1;
    node = parentNode;
  }
  return goog.dom.Range.createFromNodes(expandStart ? node : range.getStartNode(), expandStart ? offset : range.getStartOffset(), expandStart ? range.getEndNode() : node, expandStart ? range.getEndOffset() : offset);
};
goog.editor.range.selectNodeStart = function(node) {
  goog.dom.Range.createCaret(goog.editor.node.getLeftMostLeaf(node), 0).select();
};
goog.editor.range.placeCursorNextTo = function(node, toLeft) {
  var parent = node.parentNode;
  var offset = goog.array.indexOf(parent.childNodes, node) + (toLeft ? 0 : 1);
  var point = goog.editor.range.Point.createDeepestPoint(parent, offset, toLeft, true);
  var range = goog.dom.Range.createCaret(point.node, point.offset);
  range.select();
  return range;
};
goog.editor.range.selectionPreservingNormalize = function(node) {
  var doc = goog.dom.getOwnerDocument(node);
  var selection = goog.dom.Range.createFromWindow(goog.dom.getWindow(doc));
  var normalizedRange = goog.editor.range.rangePreservingNormalize(node, selection);
  if (normalizedRange) {
    normalizedRange.select();
  }
};
goog.editor.range.normalizeNodeIe_ = function(node) {
  var lastText = null;
  var child = node.firstChild;
  while (child) {
    var next = child.nextSibling;
    if (child.nodeType == goog.dom.NodeType.TEXT) {
      if (child.nodeValue == "") {
        node.removeChild(child);
      } else {
        if (lastText) {
          lastText.nodeValue += child.nodeValue;
          node.removeChild(child);
        } else {
          lastText = child;
        }
      }
    } else {
      goog.editor.range.normalizeNodeIe_(child);
      lastText = null;
    }
    child = next;
  }
};
goog.editor.range.normalizeNode = function(node) {
  if (goog.userAgent.IE) {
    goog.editor.range.normalizeNodeIe_(node);
  } else {
    node.normalize();
  }
};
goog.editor.range.rangePreservingNormalize = function(node, range) {
  if (range) {
    var rangeFactory = goog.editor.range.normalize(range);
    var container = goog.editor.style.getContainer(range.getContainerElement());
  }
  if (container) {
    goog.editor.range.normalizeNode(goog.dom.findCommonAncestor(container, node));
  } else {
    if (node) {
      goog.editor.range.normalizeNode(node);
    }
  }
  if (rangeFactory) {
    return rangeFactory();
  } else {
    return null;
  }
};
goog.editor.range.getDeepEndPoint = function(range, atStart) {
  return atStart ? goog.editor.range.Point.createDeepestPoint(range.getStartNode(), range.getStartOffset()) : goog.editor.range.Point.createDeepestPoint(range.getEndNode(), range.getEndOffset());
};
goog.editor.range.normalize = function(range) {
  var isReversed = range.isReversed();
  var anchorPoint = goog.editor.range.normalizePoint_(goog.editor.range.getDeepEndPoint(range, !isReversed));
  var anchorParent = anchorPoint.getParentPoint();
  var anchorPreviousSibling = anchorPoint.node.previousSibling;
  if (anchorPoint.node.nodeType == goog.dom.NodeType.TEXT) {
    anchorPoint.node = null;
  }
  var focusPoint = goog.editor.range.normalizePoint_(goog.editor.range.getDeepEndPoint(range, isReversed));
  var focusParent = focusPoint.getParentPoint();
  var focusPreviousSibling = focusPoint.node.previousSibling;
  if (focusPoint.node.nodeType == goog.dom.NodeType.TEXT) {
    focusPoint.node = null;
  }
  return function() {
    if (!anchorPoint.node && anchorPreviousSibling) {
      anchorPoint.node = anchorPreviousSibling.nextSibling;
      if (!anchorPoint.node) {
        anchorPoint = goog.editor.range.Point.getPointAtEndOfNode(anchorPreviousSibling);
      }
    }
    if (!focusPoint.node && focusPreviousSibling) {
      focusPoint.node = focusPreviousSibling.nextSibling;
      if (!focusPoint.node) {
        focusPoint = goog.editor.range.Point.getPointAtEndOfNode(focusPreviousSibling);
      }
    }
    return goog.dom.Range.createFromNodes(anchorPoint.node || anchorParent.node.firstChild || anchorParent.node, anchorPoint.offset, focusPoint.node || focusParent.node.firstChild || focusParent.node, focusPoint.offset);
  };
};
goog.editor.range.normalizePoint_ = function(point) {
  var previous;
  if (point.node.nodeType == goog.dom.NodeType.TEXT) {
    for (var current = point.node.previousSibling;current && current.nodeType == goog.dom.NodeType.TEXT;current = current.previousSibling) {
      point.offset += goog.editor.node.getLength(current);
    }
    previous = current;
  } else {
    previous = point.node.previousSibling;
  }
  var parent = point.node.parentNode;
  point.node = previous ? previous.nextSibling : parent.firstChild;
  return point;
};
goog.editor.range.isEditable = function(range) {
  var rangeContainer = range.getContainerElement();
  var rangeContainerIsOutsideRange = range.getStartNode() != rangeContainer.parentElement;
  return rangeContainerIsOutsideRange && goog.editor.node.isEditableContainer(rangeContainer) || goog.editor.node.isEditable(rangeContainer);
};
goog.editor.range.intersectsTag = function(range, tagName) {
  if (goog.dom.getAncestorByTagNameAndClass(range.getContainerElement(), tagName)) {
    return true;
  }
  return goog.iter.some(range, function(node) {
    return node.tagName == tagName;
  });
};
goog.editor.range.Point = function(node, offset) {
  this.node = node;
  this.offset = offset;
};
goog.editor.range.Point.prototype.getParentPoint = function() {
  var parent = this.node.parentNode;
  return new goog.editor.range.Point(parent, goog.array.indexOf(parent.childNodes, this.node));
};
goog.editor.range.Point.createDeepestPoint = function(node, offset, opt_trendLeft, opt_stopOnChildlessElement) {
  while (node.nodeType == goog.dom.NodeType.ELEMENT) {
    var child = node.childNodes[offset];
    if (!child && !node.lastChild) {
      break;
    } else {
      if (child) {
        var prevSibling = child.previousSibling;
        if (opt_trendLeft && prevSibling) {
          if (opt_stopOnChildlessElement && goog.editor.range.Point.isTerminalElement_(prevSibling)) {
            break;
          }
          node = prevSibling;
          offset = goog.editor.node.getLength(node);
        } else {
          if (opt_stopOnChildlessElement && goog.editor.range.Point.isTerminalElement_(child)) {
            break;
          }
          node = child;
          offset = 0;
        }
      } else {
        if (opt_stopOnChildlessElement && goog.editor.range.Point.isTerminalElement_(node.lastChild)) {
          break;
        }
        node = node.lastChild;
        offset = goog.editor.node.getLength(node);
      }
    }
  }
  return new goog.editor.range.Point(node, offset);
};
goog.editor.range.Point.isTerminalElement_ = function(node) {
  return node.nodeType == goog.dom.NodeType.ELEMENT && !goog.dom.canHaveChildren(node);
};
goog.editor.range.Point.getPointAtEndOfNode = function(node) {
  return new goog.editor.range.Point(node, goog.editor.node.getLength(node));
};
goog.editor.range.saveUsingNormalizedCarets = function(range) {
  return new goog.editor.range.NormalizedCaretRange_(range);
};
goog.editor.range.NormalizedCaretRange_ = function(range) {
  goog.dom.SavedCaretRange.call(this, range);
};
goog.inherits(goog.editor.range.NormalizedCaretRange_, goog.dom.SavedCaretRange);
goog.editor.range.NormalizedCaretRange_.prototype.removeCarets = function(opt_range) {
  var startCaret = this.getCaret(true);
  var endCaret = this.getCaret(false);
  var node = startCaret && endCaret ? goog.dom.findCommonAncestor(startCaret, endCaret) : startCaret || endCaret;
  goog.editor.range.NormalizedCaretRange_.superClass_.removeCarets.call(this);
  if (opt_range) {
    return goog.editor.range.rangePreservingNormalize(node, opt_range);
  } else {
    if (node) {
      goog.editor.range.selectionPreservingNormalize(node);
    }
  }
};
goog.provide("goog.events.EventHandler");
goog.require("goog.Disposable");
goog.require("goog.events");
goog.require("goog.object");
goog.forwardDeclare("goog.events.EventWrapper");
goog.events.EventHandler = function(opt_scope) {
  goog.Disposable.call(this);
  this.handler_ = opt_scope;
  this.keys_ = {};
};
goog.inherits(goog.events.EventHandler, goog.Disposable);
goog.events.EventHandler.typeArray_ = [];
goog.events.EventHandler.prototype.listen = function(src, type, opt_fn, opt_capture) {
  return this.listen_(src, type, opt_fn, opt_capture);
};
goog.events.EventHandler.prototype.listenWithScope = function(src, type, fn, capture, scope) {
  return this.listen_(src, type, fn, capture, scope);
};
goog.events.EventHandler.prototype.listen_ = function(src, type, opt_fn, opt_capture, opt_scope) {
  if (!goog.isArray(type)) {
    if (type) {
      goog.events.EventHandler.typeArray_[0] = type.toString();
    }
    type = goog.events.EventHandler.typeArray_;
  }
  for (var i = 0;i < type.length;i++) {
    var listenerObj = goog.events.listen(src, type[i], opt_fn || this.handleEvent, opt_capture || false, opt_scope || this.handler_ || this);
    if (!listenerObj) {
      return this;
    }
    var key = listenerObj.key;
    this.keys_[key] = listenerObj;
  }
  return this;
};
goog.events.EventHandler.prototype.listenOnce = function(src, type, opt_fn, opt_capture) {
  return this.listenOnce_(src, type, opt_fn, opt_capture);
};
goog.events.EventHandler.prototype.listenOnceWithScope = function(src, type, fn, capture, scope) {
  return this.listenOnce_(src, type, fn, capture, scope);
};
goog.events.EventHandler.prototype.listenOnce_ = function(src, type, opt_fn, opt_capture, opt_scope) {
  if (goog.isArray(type)) {
    for (var i = 0;i < type.length;i++) {
      this.listenOnce_(src, type[i], opt_fn, opt_capture, opt_scope);
    }
  } else {
    var listenerObj = goog.events.listenOnce(src, type, opt_fn || this.handleEvent, opt_capture, opt_scope || this.handler_ || this);
    if (!listenerObj) {
      return this;
    }
    var key = listenerObj.key;
    this.keys_[key] = listenerObj;
  }
  return this;
};
goog.events.EventHandler.prototype.listenWithWrapper = function(src, wrapper, listener, opt_capt) {
  return this.listenWithWrapper_(src, wrapper, listener, opt_capt);
};
goog.events.EventHandler.prototype.listenWithWrapperAndScope = function(src, wrapper, listener, capture, scope) {
  return this.listenWithWrapper_(src, wrapper, listener, capture, scope);
};
goog.events.EventHandler.prototype.listenWithWrapper_ = function(src, wrapper, listener, opt_capt, opt_scope) {
  wrapper.listen(src, listener, opt_capt, opt_scope || this.handler_ || this, this);
  return this;
};
goog.events.EventHandler.prototype.getListenerCount = function() {
  var count = 0;
  for (var key in this.keys_) {
    if (Object.prototype.hasOwnProperty.call(this.keys_, key)) {
      count++;
    }
  }
  return count;
};
goog.events.EventHandler.prototype.unlisten = function(src, type, opt_fn, opt_capture, opt_scope) {
  if (goog.isArray(type)) {
    for (var i = 0;i < type.length;i++) {
      this.unlisten(src, type[i], opt_fn, opt_capture, opt_scope);
    }
  } else {
    var listener = goog.events.getListener(src, type, opt_fn || this.handleEvent, opt_capture, opt_scope || this.handler_ || this);
    if (listener) {
      goog.events.unlistenByKey(listener);
      delete this.keys_[listener.key];
    }
  }
  return this;
};
goog.events.EventHandler.prototype.unlistenWithWrapper = function(src, wrapper, listener, opt_capt, opt_scope) {
  wrapper.unlisten(src, listener, opt_capt, opt_scope || this.handler_ || this, this);
  return this;
};
goog.events.EventHandler.prototype.removeAll = function() {
  goog.object.forEach(this.keys_, function(listenerObj, key) {
    if (this.keys_.hasOwnProperty(key)) {
      goog.events.unlistenByKey(listenerObj);
    }
  }, this);
  this.keys_ = {};
};
goog.events.EventHandler.prototype.disposeInternal = function() {
  goog.events.EventHandler.superClass_.disposeInternal.call(this);
  this.removeAll();
};
goog.events.EventHandler.prototype.handleEvent = function(e) {
  throw Error("EventHandler.handleEvent not implemented");
};
goog.provide("goog.events.KeyCodes");
goog.require("goog.userAgent");
goog.forwardDeclare("goog.events.BrowserEvent");
goog.events.KeyCodes = {WIN_KEY_FF_LINUX:0, MAC_ENTER:3, BACKSPACE:8, TAB:9, NUM_CENTER:12, ENTER:13, SHIFT:16, CTRL:17, ALT:18, PAUSE:19, CAPS_LOCK:20, ESC:27, SPACE:32, PAGE_UP:33, PAGE_DOWN:34, END:35, HOME:36, LEFT:37, UP:38, RIGHT:39, DOWN:40, PLUS_SIGN:43, PRINT_SCREEN:44, INSERT:45, DELETE:46, ZERO:48, ONE:49, TWO:50, THREE:51, FOUR:52, FIVE:53, SIX:54, SEVEN:55, EIGHT:56, NINE:57, FF_SEMICOLON:59, FF_EQUALS:61, FF_DASH:173, QUESTION_MARK:63, AT_SIGN:64, A:65, B:66, C:67, D:68, E:69, F:70, 
G:71, H:72, I:73, J:74, K:75, L:76, M:77, N:78, O:79, P:80, Q:81, R:82, S:83, T:84, U:85, V:86, W:87, X:88, Y:89, Z:90, META:91, WIN_KEY_RIGHT:92, CONTEXT_MENU:93, NUM_ZERO:96, NUM_ONE:97, NUM_TWO:98, NUM_THREE:99, NUM_FOUR:100, NUM_FIVE:101, NUM_SIX:102, NUM_SEVEN:103, NUM_EIGHT:104, NUM_NINE:105, NUM_MULTIPLY:106, NUM_PLUS:107, NUM_MINUS:109, NUM_PERIOD:110, NUM_DIVISION:111, F1:112, F2:113, F3:114, F4:115, F5:116, F6:117, F7:118, F8:119, F9:120, F10:121, F11:122, F12:123, NUMLOCK:144, SCROLL_LOCK:145, 
FIRST_MEDIA_KEY:166, LAST_MEDIA_KEY:183, SEMICOLON:186, DASH:189, EQUALS:187, COMMA:188, PERIOD:190, SLASH:191, APOSTROPHE:192, TILDE:192, SINGLE_QUOTE:222, OPEN_SQUARE_BRACKET:219, BACKSLASH:220, CLOSE_SQUARE_BRACKET:221, WIN_KEY:224, MAC_FF_META:224, MAC_WK_CMD_LEFT:91, MAC_WK_CMD_RIGHT:93, WIN_IME:229, VK_NONAME:252, PHANTOM:255};
goog.events.KeyCodes.isTextModifyingKeyEvent = function(e) {
  if (e.altKey && !e.ctrlKey || e.metaKey || e.keyCode >= goog.events.KeyCodes.F1 && e.keyCode <= goog.events.KeyCodes.F12) {
    return false;
  }
  switch(e.keyCode) {
    case goog.events.KeyCodes.ALT:
    ;
    case goog.events.KeyCodes.CAPS_LOCK:
    ;
    case goog.events.KeyCodes.CONTEXT_MENU:
    ;
    case goog.events.KeyCodes.CTRL:
    ;
    case goog.events.KeyCodes.DOWN:
    ;
    case goog.events.KeyCodes.END:
    ;
    case goog.events.KeyCodes.ESC:
    ;
    case goog.events.KeyCodes.HOME:
    ;
    case goog.events.KeyCodes.INSERT:
    ;
    case goog.events.KeyCodes.LEFT:
    ;
    case goog.events.KeyCodes.MAC_FF_META:
    ;
    case goog.events.KeyCodes.META:
    ;
    case goog.events.KeyCodes.NUMLOCK:
    ;
    case goog.events.KeyCodes.NUM_CENTER:
    ;
    case goog.events.KeyCodes.PAGE_DOWN:
    ;
    case goog.events.KeyCodes.PAGE_UP:
    ;
    case goog.events.KeyCodes.PAUSE:
    ;
    case goog.events.KeyCodes.PHANTOM:
    ;
    case goog.events.KeyCodes.PRINT_SCREEN:
    ;
    case goog.events.KeyCodes.RIGHT:
    ;
    case goog.events.KeyCodes.SCROLL_LOCK:
    ;
    case goog.events.KeyCodes.SHIFT:
    ;
    case goog.events.KeyCodes.UP:
    ;
    case goog.events.KeyCodes.VK_NONAME:
    ;
    case goog.events.KeyCodes.WIN_KEY:
    ;
    case goog.events.KeyCodes.WIN_KEY_RIGHT:
      return false;
    case goog.events.KeyCodes.WIN_KEY_FF_LINUX:
      return !goog.userAgent.GECKO;
    default:
      return e.keyCode < goog.events.KeyCodes.FIRST_MEDIA_KEY || e.keyCode > goog.events.KeyCodes.LAST_MEDIA_KEY;
  }
};
goog.events.KeyCodes.firesKeyPressEvent = function(keyCode, opt_heldKeyCode, opt_shiftKey, opt_ctrlKey, opt_altKey) {
  if (!goog.userAgent.IE && !goog.userAgent.EDGE && !(goog.userAgent.WEBKIT && goog.userAgent.isVersionOrHigher("525"))) {
    return true;
  }
  if (goog.userAgent.MAC && opt_altKey) {
    return goog.events.KeyCodes.isCharacterKey(keyCode);
  }
  if (opt_altKey && !opt_ctrlKey) {
    return false;
  }
  if (goog.isNumber(opt_heldKeyCode)) {
    opt_heldKeyCode = goog.events.KeyCodes.normalizeKeyCode(opt_heldKeyCode);
  }
  if (!opt_shiftKey && (opt_heldKeyCode == goog.events.KeyCodes.CTRL || opt_heldKeyCode == goog.events.KeyCodes.ALT || goog.userAgent.MAC && opt_heldKeyCode == goog.events.KeyCodes.META)) {
    return false;
  }
  if ((goog.userAgent.WEBKIT || goog.userAgent.EDGE) && opt_ctrlKey && opt_shiftKey) {
    switch(keyCode) {
      case goog.events.KeyCodes.BACKSLASH:
      ;
      case goog.events.KeyCodes.OPEN_SQUARE_BRACKET:
      ;
      case goog.events.KeyCodes.CLOSE_SQUARE_BRACKET:
      ;
      case goog.events.KeyCodes.TILDE:
      ;
      case goog.events.KeyCodes.SEMICOLON:
      ;
      case goog.events.KeyCodes.DASH:
      ;
      case goog.events.KeyCodes.EQUALS:
      ;
      case goog.events.KeyCodes.COMMA:
      ;
      case goog.events.KeyCodes.PERIOD:
      ;
      case goog.events.KeyCodes.SLASH:
      ;
      case goog.events.KeyCodes.APOSTROPHE:
      ;
      case goog.events.KeyCodes.SINGLE_QUOTE:
        return false;
    }
  }
  if (goog.userAgent.IE && opt_ctrlKey && opt_heldKeyCode == keyCode) {
    return false;
  }
  switch(keyCode) {
    case goog.events.KeyCodes.ENTER:
      return true;
    case goog.events.KeyCodes.ESC:
      return !(goog.userAgent.WEBKIT || goog.userAgent.EDGE);
  }
  return goog.events.KeyCodes.isCharacterKey(keyCode);
};
goog.events.KeyCodes.isCharacterKey = function(keyCode) {
  if (keyCode >= goog.events.KeyCodes.ZERO && keyCode <= goog.events.KeyCodes.NINE) {
    return true;
  }
  if (keyCode >= goog.events.KeyCodes.NUM_ZERO && keyCode <= goog.events.KeyCodes.NUM_MULTIPLY) {
    return true;
  }
  if (keyCode >= goog.events.KeyCodes.A && keyCode <= goog.events.KeyCodes.Z) {
    return true;
  }
  if ((goog.userAgent.WEBKIT || goog.userAgent.EDGE) && keyCode == 0) {
    return true;
  }
  switch(keyCode) {
    case goog.events.KeyCodes.SPACE:
    ;
    case goog.events.KeyCodes.PLUS_SIGN:
    ;
    case goog.events.KeyCodes.QUESTION_MARK:
    ;
    case goog.events.KeyCodes.AT_SIGN:
    ;
    case goog.events.KeyCodes.NUM_PLUS:
    ;
    case goog.events.KeyCodes.NUM_MINUS:
    ;
    case goog.events.KeyCodes.NUM_PERIOD:
    ;
    case goog.events.KeyCodes.NUM_DIVISION:
    ;
    case goog.events.KeyCodes.SEMICOLON:
    ;
    case goog.events.KeyCodes.FF_SEMICOLON:
    ;
    case goog.events.KeyCodes.DASH:
    ;
    case goog.events.KeyCodes.EQUALS:
    ;
    case goog.events.KeyCodes.FF_EQUALS:
    ;
    case goog.events.KeyCodes.COMMA:
    ;
    case goog.events.KeyCodes.PERIOD:
    ;
    case goog.events.KeyCodes.SLASH:
    ;
    case goog.events.KeyCodes.APOSTROPHE:
    ;
    case goog.events.KeyCodes.SINGLE_QUOTE:
    ;
    case goog.events.KeyCodes.OPEN_SQUARE_BRACKET:
    ;
    case goog.events.KeyCodes.BACKSLASH:
    ;
    case goog.events.KeyCodes.CLOSE_SQUARE_BRACKET:
      return true;
    default:
      return false;
  }
};
goog.events.KeyCodes.normalizeKeyCode = function(keyCode) {
  if (goog.userAgent.GECKO) {
    return goog.events.KeyCodes.normalizeGeckoKeyCode(keyCode);
  } else {
    if (goog.userAgent.MAC && goog.userAgent.WEBKIT) {
      return goog.events.KeyCodes.normalizeMacWebKitKeyCode(keyCode);
    } else {
      return keyCode;
    }
  }
};
goog.events.KeyCodes.normalizeGeckoKeyCode = function(keyCode) {
  switch(keyCode) {
    case goog.events.KeyCodes.FF_EQUALS:
      return goog.events.KeyCodes.EQUALS;
    case goog.events.KeyCodes.FF_SEMICOLON:
      return goog.events.KeyCodes.SEMICOLON;
    case goog.events.KeyCodes.FF_DASH:
      return goog.events.KeyCodes.DASH;
    case goog.events.KeyCodes.MAC_FF_META:
      return goog.events.KeyCodes.META;
    case goog.events.KeyCodes.WIN_KEY_FF_LINUX:
      return goog.events.KeyCodes.WIN_KEY;
    default:
      return keyCode;
  }
};
goog.events.KeyCodes.normalizeMacWebKitKeyCode = function(keyCode) {
  switch(keyCode) {
    case goog.events.KeyCodes.MAC_WK_CMD_RIGHT:
      return goog.events.KeyCodes.META;
    default:
      return keyCode;
  }
};
goog.provide("goog.editor.Field");
goog.provide("goog.editor.Field.EventType");
goog.require("goog.a11y.aria");
goog.require("goog.a11y.aria.Role");
goog.require("goog.array");
goog.require("goog.asserts");
goog.require("goog.async.Delay");
goog.require("goog.dom");
goog.require("goog.dom.Range");
goog.require("goog.dom.TagName");
goog.require("goog.dom.classlist");
goog.require("goog.editor.BrowserFeature");
goog.require("goog.editor.Command");
goog.require("goog.editor.Plugin");
goog.require("goog.editor.icontent");
goog.require("goog.editor.icontent.FieldFormatInfo");
goog.require("goog.editor.icontent.FieldStyleInfo");
goog.require("goog.editor.node");
goog.require("goog.editor.range");
goog.require("goog.events");
goog.require("goog.events.EventHandler");
goog.require("goog.events.EventTarget");
goog.require("goog.events.EventType");
goog.require("goog.events.KeyCodes");
goog.require("goog.functions");
goog.require("goog.log");
goog.require("goog.log.Level");
goog.require("goog.string");
goog.require("goog.string.Unicode");
goog.require("goog.style");
goog.require("goog.userAgent");
goog.require("goog.userAgent.product");
goog.editor.Field = function(id, opt_doc) {
  goog.events.EventTarget.call(this);
  this.id = id;
  this.hashCode_ = id;
  this.editableDomHelper = null;
  this.plugins_ = {};
  this.indexedPlugins_ = {};
  for (var op in goog.editor.Plugin.OPCODE) {
    this.indexedPlugins_[op] = [];
  }
  this.cssStyles = "";
  this.stoppedEvents_ = {};
  this.stopEvent(goog.editor.Field.EventType.CHANGE);
  this.stopEvent(goog.editor.Field.EventType.DELAYEDCHANGE);
  this.isModified_ = false;
  this.isEverModified_ = false;
  this.delayedChangeTimer_ = new goog.async.Delay(this.dispatchDelayedChange_, goog.editor.Field.DELAYED_CHANGE_FREQUENCY, this);
  this.debouncedEvents_ = {};
  for (var key in goog.editor.Field.EventType) {
    this.debouncedEvents_[goog.editor.Field.EventType[key]] = 0;
  }
  if (goog.editor.BrowserFeature.USE_MUTATION_EVENTS) {
    this.changeTimerGecko_ = new goog.async.Delay(this.handleChange, goog.editor.Field.CHANGE_FREQUENCY, this);
  }
  this.eventRegister = new goog.events.EventHandler(this);
  this.wrappers_ = [];
  this.loadState_ = goog.editor.Field.LoadState_.UNEDITABLE;
  var doc = opt_doc || document;
  this.originalDomHelper = goog.dom.getDomHelper(doc);
  this.originalElement = this.originalDomHelper.getElement(this.id);
  this.followLinkInNewWindow_ = goog.editor.BrowserFeature.FOLLOWS_EDITABLE_LINKS;
  this.appWindow_ = this.originalDomHelper.getWindow();
};
goog.inherits(goog.editor.Field, goog.events.EventTarget);
goog.editor.Field.prototype.field = null;
goog.editor.Field.prototype.logger = goog.log.getLogger("goog.editor.Field");
goog.editor.Field.EventType = {COMMAND_VALUE_CHANGE:"cvc", LOAD:"load", UNLOAD:"unload", BEFORECHANGE:"beforechange", CHANGE:"change", DELAYEDCHANGE:"delayedchange", BEFOREFOCUS:"beforefocus", FOCUS:"focus", BLUR:"blur", BEFORETAB:"beforetab", IFRAME_RESIZED:"ifrsz", BEFORESELECTIONCHANGE:"beforeselectionchange", SELECTIONCHANGE:"selectionchange"};
goog.editor.Field.LoadState_ = {UNEDITABLE:0, LOADING:1, EDITABLE:2};
goog.editor.Field.DEBOUNCE_TIME_MS_ = 500;
goog.editor.Field.activeFieldId_ = null;
goog.editor.Field.prototype.inModalMode_ = false;
goog.editor.Field.prototype.appWindow_;
goog.editor.Field.prototype.selectionChangeTarget_;
goog.editor.Field.prototype.useWindowMouseUp_ = false;
goog.editor.Field.prototype.waitingForMouseUp_ = false;
goog.editor.Field.setActiveFieldId = function(fieldId) {
  goog.editor.Field.activeFieldId_ = fieldId;
};
goog.editor.Field.getActiveFieldId = function() {
  return goog.editor.Field.activeFieldId_;
};
goog.editor.Field.prototype.setUseWindowMouseUp = function(flag) {
  goog.asserts.assert(!flag || !this.usesIframe(), "procssing window mouse up should only be enabled when not using iframe");
  this.useWindowMouseUp_ = flag;
};
goog.editor.Field.prototype.inModalMode = function() {
  return this.inModalMode_;
};
goog.editor.Field.prototype.setModalMode = function(inModalMode) {
  this.inModalMode_ = inModalMode;
};
goog.editor.Field.prototype.getHashCode = function() {
  return this.hashCode_;
};
goog.editor.Field.prototype.getElement = function() {
  return this.field;
};
goog.editor.Field.prototype.getOriginalElement = function() {
  return this.originalElement;
};
goog.editor.Field.prototype.addListener = function(type, listener, opt_capture, opt_handler) {
  var elem = this.getElement();
  if (goog.editor.BrowserFeature.USE_DOCUMENT_FOR_KEY_EVENTS && elem && this.usesIframe()) {
    elem = elem.ownerDocument;
  }
  if (opt_handler) {
    this.eventRegister.listenWithScope(elem, type, listener, opt_capture, opt_handler);
  } else {
    this.eventRegister.listen(elem, type, listener, opt_capture);
  }
};
goog.editor.Field.prototype.getPluginByClassId = function(classId) {
  return this.plugins_[classId];
};
goog.editor.Field.prototype.registerPlugin = function(plugin) {
  var classId = plugin.getTrogClassId();
  if (this.plugins_[classId]) {
    goog.log.error(this.logger, "Cannot register the same class of plugin twice.");
  }
  this.plugins_[classId] = plugin;
  for (var op in goog.editor.Plugin.OPCODE) {
    var opcode = goog.editor.Plugin.OPCODE[op];
    if (plugin[opcode]) {
      this.indexedPlugins_[op].push(plugin);
    }
  }
  plugin.registerFieldObject(this);
  if (this.isLoaded()) {
    plugin.enable(this);
  }
};
goog.editor.Field.prototype.unregisterPlugin = function(plugin) {
  var classId = plugin.getTrogClassId();
  if (!this.plugins_[classId]) {
    goog.log.error(this.logger, "Cannot unregister a plugin that isn't registered.");
  }
  delete this.plugins_[classId];
  for (var op in goog.editor.Plugin.OPCODE) {
    var opcode = goog.editor.Plugin.OPCODE[op];
    if (plugin[opcode]) {
      goog.array.remove(this.indexedPlugins_[op], plugin);
    }
  }
  plugin.unregisterFieldObject(this);
};
goog.editor.Field.prototype.setInitialStyle = function(cssText) {
  this.cssText = cssText;
};
goog.editor.Field.prototype.resetOriginalElemProperties = function() {
  var field = this.getOriginalElement();
  field.removeAttribute("contentEditable");
  field.removeAttribute("g_editable");
  field.removeAttribute("role");
  if (!this.id) {
    field.removeAttribute("id");
  } else {
    field.id = this.id;
  }
  field.className = this.savedClassName_ || "";
  var cssText = this.cssText;
  if (!cssText) {
    field.removeAttribute("style");
  } else {
    goog.dom.setProperties(field, {"style":cssText});
  }
  if (goog.isString(this.originalFieldLineHeight_)) {
    goog.style.setStyle(field, "lineHeight", this.originalFieldLineHeight_);
    this.originalFieldLineHeight_ = null;
  }
};
goog.editor.Field.prototype.isModified = function(opt_useIsEverModified) {
  return opt_useIsEverModified ? this.isEverModified_ : this.isModified_;
};
goog.editor.Field.CHANGE_FREQUENCY = 15;
goog.editor.Field.DELAYED_CHANGE_FREQUENCY = 250;
goog.editor.Field.prototype.usesIframe = goog.functions.TRUE;
goog.editor.Field.prototype.isFixedHeight = goog.functions.TRUE;
goog.editor.Field.prototype.shouldRefocusOnInputMobileSafari = goog.functions.FALSE;
goog.editor.Field.KEYS_CAUSING_CHANGES_ = {46:true, 8:true};
if (!goog.userAgent.IE) {
  goog.editor.Field.KEYS_CAUSING_CHANGES_[9] = true;
}
goog.editor.Field.CTRL_KEYS_CAUSING_CHANGES_ = {86:true, 88:true};
if (goog.userAgent.WINDOWS && !goog.userAgent.GECKO) {
  goog.editor.Field.KEYS_CAUSING_CHANGES_[229] = true;
}
goog.editor.Field.isGeneratingKey_ = function(e, testAllKeys) {
  if (goog.editor.Field.isSpecialGeneratingKey_(e)) {
    return true;
  }
  return !!(testAllKeys && !(e.ctrlKey || e.metaKey) && (!goog.userAgent.GECKO || e.charCode));
};
goog.editor.Field.isSpecialGeneratingKey_ = function(e) {
  var testCtrlKeys = (e.ctrlKey || e.metaKey) && e.keyCode in goog.editor.Field.CTRL_KEYS_CAUSING_CHANGES_;
  var testRegularKeys = !(e.ctrlKey || e.metaKey) && e.keyCode in goog.editor.Field.KEYS_CAUSING_CHANGES_;
  return testCtrlKeys || testRegularKeys;
};
goog.editor.Field.prototype.setAppWindow = function(appWindow) {
  this.appWindow_ = appWindow;
};
goog.editor.Field.prototype.getAppWindow = function() {
  return this.appWindow_;
};
goog.editor.Field.prototype.setBaseZindex = function(zindex) {
  this.baseZindex_ = zindex;
};
goog.editor.Field.prototype.getBaseZindex = function() {
  return this.baseZindex_ || 0;
};
goog.editor.Field.prototype.setupFieldObject = function(field) {
  this.loadState_ = goog.editor.Field.LoadState_.EDITABLE;
  this.field = field;
  this.editableDomHelper = goog.dom.getDomHelper(field);
  this.isModified_ = false;
  this.isEverModified_ = false;
  field.setAttribute("g_editable", "true");
  goog.a11y.aria.setRole(field, goog.a11y.aria.Role.TEXTBOX);
};
goog.editor.Field.prototype.tearDownFieldObject_ = function() {
  this.loadState_ = goog.editor.Field.LoadState_.UNEDITABLE;
  for (var classId in this.plugins_) {
    var plugin = this.plugins_[classId];
    if (!plugin.activeOnUneditableFields()) {
      plugin.disable(this);
    }
  }
  this.field = null;
  this.editableDomHelper = null;
};
goog.editor.Field.prototype.setupChangeListeners_ = function() {
  if ((goog.userAgent.product.IPHONE || goog.userAgent.product.IPAD) && this.usesIframe() && this.shouldRefocusOnInputMobileSafari()) {
    var editWindow = this.getEditableDomHelper().getWindow();
    this.boundRefocusListenerMobileSafari_ = goog.bind(editWindow.focus, editWindow);
    editWindow.addEventListener(goog.events.EventType.KEYDOWN, this.boundRefocusListenerMobileSafari_, false);
    editWindow.addEventListener(goog.events.EventType.TOUCHEND, this.boundRefocusListenerMobileSafari_, false);
  }
  if (goog.userAgent.OPERA && this.usesIframe()) {
    this.boundFocusListenerOpera_ = goog.bind(this.dispatchFocusAndBeforeFocus_, this);
    this.boundBlurListenerOpera_ = goog.bind(this.dispatchBlur, this);
    var editWindow = this.getEditableDomHelper().getWindow();
    editWindow.addEventListener(goog.events.EventType.FOCUS, this.boundFocusListenerOpera_, false);
    editWindow.addEventListener(goog.events.EventType.BLUR, this.boundBlurListenerOpera_, false);
  } else {
    if (goog.editor.BrowserFeature.SUPPORTS_FOCUSIN) {
      this.addListener(goog.events.EventType.FOCUS, this.dispatchFocus_);
      this.addListener(goog.events.EventType.FOCUSIN, this.dispatchBeforeFocus_);
    } else {
      this.addListener(goog.events.EventType.FOCUS, this.dispatchFocusAndBeforeFocus_);
    }
    this.addListener(goog.events.EventType.BLUR, this.dispatchBlur, goog.editor.BrowserFeature.USE_MUTATION_EVENTS);
  }
  if (goog.editor.BrowserFeature.USE_MUTATION_EVENTS) {
    this.setupMutationEventHandlersGecko();
  } else {
    this.addListener(["beforecut", "beforepaste", "drop", "dragend"], this.dispatchBeforeChange);
    this.addListener(["cut", "paste"], goog.functions.lock(this.dispatchChange));
    this.addListener("drop", this.handleDrop_);
  }
  var dropEventName = goog.userAgent.WEBKIT ? "dragend" : "dragdrop";
  this.addListener(dropEventName, this.handleDrop_);
  this.addListener(goog.events.EventType.KEYDOWN, this.handleKeyDown_);
  this.addListener(goog.events.EventType.KEYPRESS, this.handleKeyPress_);
  this.addListener(goog.events.EventType.KEYUP, this.handleKeyUp_);
  this.selectionChangeTimer_ = new goog.async.Delay(this.handleSelectionChangeTimer_, goog.editor.Field.SELECTION_CHANGE_FREQUENCY_, this);
  if (this.followLinkInNewWindow_) {
    this.addListener(goog.events.EventType.CLICK, goog.editor.Field.cancelLinkClick_);
  }
  this.addListener(goog.events.EventType.MOUSEDOWN, this.handleMouseDown_);
  if (this.useWindowMouseUp_) {
    this.eventRegister.listen(this.editableDomHelper.getDocument(), goog.events.EventType.MOUSEUP, this.handleMouseUp_);
    this.addListener(goog.events.EventType.DRAGSTART, this.handleDragStart_);
  } else {
    this.addListener(goog.events.EventType.MOUSEUP, this.handleMouseUp_);
  }
};
goog.editor.Field.SELECTION_CHANGE_FREQUENCY_ = 250;
goog.editor.Field.prototype.clearListeners = function() {
  if (this.eventRegister) {
    this.eventRegister.removeAll();
  }
  if ((goog.userAgent.product.IPHONE || goog.userAgent.product.IPAD) && this.usesIframe() && this.shouldRefocusOnInputMobileSafari()) {
    try {
      var editWindow = this.getEditableDomHelper().getWindow();
      editWindow.removeEventListener(goog.events.EventType.KEYDOWN, this.boundRefocusListenerMobileSafari_, false);
      editWindow.removeEventListener(goog.events.EventType.TOUCHEND, this.boundRefocusListenerMobileSafari_, false);
    } catch (e) {
    }
    delete this.boundRefocusListenerMobileSafari_;
  }
  if (goog.userAgent.OPERA && this.usesIframe()) {
    try {
      var editWindow = this.getEditableDomHelper().getWindow();
      editWindow.removeEventListener(goog.events.EventType.FOCUS, this.boundFocusListenerOpera_, false);
      editWindow.removeEventListener(goog.events.EventType.BLUR, this.boundBlurListenerOpera_, false);
    } catch (e$3) {
    }
    delete this.boundFocusListenerOpera_;
    delete this.boundBlurListenerOpera_;
  }
  if (this.changeTimerGecko_) {
    this.changeTimerGecko_.stop();
  }
  this.delayedChangeTimer_.stop();
};
goog.editor.Field.prototype.disposeInternal = function() {
  if (this.isLoading() || this.isLoaded()) {
    goog.log.warning(this.logger, "Disposing a field that is in use.");
  }
  if (this.getOriginalElement()) {
    this.execCommand(goog.editor.Command.CLEAR_LOREM);
  }
  this.tearDownFieldObject_();
  this.clearListeners();
  this.clearFieldLoadListener_();
  this.originalDomHelper = null;
  if (this.eventRegister) {
    this.eventRegister.dispose();
    this.eventRegister = null;
  }
  this.removeAllWrappers();
  if (goog.editor.Field.getActiveFieldId() == this.id) {
    goog.editor.Field.setActiveFieldId(null);
  }
  for (var classId in this.plugins_) {
    var plugin = this.plugins_[classId];
    if (plugin.isAutoDispose()) {
      plugin.dispose();
    }
  }
  delete this.plugins_;
  goog.editor.Field.superClass_.disposeInternal.call(this);
};
goog.editor.Field.prototype.attachWrapper = function(wrapper) {
  this.wrappers_.push(wrapper);
};
goog.editor.Field.prototype.removeAllWrappers = function() {
  var wrapper;
  while (wrapper = this.wrappers_.pop()) {
    wrapper.dispose();
  }
};
goog.editor.Field.prototype.setFollowLinkInNewWindow = function(followLinkInNewWindow) {
  this.followLinkInNewWindow_ = followLinkInNewWindow;
};
goog.editor.Field.MUTATION_EVENTS_GECKO = ["DOMNodeInserted", "DOMNodeRemoved", "DOMNodeRemovedFromDocument", "DOMNodeInsertedIntoDocument", "DOMCharacterDataModified"];
goog.editor.Field.prototype.setupMutationEventHandlersGecko = function() {
  if (goog.editor.BrowserFeature.HAS_DOM_SUBTREE_MODIFIED_EVENT || !this.usesIframe()) {
    this.eventRegister.listen(this.getElement(), "DOMSubtreeModified", this.handleMutationEventGecko_);
  } else {
    var doc = this.getEditableDomHelper().getDocument();
    this.eventRegister.listen(doc, goog.editor.Field.MUTATION_EVENTS_GECKO, this.handleMutationEventGecko_, true);
    this.eventRegister.listen(doc, "DOMAttrModified", goog.bind(this.handleDomAttrChange, this, this.handleMutationEventGecko_), true);
  }
};
goog.editor.Field.prototype.handleBeforeChangeKeyEvent_ = function(e) {
  var block = e.keyCode == goog.events.KeyCodes.TAB && !this.dispatchBeforeTab_(e) || goog.userAgent.GECKO && e.metaKey && !goog.userAgent.isVersionOrHigher(29) && (e.keyCode == goog.events.KeyCodes.LEFT || e.keyCode == goog.events.KeyCodes.RIGHT);
  if (block) {
    e.preventDefault();
    return false;
  } else {
    this.gotGeneratingKey_ = e.charCode || goog.editor.Field.isGeneratingKey_(e, goog.userAgent.GECKO);
    if (this.gotGeneratingKey_) {
      this.dispatchBeforeChange();
    }
  }
  return true;
};
goog.editor.Field.SELECTION_CHANGE_KEYCODES = {8:1, 9:1, 13:1, 33:1, 34:1, 35:1, 36:1, 37:1, 38:1, 39:1, 40:1, 46:1};
goog.editor.Field.CTRL_KEYS_CAUSING_SELECTION_CHANGES_ = {65:true, 86:true, 88:true};
goog.editor.Field.POTENTIAL_SHORTCUT_KEYCODES_ = {8:1, 9:1, 13:1, 27:1, 33:1, 34:1, 37:1, 38:1, 39:1, 40:1};
goog.editor.Field.prototype.invokeShortCircuitingOp_ = function(op, var_args) {
  var plugins = this.indexedPlugins_[op];
  var argList = goog.array.slice(arguments, 1);
  for (var i = 0;i < plugins.length;++i) {
    var plugin = plugins[i];
    if ((plugin.isEnabled(this) || goog.editor.Plugin.IRREPRESSIBLE_OPS[op]) && plugin[goog.editor.Plugin.OPCODE[op]].apply(plugin, argList)) {
      return true;
    }
  }
  return false;
};
goog.editor.Field.prototype.invokeOp_ = function(op, var_args) {
  var plugins = this.indexedPlugins_[op];
  var argList = goog.array.slice(arguments, 1);
  for (var i = 0;i < plugins.length;++i) {
    var plugin = plugins[i];
    if (plugin.isEnabled(this) || goog.editor.Plugin.IRREPRESSIBLE_OPS[op]) {
      plugin[goog.editor.Plugin.OPCODE[op]].apply(plugin, argList);
    }
  }
};
goog.editor.Field.prototype.reduceOp_ = function(op, arg, var_args) {
  var plugins = this.indexedPlugins_[op];
  var argList = goog.array.slice(arguments, 1);
  for (var i = 0;i < plugins.length;++i) {
    var plugin = plugins[i];
    if (plugin.isEnabled(this) || goog.editor.Plugin.IRREPRESSIBLE_OPS[op]) {
      argList[0] = plugin[goog.editor.Plugin.OPCODE[op]].apply(plugin, argList);
    }
  }
  return argList[0];
};
goog.editor.Field.prototype.injectContents = function(contents, field) {
  var styles = {};
  var newHtml = this.getInjectableContents(contents, styles);
  goog.style.setStyle(field, styles);
  goog.editor.node.replaceInnerHtml(field, newHtml);
};
goog.editor.Field.prototype.getInjectableContents = function(contents, styles) {
  return this.reduceOp_(goog.editor.Plugin.Op.PREPARE_CONTENTS_HTML, contents || "", styles);
};
goog.editor.Field.prototype.handleKeyDown_ = function(e) {
  if (goog.userAgent.MAC && e.keyCode == goog.events.KeyCodes.A) {
    this.maybeStartSelectionChangeTimer_(e);
  }
  if (!goog.editor.BrowserFeature.USE_MUTATION_EVENTS) {
    if (!this.handleBeforeChangeKeyEvent_(e)) {
      return;
    }
  }
  if (!this.invokeShortCircuitingOp_(goog.editor.Plugin.Op.KEYDOWN, e) && goog.editor.BrowserFeature.USES_KEYDOWN) {
    this.handleKeyboardShortcut_(e);
  }
};
goog.editor.Field.prototype.handleKeyPress_ = function(e) {
  if (goog.editor.BrowserFeature.USE_MUTATION_EVENTS) {
    if (!this.handleBeforeChangeKeyEvent_(e)) {
      return;
    }
  } else {
    this.gotGeneratingKey_ = true;
    this.dispatchBeforeChange();
  }
  if (!this.invokeShortCircuitingOp_(goog.editor.Plugin.Op.KEYPRESS, e) && !goog.editor.BrowserFeature.USES_KEYDOWN) {
    this.handleKeyboardShortcut_(e);
  }
};
goog.editor.Field.prototype.handleKeyUp_ = function(e) {
  if (!goog.editor.BrowserFeature.USE_MUTATION_EVENTS && (this.gotGeneratingKey_ || goog.editor.Field.isSpecialGeneratingKey_(e))) {
    this.handleChange();
  }
  this.invokeShortCircuitingOp_(goog.editor.Plugin.Op.KEYUP, e);
  this.maybeStartSelectionChangeTimer_(e);
};
goog.editor.Field.prototype.maybeStartSelectionChangeTimer_ = function(e) {
  if (this.isEventStopped(goog.editor.Field.EventType.SELECTIONCHANGE)) {
    return;
  }
  if (goog.editor.Field.SELECTION_CHANGE_KEYCODES[e.keyCode] || (e.ctrlKey || e.metaKey) && goog.editor.Field.CTRL_KEYS_CAUSING_SELECTION_CHANGES_[e.keyCode]) {
    this.dispatchEvent(goog.editor.Field.EventType.BEFORESELECTIONCHANGE);
    this.selectionChangeTimer_.start();
  }
};
goog.editor.Field.prototype.handleKeyboardShortcut_ = function(e) {
  if (e.altKey) {
    return;
  }
  var isModifierPressed = goog.userAgent.MAC ? e.metaKey : e.ctrlKey;
  if (isModifierPressed || goog.editor.Field.POTENTIAL_SHORTCUT_KEYCODES_[e.keyCode]) {
    var key = e.charCode || e.keyCode;
    if (key == 17) {
      return;
    }
    var stringKey = String.fromCharCode(key).toLowerCase();
    if (goog.userAgent.MAC && goog.userAgent.GECKO && stringKey == "`" && e.getBrowserEvent().key == " ") {
      stringKey = " ";
    }
    if (this.invokeShortCircuitingOp_(goog.editor.Plugin.Op.SHORTCUT, e, stringKey, isModifierPressed)) {
      e.preventDefault();
    }
  }
};
goog.editor.Field.prototype.execCommand = function(command, var_args) {
  var args = arguments;
  var result;
  var plugins = this.indexedPlugins_[goog.editor.Plugin.Op.EXEC_COMMAND];
  for (var i = 0;i < plugins.length;++i) {
    var plugin = plugins[i];
    if (plugin.isEnabled(this) && plugin.isSupportedCommand(command)) {
      result = plugin.execCommand.apply(plugin, args);
      break;
    }
  }
  return result;
};
goog.editor.Field.prototype.queryCommandValue = function(commands) {
  var isEditable = this.isLoaded() && this.isSelectionEditable();
  if (goog.isString(commands)) {
    return this.queryCommandValueInternal_(commands, isEditable);
  } else {
    var state = {};
    for (var i = 0;i < commands.length;i++) {
      state[commands[i]] = this.queryCommandValueInternal_(commands[i], isEditable);
    }
    return state;
  }
};
goog.editor.Field.prototype.queryCommandValueInternal_ = function(command, isEditable) {
  var plugins = this.indexedPlugins_[goog.editor.Plugin.Op.QUERY_COMMAND];
  for (var i = 0;i < plugins.length;++i) {
    var plugin = plugins[i];
    if (plugin.isEnabled(this) && plugin.isSupportedCommand(command) && (isEditable || plugin.activeOnUneditableFields())) {
      return plugin.queryCommandValue(command);
    }
  }
  return isEditable ? null : false;
};
goog.editor.Field.prototype.handleDomAttrChange = function(handler, browserEvent) {
  if (this.isEventStopped(goog.editor.Field.EventType.CHANGE)) {
    return;
  }
  var e = browserEvent.getBrowserEvent();
  try {
    if (e.originalTarget.prefix || e.originalTarget.nodeName == "scrollbar") {
      return;
    }
  } catch (ex1) {
    return;
  }
  if (e.prevValue == e.newValue) {
    return;
  }
  handler.call(this, e);
};
goog.editor.Field.prototype.handleMutationEventGecko_ = function(e) {
  if (this.isEventStopped(goog.editor.Field.EventType.CHANGE)) {
    return;
  }
  e = e.getBrowserEvent ? e.getBrowserEvent() : e;
  if (e.target.firebugIgnore) {
    return;
  }
  this.isModified_ = true;
  this.isEverModified_ = true;
  this.changeTimerGecko_.start();
};
goog.editor.Field.prototype.handleDrop_ = function(e) {
  if (goog.userAgent.IE) {
    this.execCommand(goog.editor.Command.CLEAR_LOREM, true);
  }
  if (goog.editor.BrowserFeature.USE_MUTATION_EVENTS) {
    this.dispatchFocusAndBeforeFocus_();
  }
  this.dispatchChange();
};
goog.editor.Field.prototype.getEditableIframe = function() {
  var dh;
  if (this.usesIframe() && (dh = this.getEditableDomHelper())) {
    var win = dh.getWindow();
    return (win && win.frameElement);
  }
  return null;
};
goog.editor.Field.prototype.getEditableDomHelper = function() {
  return this.editableDomHelper;
};
goog.editor.Field.prototype.getRange = function() {
  var win = this.editableDomHelper && this.editableDomHelper.getWindow();
  return win && goog.dom.Range.createFromWindow(win);
};
goog.editor.Field.prototype.dispatchSelectionChangeEvent = function(opt_e, opt_target) {
  if (this.isEventStopped(goog.editor.Field.EventType.SELECTIONCHANGE)) {
    return;
  }
  var range = this.getRange();
  var rangeContainer = range && range.getContainerElement();
  this.isSelectionEditable_ = !!rangeContainer && goog.dom.contains(this.getElement(), rangeContainer);
  this.dispatchCommandValueChange();
  this.dispatchEvent({type:goog.editor.Field.EventType.SELECTIONCHANGE, originalType:opt_e && opt_e.type});
  this.invokeShortCircuitingOp_(goog.editor.Plugin.Op.SELECTION, opt_e, opt_target);
};
goog.editor.Field.prototype.handleSelectionChangeTimer_ = function() {
  var t = this.selectionChangeTarget_;
  this.selectionChangeTarget_ = null;
  this.dispatchSelectionChangeEvent(undefined, t);
};
goog.editor.Field.prototype.dispatchBeforeChange = function() {
  if (this.isEventStopped(goog.editor.Field.EventType.BEFORECHANGE)) {
    return;
  }
  this.dispatchEvent(goog.editor.Field.EventType.BEFORECHANGE);
};
goog.editor.Field.prototype.dispatchBeforeTab_ = function(e) {
  return this.dispatchEvent({type:goog.editor.Field.EventType.BEFORETAB, shiftKey:e.shiftKey, altKey:e.altKey, ctrlKey:e.ctrlKey});
};
goog.editor.Field.prototype.stopChangeEvents = function(opt_stopChange, opt_stopDelayedChange) {
  if (opt_stopChange) {
    if (this.changeTimerGecko_) {
      this.changeTimerGecko_.fireIfActive();
    }
    this.stopEvent(goog.editor.Field.EventType.CHANGE);
  }
  if (opt_stopDelayedChange) {
    this.clearDelayedChange();
    this.stopEvent(goog.editor.Field.EventType.DELAYEDCHANGE);
  }
};
goog.editor.Field.prototype.startChangeEvents = function(opt_fireChange, opt_fireDelayedChange) {
  if (!opt_fireChange && this.changeTimerGecko_) {
    this.changeTimerGecko_.fireIfActive();
  }
  this.startEvent(goog.editor.Field.EventType.CHANGE);
  this.startEvent(goog.editor.Field.EventType.DELAYEDCHANGE);
  if (opt_fireChange) {
    this.handleChange();
  }
  if (opt_fireDelayedChange) {
    this.dispatchDelayedChange_();
  }
};
goog.editor.Field.prototype.stopEvent = function(eventType) {
  this.stoppedEvents_[eventType] = 1;
};
goog.editor.Field.prototype.startEvent = function(eventType) {
  this.stoppedEvents_[eventType] = 0;
};
goog.editor.Field.prototype.debounceEvent = function(eventType) {
  this.debouncedEvents_[eventType] = goog.now();
};
goog.editor.Field.prototype.isEventStopped = function(eventType) {
  return !!this.stoppedEvents_[eventType] || this.debouncedEvents_[eventType] && goog.now() - this.debouncedEvents_[eventType] <= goog.editor.Field.DEBOUNCE_TIME_MS_;
};
goog.editor.Field.prototype.manipulateDom = function(func, opt_preventDelayedChange, opt_handler) {
  this.stopChangeEvents(true, true);
  try {
    func.call(opt_handler);
  } finally {
    if (this.isLoaded()) {
      if (opt_preventDelayedChange) {
        this.startEvent(goog.editor.Field.EventType.CHANGE);
        this.handleChange();
        this.startEvent(goog.editor.Field.EventType.DELAYEDCHANGE);
      } else {
        this.dispatchChange();
      }
    }
  }
};
goog.editor.Field.prototype.dispatchCommandValueChange = function(opt_commands) {
  if (opt_commands) {
    this.dispatchEvent({type:goog.editor.Field.EventType.COMMAND_VALUE_CHANGE, commands:opt_commands});
  } else {
    this.dispatchEvent(goog.editor.Field.EventType.COMMAND_VALUE_CHANGE);
  }
};
goog.editor.Field.prototype.dispatchChange = function(opt_noDelay) {
  this.startChangeEvents(true, opt_noDelay);
};
goog.editor.Field.prototype.handleChange = function() {
  if (this.isEventStopped(goog.editor.Field.EventType.CHANGE)) {
    return;
  }
  if (this.changeTimerGecko_) {
    this.changeTimerGecko_.stop();
  }
  this.isModified_ = true;
  this.isEverModified_ = true;
  if (this.isEventStopped(goog.editor.Field.EventType.DELAYEDCHANGE)) {
    return;
  }
  this.delayedChangeTimer_.start();
};
goog.editor.Field.prototype.dispatchDelayedChange_ = function() {
  if (this.isEventStopped(goog.editor.Field.EventType.DELAYEDCHANGE)) {
    return;
  }
  this.delayedChangeTimer_.stop();
  this.isModified_ = false;
  this.dispatchEvent(goog.editor.Field.EventType.DELAYEDCHANGE);
};
goog.editor.Field.prototype.clearDelayedChange = function() {
  if (this.changeTimerGecko_) {
    this.changeTimerGecko_.fireIfActive();
  }
  this.delayedChangeTimer_.fireIfActive();
};
goog.editor.Field.prototype.dispatchFocusAndBeforeFocus_ = function() {
  this.dispatchBeforeFocus_();
  this.dispatchFocus_();
};
goog.editor.Field.prototype.dispatchBeforeFocus_ = function() {
  if (this.isEventStopped(goog.editor.Field.EventType.BEFOREFOCUS)) {
    return;
  }
  this.execCommand(goog.editor.Command.CLEAR_LOREM, true);
  this.dispatchEvent(goog.editor.Field.EventType.BEFOREFOCUS);
};
goog.editor.Field.prototype.dispatchFocus_ = function() {
  if (this.isEventStopped(goog.editor.Field.EventType.FOCUS)) {
    return;
  }
  goog.editor.Field.setActiveFieldId(this.id);
  this.isSelectionEditable_ = true;
  this.dispatchEvent(goog.editor.Field.EventType.FOCUS);
  if (goog.editor.BrowserFeature.PUTS_CURSOR_BEFORE_FIRST_BLOCK_ELEMENT_ON_FOCUS) {
    var field = this.getElement();
    var range = this.getRange();
    if (range) {
      var focusNode = (range.getFocusNode());
      if (range.getFocusOffset() == 0 && (!focusNode || focusNode == field || focusNode.tagName == goog.dom.TagName.BODY)) {
        goog.editor.range.selectNodeStart(field);
      }
    }
  }
  if (!goog.editor.BrowserFeature.CLEARS_SELECTION_WHEN_FOCUS_LEAVES && this.usesIframe()) {
    var parent = this.getEditableDomHelper().getWindow().parent;
    parent.getSelection().removeAllRanges();
  }
};
goog.editor.Field.prototype.dispatchBlur = function() {
  if (this.isEventStopped(goog.editor.Field.EventType.BLUR)) {
    return;
  }
  if (goog.editor.Field.getActiveFieldId() == this.id) {
    goog.editor.Field.setActiveFieldId(null);
  }
  this.isSelectionEditable_ = false;
  this.dispatchEvent(goog.editor.Field.EventType.BLUR);
};
goog.editor.Field.prototype.isSelectionEditable = function() {
  return this.isSelectionEditable_;
};
goog.editor.Field.cancelLinkClick_ = function(e) {
  if (goog.dom.getAncestorByTagNameAndClass((e.target), goog.dom.TagName.A)) {
    e.preventDefault();
  }
};
goog.editor.Field.prototype.handleMouseDown_ = function(e) {
  goog.editor.Field.setActiveFieldId(this.id);
  if (goog.userAgent.IE) {
    var targetElement = e.target;
    if (targetElement && (targetElement).tagName == goog.dom.TagName.A && e.ctrlKey) {
      this.originalDomHelper.getWindow().open(targetElement.href);
    }
  }
  this.waitingForMouseUp_ = true;
};
goog.editor.Field.prototype.handleDragStart_ = function(e) {
  this.waitingForMouseUp_ = false;
};
goog.editor.Field.prototype.handleMouseUp_ = function(e) {
  if (this.useWindowMouseUp_ && !this.waitingForMouseUp_) {
    return;
  }
  this.waitingForMouseUp_ = false;
  this.dispatchEvent(goog.editor.Field.EventType.BEFORESELECTIONCHANGE);
  this.dispatchSelectionChangeEvent(e);
  if (goog.userAgent.IE) {
    this.selectionChangeTarget_ = (e.target);
    this.selectionChangeTimer_.start();
  }
};
goog.editor.Field.prototype.getCleanContents = function() {
  if (this.queryCommandValue(goog.editor.Command.USING_LOREM)) {
    return goog.string.Unicode.NBSP;
  }
  if (!this.isLoaded()) {
    var elem = this.getOriginalElement();
    if (!elem) {
      goog.log.log(this.logger, goog.log.Level.SHOUT, "Couldn't get the field element to read the contents");
    }
    return elem.innerHTML;
  }
  var fieldCopy = this.getFieldCopy();
  this.invokeOp_(goog.editor.Plugin.Op.CLEAN_CONTENTS_DOM, fieldCopy);
  return this.reduceOp_(goog.editor.Plugin.Op.CLEAN_CONTENTS_HTML, fieldCopy.innerHTML);
};
goog.editor.Field.prototype.getFieldCopy = function() {
  var field = this.getElement();
  var fieldCopy = (field.cloneNode(false));
  var html = field.innerHTML;
  if (goog.userAgent.IE && html.match(/^\s*<script/i)) {
    html = goog.string.Unicode.NBSP + html;
  }
  fieldCopy.innerHTML = html;
  return fieldCopy;
};
goog.editor.Field.prototype.setHtml = function(addParas, html, opt_dontFireDelayedChange, opt_applyLorem) {
  if (this.isLoading()) {
    goog.log.error(this.logger, "Can't set html while loading Trogedit");
    return;
  }
  if (opt_applyLorem) {
    this.execCommand(goog.editor.Command.CLEAR_LOREM);
  }
  if (html && addParas) {
    html = "<p>" + html + "</p>";
  }
  if (opt_dontFireDelayedChange) {
    this.stopChangeEvents(false, true);
  }
  this.setInnerHtml_(html);
  if (opt_applyLorem) {
    this.execCommand(goog.editor.Command.UPDATE_LOREM);
  }
  if (this.isLoaded()) {
    if (opt_dontFireDelayedChange) {
      if (goog.editor.BrowserFeature.USE_MUTATION_EVENTS) {
        this.changeTimerGecko_.fireIfActive();
      }
      this.startChangeEvents();
    } else {
      this.dispatchChange();
    }
  }
};
goog.editor.Field.prototype.setInnerHtml_ = function(html) {
  var field = this.getElement();
  if (field) {
    if (this.usesIframe() && goog.editor.BrowserFeature.MOVES_STYLE_TO_HEAD) {
      var heads = field.ownerDocument.getElementsByTagName(goog.dom.TagName.HEAD);
      for (var i = heads.length - 1;i >= 1;--i) {
        heads[i].parentNode.removeChild(heads[i]);
      }
    }
  } else {
    field = this.getOriginalElement();
  }
  if (field) {
    this.injectContents(html, field);
  }
};
goog.editor.Field.prototype.turnOnDesignModeGecko = function() {
  var doc = this.getEditableDomHelper().getDocument();
  doc.designMode = "on";
  if (goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS) {
    doc.execCommand("styleWithCSS", false, false);
  }
};
goog.editor.Field.prototype.installStyles = function() {
  if (this.cssStyles && this.shouldLoadAsynchronously()) {
    goog.style.installStyles(this.cssStyles, this.getElement());
  }
};
goog.editor.Field.prototype.dispatchLoadEvent_ = function() {
  var field = this.getElement();
  this.installStyles();
  this.startChangeEvents();
  goog.log.info(this.logger, "Dispatching load " + this.id);
  this.dispatchEvent(goog.editor.Field.EventType.LOAD);
};
goog.editor.Field.prototype.isUneditable = function() {
  return this.loadState_ == goog.editor.Field.LoadState_.UNEDITABLE;
};
goog.editor.Field.prototype.isLoaded = function() {
  return this.loadState_ == goog.editor.Field.LoadState_.EDITABLE;
};
goog.editor.Field.prototype.isLoading = function() {
  return this.loadState_ == goog.editor.Field.LoadState_.LOADING;
};
goog.editor.Field.prototype.focus = function() {
  if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE && this.usesIframe()) {
    this.getEditableDomHelper().getWindow().focus();
  } else {
    if (goog.userAgent.OPERA) {
      var scrollX = this.appWindow_.pageXOffset;
      var scrollY = this.appWindow_.pageYOffset;
    }
    this.getElement().focus();
    if (goog.userAgent.OPERA) {
      this.appWindow_.scrollTo((scrollX), (scrollY));
    }
  }
};
goog.editor.Field.prototype.focusAndPlaceCursorAtStart = function() {
  if (goog.editor.BrowserFeature.HAS_IE_RANGES || !goog.userAgent.GECKO) {
    this.placeCursorAtStart();
  }
  this.focus();
};
goog.editor.Field.prototype.placeCursorAtStart = function() {
  this.placeCursorAtStartOrEnd_(true);
};
goog.editor.Field.prototype.placeCursorAtEnd = function() {
  this.placeCursorAtStartOrEnd_(false);
};
goog.editor.Field.prototype.placeCursorAtStartOrEnd_ = function(isStart) {
  var field = this.getElement();
  if (field) {
    var cursorPosition = isStart ? goog.editor.node.getLeftMostLeaf(field) : goog.editor.node.getRightMostLeaf(field);
    if (field == cursorPosition) {
      goog.dom.Range.createCaret(field, 0).select();
    } else {
      goog.editor.range.placeCursorNextTo(cursorPosition, isStart);
    }
    this.dispatchSelectionChangeEvent();
  }
};
goog.editor.Field.prototype.restoreSavedRange = function(opt_range) {
  if (opt_range) {
    opt_range.restore();
  }
  this.focus();
};
goog.editor.Field.prototype.makeEditable = function(opt_iframeSrc) {
  this.loadState_ = goog.editor.Field.LoadState_.LOADING;
  var field = this.getOriginalElement();
  this.nodeName = field.nodeName;
  this.savedClassName_ = field.className;
  this.setInitialStyle(field.style.cssText);
  goog.dom.classlist.add(field, "editable");
  this.makeEditableInternal(opt_iframeSrc);
};
goog.editor.Field.prototype.makeEditableInternal = function(opt_iframeSrc) {
  this.makeIframeField_(opt_iframeSrc);
};
goog.editor.Field.prototype.handleFieldLoad = function() {
  if (goog.userAgent.IE) {
    goog.dom.Range.clearSelection(this.editableDomHelper.getWindow());
  }
  if (goog.editor.Field.getActiveFieldId() != this.id) {
    this.execCommand(goog.editor.Command.UPDATE_LOREM);
  }
  this.setupChangeListeners_();
  this.dispatchLoadEvent_();
  for (var classId in this.plugins_) {
    this.plugins_[classId].enable(this);
  }
};
goog.editor.Field.prototype.makeUneditable = function(opt_skipRestore) {
  if (this.isUneditable()) {
    throw Error("makeUneditable: Field is already uneditable");
  }
  this.clearDelayedChange();
  this.selectionChangeTimer_.fireIfActive();
  this.execCommand(goog.editor.Command.CLEAR_LOREM);
  var html = null;
  if (!opt_skipRestore && this.getElement()) {
    html = this.getCleanContents();
  }
  this.clearFieldLoadListener_();
  var field = this.getOriginalElement();
  if (goog.editor.Field.getActiveFieldId() == field.id) {
    goog.editor.Field.setActiveFieldId(null);
  }
  this.clearListeners();
  if (goog.isString(html)) {
    goog.editor.node.replaceInnerHtml(field, html);
    this.resetOriginalElemProperties();
  }
  this.restoreDom();
  this.tearDownFieldObject_();
  if (goog.userAgent.WEBKIT) {
    field.blur();
  }
  this.execCommand(goog.editor.Command.UPDATE_LOREM);
  this.dispatchEvent(goog.editor.Field.EventType.UNLOAD);
};
goog.editor.Field.prototype.restoreDom = function() {
  var field = this.getOriginalElement();
  if (field) {
    var iframe = this.getEditableIframe();
    if (iframe) {
      goog.dom.replaceNode(field, iframe);
    }
  }
};
goog.editor.Field.prototype.shouldLoadAsynchronously = function() {
  if (!goog.isDef(this.isHttps_)) {
    this.isHttps_ = false;
    if (goog.userAgent.IE && this.usesIframe()) {
      var win = this.originalDomHelper.getWindow();
      while (win != win.parent) {
        try {
          win = win.parent;
        } catch (e) {
          break;
        }
      }
      var loc = win.location;
      this.isHttps_ = loc.protocol == "https:" && loc.search.indexOf("nocheckhttps") == -1;
    }
  }
  return this.isHttps_;
};
goog.editor.Field.prototype.makeIframeField_ = function(opt_iframeSrc) {
  var field = this.getOriginalElement();
  if (field) {
    var html = field.innerHTML;
    var styles = {};
    html = this.reduceOp_(goog.editor.Plugin.Op.PREPARE_CONTENTS_HTML, html, styles);
    var iframe = (this.originalDomHelper.createDom(goog.dom.TagName.IFRAME, this.getIframeAttributes()));
    if (this.shouldLoadAsynchronously()) {
      var onLoad = goog.bind(this.iframeFieldLoadHandler, this, iframe, html, styles);
      this.fieldLoadListenerKey_ = goog.events.listen(iframe, goog.events.EventType.LOAD, onLoad, true);
      if (opt_iframeSrc) {
        iframe.src = opt_iframeSrc;
      }
    }
    this.attachIframe(iframe);
    if (!this.shouldLoadAsynchronously()) {
      this.iframeFieldLoadHandler(iframe, html, styles);
    }
  }
};
goog.editor.Field.prototype.attachIframe = function(iframe) {
  var field = this.getOriginalElement();
  iframe.className = field.className;
  iframe.id = field.id;
  goog.dom.replaceNode(iframe, field);
};
goog.editor.Field.prototype.getFieldFormatInfo = function(extraStyles) {
  var originalElement = this.getOriginalElement();
  var isStandardsMode = goog.editor.node.isStandardsMode(originalElement);
  return new goog.editor.icontent.FieldFormatInfo(this.id, isStandardsMode, false, false, extraStyles);
};
goog.editor.Field.prototype.writeIframeContent = function(iframe, innerHtml, extraStyles) {
  var formatInfo = this.getFieldFormatInfo(extraStyles);
  if (this.shouldLoadAsynchronously()) {
    var doc = goog.dom.getFrameContentDocument(iframe);
    goog.editor.icontent.writeHttpsInitialIframe(formatInfo, doc, innerHtml);
  } else {
    var styleInfo = new goog.editor.icontent.FieldStyleInfo(this.getElement(), this.cssStyles);
    goog.editor.icontent.writeNormalInitialIframe(formatInfo, innerHtml, styleInfo, iframe);
  }
};
goog.editor.Field.prototype.iframeFieldLoadHandler = function(iframe, innerHtml, styles) {
  this.clearFieldLoadListener_();
  iframe.allowTransparency = "true";
  this.writeIframeContent(iframe, innerHtml, styles);
  var doc = goog.dom.getFrameContentDocument(iframe);
  var body = doc.body;
  this.setupFieldObject(body);
  if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE && this.usesIframe()) {
    this.turnOnDesignModeGecko();
  }
  this.handleFieldLoad();
};
goog.editor.Field.prototype.clearFieldLoadListener_ = function() {
  if (this.fieldLoadListenerKey_) {
    goog.events.unlistenByKey(this.fieldLoadListenerKey_);
    this.fieldLoadListenerKey_ = null;
  }
};
goog.editor.Field.prototype.getIframeAttributes = function() {
  var iframeStyle = "padding:0;" + this.getOriginalElement().style.cssText;
  if (!goog.string.endsWith(iframeStyle, ";")) {
    iframeStyle += ";";
  }
  iframeStyle += "background-color:white;";
  if (goog.userAgent.IE) {
    iframeStyle += "overflow:visible;";
  }
  return {"frameBorder":0, "style":iframeStyle};
};
goog.provide("goog.cssom");
goog.provide("goog.cssom.CssRuleType");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.TagName");
goog.cssom.CssRuleType = {STYLE:1, IMPORT:3, MEDIA:4, FONT_FACE:5, PAGE:6, NAMESPACE:7};
goog.cssom.getAllCssText = function(opt_styleSheet) {
  var styleSheet = opt_styleSheet || document.styleSheets;
  return (goog.cssom.getAllCss_(styleSheet, true));
};
goog.cssom.getAllCssStyleRules = function(opt_styleSheet) {
  var styleSheet = opt_styleSheet || document.styleSheets;
  return (goog.cssom.getAllCss_(styleSheet, false));
};
goog.cssom.getCssRulesFromStyleSheet = function(styleSheet) {
  var cssRuleList = null;
  try {
    cssRuleList = styleSheet.cssRules || styleSheet.rules;
  } catch (e) {
    if (e.code == 15) {
      e.styleSheet = styleSheet;
      throw e;
    }
  }
  return cssRuleList;
};
goog.cssom.getAllCssStyleSheets = function(opt_styleSheet, opt_includeDisabled) {
  var styleSheetsOutput = [];
  var styleSheet = opt_styleSheet || document.styleSheets;
  var includeDisabled = goog.isDef(opt_includeDisabled) ? opt_includeDisabled : false;
  if (styleSheet.imports && styleSheet.imports.length) {
    for (var i = 0, n = styleSheet.imports.length;i < n;i++) {
      goog.array.extend(styleSheetsOutput, goog.cssom.getAllCssStyleSheets((styleSheet.imports[i])));
    }
  } else {
    if (styleSheet.length) {
      for (var i = 0, n = styleSheet.length;i < n;i++) {
        goog.array.extend(styleSheetsOutput, goog.cssom.getAllCssStyleSheets(styleSheet[i]));
      }
    } else {
      var cssRuleList = goog.cssom.getCssRulesFromStyleSheet((styleSheet));
      if (cssRuleList && cssRuleList.length) {
        for (var i = 0, n = cssRuleList.length, cssRule;i < n;i++) {
          cssRule = cssRuleList[i];
          if (cssRule.styleSheet) {
            goog.array.extend(styleSheetsOutput, goog.cssom.getAllCssStyleSheets(cssRule.styleSheet));
          }
        }
      }
    }
  }
  if ((styleSheet.type || styleSheet.rules || styleSheet.cssRules) && (!styleSheet.disabled || includeDisabled)) {
    styleSheetsOutput.push(styleSheet);
  }
  return styleSheetsOutput;
};
goog.cssom.getCssTextFromCssRule = function(cssRule) {
  var cssText = "";
  if (cssRule.cssText) {
    cssText = cssRule.cssText;
  } else {
    if (cssRule.style && cssRule.style.cssText && cssRule.selectorText) {
      var styleCssText = cssRule.style.cssText.replace(/\s*-closure-parent-stylesheet:\s*\[object\];?\s*/gi, "").replace(/\s*-closure-rule-index:\s*[\d]+;?\s*/gi, "");
      var thisCssText = cssRule.selectorText + " { " + styleCssText + " }";
      cssText = thisCssText;
    }
  }
  return cssText;
};
goog.cssom.getCssRuleIndexInParentStyleSheet = function(cssRule, opt_parentStyleSheet) {
  if (cssRule.style && cssRule.style["-closure-rule-index"]) {
    return cssRule.style["-closure-rule-index"];
  }
  var parentStyleSheet = opt_parentStyleSheet || goog.cssom.getParentStyleSheet(cssRule);
  if (!parentStyleSheet) {
    throw Error("Cannot find a parentStyleSheet.");
  }
  var cssRuleList = goog.cssom.getCssRulesFromStyleSheet(parentStyleSheet);
  if (cssRuleList && cssRuleList.length) {
    for (var i = 0, n = cssRuleList.length, thisCssRule;i < n;i++) {
      thisCssRule = cssRuleList[i];
      if (thisCssRule == cssRule) {
        return i;
      }
    }
  }
  return -1;
};
goog.cssom.getParentStyleSheet = function(cssRule) {
  return cssRule.parentStyleSheet || cssRule.style && cssRule.style["-closure-parent-stylesheet"];
};
goog.cssom.replaceCssRule = function(cssRule, cssText, opt_parentStyleSheet, opt_index) {
  var parentStyleSheet = opt_parentStyleSheet || goog.cssom.getParentStyleSheet(cssRule);
  if (parentStyleSheet) {
    var index = Number(opt_index) >= 0 ? Number(opt_index) : goog.cssom.getCssRuleIndexInParentStyleSheet(cssRule, parentStyleSheet);
    if (index >= 0) {
      goog.cssom.removeCssRule(parentStyleSheet, index);
      goog.cssom.addCssRule(parentStyleSheet, cssText, index);
    } else {
      throw Error("Cannot proceed without the index of the cssRule.");
    }
  } else {
    throw Error("Cannot proceed without the parentStyleSheet.");
  }
};
goog.cssom.addCssRule = function(cssStyleSheet, cssText, opt_index) {
  var index = opt_index;
  if (index == undefined || index < 0) {
    var rules = goog.cssom.getCssRulesFromStyleSheet(cssStyleSheet);
    index = rules.length;
  }
  if (cssStyleSheet.insertRule) {
    cssStyleSheet.insertRule(cssText, index);
  } else {
    var matches = /^([^\{]+)\{([^\{]+)\}/.exec(cssText);
    if (matches.length == 3) {
      var selector = matches[1];
      var style = matches[2];
      cssStyleSheet.addRule(selector, style, index);
    } else {
      throw Error("Your CSSRule appears to be ill-formatted.");
    }
  }
};
goog.cssom.removeCssRule = function(cssStyleSheet, index) {
  if (cssStyleSheet.deleteRule) {
    cssStyleSheet.deleteRule(index);
  } else {
    cssStyleSheet.removeRule(index);
  }
};
goog.cssom.addCssText = function(cssText, opt_domHelper) {
  var document = opt_domHelper ? opt_domHelper.getDocument() : goog.dom.getDocument();
  var cssNode = document.createElement(goog.dom.TagName.STYLE);
  cssNode.type = "text/css";
  var head = document.getElementsByTagName(goog.dom.TagName.HEAD)[0];
  head.appendChild(cssNode);
  if (cssNode.styleSheet) {
    cssNode.styleSheet.cssText = cssText;
  } else {
    var cssTextNode = document.createTextNode(cssText);
    cssNode.appendChild(cssTextNode);
  }
  return cssNode;
};
goog.cssom.getFileNameFromStyleSheet = function(styleSheet) {
  var href = styleSheet.href;
  if (!href) {
    return null;
  }
  var matches = /([^\/\?]+)[^\/]*$/.exec(href);
  var filename = matches[1];
  return filename;
};
goog.cssom.getAllCss_ = function(styleSheet, isTextOutput) {
  var cssOut = [];
  var styleSheets = goog.cssom.getAllCssStyleSheets(styleSheet);
  for (var i = 0;styleSheet = styleSheets[i];i++) {
    var cssRuleList = goog.cssom.getCssRulesFromStyleSheet(styleSheet);
    if (cssRuleList && cssRuleList.length) {
      var ruleIndex = 0;
      for (var j = 0, n = cssRuleList.length, cssRule;j < n;j++) {
        cssRule = cssRuleList[j];
        if (isTextOutput && !cssRule.href) {
          var res = goog.cssom.getCssTextFromCssRule(cssRule);
          cssOut.push(res);
        } else {
          if (!cssRule.href) {
            if (cssRule.style) {
              if (!cssRule.parentStyleSheet) {
                cssRule.style["-closure-parent-stylesheet"] = styleSheet;
              }
              cssRule.style["-closure-rule-index"] = isTextOutput ? undefined : ruleIndex;
            }
            cssOut.push(cssRule);
          }
        }
        if (!isTextOutput) {
          ruleIndex++;
        }
      }
    }
  }
  return isTextOutput ? cssOut.join(" ") : cssOut;
};
goog.provide("goog.cssom.iframe.style");
goog.require("goog.asserts");
goog.require("goog.cssom");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.TagName");
goog.require("goog.dom.classlist");
goog.require("goog.string");
goog.require("goog.style");
goog.require("goog.userAgent");
goog.cssom.iframe.style.selectorPartAnchorRegex_ = /a(:(link|visited|active|hover))?/;
goog.cssom.iframe.style.SELECTOR_DELIMITER_ = ",";
goog.cssom.iframe.style.SELECTOR_PART_DELIMITER_ = " ";
goog.cssom.iframe.style.DECLARATION_START_DELIMITER_ = "{";
goog.cssom.iframe.style.DECLARATION_END_DELIMITER_ = "}\n";
goog.cssom.iframe.style.CssRuleSet_ = function() {
  this.declarationText = "";
  this.selectors = [];
};
goog.cssom.iframe.style.CssRuleSet_.prototype.initializeFromCssRule = function(cssRule) {
  var ruleStyle = cssRule.style;
  if (!ruleStyle) {
    return false;
  }
  var selector;
  var declarations = "";
  if (ruleStyle && (selector = cssRule.selectorText) && (declarations = ruleStyle.cssText)) {
    if (goog.userAgent.IE) {
      declarations += "/* */";
    }
  } else {
    if (cssRule.cssText) {
      var cssSelectorMatch = /([^\{]+)\{/;
      var endTagMatch = /\}[^\}]*$/g;
      selector = cssSelectorMatch.exec(cssRule.cssText)[1];
      declarations = cssRule.cssText.replace(cssSelectorMatch, "").replace(endTagMatch, "");
    }
  }
  if (selector) {
    this.setSelectorsFromString(selector);
    this.declarationText = declarations;
    return true;
  }
  return false;
};
goog.cssom.iframe.style.CssRuleSet_.prototype.setSelectorsFromString = function(selectorsString) {
  this.selectors = [];
  var selectors = selectorsString.split(/,\s*/gm);
  for (var i = 0;i < selectors.length;i++) {
    var selector = selectors[i];
    if (selector.length > 0) {
      this.selectors.push(new goog.cssom.iframe.style.CssSelector_(selector));
    }
  }
};
goog.cssom.iframe.style.CssRuleSet_.prototype.clone = function() {
  var newRuleSet = new goog.cssom.iframe.style.CssRuleSet_;
  newRuleSet.selectors = this.selectors.concat();
  newRuleSet.declarationText = this.declarationText;
  return newRuleSet;
};
goog.cssom.iframe.style.CssRuleSet_.prototype.setDeclarationTextFromObject = function(sourceObject, opt_important) {
  var stringParts = [];
  for (var prop in sourceObject) {
    var value = sourceObject[prop];
    if (value) {
      stringParts.push(prop, ":", value, opt_important ? " !important" : "", ";");
    }
  }
  this.declarationText = stringParts.join("");
};
goog.cssom.iframe.style.CssRuleSet_.prototype.writeToArray = function(array) {
  var selectorCount = this.selectors.length;
  var matchesAnchorTag = false;
  for (var i = 0;i < selectorCount;i++) {
    var selectorParts = this.selectors[i].parts;
    var partCount = selectorParts.length;
    for (var j = 0;j < partCount;j++) {
      array.push(selectorParts[j].inputString_, goog.cssom.iframe.style.SELECTOR_PART_DELIMITER_);
    }
    if (i < selectorCount - 1) {
      array.push(goog.cssom.iframe.style.SELECTOR_DELIMITER_);
    }
    if (goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher("1.9a")) {
      matchesAnchorTag = matchesAnchorTag || goog.cssom.iframe.style.selectorPartAnchorRegex_.test(selectorParts[partCount - 1].inputString_);
    }
  }
  var declarationText = this.declarationText;
  if (matchesAnchorTag) {
    declarationText = goog.cssom.iframe.style.makeColorRuleImportant_(declarationText);
  }
  array.push(goog.cssom.iframe.style.DECLARATION_START_DELIMITER_, declarationText, goog.cssom.iframe.style.DECLARATION_END_DELIMITER_);
};
goog.cssom.iframe.style.colorImportantReplaceRegex_ = /(^|;|{)\s*color:([^;]+);/g;
goog.cssom.iframe.style.makeColorRuleImportant_ = function(cssText) {
  return cssText.replace(goog.cssom.iframe.style.colorImportantReplaceRegex_, "$1 color: $2 ! important; ");
};
goog.cssom.iframe.style.CssSelector_ = function(opt_selectorString) {
  this.ancestryMatchCache_ = {};
  if (opt_selectorString) {
    this.setPartsFromString_(opt_selectorString);
  }
};
goog.cssom.iframe.style.CssSelector_.prototype.setPartsFromString_ = function(selectorString) {
  var parts = [];
  var selectorPartStrings = selectorString.split(/\s+/gm);
  for (var i = 0;i < selectorPartStrings.length;i++) {
    if (!selectorPartStrings[i]) {
      continue;
    }
    var part = new goog.cssom.iframe.style.CssSelectorPart_(selectorPartStrings[i]);
    parts.push(part);
  }
  this.parts = parts;
};
goog.cssom.iframe.style.CssSelector_.prototype.matchElementAncestry = function(elementAncestry) {
  var ancestryUid = elementAncestry.uid;
  if (this.ancestryMatchCache_[ancestryUid]) {
    return this.ancestryMatchCache_[ancestryUid];
  }
  var elementIndex = 0;
  var match = null;
  var selectorPart = null;
  var lastSelectorPart = null;
  var ancestorNodes = elementAncestry.nodes;
  var ancestorNodeCount = ancestorNodes.length;
  for (var i = 0;i <= this.parts.length;i++) {
    selectorPart = this.parts[i];
    while (elementIndex < ancestorNodeCount) {
      var currentElementInfo = ancestorNodes[elementIndex];
      if (selectorPart && selectorPart.testElement(currentElementInfo)) {
        match = {elementIndex:elementIndex, selectorPartIndex:i};
        elementIndex++;
        break;
      } else {
        if (lastSelectorPart && lastSelectorPart.testElement(currentElementInfo)) {
          match = {elementIndex:elementIndex, selectorPartIndex:i - 1};
        }
      }
      elementIndex++;
    }
    lastSelectorPart = selectorPart;
  }
  this.ancestryMatchCache_[ancestryUid] = match;
  return match;
};
goog.cssom.iframe.style.CssSelectorPart_ = function(selectorPartString) {
  var cacheEntry = goog.cssom.iframe.style.CssSelectorPart_.instances_[selectorPartString];
  if (cacheEntry) {
    return cacheEntry;
  }
  var identifiers;
  if (selectorPartString.match(/[#\.]/)) {
    identifiers = selectorPartString.split(/(?=[#\.])/);
  } else {
    identifiers = [selectorPartString];
  }
  var properties = {};
  for (var i = 0;i < identifiers.length;i++) {
    var identifier = identifiers[i];
    if (identifier.charAt(0) == ".") {
      properties.className = identifier.substring(1, identifier.length);
    } else {
      if (identifier.charAt(0) == "#") {
        properties.id = identifier.substring(1, identifier.length);
      } else {
        properties.tagName = identifier.toUpperCase();
      }
    }
  }
  this.inputString_ = selectorPartString;
  this.matchProperties_ = properties;
  this.testedElements_ = {};
  goog.cssom.iframe.style.CssSelectorPart_.instances_[selectorPartString] = this;
};
goog.cssom.iframe.style.CssSelectorPart_.instances_ = {};
goog.cssom.iframe.style.CssSelectorPart_.prototype.testElement = function(elementInfo) {
  var elementUid = elementInfo.uid;
  var cachedMatch = this.testedElements_[elementUid];
  if (typeof cachedMatch != "undefined") {
    return cachedMatch;
  }
  var matchProperties = this.matchProperties_;
  var testTag = matchProperties.tagName;
  var testClass = matchProperties.className;
  var testId = matchProperties.id;
  var matched = true;
  if (testTag && testTag != "*" && testTag != elementInfo.nodeName) {
    matched = false;
  } else {
    if (testId && testId != elementInfo.id) {
      matched = false;
    } else {
      if (testClass && !elementInfo.classNames[testClass]) {
        matched = false;
      }
    }
  }
  this.testedElements_[elementUid] = matched;
  return matched;
};
goog.cssom.iframe.style.NodeAncestry_ = function(el) {
  var node = el;
  var nodeUid = goog.getUid(node);
  var ancestry = goog.cssom.iframe.style.NodeAncestry_.instances_[nodeUid];
  if (ancestry) {
    return ancestry;
  }
  var nodes = [];
  do {
    var nodeInfo = {id:node.id, nodeName:node.nodeName};
    nodeInfo.uid = goog.getUid(nodeInfo);
    var className = node.className;
    var classNamesLookup = {};
    if (className) {
      var classNames = goog.dom.classlist.get(goog.asserts.assertElement(node));
      for (var i = 0;i < classNames.length;i++) {
        classNamesLookup[classNames[i]] = 1;
      }
    }
    nodeInfo.classNames = classNamesLookup;
    nodes.unshift(nodeInfo);
  } while (node = node.parentNode);
  this.nodes = nodes;
  this.uid = goog.getUid(this);
  goog.cssom.iframe.style.NodeAncestry_.instances_[nodeUid] = this;
};
goog.cssom.iframe.style.NodeAncestry_.instances_ = {};
goog.cssom.iframe.style.resetDomCache = function() {
  goog.cssom.iframe.style.NodeAncestry_.instances_ = {};
};
goog.cssom.iframe.style.getRuleSetsFromDocument_ = function(doc) {
  var ruleSets = [];
  var styleSheets = goog.cssom.getAllCssStyleSheets(doc.styleSheets);
  for (var i = 0, styleSheet;styleSheet = styleSheets[i];i++) {
    var domRuleSets = goog.cssom.getCssRulesFromStyleSheet(styleSheet);
    if (domRuleSets && domRuleSets.length) {
      for (var j = 0, n = domRuleSets.length;j < n;j++) {
        var ruleSet = new goog.cssom.iframe.style.CssRuleSet_;
        if (ruleSet.initializeFromCssRule(domRuleSets[j])) {
          ruleSets.push(ruleSet);
        }
      }
    }
  }
  return ruleSets;
};
goog.cssom.iframe.style.ruleSetCache_ = {};
goog.cssom.iframe.style.ruleSetCache_.ruleSetCache_ = {};
goog.cssom.iframe.style.ruleSetCache_.loadRuleSetsForDocument = function(doc) {
  var docUid = goog.getUid(doc);
  goog.cssom.iframe.style.ruleSetCache_.ruleSetCache_[docUid] = goog.cssom.iframe.style.getRuleSetsFromDocument_(doc);
};
goog.cssom.iframe.style.ruleSetCache_.getRuleSetsForDocument = function(doc) {
  var docUid = goog.getUid(doc);
  var cache = goog.cssom.iframe.style.ruleSetCache_.ruleSetCache_;
  if (!cache[docUid]) {
    goog.cssom.iframe.style.ruleSetCache_.loadRuleSetsForDocument(doc);
  }
  var ruleSets = cache[docUid];
  var ruleSetsCopy = [];
  for (var i = 0;i < ruleSets.length;i++) {
    ruleSetsCopy.push(ruleSets[i].clone());
  }
  return ruleSetsCopy;
};
goog.cssom.iframe.style.inheritedProperties_ = ["color", "visibility", "quotes", "list-style-type", "list-style-image", "list-style-position", "list-style", "page-break-inside", "orphans", "widows", "font-family", "font-style", "font-variant", "font-weight", "text-indent", "text-align", "text-transform", "white-space", "caption-side", "border-collapse", "border-spacing", "empty-cells", "cursor"];
goog.cssom.iframe.style.textProperties_ = ["font-family", "font-size", "font-weight", "font-variant", "font-style", "color", "text-align", "text-decoration", "text-indent", "text-transform", "letter-spacing", "white-space", "word-spacing"];
goog.cssom.iframe.style.getElementContext = function(element, opt_forceRuleSetCacheUpdate, opt_copyBackgroundContext) {
  var sourceDocument = element.ownerDocument;
  if (opt_forceRuleSetCacheUpdate) {
    goog.cssom.iframe.style.ruleSetCache_.loadRuleSetsForDocument(sourceDocument);
  }
  var ruleSets = goog.cssom.iframe.style.ruleSetCache_.getRuleSetsForDocument(sourceDocument);
  var elementAncestry = new goog.cssom.iframe.style.NodeAncestry_(element);
  var bodySelectorPart = new goog.cssom.iframe.style.CssSelectorPart_("body");
  for (var i = 0;i < ruleSets.length;i++) {
    var ruleSet = ruleSets[i];
    var selectors = ruleSet.selectors;
    var ruleCount = selectors.length;
    for (var j = 0;j < ruleCount;j++) {
      var selector = selectors[j];
      var match = selector.matchElementAncestry(elementAncestry);
      if (match) {
        var ruleIndex = match.selectorPartIndex;
        var selectorParts = selector.parts;
        var lastSelectorPartIndex = selectorParts.length - 1;
        var selectorCopy;
        if (match.elementIndex == elementAncestry.nodes.length - 1 || ruleIndex < lastSelectorPartIndex) {
          var selectorPartsCopy = selectorParts.concat();
          selectorPartsCopy.splice(0, ruleIndex + 1, bodySelectorPart);
          selectorCopy = new goog.cssom.iframe.style.CssSelector_;
          selectorCopy.parts = selectorPartsCopy;
          selectors.push(selectorCopy);
        } else {
          if (ruleIndex > 0 && ruleIndex == lastSelectorPartIndex) {
            selectorCopy = new goog.cssom.iframe.style.CssSelector_;
            selectorCopy.parts = [bodySelectorPart, selectorParts[lastSelectorPartIndex]];
            selectors.push(selectorCopy);
          }
        }
      }
    }
  }
  var defaultPropertiesRuleSet = new goog.cssom.iframe.style.CssRuleSet_;
  var computedStyle = goog.cssom.iframe.style.getComputedStyleObject_(element);
  var htmlSelector = new goog.cssom.iframe.style.CssSelector_;
  htmlSelector.parts = [new goog.cssom.iframe.style.CssSelectorPart_("html")];
  defaultPropertiesRuleSet.selectors = [htmlSelector];
  var defaultProperties = {};
  for (var i = 0, prop;prop = goog.cssom.iframe.style.inheritedProperties_[i];i++) {
    defaultProperties[prop] = computedStyle[goog.string.toCamelCase(prop)];
  }
  defaultPropertiesRuleSet.setDeclarationTextFromObject(defaultProperties);
  ruleSets.push(defaultPropertiesRuleSet);
  var bodyRuleSet = new goog.cssom.iframe.style.CssRuleSet_;
  var bodySelector = new goog.cssom.iframe.style.CssSelector_;
  bodySelector.parts = [new goog.cssom.iframe.style.CssSelectorPart_("body")];
  var bodyProperties = {position:"relative", top:"0", left:"0", right:"auto", display:"block", visibility:"visible"};
  for (i = 0;prop = goog.cssom.iframe.style.textProperties_[i];i++) {
    bodyProperties[prop] = computedStyle[goog.string.toCamelCase(prop)];
  }
  if (opt_copyBackgroundContext && goog.cssom.iframe.style.isTransparentValue_(computedStyle["backgroundColor"])) {
    var bgProperties = goog.cssom.iframe.style.getBackgroundContext(element);
    bodyProperties["background-color"] = bgProperties["backgroundColor"];
    var elementBgImage = computedStyle["backgroundImage"];
    if (!elementBgImage || elementBgImage == "none") {
      bodyProperties["background-image"] = bgProperties["backgroundImage"];
      bodyProperties["background-repeat"] = bgProperties["backgroundRepeat"];
      bodyProperties["background-position"] = bgProperties["backgroundPosition"];
    }
  }
  bodyRuleSet.setDeclarationTextFromObject(bodyProperties, true);
  bodyRuleSet.selectors = [bodySelector];
  ruleSets.push(bodyRuleSet);
  var ruleSetStrings = [];
  ruleCount = ruleSets.length;
  for (i = 0;i < ruleCount;i++) {
    ruleSets[i].writeToArray(ruleSetStrings);
  }
  return ruleSetStrings.join("");
};
goog.cssom.iframe.style.isTransparentValue_ = function(colorValue) {
  return colorValue == "transparent" || colorValue == "rgba(0, 0, 0, 0)";
};
goog.cssom.iframe.style.getComputedStyleObject_ = function(element) {
  return element.currentStyle || goog.dom.getOwnerDocument(element).defaultView.getComputedStyle(element, "") || {};
};
goog.cssom.iframe.style.valueWithUnitsRegEx_ = /^(-?)([0-9]+)([a-z]*|%)/;
goog.cssom.iframe.style.getBackgroundXYValues_ = function(styleObject) {
  if (styleObject["backgroundPositionY"]) {
    return [styleObject["backgroundPositionX"], styleObject["backgroundPositionY"]];
  } else {
    return (styleObject["backgroundPosition"] || "0 0").split(" ");
  }
};
goog.cssom.iframe.style.getBackgroundContext = function(element) {
  var propertyValues = {"backgroundImage":"none"};
  var ancestor = element;
  var currentIframeWindow;
  while ((ancestor = (ancestor.parentNode)) && ancestor.nodeType == goog.dom.NodeType.ELEMENT) {
    var computedStyle = goog.cssom.iframe.style.getComputedStyleObject_(ancestor);
    var backgroundColorValue = computedStyle["backgroundColor"];
    if (!goog.cssom.iframe.style.isTransparentValue_(backgroundColorValue)) {
      propertyValues["backgroundColor"] = backgroundColorValue;
    }
    if (computedStyle["backgroundImage"] && computedStyle["backgroundImage"] != "none") {
      propertyValues["backgroundImage"] = computedStyle["backgroundImage"];
      propertyValues["backgroundRepeat"] = computedStyle["backgroundRepeat"];
      var relativePosition;
      if (currentIframeWindow) {
        relativePosition = goog.style.getFramedPageOffset(element, currentIframeWindow);
        var frameElement = currentIframeWindow.frameElement;
        var iframeRelativePosition = goog.style.getRelativePosition((frameElement), ancestor);
        var iframeBorders = goog.style.getBorderBox(frameElement);
        relativePosition.x += iframeRelativePosition.x + iframeBorders.left;
        relativePosition.y += iframeRelativePosition.y + iframeBorders.top;
      } else {
        relativePosition = goog.style.getRelativePosition(element, ancestor);
      }
      var backgroundXYValues = goog.cssom.iframe.style.getBackgroundXYValues_(computedStyle);
      for (var i = 0;i < 2;i++) {
        var positionValue = backgroundXYValues[i];
        var coordinate = i == 0 ? "X" : "Y";
        var positionProperty = "backgroundPosition" + coordinate;
        var positionValueParts = goog.cssom.iframe.style.valueWithUnitsRegEx_.exec(positionValue);
        if (positionValueParts) {
          var value = parseInt(positionValueParts[1] + positionValueParts[2], 10);
          var units = positionValueParts[3];
          if (value == 0 || units == "px") {
            value -= coordinate == "X" ? relativePosition.x : relativePosition.y;
          }
          positionValue = value + units;
        }
        propertyValues[positionProperty] = positionValue;
      }
      propertyValues["backgroundPosition"] = propertyValues["backgroundPositionX"] + " " + propertyValues["backgroundPositionY"];
    }
    if (propertyValues["backgroundColor"]) {
      break;
    }
    if (ancestor.tagName == goog.dom.TagName.HTML) {
      try {
        currentIframeWindow = goog.dom.getWindow((ancestor.parentNode));
        ancestor = currentIframeWindow.frameElement;
        if (!ancestor) {
          break;
        }
      } catch (e) {
        break;
      }
    }
  }
  return propertyValues;
};
goog.provide("goog.editor.SeamlessField");
goog.require("goog.cssom.iframe.style");
goog.require("goog.dom");
goog.require("goog.dom.Range");
goog.require("goog.dom.TagName");
goog.require("goog.dom.safe");
goog.require("goog.editor.BrowserFeature");
goog.require("goog.editor.Field");
goog.require("goog.editor.icontent");
goog.require("goog.editor.icontent.FieldFormatInfo");
goog.require("goog.editor.icontent.FieldStyleInfo");
goog.require("goog.editor.node");
goog.require("goog.events");
goog.require("goog.events.EventType");
goog.require("goog.html.uncheckedconversions");
goog.require("goog.log");
goog.require("goog.string.Const");
goog.require("goog.style");
goog.editor.SeamlessField = function(id, opt_doc) {
  goog.editor.Field.call(this, id, opt_doc);
};
goog.inherits(goog.editor.SeamlessField, goog.editor.Field);
goog.editor.SeamlessField.prototype.logger = goog.log.getLogger("goog.editor.SeamlessField");
goog.editor.SeamlessField.prototype.listenForDragOverEventKey_;
goog.editor.SeamlessField.prototype.listenForIframeLoadEventKey_;
goog.editor.SeamlessField.prototype.setMinHeight = function(height) {
  if (height == this.minHeight_) {
    return;
  }
  this.minHeight_ = height;
  if (this.usesIframe()) {
    this.doFieldSizingGecko();
  }
};
goog.editor.SeamlessField.prototype.isFixedHeight_ = false;
goog.editor.SeamlessField.prototype.isFixedHeightOverridden_ = false;
goog.editor.SeamlessField.prototype.isFixedHeight = function() {
  return this.isFixedHeight_;
};
goog.editor.SeamlessField.prototype.overrideFixedHeight = function(newVal) {
  this.isFixedHeight_ = newVal;
  this.isFixedHeightOverridden_ = true;
};
goog.editor.SeamlessField.prototype.autoDetectFixedHeight_ = function() {
  if (!this.isFixedHeightOverridden_) {
    var originalElement = this.getOriginalElement();
    if (originalElement) {
      this.isFixedHeight_ = goog.style.getComputedOverflowY(originalElement) == "auto";
    }
  }
};
goog.editor.SeamlessField.prototype.handleOuterDocChange_ = function() {
  if (this.isEventStopped(goog.editor.Field.EventType.CHANGE)) {
    return;
  }
  this.sizeIframeToWrapperGecko_();
};
goog.editor.SeamlessField.prototype.sizeIframeToBodyHeightGecko_ = function() {
  if (this.acquireSizeIframeLockGecko_()) {
    var resized = false;
    var ifr = this.getEditableIframe();
    if (ifr) {
      var fieldHeight = this.getIframeBodyHeightGecko_();
      if (this.minHeight_) {
        fieldHeight = Math.max(fieldHeight, this.minHeight_);
      }
      if (parseInt(goog.style.getStyle(ifr, "height"), 10) != fieldHeight) {
        ifr.style.height = fieldHeight + "px";
        resized = true;
      }
    }
    this.releaseSizeIframeLockGecko_();
    if (resized) {
      this.dispatchEvent(goog.editor.Field.EventType.IFRAME_RESIZED);
    }
  }
};
goog.editor.SeamlessField.prototype.getIframeBodyHeightGecko_ = function() {
  var ifr = this.getEditableIframe();
  var body = ifr.contentDocument.body;
  var htmlElement = (body.parentNode);
  if (parseInt(goog.style.getStyle(ifr, "height"), 10) === 0) {
    goog.style.setStyle(ifr, "height", 1 + "px");
  }
  var fieldHeight;
  if (goog.editor.node.isStandardsMode(body)) {
    fieldHeight = htmlElement.offsetHeight;
  } else {
    fieldHeight = htmlElement.scrollHeight;
    if (htmlElement.clientHeight != htmlElement.offsetHeight) {
      fieldHeight += goog.editor.SeamlessField.getScrollbarWidth_();
    }
  }
  return fieldHeight;
};
goog.editor.SeamlessField.getScrollbarWidth_ = function() {
  return goog.editor.SeamlessField.scrollbarWidth_ || (goog.editor.SeamlessField.scrollbarWidth_ = goog.style.getScrollbarWidth());
};
goog.editor.SeamlessField.prototype.sizeIframeToWrapperGecko_ = function() {
  if (this.acquireSizeIframeLockGecko_()) {
    var ifr = this.getEditableIframe();
    var field = this.getElement();
    var resized = false;
    if (ifr && field) {
      var fieldPaddingBox;
      var widthDiv = (ifr.parentNode);
      var width = widthDiv.offsetWidth;
      if (parseInt(goog.style.getStyle(ifr, "width"), 10) != width) {
        fieldPaddingBox = goog.style.getPaddingBox(field);
        ifr.style.width = width + "px";
        field.style.width = width - fieldPaddingBox.left - fieldPaddingBox.right + "px";
        resized = true;
      }
      var height = widthDiv.offsetHeight;
      if (this.isFixedHeight() && parseInt(goog.style.getStyle(ifr, "height"), 10) != height) {
        if (!fieldPaddingBox) {
          fieldPaddingBox = goog.style.getPaddingBox(field);
        }
        ifr.style.height = height + "px";
        field.style.height = height - fieldPaddingBox.top - fieldPaddingBox.bottom + "px";
        resized = true;
      }
    }
    this.releaseSizeIframeLockGecko_();
    if (resized) {
      this.dispatchEvent(goog.editor.Field.EventType.IFRAME_RESIZED);
    }
  }
};
goog.editor.SeamlessField.prototype.doFieldSizingGecko = function() {
  if (this.getElement()) {
    this.sizeIframeToWrapperGecko_();
    if (!this.isFixedHeight()) {
      this.sizeIframeToBodyHeightGecko_();
    }
  }
};
goog.editor.SeamlessField.prototype.acquireSizeIframeLockGecko_ = function() {
  if (this.sizeIframeLock_) {
    return false;
  }
  return this.sizeIframeLock_ = true;
};
goog.editor.SeamlessField.prototype.releaseSizeIframeLockGecko_ = function() {
  this.sizeIframeLock_ = false;
};
goog.editor.SeamlessField.prototype.iframeableCss_ = "";
goog.editor.SeamlessField.prototype.getIframeableCss = function(opt_forceRegeneration) {
  if (!this.iframeableCss_ || opt_forceRegeneration) {
    var originalElement = this.getOriginalElement();
    if (originalElement) {
      this.iframeableCss_ = goog.cssom.iframe.style.getElementContext(originalElement, opt_forceRegeneration);
    }
  }
  return this.iframeableCss_;
};
goog.editor.SeamlessField.prototype.setIframeableCss = function(iframeableCss) {
  this.iframeableCss_ = iframeableCss;
};
goog.editor.SeamlessField.haveInstalledCss_ = false;
goog.editor.SeamlessField.prototype.inheritBlendedCSS = function() {
  if (!this.usesIframe()) {
    return;
  }
  var field = this.getElement();
  var head = goog.dom.getDomHelper(field).getElementsByTagNameAndClass(goog.dom.TagName.HEAD)[0];
  if (head) {
    goog.dom.removeChildren(head);
  }
  var newCSS = this.getIframeableCss(true);
  goog.style.installStyles(newCSS, field);
};
goog.editor.SeamlessField.prototype.usesIframe = function() {
  return !goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE;
};
goog.editor.SeamlessField.prototype.setupMutationEventHandlersGecko = function() {
  goog.editor.SeamlessField.superClass_.setupMutationEventHandlersGecko.call(this);
  if (this.usesIframe()) {
    var iframe = this.getEditableIframe();
    var outerDoc = iframe.ownerDocument;
    this.eventRegister.listen(outerDoc, goog.editor.Field.MUTATION_EVENTS_GECKO, this.handleOuterDocChange_, true);
    this.listenForIframeLoadEventKey_ = goog.events.listenOnce(this.getEditableDomHelper().getWindow(), goog.events.EventType.LOAD, this.sizeIframeToBodyHeightGecko_, true, this);
    this.eventRegister.listen(outerDoc, "DOMAttrModified", goog.bind(this.handleDomAttrChange, this, this.handleOuterDocChange_), true);
  }
};
goog.editor.SeamlessField.prototype.handleChange = function() {
  if (this.isEventStopped(goog.editor.Field.EventType.CHANGE)) {
    return;
  }
  goog.editor.SeamlessField.superClass_.handleChange.call(this);
  if (this.usesIframe()) {
    this.sizeIframeToBodyHeightGecko_();
  }
};
goog.editor.SeamlessField.prototype.dispatchBlur = function() {
  if (this.isEventStopped(goog.editor.Field.EventType.BLUR)) {
    return;
  }
  goog.editor.SeamlessField.superClass_.dispatchBlur.call(this);
  if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE && !goog.editor.BrowserFeature.CLEARS_SELECTION_WHEN_FOCUS_LEAVES) {
    var win = this.getEditableDomHelper().getWindow();
    var dragging = false;
    goog.events.unlistenByKey(this.listenForDragOverEventKey_);
    this.listenForDragOverEventKey_ = goog.events.listenOnce(win.document.body, "dragover", function() {
      dragging = true;
    });
    goog.global.setTimeout(goog.bind(function() {
      if (!dragging) {
        if (this.editableDomHelper) {
          var rng = this.getRange();
          var iframeWindow = this.editableDomHelper.getWindow();
          goog.dom.Range.clearSelection(iframeWindow);
          if (rng) {
            rng.collapse(true);
            rng.select();
          }
        }
      }
    }, this), 0);
  }
};
goog.editor.SeamlessField.prototype.turnOnDesignModeGecko = function() {
  goog.editor.SeamlessField.superClass_.turnOnDesignModeGecko.call(this);
  var doc = this.getEditableDomHelper().getDocument();
  doc.execCommand("enableInlineTableEditing", false, "false");
  doc.execCommand("enableObjectResizing", false, "false");
};
goog.editor.SeamlessField.prototype.installStyles = function() {
  if (!this.usesIframe()) {
    if (!goog.editor.SeamlessField.haveInstalledCss_) {
      if (this.cssStyles) {
        goog.style.installStyles(this.cssStyles, this.getElement());
      }
      goog.editor.SeamlessField.haveInstalledCss_ = true;
    }
  }
};
goog.editor.SeamlessField.prototype.makeEditableInternal = function(opt_iframeSrc) {
  if (this.usesIframe()) {
    goog.editor.SeamlessField.superClass_.makeEditableInternal.call(this, opt_iframeSrc);
  } else {
    var field = this.getOriginalElement();
    if (field) {
      this.setupFieldObject(field);
      field.contentEditable = true;
      this.injectContents(field.innerHTML, field);
      this.handleFieldLoad();
    }
  }
};
goog.editor.SeamlessField.prototype.handleFieldLoad = function() {
  if (this.usesIframe()) {
    var self = this;
    goog.global.setTimeout(function() {
      self.doFieldSizingGecko();
    }, 0);
  }
  goog.editor.SeamlessField.superClass_.handleFieldLoad.call(this);
};
goog.editor.SeamlessField.prototype.getIframeAttributes = function() {
  return {"frameBorder":0, "style":"padding:0;"};
};
goog.editor.SeamlessField.prototype.attachIframe = function(iframe) {
  this.autoDetectFixedHeight_();
  var field = this.getOriginalElement();
  var dh = goog.dom.getDomHelper(field);
  var oldWidth = field.style.width;
  var oldHeight = field.style.height;
  goog.style.setStyle(field, "visibility", "hidden");
  var startDiv = dh.createDom(goog.dom.TagName.DIV, {"style":"height:0;clear:both", "innerHTML":"&nbsp;"});
  var endDiv = startDiv.cloneNode(true);
  field.insertBefore(startDiv, field.firstChild);
  goog.dom.appendChild(field, endDiv);
  var contentBox = goog.style.getContentBoxSize(field);
  var width = contentBox.width;
  var height = contentBox.height;
  var html = "";
  if (this.isFixedHeight()) {
    html = "&nbsp;";
    goog.style.setStyle(field, "position", "relative");
    goog.style.setStyle(field, "overflow", "visible");
    goog.style.setStyle(iframe, "position", "absolute");
    goog.style.setStyle(iframe, "top", "0");
    goog.style.setStyle(iframe, "left", "0");
  }
  goog.style.setSize(field, width, height);
  if (goog.editor.node.isStandardsMode(field)) {
    this.originalFieldLineHeight_ = field.style.lineHeight;
    goog.style.setStyle(field, "lineHeight", "0");
  }
  goog.editor.node.replaceInnerHtml(field, html);
  goog.style.setSize(iframe, width, height);
  goog.style.setSize(field, oldWidth, oldHeight);
  goog.style.setStyle(field, "visibility", "");
  goog.dom.appendChild(field, iframe);
  if (!this.shouldLoadAsynchronously()) {
    var doc = iframe.contentWindow.document;
    if (goog.editor.node.isStandardsMode(iframe.ownerDocument)) {
      doc.open();
      var emptyHtml = goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("HTML from constant string"), "<!DOCTYPE HTML><html></html>");
      goog.dom.safe.documentWrite(doc, emptyHtml);
      doc.close();
    }
  }
};
goog.editor.SeamlessField.prototype.getFieldFormatInfo = function(extraStyles) {
  var originalElement = this.getOriginalElement();
  if (originalElement) {
    return new goog.editor.icontent.FieldFormatInfo(this.id, goog.editor.node.isStandardsMode(originalElement), true, this.isFixedHeight(), extraStyles);
  }
  throw Error("no field");
};
goog.editor.SeamlessField.prototype.writeIframeContent = function(iframe, innerHtml, extraStyles) {
  goog.style.setStyle(iframe, "visibility", "hidden");
  var formatInfo = this.getFieldFormatInfo(extraStyles);
  var styleInfo = new goog.editor.icontent.FieldStyleInfo(this.getOriginalElement(), this.cssStyles + this.getIframeableCss());
  goog.editor.icontent.writeNormalInitialBlendedIframe(formatInfo, innerHtml, styleInfo, iframe);
  this.doFieldSizingGecko();
  goog.style.setStyle(iframe, "visibility", "visible");
};
goog.editor.SeamlessField.prototype.restoreDom = function() {
  if (this.usesIframe()) {
    goog.dom.removeNode(this.getEditableIframe());
  }
};
goog.editor.SeamlessField.prototype.clearListeners = function() {
  goog.events.unlistenByKey(this.listenForDragOverEventKey_);
  goog.events.unlistenByKey(this.listenForIframeLoadEventKey_);
  goog.editor.SeamlessField.base(this, "clearListeners");
};
goog.provide("goog.uri.utils");
goog.provide("goog.uri.utils.ComponentIndex");
goog.provide("goog.uri.utils.QueryArray");
goog.provide("goog.uri.utils.QueryValue");
goog.provide("goog.uri.utils.StandardQueryParam");
goog.require("goog.asserts");
goog.require("goog.string");
goog.uri.utils.CharCode_ = {AMPERSAND:38, EQUAL:61, HASH:35, QUESTION:63};
goog.uri.utils.buildFromEncodedParts = function(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_queryData, opt_fragment) {
  var out = "";
  if (opt_scheme) {
    out += opt_scheme + ":";
  }
  if (opt_domain) {
    out += "//";
    if (opt_userInfo) {
      out += opt_userInfo + "@";
    }
    out += opt_domain;
    if (opt_port) {
      out += ":" + opt_port;
    }
  }
  if (opt_path) {
    out += opt_path;
  }
  if (opt_queryData) {
    out += "?" + opt_queryData;
  }
  if (opt_fragment) {
    out += "#" + opt_fragment;
  }
  return out;
};
goog.uri.utils.splitRe_ = new RegExp("^" + "(?:" + "([^:/?#.]+)" + ":)?" + "(?://" + "(?:([^/?#]*)@)?" + "([^/#?]*?)" + "(?::([0-9]+))?" + "(?=[/#?]|$)" + ")?" + "([^?#]+)?" + "(?:\\?([^#]*))?" + "(?:#(.*))?" + "$");
goog.uri.utils.ComponentIndex = {SCHEME:1, USER_INFO:2, DOMAIN:3, PORT:4, PATH:5, QUERY_DATA:6, FRAGMENT:7};
goog.uri.utils.split = function(uri) {
  return (uri.match(goog.uri.utils.splitRe_));
};
goog.uri.utils.decodeIfPossible_ = function(uri, opt_preserveReserved) {
  if (!uri) {
    return uri;
  }
  return opt_preserveReserved ? decodeURI(uri) : decodeURIComponent(uri);
};
goog.uri.utils.getComponentByIndex_ = function(componentIndex, uri) {
  return goog.uri.utils.split(uri)[componentIndex] || null;
};
goog.uri.utils.getScheme = function(uri) {
  return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.SCHEME, uri);
};
goog.uri.utils.getEffectiveScheme = function(uri) {
  var scheme = goog.uri.utils.getScheme(uri);
  if (!scheme && goog.global.self && goog.global.self.location) {
    var protocol = goog.global.self.location.protocol;
    scheme = protocol.substr(0, protocol.length - 1);
  }
  return scheme ? scheme.toLowerCase() : "";
};
goog.uri.utils.getUserInfoEncoded = function(uri) {
  return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.USER_INFO, uri);
};
goog.uri.utils.getUserInfo = function(uri) {
  return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getUserInfoEncoded(uri));
};
goog.uri.utils.getDomainEncoded = function(uri) {
  return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.DOMAIN, uri);
};
goog.uri.utils.getDomain = function(uri) {
  return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getDomainEncoded(uri), true);
};
goog.uri.utils.getPort = function(uri) {
  return Number(goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.PORT, uri)) || null;
};
goog.uri.utils.getPathEncoded = function(uri) {
  return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.PATH, uri);
};
goog.uri.utils.getPath = function(uri) {
  return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getPathEncoded(uri), true);
};
goog.uri.utils.getQueryData = function(uri) {
  return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.QUERY_DATA, uri);
};
goog.uri.utils.getFragmentEncoded = function(uri) {
  var hashIndex = uri.indexOf("#");
  return hashIndex < 0 ? null : uri.substr(hashIndex + 1);
};
goog.uri.utils.setFragmentEncoded = function(uri, fragment) {
  return goog.uri.utils.removeFragment(uri) + (fragment ? "#" + fragment : "");
};
goog.uri.utils.getFragment = function(uri) {
  return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getFragmentEncoded(uri));
};
goog.uri.utils.getHost = function(uri) {
  var pieces = goog.uri.utils.split(uri);
  return goog.uri.utils.buildFromEncodedParts(pieces[goog.uri.utils.ComponentIndex.SCHEME], pieces[goog.uri.utils.ComponentIndex.USER_INFO], pieces[goog.uri.utils.ComponentIndex.DOMAIN], pieces[goog.uri.utils.ComponentIndex.PORT]);
};
goog.uri.utils.getPathAndAfter = function(uri) {
  var pieces = goog.uri.utils.split(uri);
  return goog.uri.utils.buildFromEncodedParts(null, null, null, null, pieces[goog.uri.utils.ComponentIndex.PATH], pieces[goog.uri.utils.ComponentIndex.QUERY_DATA], pieces[goog.uri.utils.ComponentIndex.FRAGMENT]);
};
goog.uri.utils.removeFragment = function(uri) {
  var hashIndex = uri.indexOf("#");
  return hashIndex < 0 ? uri : uri.substr(0, hashIndex);
};
goog.uri.utils.haveSameDomain = function(uri1, uri2) {
  var pieces1 = goog.uri.utils.split(uri1);
  var pieces2 = goog.uri.utils.split(uri2);
  return pieces1[goog.uri.utils.ComponentIndex.DOMAIN] == pieces2[goog.uri.utils.ComponentIndex.DOMAIN] && pieces1[goog.uri.utils.ComponentIndex.SCHEME] == pieces2[goog.uri.utils.ComponentIndex.SCHEME] && pieces1[goog.uri.utils.ComponentIndex.PORT] == pieces2[goog.uri.utils.ComponentIndex.PORT];
};
goog.uri.utils.assertNoFragmentsOrQueries_ = function(uri) {
  if (goog.DEBUG && (uri.indexOf("#") >= 0 || uri.indexOf("?") >= 0)) {
    throw Error("goog.uri.utils: Fragment or query identifiers are not " + "supported: [" + uri + "]");
  }
};
goog.uri.utils.QueryValue;
goog.uri.utils.QueryArray;
goog.uri.utils.parseQueryData = function(encodedQuery, callback) {
  if (!encodedQuery) {
    return;
  }
  var pairs = encodedQuery.split("&");
  for (var i = 0;i < pairs.length;i++) {
    var indexOfEquals = pairs[i].indexOf("=");
    var name = null;
    var value = null;
    if (indexOfEquals >= 0) {
      name = pairs[i].substring(0, indexOfEquals);
      value = pairs[i].substring(indexOfEquals + 1);
    } else {
      name = pairs[i];
    }
    callback(name, value ? goog.string.urlDecode(value) : "");
  }
};
goog.uri.utils.appendQueryData_ = function(buffer) {
  if (buffer[1]) {
    var baseUri = (buffer[0]);
    var hashIndex = baseUri.indexOf("#");
    if (hashIndex >= 0) {
      buffer.push(baseUri.substr(hashIndex));
      buffer[0] = baseUri = baseUri.substr(0, hashIndex);
    }
    var questionIndex = baseUri.indexOf("?");
    if (questionIndex < 0) {
      buffer[1] = "?";
    } else {
      if (questionIndex == baseUri.length - 1) {
        buffer[1] = undefined;
      }
    }
  }
  return buffer.join("");
};
goog.uri.utils.appendKeyValuePairs_ = function(key, value, pairs) {
  if (goog.isArray(value)) {
    goog.asserts.assertArray(value);
    for (var j = 0;j < value.length;j++) {
      goog.uri.utils.appendKeyValuePairs_(key, String(value[j]), pairs);
    }
  } else {
    if (value != null) {
      pairs.push("&", key, value === "" ? "" : "=", goog.string.urlEncode(value));
    }
  }
};
goog.uri.utils.buildQueryDataBuffer_ = function(buffer, keysAndValues, opt_startIndex) {
  goog.asserts.assert(Math.max(keysAndValues.length - (opt_startIndex || 0), 0) % 2 == 0, "goog.uri.utils: Key/value lists must be even in length.");
  for (var i = opt_startIndex || 0;i < keysAndValues.length;i += 2) {
    goog.uri.utils.appendKeyValuePairs_(keysAndValues[i], keysAndValues[i + 1], buffer);
  }
  return buffer;
};
goog.uri.utils.buildQueryData = function(keysAndValues, opt_startIndex) {
  var buffer = goog.uri.utils.buildQueryDataBuffer_([], keysAndValues, opt_startIndex);
  buffer[0] = "";
  return buffer.join("");
};
goog.uri.utils.buildQueryDataBufferFromMap_ = function(buffer, map) {
  for (var key in map) {
    goog.uri.utils.appendKeyValuePairs_(key, map[key], buffer);
  }
  return buffer;
};
goog.uri.utils.buildQueryDataFromMap = function(map) {
  var buffer = goog.uri.utils.buildQueryDataBufferFromMap_([], map);
  buffer[0] = "";
  return buffer.join("");
};
goog.uri.utils.appendParams = function(uri, var_args) {
  return goog.uri.utils.appendQueryData_(arguments.length == 2 ? goog.uri.utils.buildQueryDataBuffer_([uri], arguments[1], 0) : goog.uri.utils.buildQueryDataBuffer_([uri], arguments, 1));
};
goog.uri.utils.appendParamsFromMap = function(uri, map) {
  return goog.uri.utils.appendQueryData_(goog.uri.utils.buildQueryDataBufferFromMap_([uri], map));
};
goog.uri.utils.appendParam = function(uri, key, opt_value) {
  var paramArr = [uri, "&", key];
  if (goog.isDefAndNotNull(opt_value)) {
    paramArr.push("=", goog.string.urlEncode(opt_value));
  }
  return goog.uri.utils.appendQueryData_(paramArr);
};
goog.uri.utils.findParam_ = function(uri, startIndex, keyEncoded, hashOrEndIndex) {
  var index = startIndex;
  var keyLength = keyEncoded.length;
  while ((index = uri.indexOf(keyEncoded, index)) >= 0 && index < hashOrEndIndex) {
    var precedingChar = uri.charCodeAt(index - 1);
    if (precedingChar == goog.uri.utils.CharCode_.AMPERSAND || precedingChar == goog.uri.utils.CharCode_.QUESTION) {
      var followingChar = uri.charCodeAt(index + keyLength);
      if (!followingChar || followingChar == goog.uri.utils.CharCode_.EQUAL || followingChar == goog.uri.utils.CharCode_.AMPERSAND || followingChar == goog.uri.utils.CharCode_.HASH) {
        return index;
      }
    }
    index += keyLength + 1;
  }
  return -1;
};
goog.uri.utils.hashOrEndRe_ = /#|$/;
goog.uri.utils.hasParam = function(uri, keyEncoded) {
  return goog.uri.utils.findParam_(uri, 0, keyEncoded, uri.search(goog.uri.utils.hashOrEndRe_)) >= 0;
};
goog.uri.utils.getParamValue = function(uri, keyEncoded) {
  var hashOrEndIndex = uri.search(goog.uri.utils.hashOrEndRe_);
  var foundIndex = goog.uri.utils.findParam_(uri, 0, keyEncoded, hashOrEndIndex);
  if (foundIndex < 0) {
    return null;
  } else {
    var endPosition = uri.indexOf("&", foundIndex);
    if (endPosition < 0 || endPosition > hashOrEndIndex) {
      endPosition = hashOrEndIndex;
    }
    foundIndex += keyEncoded.length + 1;
    return goog.string.urlDecode(uri.substr(foundIndex, endPosition - foundIndex));
  }
};
goog.uri.utils.getParamValues = function(uri, keyEncoded) {
  var hashOrEndIndex = uri.search(goog.uri.utils.hashOrEndRe_);
  var position = 0;
  var foundIndex;
  var result = [];
  while ((foundIndex = goog.uri.utils.findParam_(uri, position, keyEncoded, hashOrEndIndex)) >= 0) {
    position = uri.indexOf("&", foundIndex);
    if (position < 0 || position > hashOrEndIndex) {
      position = hashOrEndIndex;
    }
    foundIndex += keyEncoded.length + 1;
    result.push(goog.string.urlDecode(uri.substr(foundIndex, position - foundIndex)));
  }
  return result;
};
goog.uri.utils.trailingQueryPunctuationRe_ = /[?&]($|#)/;
goog.uri.utils.removeParam = function(uri, keyEncoded) {
  var hashOrEndIndex = uri.search(goog.uri.utils.hashOrEndRe_);
  var position = 0;
  var foundIndex;
  var buffer = [];
  while ((foundIndex = goog.uri.utils.findParam_(uri, position, keyEncoded, hashOrEndIndex)) >= 0) {
    buffer.push(uri.substring(position, foundIndex));
    position = Math.min(uri.indexOf("&", foundIndex) + 1 || hashOrEndIndex, hashOrEndIndex);
  }
  buffer.push(uri.substr(position));
  return buffer.join("").replace(goog.uri.utils.trailingQueryPunctuationRe_, "$1");
};
goog.uri.utils.setParam = function(uri, keyEncoded, value) {
  return goog.uri.utils.appendParam(goog.uri.utils.removeParam(uri, keyEncoded), keyEncoded, value);
};
goog.uri.utils.appendPath = function(baseUri, path) {
  goog.uri.utils.assertNoFragmentsOrQueries_(baseUri);
  if (goog.string.endsWith(baseUri, "/")) {
    baseUri = baseUri.substr(0, baseUri.length - 1);
  }
  if (goog.string.startsWith(path, "/")) {
    path = path.substr(1);
  }
  return goog.string.buildString(baseUri, "/", path);
};
goog.uri.utils.setPath = function(uri, path) {
  if (!goog.string.startsWith(path, "/")) {
    path = "/" + path;
  }
  var parts = goog.uri.utils.split(uri);
  return goog.uri.utils.buildFromEncodedParts(parts[goog.uri.utils.ComponentIndex.SCHEME], parts[goog.uri.utils.ComponentIndex.USER_INFO], parts[goog.uri.utils.ComponentIndex.DOMAIN], parts[goog.uri.utils.ComponentIndex.PORT], path, parts[goog.uri.utils.ComponentIndex.QUERY_DATA], parts[goog.uri.utils.ComponentIndex.FRAGMENT]);
};
goog.uri.utils.StandardQueryParam = {RANDOM:"zx"};
goog.uri.utils.makeUnique = function(uri) {
  return goog.uri.utils.setParam(uri, goog.uri.utils.StandardQueryParam.RANDOM, goog.string.getRandomString());
};
goog.provide("goog.editor.Link");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.Range");
goog.require("goog.dom.TagName");
goog.require("goog.editor.BrowserFeature");
goog.require("goog.editor.Command");
goog.require("goog.editor.node");
goog.require("goog.editor.range");
goog.require("goog.string");
goog.require("goog.string.Unicode");
goog.require("goog.uri.utils");
goog.require("goog.uri.utils.ComponentIndex");
goog.editor.Link = function(anchor, isNew) {
  this.anchor_ = anchor;
  this.isNew_ = isNew;
  this.extraAnchors_ = [];
};
goog.editor.Link.prototype.getAnchor = function() {
  return this.anchor_;
};
goog.editor.Link.prototype.getExtraAnchors = function() {
  return this.extraAnchors_;
};
goog.editor.Link.prototype.getCurrentText = function() {
  if (!this.currentText_) {
    var anchor = this.getAnchor();
    var leaf = goog.editor.node.getLeftMostLeaf(anchor);
    if (leaf.tagName && leaf.tagName == goog.dom.TagName.IMG) {
      this.currentText_ = leaf.getAttribute("alt");
    } else {
      this.currentText_ = goog.dom.getRawTextContent(this.getAnchor());
    }
  }
  return this.currentText_;
};
goog.editor.Link.prototype.isNew = function() {
  return this.isNew_;
};
goog.editor.Link.prototype.initializeUrl = function(url) {
  this.getAnchor().href = url;
};
goog.editor.Link.prototype.removeLink = function() {
  goog.dom.flattenElement(this.anchor_);
  this.anchor_ = null;
  while (this.extraAnchors_.length) {
    goog.dom.flattenElement((this.extraAnchors_.pop()));
  }
};
goog.editor.Link.prototype.setTextAndUrl = function(newText, newUrl) {
  var anchor = this.getAnchor();
  anchor.href = newUrl;
  var currentText = this.getCurrentText();
  if (newText != currentText) {
    var leaf = goog.editor.node.getLeftMostLeaf(anchor);
    if (leaf.tagName && leaf.tagName == goog.dom.TagName.IMG) {
      leaf.setAttribute("alt", newText ? newText : "");
    } else {
      if (leaf.nodeType == goog.dom.NodeType.TEXT) {
        leaf = leaf.parentNode;
      }
      if (goog.dom.getRawTextContent(leaf) != currentText) {
        leaf = anchor;
      }
      goog.dom.removeChildren(leaf);
      var domHelper = goog.dom.getDomHelper(leaf);
      goog.dom.appendChild(leaf, domHelper.createTextNode(newText));
    }
    this.currentText_ = null;
  }
  this.isNew_ = false;
};
goog.editor.Link.prototype.placeCursorRightOf = function() {
  var anchor = this.getAnchor();
  if (goog.editor.BrowserFeature.GETS_STUCK_IN_LINKS) {
    var spaceNode;
    var nextSibling = anchor.nextSibling;
    if (nextSibling && nextSibling.nodeType == goog.dom.NodeType.TEXT && (goog.string.startsWith(nextSibling.data, goog.string.Unicode.NBSP) || goog.string.startsWith(nextSibling.data, " "))) {
      spaceNode = nextSibling;
    } else {
      var dh = goog.dom.getDomHelper(anchor);
      spaceNode = dh.createTextNode(goog.string.Unicode.NBSP);
      goog.dom.insertSiblingAfter(spaceNode, anchor);
    }
    var range = goog.dom.Range.createCaret(spaceNode, 1);
    range.select();
  } else {
    goog.editor.range.placeCursorNextTo(anchor, false);
  }
};
goog.editor.Link.prototype.updateLinkDisplay_ = function(field, url) {
  this.initializeUrl(url);
  this.placeCursorRightOf();
  field.execCommand(goog.editor.Command.UPDATE_LINK_BUBBLE);
};
goog.editor.Link.prototype.getValidLinkFromText = function() {
  var text = goog.string.trim(this.getCurrentText());
  if (goog.editor.Link.isLikelyUrl(text)) {
    if (text.search(/:/) < 0) {
      return "http://" + goog.string.trimLeft(text);
    }
    return text;
  } else {
    if (goog.editor.Link.isLikelyEmailAddress(text)) {
      return "mailto:" + text;
    }
  }
  return null;
};
goog.editor.Link.prototype.finishLinkCreation = function(field) {
  var linkFromText = this.getValidLinkFromText();
  if (linkFromText) {
    this.updateLinkDisplay_(field, linkFromText);
  } else {
    field.execCommand(goog.editor.Command.MODAL_LINK_EDITOR, this);
  }
};
goog.editor.Link.createNewLink = function(anchor, url, opt_target, opt_extraAnchors) {
  var link = new goog.editor.Link(anchor, true);
  link.initializeUrl(url);
  if (opt_target) {
    anchor.target = opt_target;
  }
  if (opt_extraAnchors) {
    link.extraAnchors_ = opt_extraAnchors;
  }
  return link;
};
goog.editor.Link.createNewLinkFromText = function(anchor, opt_target) {
  var link = new goog.editor.Link(anchor, true);
  var text = link.getValidLinkFromText();
  link.initializeUrl(text ? text : "");
  if (opt_target) {
    anchor.target = opt_target;
  }
  return link;
};
goog.editor.Link.isLikelyUrl = function(str) {
  if (/\s/.test(str)) {
    return false;
  }
  if (goog.editor.Link.isLikelyEmailAddress(str)) {
    return false;
  }
  var addedScheme = false;
  if (!/^[^:\/?#.]+:/.test(str)) {
    str = "http://" + str;
    addedScheme = true;
  }
  var parts = goog.uri.utils.split(str);
  var scheme = parts[goog.uri.utils.ComponentIndex.SCHEME];
  if (goog.array.indexOf(["mailto", "aim"], scheme) != -1) {
    return true;
  }
  var domain = parts[goog.uri.utils.ComponentIndex.DOMAIN];
  if (!domain || addedScheme && domain.indexOf(".") == -1 || /[^\w\d\-\u0100-\uffff.%]/.test(domain)) {
    return false;
  }
  var path = parts[goog.uri.utils.ComponentIndex.PATH];
  return !path || path.indexOf("/") == 0;
};
goog.editor.Link.LIKELY_EMAIL_ADDRESS_ = new RegExp("^" + "[\\w-]+(\\.[\\w-]+)*" + "\\@" + "([\\w-]+\\.)+" + "(\\d+|\\w\\w+)$", "i");
goog.editor.Link.isLikelyEmailAddress = function(str) {
  return goog.editor.Link.LIKELY_EMAIL_ADDRESS_.test(str);
};
goog.editor.Link.isMailto = function(url) {
  return !!url && goog.string.startsWith(url, "mailto:");
};
goog.provide("goog.ui.editor.messages");
goog.require("goog.html.uncheckedconversions");
goog.require("goog.string.Const");
goog.ui.editor.messages.MSG_LINK_CAPTION = goog.getMsg("Link");
goog.ui.editor.messages.MSG_EDIT_LINK = goog.getMsg("Edit Link");
goog.ui.editor.messages.MSG_TEXT_TO_DISPLAY = goog.getMsg("Text to display:");
goog.ui.editor.messages.MSG_LINK_TO = goog.getMsg("Link to:");
goog.ui.editor.messages.MSG_ON_THE_WEB = goog.getMsg("Web address");
goog.ui.editor.messages.MSG_ON_THE_WEB_TIP = goog.getMsg("Link to a page or file somewhere else on the web");
goog.ui.editor.messages.MSG_TEST_THIS_LINK = goog.getMsg("Test this link");
goog.ui.editor.messages.MSG_TR_LINK_EXPLANATION = goog.getMsg("{$startBold}Not sure what to put in the box?{$endBold} " + "First, find the page on the web that you want to " + "link to. (A {$searchEngineLink}search engine{$endLink} " + "might be useful.) Then, copy the web address from " + "the box in your browser's address bar, and paste it into " + "the box above.", {"startBold":"<b>", "endBold":"</b>", "searchEngineLink":"<a href='http://www.google.com/' target='_new'>", "endLink":"</a>"});
goog.ui.editor.messages.getTrLinkExplanationSafeHtml = function() {
  return goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Parameterless translation"), goog.ui.editor.messages.MSG_TR_LINK_EXPLANATION);
};
goog.ui.editor.messages.MSG_WHAT_URL = goog.getMsg("To what URL should this link go?");
goog.ui.editor.messages.MSG_EMAIL_ADDRESS = goog.getMsg("Email address");
goog.ui.editor.messages.MSG_EMAIL_ADDRESS_TIP = goog.getMsg("Link to an email address");
goog.ui.editor.messages.MSG_INVALID_EMAIL = goog.getMsg("Invalid email address");
goog.ui.editor.messages.MSG_WHAT_EMAIL = goog.getMsg("To what email address should this link?");
goog.ui.editor.messages.MSG_EMAIL_EXPLANATION = goog.getMsg("{$preb}Be careful.{$postb} " + "Remember that any time you include an email address on a web page, " + "nasty spammers can find it too.", {"preb":"<b>", "postb":"</b>"});
goog.ui.editor.messages.getEmailExplanationSafeHtml = function() {
  return goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Parameterless translation"), goog.ui.editor.messages.MSG_EMAIL_EXPLANATION);
};
goog.ui.editor.messages.MSG_OPEN_IN_NEW_WINDOW = goog.getMsg("Open this link in a new window");
goog.ui.editor.messages.MSG_IMAGE_CAPTION = goog.getMsg("Image");
goog.provide("goog.editor.plugins.BasicTextFormatter");
goog.provide("goog.editor.plugins.BasicTextFormatter.COMMAND");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.Range");
goog.require("goog.dom.TagName");
goog.require("goog.editor.BrowserFeature");
goog.require("goog.editor.Command");
goog.require("goog.editor.Link");
goog.require("goog.editor.Plugin");
goog.require("goog.editor.node");
goog.require("goog.editor.range");
goog.require("goog.editor.style");
goog.require("goog.iter");
goog.require("goog.iter.StopIteration");
goog.require("goog.log");
goog.require("goog.object");
goog.require("goog.string");
goog.require("goog.string.Unicode");
goog.require("goog.style");
goog.require("goog.ui.editor.messages");
goog.require("goog.userAgent");
goog.editor.plugins.BasicTextFormatter = function() {
  goog.editor.Plugin.call(this);
};
goog.inherits(goog.editor.plugins.BasicTextFormatter, goog.editor.Plugin);
goog.editor.plugins.BasicTextFormatter.prototype.getTrogClassId = function() {
  return "BTF";
};
goog.editor.plugins.BasicTextFormatter.prototype.logger = goog.log.getLogger("goog.editor.plugins.BasicTextFormatter");
goog.editor.plugins.BasicTextFormatter.COMMAND = {LINK:"+link", CREATE_LINK:"+createLink", FORMAT_BLOCK:"+formatBlock", INDENT:"+indent", OUTDENT:"+outdent", STRIKE_THROUGH:"+strikeThrough", HORIZONTAL_RULE:"+insertHorizontalRule", SUBSCRIPT:"+subscript", SUPERSCRIPT:"+superscript", UNDERLINE:"+underline", BOLD:"+bold", ITALIC:"+italic", FONT_SIZE:"+fontSize", FONT_FACE:"+fontName", FONT_COLOR:"+foreColor", BACKGROUND_COLOR:"+backColor", ORDERED_LIST:"+insertOrderedList", UNORDERED_LIST:"+insertUnorderedList", 
JUSTIFY_CENTER:"+justifyCenter", JUSTIFY_FULL:"+justifyFull", JUSTIFY_RIGHT:"+justifyRight", JUSTIFY_LEFT:"+justifyLeft"};
goog.editor.plugins.BasicTextFormatter.SUPPORTED_COMMANDS_ = goog.object.transpose(goog.editor.plugins.BasicTextFormatter.COMMAND);
goog.editor.plugins.BasicTextFormatter.prototype.isSupportedCommand = function(command) {
  return command in goog.editor.plugins.BasicTextFormatter.SUPPORTED_COMMANDS_;
};
goog.editor.plugins.BasicTextFormatter.SILENT_COMMANDS_ = [goog.editor.plugins.BasicTextFormatter.COMMAND.CREATE_LINK];
goog.editor.plugins.BasicTextFormatter.prototype.isSilentCommand = function(command) {
  return goog.array.contains(goog.editor.plugins.BasicTextFormatter.SILENT_COMMANDS_, command);
};
goog.editor.plugins.BasicTextFormatter.prototype.getRange_ = function() {
  return this.getFieldObject().getRange();
};
goog.editor.plugins.BasicTextFormatter.prototype.getDocument_ = function() {
  return this.getFieldDomHelper().getDocument();
};
goog.editor.plugins.BasicTextFormatter.prototype.execCommandInternal = function(command, var_args) {
  var preserveDir, styleWithCss, needsFormatBlockDiv, hasDummySelection;
  var result;
  var opt_arg = arguments[1];
  switch(command) {
    case goog.editor.plugins.BasicTextFormatter.COMMAND.BACKGROUND_COLOR:
      if (!goog.isNull(opt_arg)) {
        if (goog.editor.BrowserFeature.EATS_EMPTY_BACKGROUND_COLOR) {
          this.applyBgColorManually_(opt_arg);
        } else {
          if (goog.userAgent.OPERA) {
            this.execCommandHelper_("hiliteColor", opt_arg);
          } else {
            this.execCommandHelper_(command, opt_arg);
          }
        }
      }
      break;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.CREATE_LINK:
      result = this.createLink_(arguments[1], arguments[2], arguments[3]);
      break;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.LINK:
      result = this.toggleLink_(opt_arg);
      break;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_CENTER:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_FULL:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_RIGHT:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_LEFT:
      this.justify_(command);
      break;
    default:
      if (goog.userAgent.IE && command == goog.editor.plugins.BasicTextFormatter.COMMAND.FORMAT_BLOCK && opt_arg) {
        opt_arg = "<" + opt_arg + ">";
      }
      if (command == goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_COLOR && goog.isNull(opt_arg)) {
        break;
      }
      switch(command) {
        case goog.editor.plugins.BasicTextFormatter.COMMAND.INDENT:
        ;
        case goog.editor.plugins.BasicTextFormatter.COMMAND.OUTDENT:
          if (goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS) {
            if (goog.userAgent.GECKO) {
              styleWithCss = true;
            }
            if (goog.userAgent.OPERA) {
              if (command == goog.editor.plugins.BasicTextFormatter.COMMAND.OUTDENT) {
                styleWithCss = !this.getDocument_().queryCommandEnabled("outdent");
              } else {
                styleWithCss = true;
              }
            }
          }
        ;
        case goog.editor.plugins.BasicTextFormatter.COMMAND.ORDERED_LIST:
        ;
        case goog.editor.plugins.BasicTextFormatter.COMMAND.UNORDERED_LIST:
          if (goog.editor.BrowserFeature.LEAVES_P_WHEN_REMOVING_LISTS && this.queryCommandStateInternal_(this.getDocument_(), command)) {
            needsFormatBlockDiv = this.getFieldObject().queryCommandValue(goog.editor.Command.DEFAULT_TAG) != goog.dom.TagName.P;
          } else {
            if (!goog.editor.BrowserFeature.CAN_LISTIFY_BR) {
              this.convertBreaksToDivs_();
            }
          }
          if (goog.userAgent.GECKO && goog.editor.BrowserFeature.FORGETS_FORMATTING_WHEN_LISTIFYING && !this.queryCommandValue(command)) {
            hasDummySelection |= this.beforeInsertListGecko_();
          }
        ;
        case goog.editor.plugins.BasicTextFormatter.COMMAND.FORMAT_BLOCK:
          preserveDir = !!this.getFieldObject().getPluginByClassId("Bidi");
          break;
        case goog.editor.plugins.BasicTextFormatter.COMMAND.SUBSCRIPT:
        ;
        case goog.editor.plugins.BasicTextFormatter.COMMAND.SUPERSCRIPT:
          if (goog.editor.BrowserFeature.NESTS_SUBSCRIPT_SUPERSCRIPT) {
            this.applySubscriptSuperscriptWorkarounds_(command);
          }
          break;
        case goog.editor.plugins.BasicTextFormatter.COMMAND.UNDERLINE:
        ;
        case goog.editor.plugins.BasicTextFormatter.COMMAND.BOLD:
        ;
        case goog.editor.plugins.BasicTextFormatter.COMMAND.ITALIC:
          styleWithCss = goog.userAgent.GECKO && goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS && this.queryCommandValue(command);
          break;
        case goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_COLOR:
        ;
        case goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_FACE:
          styleWithCss = goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS && goog.userAgent.GECKO;
      }
      this.execCommandHelper_(command, opt_arg, preserveDir, !!styleWithCss);
      if (hasDummySelection) {
        this.getDocument_().execCommand("Delete", false, true);
      }
      if (needsFormatBlockDiv) {
        this.getDocument_().execCommand("FormatBlock", false, "<div>");
      }
    ;
  }
  if (goog.userAgent.GECKO && !this.getFieldObject().inModalMode()) {
    this.focusField_();
  }
  return result;
};
goog.editor.plugins.BasicTextFormatter.prototype.focusField_ = function() {
  this.getFieldDomHelper().getWindow().focus();
};
goog.editor.plugins.BasicTextFormatter.prototype.queryCommandValue = function(command) {
  var styleWithCss;
  switch(command) {
    case goog.editor.plugins.BasicTextFormatter.COMMAND.LINK:
      return this.isNodeInState_(goog.dom.TagName.A);
    case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_CENTER:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_FULL:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_RIGHT:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_LEFT:
      return this.isJustification_(command);
    case goog.editor.plugins.BasicTextFormatter.COMMAND.FORMAT_BLOCK:
      return goog.editor.plugins.BasicTextFormatter.getSelectionBlockState_(this.getFieldObject().getRange());
    case goog.editor.plugins.BasicTextFormatter.COMMAND.INDENT:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.OUTDENT:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.HORIZONTAL_RULE:
      return false;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_SIZE:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_FACE:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_COLOR:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.BACKGROUND_COLOR:
      return this.queryCommandValueInternal_(this.getDocument_(), command, goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS && goog.userAgent.GECKO);
    case goog.editor.plugins.BasicTextFormatter.COMMAND.UNDERLINE:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.BOLD:
    ;
    case goog.editor.plugins.BasicTextFormatter.COMMAND.ITALIC:
      styleWithCss = goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS && goog.userAgent.GECKO;
    default:
      return this.queryCommandStateInternal_(this.getDocument_(), command, styleWithCss);
  }
};
goog.editor.plugins.BasicTextFormatter.prototype.prepareContentsHtml = function(html) {
  if (goog.editor.BrowserFeature.COLLAPSES_EMPTY_NODES && html.match(/^\s*<script/i)) {
    html = "&nbsp;" + html;
  }
  if (goog.editor.BrowserFeature.CONVERT_TO_B_AND_I_TAGS) {
    html = html.replace(/<(\/?)strong([^\w])/gi, "<$1b$2");
    html = html.replace(/<(\/?)em([^\w])/gi, "<$1i$2");
  }
  return html;
};
goog.editor.plugins.BasicTextFormatter.prototype.cleanContentsDom = function(fieldCopy) {
  var images = fieldCopy.getElementsByTagName(goog.dom.TagName.IMG);
  for (var i = 0, image;image = images[i];i++) {
    if (goog.editor.BrowserFeature.SHOWS_CUSTOM_ATTRS_IN_INNER_HTML) {
      image.removeAttribute("tabIndex");
      image.removeAttribute("tabIndexSet");
      goog.removeUid(image);
      image.oldTabIndex;
      if (image.oldTabIndex) {
        image.tabIndex = image.oldTabIndex;
      }
    }
  }
};
goog.editor.plugins.BasicTextFormatter.prototype.cleanContentsHtml = function(html) {
  if (goog.editor.BrowserFeature.MOVES_STYLE_TO_HEAD) {
    var heads = this.getFieldObject().getEditableDomHelper().getElementsByTagNameAndClass(goog.dom.TagName.HEAD);
    var stylesHtmlArr = [];
    var numHeads = heads.length;
    for (var i = 1;i < numHeads;++i) {
      var styles = heads[i].getElementsByTagName(goog.dom.TagName.STYLE);
      var numStyles = styles.length;
      for (var j = 0;j < numStyles;++j) {
        stylesHtmlArr.push(styles[j].outerHTML);
      }
    }
    return stylesHtmlArr.join("") + html;
  }
  return html;
};
goog.editor.plugins.BasicTextFormatter.prototype.handleKeyboardShortcut = function(e, key, isModifierPressed) {
  if (!isModifierPressed) {
    return false;
  }
  var command;
  switch(key) {
    case "b":
      command = goog.editor.plugins.BasicTextFormatter.COMMAND.BOLD;
      break;
    case "i":
      command = goog.editor.plugins.BasicTextFormatter.COMMAND.ITALIC;
      break;
    case "u":
      command = goog.editor.plugins.BasicTextFormatter.COMMAND.UNDERLINE;
      break;
    case "s":
      return true;
  }
  if (command) {
    this.getFieldObject().execCommand(command);
    return true;
  }
  return false;
};
goog.editor.plugins.BasicTextFormatter.BR_REGEXP_ = goog.userAgent.IE ? /<br([^\/>]*)\/?>/gi : /<br([^\/>]*)\/?>(?!<\/(div|p)>)/gi;
goog.editor.plugins.BasicTextFormatter.prototype.convertBreaksToDivs_ = function() {
  if (!goog.userAgent.IE && !goog.userAgent.OPERA) {
    return false;
  }
  var range = this.getRange_();
  var parent = range.getContainerElement();
  var doc = this.getDocument_();
  goog.editor.plugins.BasicTextFormatter.BR_REGEXP_.lastIndex = 0;
  if (goog.editor.plugins.BasicTextFormatter.BR_REGEXP_.test(parent.innerHTML)) {
    var savedRange = range.saveUsingCarets();
    if (parent.tagName == goog.dom.TagName.P) {
      goog.editor.plugins.BasicTextFormatter.convertParagraphToDiv_(parent, true);
    } else {
      var attribute = "trtempbr";
      var value = "temp_br";
      var newHtml = parent.innerHTML.replace(goog.editor.plugins.BasicTextFormatter.BR_REGEXP_, "<p$1 " + attribute + '="' + value + '">');
      goog.editor.node.replaceInnerHtml(parent, newHtml);
      var paragraphs = goog.array.toArray(parent.getElementsByTagName(goog.dom.TagName.P));
      goog.iter.forEach(paragraphs, function(paragraph) {
        if (paragraph.getAttribute(attribute) == value) {
          paragraph.removeAttribute(attribute);
          if (goog.string.isBreakingWhitespace(goog.dom.getTextContent(paragraph))) {
            var child = goog.userAgent.IE ? doc.createTextNode(goog.string.Unicode.NBSP) : doc.createElement(goog.dom.TagName.BR);
            paragraph.appendChild(child);
          }
          goog.editor.plugins.BasicTextFormatter.convertParagraphToDiv_(paragraph);
        }
      });
    }
    savedRange.restore();
    return true;
  }
  return false;
};
goog.editor.plugins.BasicTextFormatter.convertParagraphToDiv_ = function(paragraph, opt_convertBrs) {
  if (!goog.userAgent.IE && !goog.userAgent.OPERA) {
    return;
  }
  var outerHTML = paragraph.outerHTML.replace(/<(\/?)p/gi, "<$1div");
  if (opt_convertBrs) {
    outerHTML = outerHTML.replace(goog.editor.plugins.BasicTextFormatter.BR_REGEXP_, "</div><div$1>");
  }
  if (goog.userAgent.OPERA && !/<\/div>$/i.test(outerHTML)) {
    outerHTML += "</div>";
  }
  paragraph.outerHTML = outerHTML;
};
goog.editor.plugins.BasicTextFormatter.convertToRealExecCommand_ = function(command) {
  return command.indexOf("+") == 0 ? command.substring(1) : command;
};
goog.editor.plugins.BasicTextFormatter.prototype.justify_ = function(command) {
  this.execCommandHelper_(command, null, false, true);
  if (goog.userAgent.GECKO) {
    this.execCommandHelper_(command, null, false, true);
  }
  if (!(goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS && goog.userAgent.GECKO)) {
    goog.iter.forEach(this.getFieldObject().getRange(), goog.editor.plugins.BasicTextFormatter.convertContainerToTextAlign_);
  }
};
goog.editor.plugins.BasicTextFormatter.convertContainerToTextAlign_ = function(node) {
  var container = goog.editor.style.getContainer(node);
  if (container.align) {
    container.style.textAlign = container.align;
    container.removeAttribute("align");
  }
};
goog.editor.plugins.BasicTextFormatter.prototype.execCommandHelper_ = function(command, opt_value, opt_preserveDir, opt_styleWithCss) {
  var dir = null;
  if (opt_preserveDir) {
    dir = this.getFieldObject().queryCommandValue(goog.editor.Command.DIR_RTL) ? "rtl" : this.getFieldObject().queryCommandValue(goog.editor.Command.DIR_LTR) ? "ltr" : null;
  }
  command = goog.editor.plugins.BasicTextFormatter.convertToRealExecCommand_(command);
  var endDiv, nbsp;
  if (goog.userAgent.IE) {
    var ret = this.applyExecCommandIEFixes_(command);
    endDiv = ret[0];
    nbsp = ret[1];
  }
  if (goog.userAgent.WEBKIT) {
    endDiv = this.applyExecCommandSafariFixes_(command);
  }
  if (goog.userAgent.GECKO) {
    this.applyExecCommandGeckoFixes_(command);
  }
  if (goog.editor.BrowserFeature.DOESNT_OVERRIDE_FONT_SIZE_IN_STYLE_ATTR && command.toLowerCase() == "fontsize") {
    this.removeFontSizeFromStyleAttrs_();
  }
  var doc = this.getDocument_();
  if (opt_styleWithCss && goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS) {
    doc.execCommand("styleWithCSS", false, true);
    if (goog.userAgent.OPERA) {
      this.invalidateInlineCss_();
    }
  }
  doc.execCommand(command, false, opt_value);
  if (opt_styleWithCss && goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS) {
    doc.execCommand("styleWithCSS", false, false);
  }
  if (goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher("526") && command.toLowerCase() == "formatblock" && opt_value && /^[<]?h\d[>]?$/i.test(opt_value)) {
    this.cleanUpSafariHeadings_();
  }
  if (/insert(un)?orderedlist/i.test(command)) {
    if (goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher(534)) {
      this.fixSafariLists_();
    }
    if (goog.userAgent.IE) {
      this.fixIELists_();
      if (nbsp) {
        goog.dom.removeNode(nbsp);
      }
    }
  }
  if (endDiv) {
    goog.dom.removeNode(endDiv);
  }
  if (dir) {
    this.getFieldObject().execCommand(dir);
  }
};
goog.editor.plugins.BasicTextFormatter.prototype.applyBgColorManually_ = function(bgColor) {
  var needsSpaceInTextNode = goog.userAgent.GECKO;
  var range = this.getFieldObject().getRange();
  var textNode;
  var parentTag;
  if (range && range.isCollapsed()) {
    textNode = this.getFieldDomHelper().createTextNode(needsSpaceInTextNode ? " " : "");
    var containerNode = range.getStartNode();
    parentTag = containerNode.nodeType == goog.dom.NodeType.ELEMENT ? containerNode : containerNode.parentNode;
    if (parentTag.innerHTML == "") {
      parentTag.style.textIndent = "-10000px";
      parentTag.appendChild(textNode);
    } else {
      parentTag = this.getFieldDomHelper().createDom(goog.dom.TagName.SPAN, {"style":"text-indent:-10000px"}, textNode);
      range.replaceContentsWithNode(parentTag);
    }
    goog.dom.Range.createFromNodeContents(textNode).select();
  }
  this.execCommandHelper_("hiliteColor", bgColor, false, true);
  if (textNode) {
    if (needsSpaceInTextNode) {
      textNode.data = "";
    }
    parentTag.style.textIndent = "";
  }
};
goog.editor.plugins.BasicTextFormatter.prototype.toggleLink_ = function(opt_target) {
  if (!this.getFieldObject().isSelectionEditable()) {
    this.focusField_();
  }
  var range = this.getRange_();
  var parent = range && range.getContainerElement();
  var link = (goog.dom.getAncestorByTagNameAndClass(parent, goog.dom.TagName.A));
  if (link && goog.editor.node.isEditable(link)) {
    goog.dom.flattenElement(link);
  } else {
    var editableLink = this.createLink_(range, "/", opt_target);
    if (editableLink) {
      if (!this.getFieldObject().execCommand(goog.editor.Command.MODAL_LINK_EDITOR, editableLink)) {
        var url = this.getFieldObject().getAppWindow().prompt(goog.ui.editor.messages.MSG_LINK_TO, "http://");
        if (url) {
          editableLink.setTextAndUrl(editableLink.getCurrentText() || url, url);
          editableLink.placeCursorRightOf();
        } else {
          var savedRange = goog.editor.range.saveUsingNormalizedCarets(goog.dom.Range.createFromNodeContents(editableLink.getAnchor()));
          editableLink.removeLink();
          savedRange.restore().select();
          return null;
        }
      }
      return editableLink;
    }
  }
  return null;
};
goog.editor.plugins.BasicTextFormatter.prototype.createLink_ = function(range, url, opt_target) {
  var anchor = null;
  var anchors = [];
  var parent = range && range.getContainerElement();
  if (parent && parent.tagName == goog.dom.TagName.IMG) {
    return null;
  }
  if (!range) {
    return null;
  }
  if (range.isCollapsed()) {
    var textRange = range.getTextRange(0).getBrowserRangeObject();
    if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
      anchor = this.getFieldDomHelper().createElement(goog.dom.TagName.A);
      textRange.insertNode(anchor);
    } else {
      if (goog.editor.BrowserFeature.HAS_IE_RANGES) {
        textRange.pasteHTML("<a id='newLink'></a>");
        anchor = this.getFieldDomHelper().getElement("newLink");
        anchor.removeAttribute("id");
      }
    }
  } else {
    var uniqueId = goog.string.createUniqueString();
    this.execCommandHelper_("CreateLink", uniqueId);
    var setHrefAndLink = function(element, index, arr) {
      if (goog.string.endsWith(element.href, uniqueId)) {
        anchors.push(element);
      }
    };
    goog.array.forEach(this.getFieldObject().getElement().getElementsByTagName(goog.dom.TagName.A), setHrefAndLink);
    if (anchors.length) {
      anchor = anchors.pop();
    }
    var isLikelyUrl = function(a, i, anchors) {
      return goog.editor.Link.isLikelyUrl(goog.dom.getRawTextContent(a));
    };
    if (anchors.length && goog.array.every(anchors, isLikelyUrl)) {
      for (var i = 0, a;a = anchors[i];i++) {
        goog.editor.Link.createNewLinkFromText(a, opt_target);
      }
      anchors = null;
    }
  }
  return goog.editor.Link.createNewLink((anchor), url, opt_target, anchors);
};
goog.editor.plugins.BasicTextFormatter.brokenExecCommandsIE_ = {"indent":1, "outdent":1, "insertOrderedList":1, "insertUnorderedList":1, "justifyCenter":1, "justifyFull":1, "justifyRight":1, "justifyLeft":1, "ltr":1, "rtl":1};
goog.editor.plugins.BasicTextFormatter.blockquoteHatingCommandsIE_ = {"insertOrderedList":1, "insertUnorderedList":1};
goog.editor.plugins.BasicTextFormatter.prototype.applySubscriptSuperscriptWorkarounds_ = function(command) {
  if (!this.queryCommandValue(command)) {
    var oppositeCommand = command == goog.editor.plugins.BasicTextFormatter.COMMAND.SUBSCRIPT ? goog.editor.plugins.BasicTextFormatter.COMMAND.SUPERSCRIPT : goog.editor.plugins.BasicTextFormatter.COMMAND.SUBSCRIPT;
    var oppositeExecCommand = goog.editor.plugins.BasicTextFormatter.convertToRealExecCommand_(oppositeCommand);
    if (!this.queryCommandValue(oppositeCommand)) {
      this.getDocument_().execCommand(oppositeExecCommand, false, null);
    }
    this.getDocument_().execCommand(oppositeExecCommand, false, null);
  }
};
goog.editor.plugins.BasicTextFormatter.prototype.removeFontSizeFromStyleAttrs_ = function() {
  var range = goog.editor.range.expand(this.getFieldObject().getRange(), this.getFieldObject().getElement());
  goog.iter.forEach(goog.iter.filter(range, function(tag, dummy, iter) {
    return iter.isStartTag() && range.containsNode(tag);
  }), function(node) {
    goog.style.setStyle(node, "font-size", "");
    if (goog.userAgent.GECKO && node.style.length == 0 && node.getAttribute("style") != null) {
      node.removeAttribute("style");
    }
  });
};
goog.editor.plugins.BasicTextFormatter.prototype.applyExecCommandIEFixes_ = function(command) {
  var toRemove = [];
  var endDiv = null;
  var range = this.getRange_();
  var dh = this.getFieldDomHelper();
  if (command in goog.editor.plugins.BasicTextFormatter.blockquoteHatingCommandsIE_) {
    var parent = range && range.getContainerElement();
    if (parent) {
      var blockquotes = goog.dom.getElementsByTagNameAndClass(goog.dom.TagName.BLOCKQUOTE, null, parent);
      var bq;
      for (var i = 0;i < blockquotes.length;i++) {
        if (range.containsNode(blockquotes[i])) {
          bq = blockquotes[i];
          break;
        }
      }
      var bqThatNeedsDummyDiv = bq || goog.dom.getAncestorByTagNameAndClass(parent, goog.dom.TagName.BLOCKQUOTE);
      if (bqThatNeedsDummyDiv) {
        endDiv = dh.createDom(goog.dom.TagName.DIV, {style:"height:0"});
        goog.dom.appendChild(bqThatNeedsDummyDiv, endDiv);
        toRemove.push(endDiv);
        if (bq) {
          range = goog.dom.Range.createFromNodes(bq, 0, endDiv, 0);
        } else {
          if (range.containsNode(endDiv)) {
            range = goog.dom.Range.createFromNodes(range.getStartNode(), range.getStartOffset(), endDiv, 0);
          }
        }
        range.select();
      }
    }
  }
  var fieldObject = this.getFieldObject();
  if (!fieldObject.usesIframe() && !endDiv) {
    if (command in goog.editor.plugins.BasicTextFormatter.brokenExecCommandsIE_) {
      var field = fieldObject.getElement();
      if (range && range.isCollapsed() && !goog.dom.getFirstElementChild(field)) {
        var selection = range.getTextRange(0).getBrowserRangeObject();
        var testRange = selection.duplicate();
        testRange.moveToElementText(field);
        testRange.collapse(false);
        if (testRange.isEqual(selection)) {
          var nbsp = dh.createTextNode(goog.string.Unicode.NBSP);
          field.appendChild(nbsp);
          selection.move("character", 1);
          selection.move("character", -1);
          selection.select();
          toRemove.push(nbsp);
        }
      }
      endDiv = dh.createDom(goog.dom.TagName.DIV, {style:"height:0"});
      goog.dom.appendChild(field, endDiv);
      toRemove.push(endDiv);
    }
  }
  return toRemove;
};
goog.editor.plugins.BasicTextFormatter.prototype.cleanUpSafariHeadings_ = function() {
  goog.iter.forEach(this.getRange_(), function(node) {
    if (node.className == "Apple-style-span") {
      node.style.fontSize = "";
      node.style.fontWeight = "";
    }
  });
};
goog.editor.plugins.BasicTextFormatter.prototype.fixSafariLists_ = function() {
  var previousList = false;
  goog.iter.forEach(this.getRange_(), function(node) {
    var tagName = node.tagName;
    if (tagName == goog.dom.TagName.UL || tagName == goog.dom.TagName.OL) {
      if (!previousList) {
        previousList = true;
        return;
      }
      var previousElementSibling = goog.dom.getPreviousElementSibling(node);
      if (!previousElementSibling) {
        return;
      }
      var range = node.ownerDocument.createRange();
      range.setStartAfter(previousElementSibling);
      range.setEndBefore(node);
      if (!goog.string.isEmptyOrWhitespace(range.toString())) {
        return;
      }
      if (previousElementSibling.nodeName == node.nodeName) {
        while (previousElementSibling.lastChild) {
          node.insertBefore(previousElementSibling.lastChild, node.firstChild);
        }
        previousElementSibling.parentNode.removeChild(previousElementSibling);
      }
    }
  });
};
goog.editor.plugins.BasicTextFormatter.orderedListTypes_ = {1:1, "a":1, "A":1, "i":1, "I":1};
goog.editor.plugins.BasicTextFormatter.unorderedListTypes_ = {"disc":1, "circle":1, "square":1};
goog.editor.plugins.BasicTextFormatter.prototype.fixIELists_ = function() {
  var range = this.getRange_();
  var container = range && range.getContainer();
  while (container && (container).tagName != goog.dom.TagName.UL && (container).tagName != goog.dom.TagName.OL) {
    container = container.parentNode;
  }
  if (container) {
    container = container.parentNode;
  }
  if (!container) {
    return;
  }
  var lists = goog.array.toArray((container).getElementsByTagName(goog.dom.TagName.UL));
  goog.array.extend(lists, goog.array.toArray((container).getElementsByTagName(goog.dom.TagName.OL)));
  goog.array.forEach(lists, function(node) {
    var type = node.type;
    if (type) {
      var saneTypes = node.tagName == goog.dom.TagName.UL ? goog.editor.plugins.BasicTextFormatter.unorderedListTypes_ : goog.editor.plugins.BasicTextFormatter.orderedListTypes_;
      if (!saneTypes[type]) {
        node.type = "";
      }
    }
  });
};
goog.editor.plugins.BasicTextFormatter.brokenExecCommandsSafari_ = {"justifyCenter":1, "justifyFull":1, "justifyRight":1, "justifyLeft":1, "formatBlock":1};
goog.editor.plugins.BasicTextFormatter.hangingExecCommandWebkit_ = {"insertOrderedList":1, "insertUnorderedList":1};
goog.editor.plugins.BasicTextFormatter.prototype.applyExecCommandSafariFixes_ = function(command) {
  var div;
  if (goog.editor.plugins.BasicTextFormatter.brokenExecCommandsSafari_[command]) {
    div = this.getFieldDomHelper().createDom(goog.dom.TagName.DIV, {"style":"height: 0"}, "x");
    goog.dom.appendChild(this.getFieldObject().getElement(), div);
  }
  if (!goog.userAgent.isVersionOrHigher(534) && goog.editor.plugins.BasicTextFormatter.hangingExecCommandWebkit_[command]) {
    var field = this.getFieldObject().getElement();
    div = this.getFieldDomHelper().createDom(goog.dom.TagName.DIV, {"style":"height: 0"}, "x");
    field.insertBefore(div, field.firstChild);
  }
  return div;
};
goog.editor.plugins.BasicTextFormatter.prototype.applyExecCommandGeckoFixes_ = function(command) {
  if (goog.userAgent.isVersionOrHigher("1.9") && command.toLowerCase() == "formatblock") {
    var range = this.getRange_();
    var startNode = range.getStartNode();
    if (range.isCollapsed() && startNode && (startNode).tagName == goog.dom.TagName.BODY) {
      var startOffset = range.getStartOffset();
      var childNode = startNode.childNodes[startOffset];
      if (childNode && childNode.tagName == goog.dom.TagName.BR) {
        var browserRange = range.getBrowserRangeObject();
        browserRange.setStart(childNode, 0);
        browserRange.setEnd(childNode, 0);
      }
    }
  }
};
goog.editor.plugins.BasicTextFormatter.prototype.invalidateInlineCss_ = function() {
  var ancestors = [];
  var ancestor = this.getFieldObject().getRange().getContainerElement();
  do {
    ancestors.push(ancestor);
  } while (ancestor = ancestor.parentNode);
  var nodesInSelection = goog.iter.chain(goog.iter.toIterator(this.getFieldObject().getRange()), goog.iter.toIterator(ancestors));
  var containersInSelection = goog.iter.filter(nodesInSelection, goog.editor.style.isContainer);
  goog.iter.forEach(containersInSelection, function(element) {
    var oldOutline = element.style.outline;
    element.style.outline = "0px solid red";
    element.style.outline = oldOutline;
  });
};
goog.editor.plugins.BasicTextFormatter.prototype.beforeInsertListGecko_ = function() {
  var tag = this.getFieldObject().queryCommandValue(goog.editor.Command.DEFAULT_TAG);
  if (tag == goog.dom.TagName.P || tag == goog.dom.TagName.DIV) {
    return false;
  }
  var range = this.getRange_();
  if (range.isCollapsed() && range.getContainer().nodeType != goog.dom.NodeType.TEXT) {
    var tempTextNode = this.getFieldDomHelper().createTextNode(goog.string.Unicode.NBSP);
    range.insertNode(tempTextNode, false);
    goog.dom.Range.createFromNodeContents(tempTextNode).select();
    return true;
  }
  return false;
};
goog.editor.plugins.BasicTextFormatter.getSelectionBlockState_ = function(range) {
  var tagName = null;
  goog.iter.forEach(range, function(node, ignore, it) {
    if (!it.isEndTag()) {
      var container = goog.editor.style.getContainer(node);
      var thisTagName = container.tagName;
      tagName = tagName || thisTagName;
      if (tagName != thisTagName) {
        tagName = null;
        throw goog.iter.StopIteration;
      }
      it.skipTag();
    }
  });
  return tagName;
};
goog.editor.plugins.BasicTextFormatter.SUPPORTED_JUSTIFICATIONS_ = {"center":1, "justify":1, "right":1, "left":1};
goog.editor.plugins.BasicTextFormatter.prototype.isJustification_ = function(command) {
  var alignment = command.replace("+justify", "").toLowerCase();
  if (alignment == "full") {
    alignment = "justify";
  }
  var bidiPlugin = this.getFieldObject().getPluginByClassId("Bidi");
  if (bidiPlugin) {
    bidiPlugin.getSelectionAlignment;
    return alignment == bidiPlugin.getSelectionAlignment();
  } else {
    var range = this.getRange_();
    if (!range) {
      return false;
    }
    var parent = range.getContainerElement();
    var nodes = goog.array.filter(parent.childNodes, function(node) {
      return goog.editor.node.isImportant(node) && range.containsNode(node, true);
    });
    nodes = nodes.length ? nodes : [parent];
    for (var i = 0;i < nodes.length;i++) {
      var current = nodes[i];
      var container = goog.editor.style.getContainer((current));
      if (alignment != goog.editor.plugins.BasicTextFormatter.getNodeJustification_(container)) {
        return false;
      }
    }
    return true;
  }
};
goog.editor.plugins.BasicTextFormatter.getNodeJustification_ = function(element) {
  var value = goog.style.getComputedTextAlign(element);
  value = value.replace(/^-(moz|webkit)-/, "");
  if (!goog.editor.plugins.BasicTextFormatter.SUPPORTED_JUSTIFICATIONS_[value]) {
    value = element.align || "left";
  }
  return (value);
};
goog.editor.plugins.BasicTextFormatter.prototype.isNodeInState_ = function(nodeName) {
  var range = this.getRange_();
  var node = range && range.getContainerElement();
  var ancestor = goog.dom.getAncestorByTagNameAndClass(node, nodeName);
  return !!ancestor && goog.editor.node.isEditable(ancestor);
};
goog.editor.plugins.BasicTextFormatter.prototype.queryCommandStateInternal_ = function(queryObject, command, opt_styleWithCss) {
  return (this.queryCommandHelper_(true, queryObject, command, opt_styleWithCss));
};
goog.editor.plugins.BasicTextFormatter.prototype.queryCommandValueInternal_ = function(queryObject, command, opt_styleWithCss) {
  return this.queryCommandHelper_(false, queryObject, command, opt_styleWithCss);
};
goog.editor.plugins.BasicTextFormatter.prototype.queryCommandHelper_ = function(isGetQueryCommandState, queryObject, command, opt_styleWithCss) {
  command = goog.editor.plugins.BasicTextFormatter.convertToRealExecCommand_(command);
  if (opt_styleWithCss) {
    var doc = this.getDocument_();
    doc.execCommand("styleWithCSS", false, true);
  }
  var ret = isGetQueryCommandState ? queryObject.queryCommandState(command) : queryObject.queryCommandValue(command);
  if (opt_styleWithCss) {
    doc.execCommand("styleWithCSS", false, false);
  }
  return ret;
};
goog.provide("goog.dom.NodeOffset");
goog.require("goog.Disposable");
goog.require("goog.dom.TagName");
goog.dom.NodeOffset = function(node, baseNode) {
  goog.Disposable.call(this);
  this.offsetStack_ = [];
  this.nameStack_ = [];
  while (node && node.nodeName != goog.dom.TagName.BODY && node != baseNode) {
    var siblingOffset = 0;
    var sib = node.previousSibling;
    while (sib) {
      sib = sib.previousSibling;
      ++siblingOffset;
    }
    this.offsetStack_.unshift(siblingOffset);
    this.nameStack_.unshift(node.nodeName);
    node = node.parentNode;
  }
};
goog.inherits(goog.dom.NodeOffset, goog.Disposable);
goog.dom.NodeOffset.prototype.toString = function() {
  var strs = [];
  var name;
  for (var i = 0;name = this.nameStack_[i];i++) {
    strs.push(this.offsetStack_[i] + "," + name);
  }
  return strs.join("\n");
};
goog.dom.NodeOffset.prototype.findTargetNode = function(baseNode) {
  var name;
  var curNode = baseNode;
  for (var i = 0;name = this.nameStack_[i];++i) {
    curNode = curNode.childNodes[this.offsetStack_[i]];
    if (!curNode || curNode.nodeName != name) {
      return null;
    }
  }
  return curNode;
};
goog.dom.NodeOffset.prototype.disposeInternal = function() {
  delete this.offsetStack_;
  delete this.nameStack_;
};
goog.provide("goog.editor.plugins.Blockquote");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.TagName");
goog.require("goog.dom.classlist");
goog.require("goog.editor.BrowserFeature");
goog.require("goog.editor.Command");
goog.require("goog.editor.Plugin");
goog.require("goog.editor.node");
goog.require("goog.functions");
goog.require("goog.log");
goog.editor.plugins.Blockquote = function(requiresClassNameToSplit, opt_className) {
  goog.editor.Plugin.call(this);
  this.requiresClassNameToSplit_ = requiresClassNameToSplit;
  this.className_ = opt_className || goog.getCssName("tr_bq");
};
goog.inherits(goog.editor.plugins.Blockquote, goog.editor.Plugin);
goog.editor.plugins.Blockquote.SPLIT_COMMAND = "+splitBlockquote";
goog.editor.plugins.Blockquote.CLASS_ID = "Blockquote";
goog.editor.plugins.Blockquote.prototype.logger = goog.log.getLogger("goog.editor.plugins.Blockquote");
goog.editor.plugins.Blockquote.prototype.getTrogClassId = function() {
  return goog.editor.plugins.Blockquote.CLASS_ID;
};
goog.editor.plugins.Blockquote.prototype.isSilentCommand = goog.functions.TRUE;
goog.editor.plugins.Blockquote.prototype.isSplittableBlockquote = function(node) {
  if ((node).tagName != goog.dom.TagName.BLOCKQUOTE) {
    return false;
  }
  if (!this.requiresClassNameToSplit_) {
    return true;
  }
  return goog.dom.classlist.contains((node), this.className_);
};
goog.editor.plugins.Blockquote.prototype.isSetupBlockquote = function(node) {
  return (node).tagName == goog.dom.TagName.BLOCKQUOTE && goog.dom.classlist.contains((node), this.className_);
};
goog.editor.plugins.Blockquote.prototype.isUnsetupBlockquote = function(node) {
  return (node).tagName == goog.dom.TagName.BLOCKQUOTE && !this.isSetupBlockquote(node);
};
goog.editor.plugins.Blockquote.prototype.getBlockquoteClassName = function() {
  return this.className_;
};
goog.editor.plugins.Blockquote.findAndRemoveSingleChildAncestor_ = function(node, root) {
  var predicateFunc = function(parentNode) {
    return parentNode != root && parentNode.childNodes.length == 1;
  };
  var ancestor = goog.editor.node.findHighestMatchingAncestor(node, predicateFunc);
  if (!ancestor) {
    ancestor = node;
  }
  goog.dom.removeNode(ancestor);
};
goog.editor.plugins.Blockquote.removeAllWhiteSpaceNodes_ = function(nodes) {
  for (var i = 0;i < nodes.length;++i) {
    if (goog.editor.node.isEmpty(nodes[i], true)) {
      goog.dom.removeNode(nodes[i]);
    }
  }
};
goog.editor.plugins.Blockquote.prototype.isSupportedCommand = function(command) {
  return command == goog.editor.plugins.Blockquote.SPLIT_COMMAND;
};
goog.editor.plugins.Blockquote.prototype.execCommandInternal = function(command, var_args) {
  var pos = arguments[1];
  if (command == goog.editor.plugins.Blockquote.SPLIT_COMMAND && pos && (this.className_ || !this.requiresClassNameToSplit_)) {
    return goog.editor.BrowserFeature.HAS_W3C_RANGES ? this.splitQuotedBlockW3C_(pos) : this.splitQuotedBlockIE_((pos));
  }
};
goog.editor.plugins.Blockquote.prototype.splitQuotedBlockW3C_ = function(anchorPos) {
  var cursorNode = anchorPos.node;
  var quoteNode = goog.editor.node.findTopMostEditableAncestor(cursorNode.parentNode, goog.bind(this.isSplittableBlockquote, this));
  var secondHalf, textNodeToRemove;
  var insertTextNode = false;
  if (quoteNode) {
    if (cursorNode.nodeType == goog.dom.NodeType.TEXT) {
      if (anchorPos.offset == cursorNode.length) {
        var siblingNode = cursorNode.nextSibling;
        if (siblingNode && siblingNode.tagName == goog.dom.TagName.BR) {
          cursorNode = siblingNode;
          secondHalf = siblingNode.nextSibling;
        } else {
          textNodeToRemove = cursorNode.splitText(anchorPos.offset);
          secondHalf = textNodeToRemove;
        }
      } else {
        secondHalf = cursorNode.splitText(anchorPos.offset);
      }
    } else {
      if (cursorNode.tagName == goog.dom.TagName.BR) {
        secondHalf = cursorNode.nextSibling;
      } else {
        insertTextNode = true;
      }
    }
  } else {
    if (this.isSetupBlockquote(cursorNode)) {
      quoteNode = cursorNode;
      insertTextNode = true;
    }
  }
  if (insertTextNode) {
    cursorNode = this.insertEmptyTextNodeBeforeRange_();
    secondHalf = this.insertEmptyTextNodeBeforeRange_();
  }
  if (!quoteNode) {
    return false;
  }
  secondHalf = goog.editor.node.splitDomTreeAt(cursorNode, secondHalf, quoteNode);
  goog.dom.insertSiblingAfter(secondHalf, quoteNode);
  var dh = this.getFieldDomHelper();
  var tagToInsert = this.getFieldObject().queryCommandValue(goog.editor.Command.DEFAULT_TAG) || goog.dom.TagName.DIV;
  var container = dh.createElement((tagToInsert));
  container.innerHTML = "&nbsp;";
  quoteNode.parentNode.insertBefore(container, secondHalf);
  dh.getWindow().getSelection().collapse(container, 0);
  if (textNodeToRemove) {
    goog.editor.plugins.Blockquote.findAndRemoveSingleChildAncestor_(textNodeToRemove, secondHalf);
  }
  goog.editor.plugins.Blockquote.removeAllWhiteSpaceNodes_([quoteNode, secondHalf]);
  return true;
};
goog.editor.plugins.Blockquote.prototype.insertEmptyTextNodeBeforeRange_ = function() {
  var range = this.getFieldObject().getRange();
  var node = this.getFieldDomHelper().createTextNode("");
  range.insertNode(node, true);
  return node;
};
goog.editor.plugins.Blockquote.prototype.splitQuotedBlockIE_ = function(splitNode) {
  var dh = this.getFieldDomHelper();
  var quoteNode = goog.editor.node.findTopMostEditableAncestor(splitNode.parentNode, goog.bind(this.isSplittableBlockquote, this));
  if (!quoteNode) {
    return false;
  }
  var clone = splitNode.cloneNode(false);
  if (splitNode.nextSibling && (splitNode.nextSibling).tagName == goog.dom.TagName.BR) {
    splitNode = splitNode.nextSibling;
  }
  var secondHalf = goog.editor.node.splitDomTreeAt(splitNode, clone, quoteNode);
  goog.dom.insertSiblingAfter(secondHalf, quoteNode);
  var tagToInsert = this.getFieldObject().queryCommandValue(goog.editor.Command.DEFAULT_TAG) || goog.dom.TagName.DIV;
  var div = dh.createElement((tagToInsert));
  quoteNode.parentNode.insertBefore(div, secondHalf);
  div.innerHTML = "&nbsp;";
  var range = dh.getDocument().selection.createRange();
  range.moveToElementText(splitNode);
  range.move("character", 2);
  range.select();
  goog.dom.removeChildren(div);
  range.pasteHTML("");
  goog.editor.plugins.Blockquote.findAndRemoveSingleChildAncestor_(clone, secondHalf);
  goog.editor.plugins.Blockquote.removeAllWhiteSpaceNodes_([quoteNode, secondHalf]);
  return true;
};
goog.provide("goog.editor.plugins.EnterHandler");
goog.require("goog.dom");
goog.require("goog.dom.NodeOffset");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.Range");
goog.require("goog.dom.TagName");
goog.require("goog.editor.BrowserFeature");
goog.require("goog.editor.Plugin");
goog.require("goog.editor.node");
goog.require("goog.editor.plugins.Blockquote");
goog.require("goog.editor.range");
goog.require("goog.editor.style");
goog.require("goog.events.KeyCodes");
goog.require("goog.functions");
goog.require("goog.object");
goog.require("goog.string");
goog.require("goog.userAgent");
goog.editor.plugins.EnterHandler = function() {
  goog.editor.Plugin.call(this);
};
goog.inherits(goog.editor.plugins.EnterHandler, goog.editor.Plugin);
goog.editor.plugins.EnterHandler.prototype.tag = goog.dom.TagName.DIV;
goog.editor.plugins.EnterHandler.prototype.getTrogClassId = function() {
  return "EnterHandler";
};
goog.editor.plugins.EnterHandler.prototype.enable = function(fieldObject) {
  goog.editor.plugins.EnterHandler.base(this, "enable", fieldObject);
  if (goog.editor.BrowserFeature.SUPPORTS_OPERA_DEFAULTBLOCK_COMMAND && (this.tag == goog.dom.TagName.P || this.tag == goog.dom.TagName.DIV)) {
    var doc = this.getFieldDomHelper().getDocument();
    doc.execCommand("opera-defaultBlock", false, this.tag);
  }
};
goog.editor.plugins.EnterHandler.prototype.prepareContentsHtml = function(html) {
  if (!html || goog.string.isBreakingWhitespace(html)) {
    return goog.editor.BrowserFeature.COLLAPSES_EMPTY_NODES ? this.getNonCollapsingBlankHtml() : "";
  }
  return html;
};
goog.editor.plugins.EnterHandler.prototype.getNonCollapsingBlankHtml = goog.functions.constant("<br>");
goog.editor.plugins.EnterHandler.prototype.handleBackspaceInternal = function(e, range) {
  var field = this.getFieldObject().getElement();
  var container = range && range.getStartNode();
  if (field.firstChild == container && goog.editor.node.isEmpty(container)) {
    e.preventDefault();
    e.stopPropagation();
  }
};
goog.editor.plugins.EnterHandler.prototype.processParagraphTagsInternal = function(e, split) {
  if (goog.userAgent.IE || goog.userAgent.OPERA) {
    this.ensureBlockIeOpera(goog.dom.TagName.DIV);
  } else {
    if (!split && goog.userAgent.WEBKIT) {
      var range = this.getFieldObject().getRange();
      if (!range || !goog.editor.plugins.EnterHandler.isDirectlyInBlockquote(range.getContainerElement())) {
        return;
      }
      var dh = this.getFieldDomHelper();
      var br = dh.createElement(goog.dom.TagName.BR);
      range.insertNode(br, true);
      if (goog.editor.node.isBlockTag(br.parentNode) && !goog.editor.node.skipEmptyTextNodes(br.nextSibling)) {
        goog.dom.insertSiblingBefore(dh.createElement(goog.dom.TagName.BR), br);
      }
      goog.editor.range.placeCursorNextTo(br, false);
      e.preventDefault();
    }
  }
};
goog.editor.plugins.EnterHandler.isDirectlyInBlockquote = function(n) {
  for (var current = n;current;current = current.parentNode) {
    if (goog.editor.node.isBlockTag(current)) {
      return (current).tagName == goog.dom.TagName.BLOCKQUOTE;
    }
  }
  return false;
};
goog.editor.plugins.EnterHandler.prototype.handleDeleteGecko = function(e) {
  this.deleteBrGecko(e);
};
goog.editor.plugins.EnterHandler.prototype.deleteBrGecko = function(e) {
  var range = this.getFieldObject().getRange();
  if (range.isCollapsed()) {
    var container = range.getEndNode();
    if (container.nodeType == goog.dom.NodeType.ELEMENT) {
      var nextNode = container.childNodes[range.getEndOffset()];
      if (nextNode && nextNode.tagName == goog.dom.TagName.BR) {
        var previousSibling = goog.editor.node.getPreviousSibling(nextNode);
        var nextSibling = nextNode.nextSibling;
        container.removeChild(nextNode);
        e.preventDefault();
        if (nextSibling && goog.editor.node.isBlockTag(nextSibling)) {
          if (previousSibling && !(previousSibling.tagName == goog.dom.TagName.BR || goog.editor.node.isBlockTag(previousSibling))) {
            goog.dom.Range.createCaret(previousSibling, goog.editor.node.getLength(previousSibling)).select();
          } else {
            var leftMostLeaf = goog.editor.node.getLeftMostLeaf(nextSibling);
            goog.dom.Range.createCaret(leftMostLeaf, 0).select();
          }
        }
      }
    }
  }
};
goog.editor.plugins.EnterHandler.prototype.handleKeyPress = function(e) {
  if (goog.userAgent.GECKO && this.getFieldObject().inModalMode()) {
    return false;
  }
  if (e.keyCode == goog.events.KeyCodes.BACKSPACE) {
    this.handleBackspaceInternal(e, this.getFieldObject().getRange());
  } else {
    if (e.keyCode == goog.events.KeyCodes.ENTER) {
      if (goog.userAgent.GECKO) {
        if (!e.shiftKey) {
          this.handleEnterGecko_(e);
        }
      } else {
        this.getFieldObject().dispatchBeforeChange();
        var cursorPosition = this.deleteCursorSelection_();
        var split = !!this.getFieldObject().execCommand(goog.editor.plugins.Blockquote.SPLIT_COMMAND, cursorPosition);
        if (split) {
          e.preventDefault();
          e.stopPropagation();
        }
        this.releasePositionObject_(cursorPosition);
        if (goog.userAgent.WEBKIT) {
          this.handleEnterWebkitInternal(e);
        }
        this.processParagraphTagsInternal(e, split);
        this.getFieldObject().dispatchChange();
      }
    } else {
      if (goog.userAgent.GECKO && e.keyCode == goog.events.KeyCodes.DELETE) {
        this.handleDeleteGecko(e);
      }
    }
  }
  return false;
};
goog.editor.plugins.EnterHandler.prototype.handleKeyUp = function(e) {
  if (goog.userAgent.GECKO && this.getFieldObject().inModalMode()) {
    return false;
  }
  this.handleKeyUpInternal(e);
  return false;
};
goog.editor.plugins.EnterHandler.prototype.handleKeyUpInternal = function(e) {
  if ((goog.userAgent.IE || goog.userAgent.OPERA) && e.keyCode == goog.events.KeyCodes.ENTER) {
    this.ensureBlockIeOpera(goog.dom.TagName.DIV, true);
  }
};
goog.editor.plugins.EnterHandler.prototype.handleEnterGecko_ = function(e) {
  var range = this.getFieldObject().getRange();
  var wasCollapsed = !range || range.isCollapsed();
  var cursorPosition = this.deleteCursorSelection_();
  var handled = this.getFieldObject().execCommand(goog.editor.plugins.Blockquote.SPLIT_COMMAND, cursorPosition);
  if (handled) {
    e.preventDefault();
    e.stopPropagation();
  }
  this.releasePositionObject_(cursorPosition);
  if (!handled) {
    this.handleEnterAtCursorGeckoInternal(e, wasCollapsed, range);
  }
};
goog.editor.plugins.EnterHandler.prototype.handleEnterWebkitInternal = goog.nullFunction;
goog.editor.plugins.EnterHandler.prototype.handleEnterAtCursorGeckoInternal = goog.nullFunction;
goog.editor.plugins.EnterHandler.DO_NOT_ENSURE_BLOCK_NODES_ = goog.object.createSet(goog.dom.TagName.LI, goog.dom.TagName.DIV, goog.dom.TagName.H1, goog.dom.TagName.H2, goog.dom.TagName.H3, goog.dom.TagName.H4, goog.dom.TagName.H5, goog.dom.TagName.H6);
goog.editor.plugins.EnterHandler.isBrElem = function(node) {
  return goog.editor.node.isEmpty(node) && (node).getElementsByTagName(goog.dom.TagName.BR).length == 1;
};
goog.editor.plugins.EnterHandler.prototype.ensureBlockIeOpera = function(tag, opt_keyUp) {
  var range = this.getFieldObject().getRange();
  var container = range.getContainer();
  var field = this.getFieldObject().getElement();
  var paragraph;
  while (container && container != field) {
    var nodeName = container.nodeName;
    if (nodeName == tag || goog.editor.plugins.EnterHandler.DO_NOT_ENSURE_BLOCK_NODES_[nodeName] && !(opt_keyUp && goog.editor.plugins.EnterHandler.isBrElem(container))) {
      if (goog.userAgent.OPERA && paragraph) {
        if (nodeName == tag && paragraph == container.lastChild && goog.editor.node.isEmpty(paragraph)) {
          goog.dom.insertSiblingAfter(paragraph, container);
          goog.dom.Range.createFromNodeContents(paragraph).select();
        }
        break;
      }
      return;
    }
    if (goog.userAgent.OPERA && opt_keyUp && nodeName == goog.dom.TagName.P && nodeName != tag) {
      paragraph = container;
    }
    container = container.parentNode;
  }
  if (goog.userAgent.IE && !goog.userAgent.isVersionOrHigher(9)) {
    var needsHelp = false;
    range = range.getBrowserRangeObject();
    var range2 = range.duplicate();
    range2.moveEnd("character", 1);
    if (range2.text.length) {
      var parent2 = range2.parentElement();
      var range3 = range2.duplicate();
      range3.collapse(false);
      var parent3 = range3.parentElement();
      if (needsHelp = parent2 != parent3 && parent3 != range.parentElement()) {
        range.move("character", -1);
        range.select();
      }
    }
  }
  this.getFieldObject().getEditableDomHelper().getDocument().execCommand("FormatBlock", false, "<" + tag + ">");
  if (needsHelp) {
    range.move("character", 1);
    range.select();
  }
};
goog.editor.plugins.EnterHandler.prototype.deleteCursorSelection_ = function() {
  return goog.editor.BrowserFeature.HAS_W3C_RANGES ? this.deleteCursorSelectionW3C_() : this.deleteCursorSelectionIE_();
};
goog.editor.plugins.EnterHandler.prototype.releasePositionObject_ = function(position) {
  if (!goog.editor.BrowserFeature.HAS_W3C_RANGES) {
    (position).removeNode(true);
  }
};
goog.editor.plugins.EnterHandler.prototype.deleteCursorSelectionIE_ = function() {
  var doc = this.getFieldDomHelper().getDocument();
  var range = doc.selection.createRange();
  var id = goog.string.createUniqueString();
  range.pasteHTML('<span id="' + id + '"></span>');
  var splitNode = doc.getElementById(id);
  splitNode.id = "";
  return splitNode;
};
goog.editor.plugins.EnterHandler.prototype.deleteCursorSelectionW3C_ = function() {
  var range = this.getFieldObject().getRange();
  if (range && !range.isCollapsed()) {
    var shouldDelete = true;
    if (goog.userAgent.OPERA) {
      var startNode = range.getStartNode();
      var startOffset = range.getStartOffset();
      if (startNode == range.getEndNode() && startNode.lastChild && (startNode.lastChild).tagName == goog.dom.TagName.BR && startOffset == startNode.childNodes.length - 1) {
        shouldDelete = false;
      }
    }
    if (shouldDelete) {
      goog.editor.plugins.EnterHandler.deleteW3cRange_(range);
    }
  }
  return goog.editor.range.getDeepEndPoint(range, true);
};
goog.editor.plugins.EnterHandler.deleteW3cRange_ = function(range) {
  if (range && !range.isCollapsed()) {
    var reselect = true;
    var baseNode = range.getContainerElement();
    var nodeOffset = new goog.dom.NodeOffset(range.getStartNode(), baseNode);
    var rangeOffset = range.getStartOffset();
    var isInOneContainer = goog.editor.plugins.EnterHandler.isInOneContainerW3c_(range);
    var isPartialEnd = !isInOneContainer && goog.editor.plugins.EnterHandler.isPartialEndW3c_(range);
    range.removeContents();
    var node = nodeOffset.findTargetNode(baseNode);
    if (node) {
      range = goog.dom.Range.createCaret(node, rangeOffset);
    } else {
      range = goog.dom.Range.createCaret(baseNode, baseNode.childNodes.length);
      reselect = false;
    }
    range.select();
    if (isInOneContainer) {
      var container = goog.editor.style.getContainer(range.getStartNode());
      if (goog.editor.node.isEmpty(container, true)) {
        var html = "&nbsp;";
        if (goog.userAgent.OPERA && container.tagName == goog.dom.TagName.LI) {
          html = "<br>";
        }
        goog.editor.node.replaceInnerHtml(container, html);
        goog.editor.range.selectNodeStart(container.firstChild);
        reselect = false;
      }
    }
    if (isPartialEnd) {
      var rangeStart = goog.editor.style.getContainer(range.getStartNode());
      var redundantContainer = goog.editor.node.getNextSibling(rangeStart);
      if (rangeStart && redundantContainer) {
        goog.dom.append(rangeStart, redundantContainer.childNodes);
        goog.dom.removeNode(redundantContainer);
      }
    }
    if (reselect) {
      range = goog.dom.Range.createCaret(nodeOffset.findTargetNode(baseNode), rangeOffset);
      range.select();
    }
  }
  return range;
};
goog.editor.plugins.EnterHandler.isInOneContainerW3c_ = function(range) {
  var startContainer = range.getStartNode();
  if (goog.editor.style.isContainer(startContainer)) {
    startContainer = startContainer.childNodes[range.getStartOffset()] || startContainer;
  }
  startContainer = goog.editor.style.getContainer(startContainer);
  var endContainer = range.getEndNode();
  if (goog.editor.style.isContainer(endContainer)) {
    endContainer = endContainer.childNodes[range.getEndOffset()] || endContainer;
  }
  endContainer = goog.editor.style.getContainer(endContainer);
  return startContainer == endContainer;
};
goog.editor.plugins.EnterHandler.isPartialEndW3c_ = function(range) {
  var endContainer = range.getEndNode();
  var endOffset = range.getEndOffset();
  var node = endContainer;
  if (goog.editor.style.isContainer(node)) {
    var child = node.childNodes[endOffset];
    if (!child || child.nodeType == goog.dom.NodeType.ELEMENT && goog.editor.style.isContainer(child)) {
      return false;
    }
  }
  var container = goog.editor.style.getContainer(node);
  while (container != node) {
    if (goog.editor.node.getNextSibling(node)) {
      return true;
    }
    node = node.parentNode;
  }
  return endOffset != goog.editor.node.getLength(endContainer);
};
goog.provide("goog.editor.plugins.HeaderFormatter");
goog.require("goog.editor.Command");
goog.require("goog.editor.Plugin");
goog.require("goog.userAgent");
goog.editor.plugins.HeaderFormatter = function() {
  goog.editor.Plugin.call(this);
};
goog.inherits(goog.editor.plugins.HeaderFormatter, goog.editor.Plugin);
goog.editor.plugins.HeaderFormatter.prototype.getTrogClassId = function() {
  return "HeaderFormatter";
};
goog.editor.plugins.HeaderFormatter.HEADER_COMMAND = {H1:"H1", H2:"H2", H3:"H3", H4:"H4"};
goog.editor.plugins.HeaderFormatter.prototype.handleKeyboardShortcut = function(e, key, isModifierPressed) {
  if (!isModifierPressed) {
    return false;
  }
  var command = null;
  switch(key) {
    case "1":
      command = goog.editor.plugins.HeaderFormatter.HEADER_COMMAND.H1;
      break;
    case "2":
      command = goog.editor.plugins.HeaderFormatter.HEADER_COMMAND.H2;
      break;
    case "3":
      command = goog.editor.plugins.HeaderFormatter.HEADER_COMMAND.H3;
      break;
    case "4":
      command = goog.editor.plugins.HeaderFormatter.HEADER_COMMAND.H4;
      break;
  }
  if (command) {
    this.getFieldObject().execCommand(goog.editor.Command.FORMAT_BLOCK, command);
    if (goog.userAgent.GECKO) {
      e.stopPropagation();
    }
    return true;
  }
  return false;
};
goog.provide("goog.editor.plugins.AbstractTabHandler");
goog.require("goog.editor.Plugin");
goog.require("goog.events.KeyCodes");
goog.require("goog.userAgent");
goog.editor.plugins.AbstractTabHandler = function() {
  goog.editor.Plugin.call(this);
};
goog.inherits(goog.editor.plugins.AbstractTabHandler, goog.editor.Plugin);
goog.editor.plugins.AbstractTabHandler.prototype.getTrogClassId = goog.abstractMethod;
goog.editor.plugins.AbstractTabHandler.prototype.handleKeyboardShortcut = function(e, key, isModifierPressed) {
  if (goog.userAgent.GECKO && this.getFieldObject().inModalMode()) {
    return false;
  }
  if (e.keyCode == goog.events.KeyCodes.TAB && !e.metaKey && !e.ctrlKey) {
    return this.handleTabKey(e);
  }
  return false;
};
goog.editor.plugins.AbstractTabHandler.prototype.handleTabKey = goog.abstractMethod;
goog.provide("goog.editor.plugins.ListTabHandler");
goog.require("goog.dom");
goog.require("goog.dom.TagName");
goog.require("goog.editor.Command");
goog.require("goog.editor.plugins.AbstractTabHandler");
goog.require("goog.iter");
goog.editor.plugins.ListTabHandler = function() {
  goog.editor.plugins.AbstractTabHandler.call(this);
};
goog.inherits(goog.editor.plugins.ListTabHandler, goog.editor.plugins.AbstractTabHandler);
goog.editor.plugins.ListTabHandler.prototype.getTrogClassId = function() {
  return "ListTabHandler";
};
goog.editor.plugins.ListTabHandler.prototype.handleTabKey = function(e) {
  var range = this.getFieldObject().getRange();
  if (goog.dom.getAncestorByTagNameAndClass(range.getContainerElement(), goog.dom.TagName.LI) || goog.iter.some(range, function(node) {
    return node.tagName == goog.dom.TagName.LI;
  })) {
    this.getFieldObject().execCommand(e.shiftKey ? goog.editor.Command.OUTDENT : goog.editor.Command.INDENT);
    e.preventDefault();
    return true;
  }
  return false;
};
goog.provide("goog.editor.plugins.RemoveFormatting");
goog.require("goog.dom");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.Range");
goog.require("goog.dom.TagName");
goog.require("goog.editor.BrowserFeature");
goog.require("goog.editor.Plugin");
goog.require("goog.editor.node");
goog.require("goog.editor.range");
goog.require("goog.string");
goog.require("goog.userAgent");
goog.editor.plugins.RemoveFormatting = function() {
  goog.editor.Plugin.call(this);
  this.optRemoveFormattingFunc_ = null;
};
goog.inherits(goog.editor.plugins.RemoveFormatting, goog.editor.Plugin);
goog.editor.plugins.RemoveFormatting.REMOVE_FORMATTING_COMMAND = "+removeFormat";
goog.editor.plugins.RemoveFormatting.BLOCK_RE_ = /^(DIV|TR|LI|BLOCKQUOTE|H\d|PRE|XMP)/;
goog.editor.plugins.RemoveFormatting.appendNewline_ = function(sb) {
  sb.push("<br>");
};
goog.editor.plugins.RemoveFormatting.createRangeDelimitedByRanges_ = function(startRange, endRange) {
  return goog.dom.Range.createFromNodes(startRange.getStartNode(), startRange.getStartOffset(), endRange.getEndNode(), endRange.getEndOffset());
};
goog.editor.plugins.RemoveFormatting.prototype.getTrogClassId = function() {
  return "RemoveFormatting";
};
goog.editor.plugins.RemoveFormatting.prototype.isSupportedCommand = function(command) {
  return command == goog.editor.plugins.RemoveFormatting.REMOVE_FORMATTING_COMMAND;
};
goog.editor.plugins.RemoveFormatting.prototype.execCommandInternal = function(command, var_args) {
  if (command == goog.editor.plugins.RemoveFormatting.REMOVE_FORMATTING_COMMAND) {
    this.removeFormatting_();
  }
};
goog.editor.plugins.RemoveFormatting.prototype.handleKeyboardShortcut = function(e, key, isModifierPressed) {
  if (!isModifierPressed) {
    return false;
  }
  if (key == " ") {
    this.getFieldObject().execCommand(goog.editor.plugins.RemoveFormatting.REMOVE_FORMATTING_COMMAND);
    return true;
  }
  return false;
};
goog.editor.plugins.RemoveFormatting.prototype.removeFormatting_ = function() {
  var range = this.getFieldObject().getRange();
  if (range.isCollapsed()) {
    return;
  }
  var convFunc = this.optRemoveFormattingFunc_ || goog.bind(this.removeFormattingWorker_, this);
  this.convertSelectedHtmlText_(convFunc);
  var doc = this.getFieldDomHelper().getDocument();
  doc.execCommand("RemoveFormat", false, undefined);
  if (goog.editor.BrowserFeature.ADDS_NBSPS_IN_REMOVE_FORMAT) {
    this.convertSelectedHtmlText_(function(text) {
      var nbspRegExp = goog.userAgent.isVersionOrHigher("528") ? /&nbsp;/g : /\u00A0/g;
      return text.replace(nbspRegExp, " ");
    });
  }
};
goog.editor.plugins.RemoveFormatting.prototype.getTableAncestor_ = function(nodeToCheck) {
  var fieldElement = this.getFieldObject().getElement();
  while (nodeToCheck && nodeToCheck != fieldElement) {
    if (nodeToCheck.tagName == goog.dom.TagName.TABLE) {
      return nodeToCheck;
    }
    nodeToCheck = nodeToCheck.parentNode;
  }
  return null;
};
goog.editor.plugins.RemoveFormatting.prototype.pasteHtml_ = function(html) {
  var range = this.getFieldObject().getRange();
  var dh = this.getFieldDomHelper();
  var startSpanId = goog.string.createUniqueString();
  var endSpanId = goog.string.createUniqueString();
  html = '<span id="' + startSpanId + '"></span>' + html + '<span id="' + endSpanId + '"></span>';
  var dummyNodeId = goog.string.createUniqueString();
  var dummySpanText = '<span id="' + dummyNodeId + '"></span>';
  if (goog.editor.BrowserFeature.HAS_IE_RANGES) {
    var textRange = range.getTextRange(0).getBrowserRangeObject();
    textRange.pasteHTML(dummySpanText);
    var parent;
    while ((parent = textRange.parentElement()) && goog.editor.node.isEmpty(parent) && !goog.editor.node.isEditableContainer(parent)) {
      var tag = parent.nodeName;
      if (tag == goog.dom.TagName.TD || tag == goog.dom.TagName.TR || tag == goog.dom.TagName.TH) {
        break;
      }
      goog.dom.removeNode(parent);
    }
    textRange.pasteHTML(html);
    var dummySpan = dh.getElement(dummyNodeId);
    if (dummySpan) {
      goog.dom.removeNode(dummySpan);
    }
  } else {
    if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
      dh.getDocument().execCommand("insertImage", false, dummyNodeId);
      var dummyImageNodePattern = new RegExp("<[^<]*" + dummyNodeId + "[^>]*>");
      var parent = this.getFieldObject().getRange().getContainerElement();
      if (parent.nodeType == goog.dom.NodeType.TEXT) {
        parent = parent.parentNode;
      }
      while (!dummyImageNodePattern.test(parent.innerHTML)) {
        parent = parent.parentNode;
      }
      if (goog.userAgent.GECKO) {
        goog.editor.node.replaceInnerHtml(parent, parent.innerHTML.replace(dummyImageNodePattern, html.replace(/\$/g, "$$$$")));
      } else {
        goog.editor.node.replaceInnerHtml(parent, parent.innerHTML.replace(dummyImageNodePattern, dummySpanText));
        var dummySpan = dh.getElement(dummyNodeId);
        parent = dummySpan;
        while ((parent = dummySpan.parentNode) && goog.editor.node.isEmpty(parent) && !goog.editor.node.isEditableContainer(parent)) {
          var tag = parent.nodeName;
          if (tag == goog.dom.TagName.TD || tag == goog.dom.TagName.TR || tag == goog.dom.TagName.TH) {
            break;
          }
          goog.dom.insertSiblingAfter(dummySpan, parent);
          goog.dom.removeNode(parent);
        }
        goog.editor.node.replaceInnerHtml(parent, parent.innerHTML.replace(new RegExp(dummySpanText, "i"), html.replace(/\$/g, "$$$$")));
      }
    }
  }
  var startSpan = dh.getElement(startSpanId);
  var endSpan = dh.getElement(endSpanId);
  goog.dom.Range.createFromNodes(startSpan, 0, endSpan, endSpan.childNodes.length).select();
  goog.dom.removeNode(startSpan);
  goog.dom.removeNode(endSpan);
};
goog.editor.plugins.RemoveFormatting.prototype.getHtmlText_ = function(range) {
  var div = this.getFieldDomHelper().createDom(goog.dom.TagName.DIV);
  var textRange = range.getBrowserRangeObject();
  if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
    div.appendChild(textRange.cloneContents());
  } else {
    if (goog.editor.BrowserFeature.HAS_IE_RANGES) {
      var rngText = range.getText();
      rngText = rngText.replace(/\r\n/g, "\r");
      var rngTextLength = rngText.length;
      var left = rngTextLength - goog.string.trimLeft(rngText).length;
      var right = rngTextLength - goog.string.trimRight(rngText).length;
      textRange.moveStart("character", left);
      textRange.moveEnd("character", -right);
      var htmlText = textRange.htmlText;
      if (textRange.queryCommandValue("formatBlock") == "Formatted") {
        htmlText = goog.string.newLineToBr(textRange.htmlText);
      }
      div.innerHTML = htmlText;
    }
  }
  return div.innerHTML;
};
goog.editor.plugins.RemoveFormatting.prototype.adjustRangeForTables_ = function(range, startInTable, endInTable) {
  var savedCaretRange = goog.editor.range.saveUsingNormalizedCarets(range);
  var startNode = range.getStartNode();
  var startOffset = range.getStartOffset();
  var endNode = range.getEndNode();
  var endOffset = range.getEndOffset();
  var dh = this.getFieldDomHelper();
  if (startInTable) {
    var textNode = dh.createTextNode("");
    goog.dom.insertSiblingAfter(textNode, startInTable);
    startNode = textNode;
    startOffset = 0;
  }
  if (endInTable) {
    var textNode = dh.createTextNode("");
    goog.dom.insertSiblingBefore(textNode, endInTable);
    endNode = textNode;
    endOffset = 0;
  }
  goog.dom.Range.createFromNodes(startNode, startOffset, endNode, endOffset).select();
  return savedCaretRange;
};
goog.editor.plugins.RemoveFormatting.prototype.putCaretInCave_ = function(caretRange, isStart) {
  var cavedCaret = goog.dom.removeNode(caretRange.getCaret(isStart));
  if (isStart) {
    this.startCaretInCave_ = cavedCaret;
  } else {
    this.endCaretInCave_ = cavedCaret;
  }
};
goog.editor.plugins.RemoveFormatting.prototype.restoreCaretsFromCave_ = function() {
  var field = this.getFieldObject().getElement();
  if (this.startCaretInCave_) {
    field.insertBefore(this.startCaretInCave_, field.firstChild);
    this.startCaretInCave_ = null;
  }
  if (this.endCaretInCave_) {
    field.appendChild(this.endCaretInCave_);
    this.endCaretInCave_ = null;
  }
};
goog.editor.plugins.RemoveFormatting.prototype.convertSelectedHtmlText_ = function(convertFunc) {
  var range = this.getFieldObject().getRange();
  if (range.getTextRangeCount() > 1) {
    return;
  }
  if (goog.userAgent.GECKO || goog.userAgent.EDGE) {
    var expandedRange = goog.editor.range.expand(range, this.getFieldObject().getElement());
    var startInTable = this.getTableAncestor_(expandedRange.getStartNode());
    var endInTable = this.getTableAncestor_(expandedRange.getEndNode());
    if (startInTable || endInTable) {
      if (startInTable == endInTable) {
        return;
      }
      var savedCaretRange = this.adjustRangeForTables_(range, startInTable, endInTable);
      if (!startInTable) {
        this.putCaretInCave_(savedCaretRange, true);
      }
      if (!endInTable) {
        this.putCaretInCave_(savedCaretRange, false);
      }
      range = this.getFieldObject().getRange();
      expandedRange = goog.editor.range.expand(range, this.getFieldObject().getElement());
    }
    expandedRange.select();
    range = expandedRange;
  }
  var text = this.getHtmlText_(range);
  this.pasteHtml_(convertFunc(text));
  if ((goog.userAgent.GECKO || goog.userAgent.EDGE) && savedCaretRange) {
    range = this.getFieldObject().getRange();
    this.restoreCaretsFromCave_();
    var realSavedCaretRange = savedCaretRange.toAbstractRange();
    var startRange = startInTable ? realSavedCaretRange : range;
    var endRange = endInTable ? realSavedCaretRange : range;
    var restoredRange = goog.editor.plugins.RemoveFormatting.createRangeDelimitedByRanges_(startRange, endRange);
    restoredRange.select();
    savedCaretRange.dispose();
  }
};
goog.editor.plugins.RemoveFormatting.prototype.removeFormattingWorker_ = function(html) {
  var el = goog.dom.createElement(goog.dom.TagName.DIV);
  el.innerHTML = html;
  var sb = [];
  var stack = [el.childNodes, 0];
  var preTagStack = [];
  var preTagLevel = 0;
  var tableStack = [];
  var tableLevel = 0;
  for (var sp = 0;sp >= 0;sp -= 2) {
    var changedLevel = false;
    while (tableLevel > 0 && sp <= tableStack[tableLevel - 1]) {
      tableLevel--;
      changedLevel = true;
    }
    if (changedLevel) {
      goog.editor.plugins.RemoveFormatting.appendNewline_(sb);
    }
    changedLevel = false;
    while (preTagLevel > 0 && sp <= preTagStack[preTagLevel - 1]) {
      preTagLevel--;
      changedLevel = true;
    }
    if (changedLevel) {
      goog.editor.plugins.RemoveFormatting.appendNewline_(sb);
    }
    var nodeList = stack[sp];
    var numNodesProcessed = stack[sp + 1];
    while (numNodesProcessed < nodeList.length) {
      var node = nodeList[numNodesProcessed++];
      var nodeName = node.nodeName;
      var formatted = this.getValueForNode(node);
      if (goog.isDefAndNotNull(formatted)) {
        sb.push(formatted);
        continue;
      }
      switch(nodeName) {
        case "#text":
          var nodeValue = preTagLevel > 0 ? node.nodeValue : goog.string.stripNewlines(node.nodeValue);
          nodeValue = goog.string.htmlEscape(nodeValue);
          sb.push(nodeValue);
          continue;
        case goog.dom.TagName.P:
          goog.editor.plugins.RemoveFormatting.appendNewline_(sb);
          goog.editor.plugins.RemoveFormatting.appendNewline_(sb);
          break;
        case goog.dom.TagName.BR:
          goog.editor.plugins.RemoveFormatting.appendNewline_(sb);
          continue;
        case goog.dom.TagName.TABLE:
          goog.editor.plugins.RemoveFormatting.appendNewline_(sb);
          tableStack[tableLevel++] = sp;
          break;
        case goog.dom.TagName.PRE:
        ;
        case "XMP":
          preTagStack[preTagLevel++] = sp;
          break;
        case goog.dom.TagName.STYLE:
        ;
        case goog.dom.TagName.SCRIPT:
        ;
        case goog.dom.TagName.SELECT:
          continue;
        case goog.dom.TagName.A:
          if (node.href && node.href != "") {
            sb.push("<a href='");
            sb.push(node.href);
            sb.push("'>");
            sb.push(this.removeFormattingWorker_(node.innerHTML));
            sb.push("</a>");
            continue;
          } else {
            break;
          }
        ;
        case goog.dom.TagName.IMG:
          sb.push("<img src='");
          sb.push(node.src);
          sb.push("'");
          if (node.border == "0") {
            sb.push(" border='0'");
          }
          sb.push(">");
          continue;
        case goog.dom.TagName.TD:
          if (node.previousSibling) {
            sb.push(" ");
          }
          break;
        case goog.dom.TagName.TR:
          if (node.previousSibling) {
            goog.editor.plugins.RemoveFormatting.appendNewline_(sb);
          }
          break;
        case goog.dom.TagName.DIV:
          var parent = node.parentNode;
          if (parent.firstChild == node && goog.editor.plugins.RemoveFormatting.BLOCK_RE_.test(parent.tagName)) {
            break;
          }
        ;
        default:
          if (goog.editor.plugins.RemoveFormatting.BLOCK_RE_.test(nodeName)) {
            goog.editor.plugins.RemoveFormatting.appendNewline_(sb);
          }
        ;
      }
      var children = node.childNodes;
      if (children.length > 0) {
        stack[sp++] = nodeList;
        stack[sp++] = numNodesProcessed;
        nodeList = children;
        numNodesProcessed = 0;
      }
    }
  }
  return goog.string.normalizeSpaces(sb.join(""));
};
goog.editor.plugins.RemoveFormatting.prototype.getValueForNode = function(node) {
  return null;
};
goog.editor.plugins.RemoveFormatting.prototype.setRemoveFormattingFunc = function(removeFormattingFunc) {
  this.optRemoveFormattingFunc_ = removeFormattingFunc;
};
goog.provide("goog.editor.plugins.SpacesTabHandler");
goog.require("goog.dom.TagName");
goog.require("goog.editor.plugins.AbstractTabHandler");
goog.require("goog.editor.range");
goog.editor.plugins.SpacesTabHandler = function() {
  goog.editor.plugins.AbstractTabHandler.call(this);
};
goog.inherits(goog.editor.plugins.SpacesTabHandler, goog.editor.plugins.AbstractTabHandler);
goog.editor.plugins.SpacesTabHandler.prototype.getTrogClassId = function() {
  return "SpacesTabHandler";
};
goog.editor.plugins.SpacesTabHandler.prototype.handleTabKey = function(e) {
  var dh = this.getFieldDomHelper();
  var range = this.getFieldObject().getRange();
  if (!goog.editor.range.intersectsTag(range, goog.dom.TagName.LI)) {
    if (!e.shiftKey) {
      this.getFieldObject().stopChangeEvents(true, true);
      if (!range.isCollapsed()) {
        dh.getDocument().execCommand("delete", false, null);
        range = this.getFieldObject().getRange();
      }
      var elem = dh.createDom(goog.dom.TagName.SPAN, null, "\u00a0\u00a0 \u00a0");
      elem = range.insertNode(elem, false);
      this.getFieldObject().dispatchChange();
      goog.editor.range.placeCursorNextTo(elem, false);
      this.getFieldObject().dispatchSelectionChangeEvent();
    }
    e.preventDefault();
    return true;
  }
  return false;
};
goog.provide("goog.editor.Table");
goog.provide("goog.editor.TableCell");
goog.provide("goog.editor.TableRow");
goog.require("goog.dom");
goog.require("goog.dom.DomHelper");
goog.require("goog.dom.NodeType");
goog.require("goog.dom.TagName");
goog.require("goog.log");
goog.require("goog.string.Unicode");
goog.require("goog.style");
goog.editor.Table = function(node) {
  this.element = goog.dom.getAncestorByTagNameAndClass(node, goog.dom.TagName.TABLE);
  if (!this.element) {
    goog.log.error(this.logger_, "Can't create Table based on a node " + "that isn't a table, or descended from a table.");
  }
  this.dom_ = goog.dom.getDomHelper(this.element);
  this.refresh();
};
goog.editor.Table.prototype.logger_ = goog.log.getLogger("goog.editor.Table");
goog.editor.Table.prototype.refresh = function() {
  var rows = this.rows = [];
  var tbody = this.element.getElementsByTagName(goog.dom.TagName.TBODY)[0];
  if (!tbody) {
    return;
  }
  var trs = [];
  for (var child = tbody.firstChild;child;child = child.nextSibling) {
    if (child.nodeName == goog.dom.TagName.TR) {
      trs.push(child);
    }
  }
  for (var rowNum = 0, tr;tr = trs[rowNum];rowNum++) {
    var existingRow = rows[rowNum];
    var tds = goog.editor.Table.getChildCellElements(tr);
    var columnNum = 0;
    for (var cellNum = 0, td;td = tds[cellNum];cellNum++) {
      while (existingRow && existingRow.columns[columnNum]) {
        columnNum++;
      }
      var cell = new goog.editor.TableCell(td, rowNum, columnNum);
      for (var i = 0;i < cell.rowSpan;i++) {
        var cellRowNum = rowNum + i;
        var cellRow = rows[cellRowNum];
        if (!cellRow) {
          rows.push(cellRow = new goog.editor.TableRow(trs[cellRowNum], cellRowNum));
        }
        var minimumColumnLength = columnNum + cell.colSpan;
        if (cellRow.columns.length < minimumColumnLength) {
          cellRow.columns.length = minimumColumnLength;
        }
        for (var j = 0;j < cell.colSpan;j++) {
          var cellColumnNum = columnNum + j;
          cellRow.columns[cellColumnNum] = cell;
        }
      }
      columnNum += cell.colSpan;
    }
  }
};
goog.editor.Table.getChildCellElements = function(tr) {
  var cells = [];
  for (var i = 0, cell;cell = tr.childNodes[i];i++) {
    if (cell.nodeName == goog.dom.TagName.TD || cell.nodeName == goog.dom.TagName.TH) {
      cells.push(cell);
    }
  }
  return cells;
};
goog.editor.Table.prototype.insertRow = function(opt_rowIndex) {
  var rowIndex = goog.isDefAndNotNull(opt_rowIndex) ? opt_rowIndex : this.rows.length;
  var refRow;
  var insertAfter;
  if (rowIndex == 0) {
    refRow = this.rows[0];
    insertAfter = false;
  } else {
    refRow = this.rows[rowIndex - 1];
    insertAfter = true;
  }
  var newTr = this.dom_.createElement(goog.dom.TagName.TR);
  for (var i = 0, cell;cell = refRow.columns[i];i += 1) {
    if (insertAfter && cell.endRow > rowIndex || !insertAfter && cell.startRow < rowIndex) {
      cell.setRowSpan(cell.rowSpan + 1);
      if (cell.colSpan > 1) {
        i += cell.colSpan - 1;
      }
    } else {
      newTr.appendChild(this.createEmptyTd());
    }
    if (insertAfter) {
      goog.dom.insertSiblingAfter(newTr, refRow.element);
    } else {
      goog.dom.insertSiblingBefore(newTr, refRow.element);
    }
  }
  this.refresh();
  return newTr;
};
goog.editor.Table.prototype.insertColumn = function(opt_colIndex) {
  var colIndex = goog.isDefAndNotNull(opt_colIndex) ? opt_colIndex : this.rows[0] && this.rows[0].columns.length || 0;
  var newTds = [];
  for (var rowNum = 0, row;row = this.rows[rowNum];rowNum++) {
    var existingCell = row.columns[colIndex];
    if (existingCell && existingCell.endCol >= colIndex && existingCell.startCol < colIndex) {
      existingCell.setColSpan(existingCell.colSpan + 1);
      rowNum += existingCell.rowSpan - 1;
    } else {
      var newTd = this.createEmptyTd();
      newTd.style.width = goog.editor.Table.OPTIMUM_EMPTY_CELL_WIDTH + "px";
      this.insertCellElement(newTd, rowNum, colIndex);
      newTds.push(newTd);
    }
  }
  this.refresh();
  return newTds;
};
goog.editor.Table.prototype.removeRow = function(rowIndex) {
  var row = this.rows[rowIndex];
  if (!row) {
    goog.log.warning(this.logger_, "Can't remove row at position " + rowIndex + ": no such row.");
  }
  for (var i = 0, cell;cell = row.columns[i];i += cell.colSpan) {
    if (cell.rowSpan > 1) {
      cell.setRowSpan(cell.rowSpan - 1);
      if (cell.startRow == rowIndex) {
        this.insertCellElement(cell.element, rowIndex + 1, cell.startCol);
      }
    }
  }
  row.element.parentNode.removeChild(row.element);
  this.refresh();
};
goog.editor.Table.prototype.removeColumn = function(colIndex) {
  for (var i = 0, row;row = this.rows[i];i++) {
    var cell = row.columns[colIndex];
    if (!cell) {
      goog.log.error(this.logger_, "Can't remove cell at position " + i + ", " + colIndex + ": no such cell.");
    }
    if (cell.colSpan > 1) {
      cell.setColSpan(cell.colSpan - 1);
    } else {
      cell.element.parentNode.removeChild(cell.element);
    }
    i += cell.rowSpan - 1;
  }
  this.refresh();
};
goog.editor.Table.prototype.mergeCells = function(startRowIndex, startColIndex, endRowIndex, endColIndex) {
  var cells = [];
  var cell;
  if (startRowIndex == endRowIndex && startColIndex == endColIndex) {
    goog.log.warning(this.logger_, "Can't merge single cell");
    return false;
  }
  for (var i = startRowIndex;i <= endRowIndex;i++) {
    for (var j = startColIndex;j <= endColIndex;j++) {
      cell = this.rows[i].columns[j];
      if (cell.startRow < startRowIndex || cell.endRow > endRowIndex || cell.startCol < startColIndex || cell.endCol > endColIndex) {
        goog.log.warning(this.logger_, "Can't merge cells: the cell in row " + i + ", column " + j + "extends outside the supplied rectangle.");
        return false;
      }
      cells.push(cell);
    }
  }
  var targetCell = cells[0];
  var targetTd = targetCell.element;
  var doc = this.dom_.getDocument();
  for (var i = 1;cell = cells[i];i++) {
    var td = cell.element;
    if (!td.parentNode || td == targetTd) {
      continue;
    }
    if (targetTd.lastChild && targetTd.lastChild.nodeType == goog.dom.NodeType.TEXT) {
      targetTd.appendChild(doc.createTextNode(" "));
    }
    var childNode;
    while (childNode = td.firstChild) {
      targetTd.appendChild(childNode);
    }
    td.parentNode.removeChild(td);
  }
  targetCell.setColSpan(endColIndex - startColIndex + 1);
  targetCell.setRowSpan(endRowIndex - startRowIndex + 1);
  if (endColIndex > startColIndex) {
    targetTd.removeAttribute("width");
    targetTd.style.width = null;
  }
  this.refresh();
  return true;
};
goog.editor.Table.prototype.splitCell = function(rowIndex, colIndex) {
  var row = this.rows[rowIndex];
  var cell = row.columns[colIndex];
  var newTds = [];
  for (var i = 0;i < cell.rowSpan;i++) {
    for (var j = 0;j < cell.colSpan;j++) {
      if (i > 0 || j > 0) {
        var newTd = this.createEmptyTd();
        this.insertCellElement(newTd, rowIndex + i, colIndex + j);
        newTds.push(newTd);
      }
    }
  }
  cell.setColSpan(1);
  cell.setRowSpan(1);
  this.refresh();
  return newTds;
};
goog.editor.Table.prototype.insertCellElement = function(td, rowIndex, colIndex) {
  var row = this.rows[rowIndex];
  var nextSiblingElement = null;
  for (var i = colIndex, cell;cell = row.columns[i];i += cell.colSpan) {
    if (cell.startRow == rowIndex) {
      nextSiblingElement = cell.element;
      break;
    }
  }
  row.element.insertBefore(td, nextSiblingElement);
};
goog.editor.Table.prototype.createEmptyTd = function() {
  return this.dom_.createDom(goog.dom.TagName.TD, {}, goog.string.Unicode.NBSP);
};
goog.editor.TableRow = function(trElement, rowIndex) {
  this.index = rowIndex;
  this.element = trElement;
  this.columns = [];
};
goog.editor.TableCell = function(td, startRow, startCol) {
  this.element = td;
  this.colSpan = parseInt(td.colSpan, 10) || 1;
  this.rowSpan = parseInt(td.rowSpan, 10) || 1;
  this.startRow = startRow;
  this.startCol = startCol;
  this.updateCoordinates_();
};
goog.editor.TableCell.prototype.updateCoordinates_ = function() {
  this.endCol = this.startCol + this.colSpan - 1;
  this.endRow = this.startRow + this.rowSpan - 1;
};
goog.editor.TableCell.prototype.setColSpan = function(colSpan) {
  if (colSpan != this.colSpan) {
    if (colSpan > 1) {
      this.element.colSpan = colSpan;
    } else {
      this.element.colSpan = 1, this.element.removeAttribute("colSpan");
    }
    this.colSpan = colSpan;
    this.updateCoordinates_();
  }
};
goog.editor.TableCell.prototype.setRowSpan = function(rowSpan) {
  if (rowSpan != this.rowSpan) {
    if (rowSpan > 1) {
      this.element.rowSpan = rowSpan.toString();
    } else {
      this.element.rowSpan = "1";
      this.element.removeAttribute("rowSpan");
    }
    this.rowSpan = rowSpan;
    this.updateCoordinates_();
  }
};
goog.editor.Table.OPTIMUM_EMPTY_CELL_WIDTH = 60;
goog.editor.Table.OPTIMUM_MAX_NEW_TABLE_WIDTH = 600;
goog.editor.Table.DEFAULT_BORDER_COLOR = "#888";
goog.editor.Table.createDomTable = function(doc, columns, rows, opt_tableStyle) {
  var style = {borderWidth:"1", borderColor:goog.editor.Table.DEFAULT_BORDER_COLOR};
  for (var prop in opt_tableStyle) {
    style[prop] = opt_tableStyle[prop];
  }
  var dom = new goog.dom.DomHelper(doc);
  var tableElement = dom.createTable(rows, columns, true);
  var minimumCellWidth = 10;
  var cellWidth = Math.max(minimumCellWidth, Math.min(goog.editor.Table.OPTIMUM_EMPTY_CELL_WIDTH, goog.editor.Table.OPTIMUM_MAX_NEW_TABLE_WIDTH / columns));
  var tds = tableElement.getElementsByTagName(goog.dom.TagName.TD);
  for (var i = 0, td;td = tds[i];i++) {
    td.style.width = cellWidth + "px";
  }
  goog.style.setStyle(tableElement, {"borderCollapse":"collapse", "borderColor":style.borderColor, "borderWidth":style.borderWidth + "px"});
  tableElement.border = style.borderWidth;
  tableElement.setAttribute("bordercolor", style.borderColor);
  tableElement.setAttribute("cellspacing", "0");
  return tableElement;
};
goog.provide("goog.editor.plugins.TableEditor");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.dom.Range");
goog.require("goog.dom.TagName");
goog.require("goog.editor.Plugin");
goog.require("goog.editor.Table");
goog.require("goog.editor.node");
goog.require("goog.editor.range");
goog.require("goog.object");
goog.require("goog.userAgent");
goog.editor.plugins.TableEditor = function() {
  goog.editor.plugins.TableEditor.base(this, "constructor");
  this.isTableEditableFunctions_ = [];
  this.isUserEditableTableBound_ = goog.bind(this.isUserEditableTable_, this);
};
goog.inherits(goog.editor.plugins.TableEditor, goog.editor.Plugin);
goog.editor.plugins.TableEditor.prototype.getTrogClassId = function() {
  return String(goog.getUid(this.constructor));
};
goog.editor.plugins.TableEditor.COMMAND = {TABLE:"+table", INSERT_ROW_AFTER:"+insertRowAfter", INSERT_ROW_BEFORE:"+insertRowBefore", INSERT_COLUMN_AFTER:"+insertColumnAfter", INSERT_COLUMN_BEFORE:"+insertColumnBefore", REMOVE_ROWS:"+removeRows", REMOVE_COLUMNS:"+removeColumns", SPLIT_CELL:"+splitCell", MERGE_CELLS:"+mergeCells", REMOVE_TABLE:"+removeTable"};
goog.editor.plugins.TableEditor.SUPPORTED_COMMANDS_ = goog.object.transpose(goog.editor.plugins.TableEditor.COMMAND);
goog.editor.plugins.TableEditor.prototype.isSupportedCommand = function(command) {
  return command in goog.editor.plugins.TableEditor.SUPPORTED_COMMANDS_;
};
goog.editor.plugins.TableEditor.prototype.enable = function(fieldObject) {
  goog.editor.plugins.TableEditor.base(this, "enable", fieldObject);
  if (goog.userAgent.GECKO) {
    var doc = this.getFieldDomHelper().getDocument();
    doc.execCommand("enableObjectResizing", false, "true");
  }
};
goog.editor.plugins.TableEditor.prototype.getCurrentTable_ = function() {
  var selectedElement = this.getFieldObject().getRange().getContainer();
  return this.getAncestorTable_(selectedElement);
};
goog.editor.plugins.TableEditor.prototype.getAncestorTable_ = function(node) {
  var ancestor = goog.dom.getAncestor(node, this.isUserEditableTableBound_, true);
  if (goog.editor.node.isEditable(ancestor)) {
    return (ancestor);
  } else {
    return null;
  }
};
goog.editor.plugins.TableEditor.prototype.queryCommandValue = function(command) {
  if (command == goog.editor.plugins.TableEditor.COMMAND.TABLE) {
    return !!this.getCurrentTable_();
  }
};
goog.editor.plugins.TableEditor.prototype.execCommandInternal = function(command, opt_arg) {
  var result = null;
  var cursorCell = null;
  var range = this.getFieldObject().getRange();
  if (command == goog.editor.plugins.TableEditor.COMMAND.TABLE) {
    if (!goog.editor.range.isEditable(range)) {
      return null;
    }
    var tableProps = opt_arg || {width:4, height:2};
    var doc = this.getFieldDomHelper().getDocument();
    var table = goog.editor.Table.createDomTable(doc, tableProps.width, tableProps.height);
    range.replaceContentsWithNode(table);
    if (!goog.userAgent.IE) {
      cursorCell = table.getElementsByTagName(goog.dom.TagName.TD)[0];
    }
  } else {
    var cellSelection = new goog.editor.plugins.TableEditor.CellSelection_(range, goog.bind(this.getAncestorTable_, this));
    var table = cellSelection.getTable();
    if (!table) {
      return null;
    }
    switch(command) {
      case goog.editor.plugins.TableEditor.COMMAND.INSERT_ROW_BEFORE:
        table.insertRow(cellSelection.getFirstRowIndex());
        break;
      case goog.editor.plugins.TableEditor.COMMAND.INSERT_ROW_AFTER:
        table.insertRow(cellSelection.getLastRowIndex() + 1);
        break;
      case goog.editor.plugins.TableEditor.COMMAND.INSERT_COLUMN_BEFORE:
        table.insertColumn(cellSelection.getFirstColumnIndex());
        break;
      case goog.editor.plugins.TableEditor.COMMAND.INSERT_COLUMN_AFTER:
        table.insertColumn(cellSelection.getLastColumnIndex() + 1);
        break;
      case goog.editor.plugins.TableEditor.COMMAND.REMOVE_ROWS:
        var startRow = cellSelection.getFirstRowIndex();
        var endRow = cellSelection.getLastRowIndex();
        if (startRow == 0 && endRow == table.rows.length - 1) {
          return this.execCommandInternal(goog.editor.plugins.TableEditor.COMMAND.REMOVE_TABLE);
        }
        var startColumn = cellSelection.getFirstColumnIndex();
        var rowCount = endRow - startRow + 1;
        for (var i = 0;i < rowCount;i++) {
          table.removeRow(startRow);
        }
        if (table.rows.length > 0) {
          var closestRow = Math.min(startRow, table.rows.length - 1);
          cursorCell = table.rows[closestRow].columns[startColumn].element;
        }
        break;
      case goog.editor.plugins.TableEditor.COMMAND.REMOVE_COLUMNS:
        var startCol = cellSelection.getFirstColumnIndex();
        var endCol = cellSelection.getLastColumnIndex();
        if (startCol == 0 && endCol == table.rows[0].columns.length - 1) {
          return this.execCommandInternal(goog.editor.plugins.TableEditor.COMMAND.REMOVE_TABLE);
        }
        var startRow = cellSelection.getFirstRowIndex();
        var removeCount = endCol - startCol + 1;
        for (var i = 0;i < removeCount;i++) {
          table.removeColumn(startCol);
        }
        var currentRow = table.rows[startRow];
        if (currentRow) {
          var closestCol = Math.min(startCol, currentRow.columns.length - 1);
          cursorCell = currentRow.columns[closestCol].element;
        }
        break;
      case goog.editor.plugins.TableEditor.COMMAND.MERGE_CELLS:
        if (cellSelection.isRectangle()) {
          table.mergeCells(cellSelection.getFirstRowIndex(), cellSelection.getFirstColumnIndex(), cellSelection.getLastRowIndex(), cellSelection.getLastColumnIndex());
        }
        break;
      case goog.editor.plugins.TableEditor.COMMAND.SPLIT_CELL:
        if (cellSelection.containsSingleCell()) {
          table.splitCell(cellSelection.getFirstRowIndex(), cellSelection.getFirstColumnIndex());
        }
        break;
      case goog.editor.plugins.TableEditor.COMMAND.REMOVE_TABLE:
        table.element.parentNode.removeChild(table.element);
        break;
      default:
      ;
    }
  }
  if (cursorCell) {
    range = goog.dom.Range.createFromNodeContents(cursorCell);
    range.collapse(false);
    range.select();
  }
  return result;
};
goog.editor.plugins.TableEditor.prototype.isUserEditableTable_ = function(element) {
  if (element.tagName != goog.dom.TagName.TABLE) {
    return false;
  }
  return goog.array.every(this.isTableEditableFunctions_, function(func) {
    return func((element));
  });
};
goog.editor.plugins.TableEditor.prototype.addIsTableEditableFunction = function(func) {
  goog.array.insert(this.isTableEditableFunctions_, func);
};
goog.editor.plugins.TableEditor.CellSelection_ = function(range, getParentTableFunction) {
  this.cells_ = [];
  var selectionContainer = range.getContainerElement();
  var elementInSelection = function(node) {
    return selectionContainer == node || selectionContainer.parentNode == node || range.containsNode(node, false);
  };
  var parentTableElement = selectionContainer && getParentTableFunction(selectionContainer);
  if (!parentTableElement) {
    return;
  }
  var parentTable = new goog.editor.Table(parentTableElement);
  if (!parentTable.rows.length || !parentTable.rows[0].columns.length) {
    return;
  }
  for (var i = 0, row;row = parentTable.rows[i];i++) {
    for (var j = 0, cell;cell = row.columns[j];j++) {
      if (elementInSelection(cell.element)) {
        if (!this.cells_.length) {
          this.firstRowIndex_ = cell.startRow;
          this.lastRowIndex_ = cell.endRow;
          this.firstColIndex_ = cell.startCol;
          this.lastColIndex_ = cell.endCol;
        } else {
          this.firstRowIndex_ = Math.min(this.firstRowIndex_, cell.startRow);
          this.lastRowIndex_ = Math.max(this.lastRowIndex_, cell.endRow);
          this.firstColIndex_ = Math.min(this.firstColIndex_, cell.startCol);
          this.lastColIndex_ = Math.max(this.lastColIndex_, cell.endCol);
        }
        this.cells_.push(cell);
      }
    }
  }
  this.parentTable_ = parentTable;
};
goog.editor.plugins.TableEditor.CellSelection_.prototype.getTable = function() {
  return this.parentTable_;
};
goog.editor.plugins.TableEditor.CellSelection_.prototype.getFirstRowIndex = function() {
  return this.firstRowIndex_;
};
goog.editor.plugins.TableEditor.CellSelection_.prototype.getLastRowIndex = function() {
  return this.lastRowIndex_;
};
goog.editor.plugins.TableEditor.CellSelection_.prototype.getFirstColumnIndex = function() {
  return this.firstColIndex_;
};
goog.editor.plugins.TableEditor.CellSelection_.prototype.getLastColumnIndex = function() {
  return this.lastColIndex_;
};
goog.editor.plugins.TableEditor.CellSelection_.prototype.getCells = function() {
  return this.cells_;
};
goog.editor.plugins.TableEditor.CellSelection_.prototype.isRectangle = function() {
  if (!this.cells_.length) {
    return false;
  }
  var firstCell = this.cells_[0];
  var lastCell = this.cells_[this.cells_.length - 1];
  return !(this.firstRowIndex_ < firstCell.startRow || this.lastRowIndex_ > lastCell.endRow || this.firstColIndex_ < firstCell.startCol || this.lastColIndex_ > lastCell.endCol);
};
goog.editor.plugins.TableEditor.CellSelection_.prototype.containsSingleCell = function() {
  var cellCount = this.cells_.length;
  return cellCount > 0 && this.cells_[0] == this.cells_[cellCount - 1];
};
goog.provide("goog.editor.plugins.UndoRedoState");
goog.require("goog.events.EventTarget");
goog.editor.plugins.UndoRedoState = function(asynchronous) {
  goog.editor.plugins.UndoRedoState.base(this, "constructor");
  this.asynchronous_ = asynchronous;
};
goog.inherits(goog.editor.plugins.UndoRedoState, goog.events.EventTarget);
goog.editor.plugins.UndoRedoState.ACTION_COMPLETED = "action_completed";
goog.editor.plugins.UndoRedoState.prototype.isAsynchronous = function() {
  return this.asynchronous_;
};
goog.editor.plugins.UndoRedoState.prototype.undo = goog.abstractMethod;
goog.editor.plugins.UndoRedoState.prototype.redo = goog.abstractMethod;
goog.editor.plugins.UndoRedoState.prototype.equals = goog.abstractMethod;
goog.provide("goog.editor.plugins.UndoRedoManager");
goog.provide("goog.editor.plugins.UndoRedoManager.EventType");
goog.require("goog.editor.plugins.UndoRedoState");
goog.require("goog.events");
goog.require("goog.events.EventTarget");
goog.editor.plugins.UndoRedoManager = function() {
  goog.events.EventTarget.call(this);
  this.maxUndoDepth_ = 100;
  this.undoStack_ = [];
  this.redoStack_ = [];
  this.pendingActions_ = [];
};
goog.inherits(goog.editor.plugins.UndoRedoManager, goog.events.EventTarget);
goog.editor.plugins.UndoRedoManager.EventType = {STATE_CHANGE:"state_change", STATE_ADDED:"state_added", BEFORE_UNDO:"before_undo", BEFORE_REDO:"before_redo"};
goog.editor.plugins.UndoRedoManager.prototype.inProgressActionKey_ = null;
goog.editor.plugins.UndoRedoManager.prototype.setMaxUndoDepth = function(depth) {
  this.maxUndoDepth_ = depth;
};
goog.editor.plugins.UndoRedoManager.prototype.addState = function(state) {
  if (this.undoStack_.length == 0 || !state.equals(this.undoStack_[this.undoStack_.length - 1])) {
    this.undoStack_.push(state);
    if (this.undoStack_.length > this.maxUndoDepth_) {
      this.undoStack_.shift();
    }
    var redoLength = this.redoStack_.length;
    this.redoStack_.length = 0;
    this.dispatchEvent({type:goog.editor.plugins.UndoRedoManager.EventType.STATE_ADDED, state:state});
    if (this.undoStack_.length == 1 || redoLength) {
      this.dispatchStateChange_();
    }
  }
};
goog.editor.plugins.UndoRedoManager.prototype.dispatchStateChange_ = function() {
  this.dispatchEvent(goog.editor.plugins.UndoRedoManager.EventType.STATE_CHANGE);
};
goog.editor.plugins.UndoRedoManager.prototype.undo = function() {
  this.shiftState_(this.undoStack_, this.redoStack_);
};
goog.editor.plugins.UndoRedoManager.prototype.redo = function() {
  this.shiftState_(this.redoStack_, this.undoStack_);
};
goog.editor.plugins.UndoRedoManager.prototype.hasUndoState = function() {
  return this.undoStack_.length > 0;
};
goog.editor.plugins.UndoRedoManager.prototype.hasRedoState = function() {
  return this.redoStack_.length > 0;
};
goog.editor.plugins.UndoRedoManager.prototype.shiftState_ = function(fromStack, toStack) {
  if (fromStack.length) {
    var state = fromStack.pop();
    toStack.push(state);
    this.addAction_({type:fromStack == this.undoStack_ ? goog.editor.plugins.UndoRedoManager.EventType.BEFORE_UNDO : goog.editor.plugins.UndoRedoManager.EventType.BEFORE_REDO, func:fromStack == this.undoStack_ ? state.undo : state.redo, state:state});
    if (fromStack.length == 0 || toStack.length == 1) {
      this.dispatchStateChange_();
    }
  }
};
goog.editor.plugins.UndoRedoManager.prototype.addAction_ = function(action) {
  this.pendingActions_.push(action);
  if (this.pendingActions_.length == 1) {
    this.doAction_();
  }
};
goog.editor.plugins.UndoRedoManager.prototype.doAction_ = function() {
  if (this.inProgressActionKey_ || this.pendingActions_.length == 0) {
    return;
  }
  var action = this.pendingActions_.shift();
  var e = {type:action.type, state:action.state};
  if (this.dispatchEvent(e)) {
    if (action.state.isAsynchronous()) {
      this.inProgressActionKey_ = goog.events.listen(action.state, goog.editor.plugins.UndoRedoState.ACTION_COMPLETED, this.finishAction_, false, this);
      action.func.call(action.state);
    } else {
      action.func.call(action.state);
      this.doAction_();
    }
  }
};
goog.editor.plugins.UndoRedoManager.prototype.finishAction_ = function() {
  goog.events.unlistenByKey((this.inProgressActionKey_));
  this.inProgressActionKey_ = null;
  this.doAction_();
};
goog.editor.plugins.UndoRedoManager.prototype.clearHistory = function() {
  if (this.undoStack_.length > 0 || this.redoStack_.length > 0) {
    this.undoStack_.length = 0;
    this.redoStack_.length = 0;
    this.dispatchStateChange_();
  }
};
goog.editor.plugins.UndoRedoManager.prototype.undoPeek = function() {
  return this.undoStack_[this.undoStack_.length - 1];
};
goog.editor.plugins.UndoRedoManager.prototype.redoPeek = function() {
  return this.redoStack_[this.redoStack_.length - 1];
};
goog.provide("goog.editor.plugins.UndoRedo");
goog.require("goog.dom");
goog.require("goog.dom.NodeOffset");
goog.require("goog.dom.Range");
goog.require("goog.editor.BrowserFeature");
goog.require("goog.editor.Command");
goog.require("goog.editor.Field");
goog.require("goog.editor.Plugin");
goog.require("goog.editor.node");
goog.require("goog.editor.plugins.UndoRedoManager");
goog.require("goog.editor.plugins.UndoRedoState");
goog.require("goog.events");
goog.require("goog.events.EventHandler");
goog.require("goog.log");
goog.require("goog.object");
goog.editor.plugins.UndoRedo = function(opt_manager) {
  goog.editor.Plugin.call(this);
  this.setUndoRedoManager(opt_manager || new goog.editor.plugins.UndoRedoManager);
  this.eventHandlers_ = {};
  this.currentStates_ = {};
  this.initialFieldChange_ = null;
  this.boundRestoreState_ = goog.bind(this.restoreState, this);
};
goog.inherits(goog.editor.plugins.UndoRedo, goog.editor.Plugin);
goog.editor.plugins.UndoRedo.prototype.logger = goog.log.getLogger("goog.editor.plugins.UndoRedo");
goog.editor.plugins.UndoRedo.prototype.inProgressUndo_ = null;
goog.editor.plugins.UndoRedo.prototype.undoManager_;
goog.editor.plugins.UndoRedo.prototype.managerStateChangeKey_;
goog.editor.plugins.UndoRedo.COMMAND = {UNDO:"+undo", REDO:"+redo"};
goog.editor.plugins.UndoRedo.SUPPORTED_COMMANDS_ = goog.object.transpose(goog.editor.plugins.UndoRedo.COMMAND);
goog.editor.plugins.UndoRedo.prototype.setMaxUndoDepth = function(depth) {
  this.undoManager_.setMaxUndoDepth(depth);
};
goog.editor.plugins.UndoRedo.prototype.setUndoRedoManager = function(manager) {
  if (this.managerStateChangeKey_) {
    goog.events.unlistenByKey(this.managerStateChangeKey_);
  }
  this.undoManager_ = manager;
  this.managerStateChangeKey_ = goog.events.listen(this.undoManager_, goog.editor.plugins.UndoRedoManager.EventType.STATE_CHANGE, this.dispatchCommandValueChange_, false, this);
};
goog.editor.plugins.UndoRedo.prototype.isSupportedCommand = function(command) {
  return command in goog.editor.plugins.UndoRedo.SUPPORTED_COMMANDS_;
};
goog.editor.plugins.UndoRedo.prototype.unregisterFieldObject = function(fieldObject) {
  this.disable(fieldObject);
  this.setFieldObject(null);
};
goog.editor.plugins.UndoRedo.prototype.getCurrentFieldObject = function() {
  return this.getFieldObject();
};
goog.editor.plugins.UndoRedo.prototype.getFieldObjectForHash = function(fieldHashCode) {
  return this.getFieldObject();
};
goog.editor.plugins.UndoRedo.prototype.getCurrentEventTarget = function() {
  return this.getFieldObject();
};
goog.editor.plugins.UndoRedo.prototype.enable = function(fieldObject) {
  if (this.isEnabled(fieldObject)) {
    return;
  }
  fieldObject.clearDelayedChange();
  var eventHandler = new goog.events.EventHandler(this);
  if (!goog.editor.BrowserFeature.USE_MUTATION_EVENTS) {
    eventHandler.listen(fieldObject, goog.editor.Field.EventType.BEFORECHANGE, this.handleBeforeChange_);
  }
  eventHandler.listen(fieldObject, goog.editor.Field.EventType.DELAYEDCHANGE, this.handleDelayedChange_);
  eventHandler.listen(fieldObject, goog.editor.Field.EventType.BLUR, this.handleBlur_);
  this.eventHandlers_[fieldObject.getHashCode()] = eventHandler;
  this.updateCurrentState_(fieldObject);
};
goog.editor.plugins.UndoRedo.prototype.disable = function(fieldObject) {
  fieldObject.clearDelayedChange();
  var eventHandler = this.eventHandlers_[fieldObject.getHashCode()];
  if (eventHandler) {
    eventHandler.dispose();
    delete this.eventHandlers_[fieldObject.getHashCode()];
  }
  if (this.currentStates_[fieldObject.getHashCode()]) {
    delete this.currentStates_[fieldObject.getHashCode()];
  }
};
goog.editor.plugins.UndoRedo.prototype.isEnabled = function(fieldObject) {
  return !!this.eventHandlers_[fieldObject.getHashCode()];
};
goog.editor.plugins.UndoRedo.prototype.disposeInternal = function() {
  goog.editor.plugins.UndoRedo.superClass_.disposeInternal.call(this);
  for (var hashcode in this.eventHandlers_) {
    this.eventHandlers_[hashcode].dispose();
    delete this.eventHandlers_[hashcode];
  }
  this.setFieldObject(null);
  if (this.undoManager_) {
    this.undoManager_.dispose();
    delete this.undoManager_;
  }
};
goog.editor.plugins.UndoRedo.prototype.getTrogClassId = function() {
  return "UndoRedo";
};
goog.editor.plugins.UndoRedo.prototype.execCommand = function(command, var_args) {
  if (command == goog.editor.plugins.UndoRedo.COMMAND.UNDO) {
    this.undoManager_.undo();
  } else {
    if (command == goog.editor.plugins.UndoRedo.COMMAND.REDO) {
      this.undoManager_.redo();
    }
  }
};
goog.editor.plugins.UndoRedo.prototype.queryCommandValue = function(command) {
  var state = null;
  if (command == goog.editor.plugins.UndoRedo.COMMAND.UNDO) {
    state = this.undoManager_.hasUndoState();
  } else {
    if (command == goog.editor.plugins.UndoRedo.COMMAND.REDO) {
      state = this.undoManager_.hasRedoState();
    }
  }
  return state;
};
goog.editor.plugins.UndoRedo.prototype.dispatchCommandValueChange_ = function() {
  var eventTarget = this.getCurrentEventTarget();
  eventTarget.dispatchEvent({type:goog.editor.Field.EventType.COMMAND_VALUE_CHANGE, commands:[goog.editor.plugins.UndoRedo.COMMAND.REDO, goog.editor.plugins.UndoRedo.COMMAND.UNDO]});
};
goog.editor.plugins.UndoRedo.prototype.restoreState = function(state, content, cursorPosition) {
  var fieldObj = this.getFieldObjectForHash(state.fieldHashCode);
  if (!fieldObj) {
    return;
  }
  fieldObj.stopChangeEvents(true, true);
  try {
    fieldObj.dispatchBeforeChange();
    fieldObj.execCommand(goog.editor.Command.CLEAR_LOREM, true);
    goog.editor.node.replaceInnerHtml(fieldObj.getElement(), content);
    if (cursorPosition) {
      cursorPosition.select();
    }
    var previousFieldObject = this.getCurrentFieldObject();
    fieldObj.focus();
    if (previousFieldObject && previousFieldObject.getHashCode() != state.fieldHashCode) {
      previousFieldObject.execCommand(goog.editor.Command.UPDATE_LOREM);
    }
    this.currentStates_[state.fieldHashCode].setUndoState(content, cursorPosition);
  } catch (e) {
    goog.log.error(this.logger, "Error while restoring undo state", e);
  } finally {
    this.inProgressUndo_ = state;
    fieldObj.dispatchChange();
    fieldObj.dispatchSelectionChangeEvent();
  }
};
goog.editor.plugins.UndoRedo.prototype.handleKeyboardShortcut = function(e, key, isModifierPressed) {
  if (isModifierPressed) {
    var command;
    if (key == "z") {
      command = e.shiftKey ? goog.editor.plugins.UndoRedo.COMMAND.REDO : goog.editor.plugins.UndoRedo.COMMAND.UNDO;
    } else {
      if (key == "y") {
        command = goog.editor.plugins.UndoRedo.COMMAND.REDO;
      }
    }
    if (command) {
      var state = command == goog.editor.plugins.UndoRedo.COMMAND.UNDO ? this.undoManager_.undoPeek() : this.undoManager_.redoPeek();
      if (state && state.fieldHashCode) {
        this.getCurrentFieldObject().execCommand(command);
      } else {
        this.execCommand(command);
      }
      return true;
    }
  }
  return false;
};
goog.editor.plugins.UndoRedo.prototype.clearHistory = function() {
  this.getFieldObject().stopChangeEvents(true, true);
  this.undoManager_.clearHistory();
  this.getFieldObject().startChangeEvents();
};
goog.editor.plugins.UndoRedo.prototype.refreshCurrentState = function(fieldObject) {
  if (this.isEnabled(fieldObject)) {
    if (this.currentStates_[fieldObject.getHashCode()]) {
      delete this.currentStates_[fieldObject.getHashCode()];
    }
    this.updateCurrentState_(fieldObject);
  }
};
goog.editor.plugins.UndoRedo.prototype.handleBeforeChange_ = function(e) {
  if (this.inProgressUndo_) {
    return;
  }
  var fieldObj = (e.target);
  var fieldHashCode = fieldObj.getHashCode();
  if (this.initialFieldChange_ != fieldHashCode) {
    this.initialFieldChange_ = fieldHashCode;
    this.updateCurrentState_(fieldObj);
  }
};
goog.editor.plugins.UndoRedo.prototype.handleDelayedChange_ = function(e) {
  if (this.inProgressUndo_) {
    var state = this.inProgressUndo_;
    this.inProgressUndo_ = null;
    state.dispatchEvent(goog.editor.plugins.UndoRedoState.ACTION_COMPLETED);
    return;
  }
  this.updateCurrentState_((e.target));
};
goog.editor.plugins.UndoRedo.prototype.handleBlur_ = function(e) {
  var fieldObj = (e.target);
  if (fieldObj) {
    fieldObj.clearDelayedChange();
  }
};
goog.editor.plugins.UndoRedo.prototype.getCursorPosition_ = function(fieldObj) {
  var cursorPos = new goog.editor.plugins.UndoRedo.CursorPosition_(fieldObj);
  if (!cursorPos.isValid()) {
    return null;
  }
  return cursorPos;
};
goog.editor.plugins.UndoRedo.prototype.updateCurrentState_ = function(fieldObj) {
  var fieldHashCode = fieldObj.getHashCode();
  var content, cursorPos;
  if (fieldObj.queryCommandValue(goog.editor.Command.USING_LOREM)) {
    content = "";
    cursorPos = null;
  } else {
    content = fieldObj.getElement().innerHTML;
    cursorPos = this.getCursorPosition_(fieldObj);
  }
  var currentState = this.currentStates_[fieldHashCode];
  if (currentState) {
    if (currentState.undoContent_ == content) {
      return;
    } else {
      if (content == "" || currentState.undoContent_ == "") {
        var emptyContents = fieldObj.getInjectableContents("", {});
        if (content == emptyContents && currentState.undoContent_ == "" || currentState.undoContent_ == emptyContents && content == "") {
          return;
        }
      }
    }
    currentState.setRedoState(content, cursorPos);
    this.undoManager_.addState(currentState);
  }
  this.currentStates_[fieldHashCode] = new goog.editor.plugins.UndoRedo.UndoState_(fieldHashCode, content, cursorPos, this.boundRestoreState_);
};
goog.editor.plugins.UndoRedo.UndoState_ = function(fieldHashCode, content, cursorPosition, restore) {
  goog.editor.plugins.UndoRedoState.call(this, true);
  this.fieldHashCode = fieldHashCode;
  this.restore_ = restore;
  this.setUndoState(content, cursorPosition);
};
goog.inherits(goog.editor.plugins.UndoRedo.UndoState_, goog.editor.plugins.UndoRedoState);
goog.editor.plugins.UndoRedo.UndoState_.prototype.undoContent_;
goog.editor.plugins.UndoRedo.UndoState_.prototype.undoCursorPosition_;
goog.editor.plugins.UndoRedo.UndoState_.prototype.redoContent_;
goog.editor.plugins.UndoRedo.UndoState_.prototype.redoCursorPosition_;
goog.editor.plugins.UndoRedo.UndoState_.prototype.undo = function() {
  this.restore_(this, this.undoContent_, this.undoCursorPosition_);
};
goog.editor.plugins.UndoRedo.UndoState_.prototype.redo = function() {
  this.restore_(this, this.redoContent_, this.redoCursorPosition_);
};
goog.editor.plugins.UndoRedo.UndoState_.prototype.setUndoState = function(content, cursorPosition) {
  this.undoContent_ = content;
  this.undoCursorPosition_ = cursorPosition;
};
goog.editor.plugins.UndoRedo.UndoState_.prototype.setRedoState = function(content, cursorPosition) {
  this.redoContent_ = content;
  this.redoCursorPosition_ = cursorPosition;
};
goog.editor.plugins.UndoRedo.UndoState_.prototype.equals = function(rhs) {
  return this.fieldHashCode == rhs.fieldHashCode && this.undoContent_ == rhs.undoContent_ && this.redoContent_ == rhs.redoContent_;
};
goog.editor.plugins.UndoRedo.CursorPosition_ = function(field) {
  this.field_ = field;
  var win = field.getEditableDomHelper().getWindow();
  var range = field.getRange();
  var isValidRange = !!range && range.isRangeInDocument() && range.getWindow() == win;
  range = isValidRange ? range : null;
  if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
    this.initW3C_(range);
  } else {
    if (goog.editor.BrowserFeature.HAS_IE_RANGES) {
      this.initIE_(range);
    }
  }
};
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.initW3C_ = function(range) {
  this.isValid_ = false;
  if (!range) {
    return;
  }
  var anchorNode = range.getAnchorNode();
  var focusNode = range.getFocusNode();
  if (!anchorNode || !focusNode) {
    return;
  }
  var anchorOffset = range.getAnchorOffset();
  var anchor = new goog.dom.NodeOffset(anchorNode, this.field_.getElement());
  var focusOffset = range.getFocusOffset();
  var focus = new goog.dom.NodeOffset(focusNode, this.field_.getElement());
  if (range.isReversed()) {
    this.startOffset_ = focus;
    this.startChildOffset_ = focusOffset;
    this.endOffset_ = anchor;
    this.endChildOffset_ = anchorOffset;
  } else {
    this.startOffset_ = anchor;
    this.startChildOffset_ = anchorOffset;
    this.endOffset_ = focus;
    this.endChildOffset_ = focusOffset;
  }
  this.isValid_ = true;
};
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.initIE_ = function(range) {
  this.isValid_ = false;
  if (!range) {
    return;
  }
  var ieRange = range.getTextRange(0).getBrowserRangeObject();
  if (!goog.dom.contains(this.field_.getElement(), ieRange.parentElement())) {
    return;
  }
  var contentEditableRange = this.field_.getEditableDomHelper().getDocument().body.createTextRange();
  contentEditableRange.moveToElementText(this.field_.getElement());
  var startMarker = ieRange.duplicate();
  startMarker.collapse(true);
  startMarker.setEndPoint("StartToStart", contentEditableRange);
  this.startOffset_ = goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_(startMarker);
  var endMarker = ieRange.duplicate();
  endMarker.setEndPoint("StartToStart", contentEditableRange);
  this.endOffset_ = goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_(endMarker);
  this.isValid_ = true;
};
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.isValid = function() {
  return this.isValid_;
};
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.toString = function() {
  if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
    return "W3C:" + this.startOffset_.toString() + "\n" + this.startChildOffset_ + ":" + this.endOffset_.toString() + "\n" + this.endChildOffset_;
  }
  return "IE:" + this.startOffset_ + "," + this.endOffset_;
};
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.select = function() {
  var range = this.getRange_(this.field_.getElement());
  if (range) {
    if (goog.editor.BrowserFeature.HAS_IE_RANGES) {
      this.field_.getElement().focus();
    }
    goog.dom.Range.createFromBrowserRange(range).select();
  }
};
goog.editor.plugins.UndoRedo.CursorPosition_.prototype.getRange_ = function(baseNode) {
  if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
    var startNode = this.startOffset_.findTargetNode(baseNode);
    var endNode = this.endOffset_.findTargetNode(baseNode);
    if (!startNode || !endNode) {
      return null;
    }
    return (goog.dom.Range.createFromNodes(startNode, this.startChildOffset_, endNode, this.endChildOffset_).getBrowserRangeObject());
  }
  var sel = baseNode.ownerDocument.body.createTextRange();
  sel.moveToElementText(baseNode);
  sel.collapse(true);
  sel.moveEnd("character", this.endOffset_);
  sel.moveStart("character", this.startOffset_);
  return sel;
};
goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_ = function(range) {
  var testRange = range.duplicate();
  var text = range.text;
  var guess = text.length;
  testRange.collapse(true);
  testRange.moveEnd("character", guess);
  var diff;
  var numTries = 10;
  while (diff = testRange.compareEndPoints("EndToEnd", range)) {
    guess -= diff;
    testRange.moveEnd("character", -diff);
    --numTries;
    if (0 == numTries) {
      break;
    }
  }
  var offset = 0;
  var pos = text.indexOf("\n\r");
  while (pos != -1) {
    ++offset;
    pos = text.indexOf("\n\r", pos + 1);
  }
  return guess + offset;
};
goog.provide("goog.debug.RelativeTimeProvider");
goog.debug.RelativeTimeProvider = function() {
  this.relativeTimeStart_ = goog.now();
};
goog.debug.RelativeTimeProvider.defaultInstance_ = new goog.debug.RelativeTimeProvider;
goog.debug.RelativeTimeProvider.prototype.set = function(timeStamp) {
  this.relativeTimeStart_ = timeStamp;
};
goog.debug.RelativeTimeProvider.prototype.reset = function() {
  this.set(goog.now());
};
goog.debug.RelativeTimeProvider.prototype.get = function() {
  return this.relativeTimeStart_;
};
goog.debug.RelativeTimeProvider.getDefaultInstance = function() {
  return goog.debug.RelativeTimeProvider.defaultInstance_;
};
goog.provide("goog.debug.Formatter");
goog.provide("goog.debug.HtmlFormatter");
goog.provide("goog.debug.TextFormatter");
goog.require("goog.debug");
goog.require("goog.debug.Logger");
goog.require("goog.debug.RelativeTimeProvider");
goog.require("goog.html.SafeHtml");
goog.debug.Formatter = function(opt_prefix) {
  this.prefix_ = opt_prefix || "";
  this.startTimeProvider_ = goog.debug.RelativeTimeProvider.getDefaultInstance();
};
goog.debug.Formatter.prototype.appendNewline = true;
goog.debug.Formatter.prototype.showAbsoluteTime = true;
goog.debug.Formatter.prototype.showRelativeTime = true;
goog.debug.Formatter.prototype.showLoggerName = true;
goog.debug.Formatter.prototype.showExceptionText = false;
goog.debug.Formatter.prototype.showSeverityLevel = false;
goog.debug.Formatter.prototype.formatRecord = goog.abstractMethod;
goog.debug.Formatter.prototype.formatRecordAsHtml = goog.abstractMethod;
goog.debug.Formatter.prototype.setStartTimeProvider = function(provider) {
  this.startTimeProvider_ = provider;
};
goog.debug.Formatter.prototype.getStartTimeProvider = function() {
  return this.startTimeProvider_;
};
goog.debug.Formatter.prototype.resetRelativeTimeStart = function() {
  this.startTimeProvider_.reset();
};
goog.debug.Formatter.getDateTimeStamp_ = function(logRecord) {
  var time = new Date(logRecord.getMillis());
  return goog.debug.Formatter.getTwoDigitString_(time.getFullYear() - 2E3) + goog.debug.Formatter.getTwoDigitString_(time.getMonth() + 1) + goog.debug.Formatter.getTwoDigitString_(time.getDate()) + " " + goog.debug.Formatter.getTwoDigitString_(time.getHours()) + ":" + goog.debug.Formatter.getTwoDigitString_(time.getMinutes()) + ":" + goog.debug.Formatter.getTwoDigitString_(time.getSeconds()) + "." + goog.debug.Formatter.getTwoDigitString_(Math.floor(time.getMilliseconds() / 10));
};
goog.debug.Formatter.getTwoDigitString_ = function(n) {
  if (n < 10) {
    return "0" + n;
  }
  return String(n);
};
goog.debug.Formatter.getRelativeTime_ = function(logRecord, relativeTimeStart) {
  var ms = logRecord.getMillis() - relativeTimeStart;
  var sec = ms / 1E3;
  var str = sec.toFixed(3);
  var spacesToPrepend = 0;
  if (sec < 1) {
    spacesToPrepend = 2;
  } else {
    while (sec < 100) {
      spacesToPrepend++;
      sec *= 10;
    }
  }
  while (spacesToPrepend-- > 0) {
    str = " " + str;
  }
  return str;
};
goog.debug.HtmlFormatter = function(opt_prefix) {
  goog.debug.Formatter.call(this, opt_prefix);
};
goog.inherits(goog.debug.HtmlFormatter, goog.debug.Formatter);
goog.debug.HtmlFormatter.prototype.showExceptionText = true;
goog.debug.HtmlFormatter.prototype.formatRecord = function(logRecord) {
  if (!logRecord) {
    return "";
  }
  return this.formatRecordAsHtml(logRecord).getTypedStringValue();
};
goog.debug.HtmlFormatter.prototype.formatRecordAsHtml = function(logRecord) {
  if (!logRecord) {
    return goog.html.SafeHtml.EMPTY;
  }
  var className;
  switch(logRecord.getLevel().value) {
    case goog.debug.Logger.Level.SHOUT.value:
      className = "dbg-sh";
      break;
    case goog.debug.Logger.Level.SEVERE.value:
      className = "dbg-sev";
      break;
    case goog.debug.Logger.Level.WARNING.value:
      className = "dbg-w";
      break;
    case goog.debug.Logger.Level.INFO.value:
      className = "dbg-i";
      break;
    case goog.debug.Logger.Level.FINE.value:
    ;
    default:
      className = "dbg-f";
      break;
  }
  var sb = [];
  sb.push(this.prefix_, " ");
  if (this.showAbsoluteTime) {
    sb.push("[", goog.debug.Formatter.getDateTimeStamp_(logRecord), "] ");
  }
  if (this.showRelativeTime) {
    sb.push("[", goog.debug.Formatter.getRelativeTime_(logRecord, this.startTimeProvider_.get()), "s] ");
  }
  if (this.showLoggerName) {
    sb.push("[", logRecord.getLoggerName(), "] ");
  }
  if (this.showSeverityLevel) {
    sb.push("[", logRecord.getLevel().name, "] ");
  }
  var fullPrefixHtml = goog.html.SafeHtml.htmlEscapePreservingNewlinesAndSpaces(sb.join(""));
  var exceptionHtml = goog.html.SafeHtml.EMPTY;
  if (this.showExceptionText && logRecord.getException()) {
    exceptionHtml = goog.html.SafeHtml.concat(goog.html.SafeHtml.BR, goog.debug.exposeExceptionAsHtml(logRecord.getException()));
  }
  var logRecordHtml = goog.html.SafeHtml.htmlEscapePreservingNewlinesAndSpaces(logRecord.getMessage());
  var recordAndExceptionHtml = goog.html.SafeHtml.create("span", {"class":className}, goog.html.SafeHtml.concat(logRecordHtml, exceptionHtml));
  var html;
  if (this.appendNewline) {
    html = goog.html.SafeHtml.concat(fullPrefixHtml, recordAndExceptionHtml, goog.html.SafeHtml.BR);
  } else {
    html = goog.html.SafeHtml.concat(fullPrefixHtml, recordAndExceptionHtml);
  }
  return html;
};
goog.debug.TextFormatter = function(opt_prefix) {
  goog.debug.Formatter.call(this, opt_prefix);
};
goog.inherits(goog.debug.TextFormatter, goog.debug.Formatter);
goog.debug.TextFormatter.prototype.formatRecord = function(logRecord) {
  var sb = [];
  sb.push(this.prefix_, " ");
  if (this.showAbsoluteTime) {
    sb.push("[", goog.debug.Formatter.getDateTimeStamp_(logRecord), "] ");
  }
  if (this.showRelativeTime) {
    sb.push("[", goog.debug.Formatter.getRelativeTime_(logRecord, this.startTimeProvider_.get()), "s] ");
  }
  if (this.showLoggerName) {
    sb.push("[", logRecord.getLoggerName(), "] ");
  }
  if (this.showSeverityLevel) {
    sb.push("[", logRecord.getLevel().name, "] ");
  }
  sb.push(logRecord.getMessage());
  if (this.showExceptionText) {
    var exception = logRecord.getException();
    if (exception) {
      var exceptionText = exception instanceof Error ? exception.message : exception.toString();
      sb.push("\n", exceptionText);
    }
  }
  if (this.appendNewline) {
    sb.push("\n");
  }
  return sb.join("");
};
goog.debug.TextFormatter.prototype.formatRecordAsHtml = function(logRecord) {
  return goog.html.SafeHtml.htmlEscapePreservingNewlinesAndSpaces(goog.debug.TextFormatter.prototype.formatRecord(logRecord));
};
goog.provide("goog.debug.Console");
goog.require("goog.debug.LogManager");
goog.require("goog.debug.Logger");
goog.require("goog.debug.TextFormatter");
goog.debug.Console = function() {
  this.publishHandler_ = goog.bind(this.addLogRecord, this);
  this.formatter_ = new goog.debug.TextFormatter;
  this.formatter_.showAbsoluteTime = false;
  this.formatter_.showExceptionText = false;
  this.formatter_.appendNewline = false;
  this.isCapturing_ = false;
  this.logBuffer_ = "";
  this.filteredLoggers_ = {};
};
goog.debug.Console.prototype.getFormatter = function() {
  return this.formatter_;
};
goog.debug.Console.prototype.setCapturing = function(capturing) {
  if (capturing == this.isCapturing_) {
    return;
  }
  var rootLogger = goog.debug.LogManager.getRoot();
  if (capturing) {
    rootLogger.addHandler(this.publishHandler_);
  } else {
    rootLogger.removeHandler(this.publishHandler_);
    this.logBuffer = "";
  }
  this.isCapturing_ = capturing;
};
goog.debug.Console.prototype.addLogRecord = function(logRecord) {
  if (this.filteredLoggers_[logRecord.getLoggerName()]) {
    return;
  }
  var record = this.formatter_.formatRecord(logRecord);
  var console = goog.debug.Console.console_;
  if (console) {
    switch(logRecord.getLevel()) {
      case goog.debug.Logger.Level.SHOUT:
        goog.debug.Console.logToConsole_(console, "info", record);
        break;
      case goog.debug.Logger.Level.SEVERE:
        goog.debug.Console.logToConsole_(console, "error", record);
        break;
      case goog.debug.Logger.Level.WARNING:
        goog.debug.Console.logToConsole_(console, "warn", record);
        break;
      default:
        goog.debug.Console.logToConsole_(console, "debug", record);
        break;
    }
  } else {
    this.logBuffer_ += record;
  }
};
goog.debug.Console.prototype.addFilter = function(loggerName) {
  this.filteredLoggers_[loggerName] = true;
};
goog.debug.Console.prototype.removeFilter = function(loggerName) {
  delete this.filteredLoggers_[loggerName];
};
goog.debug.Console.instance = null;
goog.debug.Console.console_ = goog.global["console"];
goog.debug.Console.setConsole = function(console) {
  goog.debug.Console.console_ = (console);
};
goog.debug.Console.autoInstall = function() {
  if (!goog.debug.Console.instance) {
    goog.debug.Console.instance = new goog.debug.Console;
  }
  if (goog.global.location && goog.global.location.href.indexOf("Debug=true") != -1) {
    goog.debug.Console.instance.setCapturing(true);
  }
};
goog.debug.Console.show = function() {
  alert(goog.debug.Console.instance.logBuffer_);
};
goog.debug.Console.logToConsole_ = function(console, fnName, record) {
  if (console[fnName]) {
    console[fnName](record);
  } else {
    console.log(record);
  }
};
goog.provide("uno.ConsoleLogger");
goog.require("goog.debug.Console");
(function() {
  var ConsoleLogger = uno.ConsoleLogger = function(opt) {
    goog.debug.Console.call(this);
    this.cache = [];
    this.cachingEnabled = true;
    this.maxEntries = null;
    this.configure(opt);
  };
  goog.inherits(uno.ConsoleLogger, goog.debug.Console);
  ConsoleLogger.prototype.configure = function(opt) {
    opt = opt || {};
    if (typeof opt.cachingEnabled !== "undefined") {
      this.cachingEnabled = !!opt.cachingEnabled;
    }
    this.maxEntries = opt.maxEntries;
    if (!this.cachingEnabled) {
      this.clear();
    }
    if (this.maxEntries != null && this.cache.length > this.maxEntries) {
      this.cache = this.cache.slice(this.cache.length - this.maxEntries);
    }
  };
  ConsoleLogger.prototype.addLogRecord = function(logRecord) {
    if (this.filteredLoggers_[logRecord.getLoggerName()]) {
      return;
    }
    logRecord.formattedText = this.formatter_.formatRecord(logRecord);
    this.print(logRecord.getLevel(), logRecord.formattedText);
    if (this.cachingEnabled) {
      if (this.maxEntries != null && this.maxEntries <= this.cache.length) {
        this.cache.shift();
      }
      this.cache.push(logRecord);
    }
  };
  ConsoleLogger.prototype.print = function(level, formattedText) {
    var console = goog.debug.Console.console_;
    if (console) {
      switch(level) {
        case goog.debug.Logger.Level.SHOUT:
          goog.debug.Console.logToConsole_(console, "info", formattedText);
          break;
        case goog.debug.Logger.Level.SEVERE:
          goog.debug.Console.logToConsole_(console, "error", formattedText);
          break;
        case goog.debug.Logger.Level.WARNING:
          goog.debug.Console.logToConsole_(console, "warn", formattedText);
          break;
        default:
          goog.debug.Console.logToConsole_(console, "debug", formattedText);
          break;
      }
    }
  };
  ConsoleLogger.prototype.dump = function() {
    var me = this;
    this.cache.forEach(function(record) {
      me.print(record.getLevel(), record.formattedText);
    });
  };
  ConsoleLogger.prototype.clear = function() {
    this.cache = [];
  };
})();
goog.provide("uno.defs");
(function() {
  uno.defs = {containers:{EDITOR_BODY_SELECTOR:"en-note", TOOLS_SELECTOR:"en-tools", EDITOR_CONTAINER_CLASS:"en-container"}, classes:{RESOURCE_CLASS:"en-media", MODULE_CLASS:"en-module"}, tags:{BLOCK:"div", BOLD:"b", ITALIC:"i", STRIKETHROUGH:"s", UNDERLINE:"u", TT:"tt"}, objects:{OBJECT_PLACEHOLDER_CLASS:"en-object-placeholder"}, crypto:{CRYPT_CLASS:"en-crypt", CRYPT_HIDDEN_CLASS:"en-crypt-placeholder", CRYPT_VISIBLE_CLASS:"en-crypt-revealed", CRYPT_REV_ATTRIBUTE:"data-en-crypt-rev"}, format:{CLIPBOARD:"clipboard", 
  ENML:"enml", PLATFORM_HTML:"platform_html"}, image:{TRANSPARENT_IMAGE_DATA_URL:"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"}, regex:{BULLETED_LIST:"^\\s*\\*", HORIZONTAL_RULE:"^\\s*[\\*\\-\\=]{3}[\\s\\*\\-\\=]*", INVALID_HTML_CHARS:"[\x00\u0001-\b\u000e-\u001f\u007f-\u009f\ufdd0-\ufdef\x0B\ufffe\uffff]|[\u0001-\u0010][\ufffe-\uffff]", NUMBERED_LIST:"^\\s*[0-9]+\\.", SIMPLE_EMAIL:"[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}", TABLE:"^\\s*(\\[\\s*\\]){2,}([xX][0-9]+)?", 
  TODO:"\\[[\\sxX]?\\]", SIMPLE_URL:"(?:https?://|ftp://|www\\.)\\S+" + "|" + "\\S+\\." + "(?:com|net|edu|org)" + "(?:" + "(?:\\:|/|#|\\?)\\S*|\\b" + ")", WEB_URL:"" + "(?:(?:https?|ftp)://)" + "(?:\\S+(?::\\S*)?@)?" + "(" + "(?:" + ("(?!(?:10|127)(?:\\.\\d{1,3}){3})" + "(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})" + "(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})" + "(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])" + "(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}" + "(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))") + 
  "|" + ("(?:(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)" + "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*" + "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))") + ")" + ")" + "(?::\\d{2,5})?" + "(?:/\\S*)?"}, nbsp:{CHARACTER_SEQUENCE:"\u00a0"}, highlight:{BACKGROUND_COLOR_IOS:"rgb(255, 204, 102)", BACKGROUND_COLOR_MAC:"rgb(255, 250, 165)", BACKGROUND_COLOR_CLEARLY:"rgb(246, 238, 150)", STYLE_LEGACY:"-evernote-highlighted", STYLE:"-evernote-highlight", STYLE_VALUE:"true", BACKGROUND_STYLE:"background-color", 
  BACKGROUND_SELECTOR:"*[style*='background-color']"}, bitfields:{NODE_SHOW_ALL:-1, NODE_SHOW_TEXT:4, NODE_FILTER_ACCEPT:1, NODE_FILTER_REJECT:2, NODE_ELEMENT_NODE:1, NODE_ATTRIBUTE_NODE:2, NODE_TEXT_NODE:3, NODE_CDATA_SECTION_NODE:4, NODE_ENTITY_REFERENCE_NODE:5, NODE_ENTITY_NODE:6, NODE_PROCESSING_INSTRUCTION_NODE:7, NODE_COMMENT_NODE:8, NODE_DOCUMENT_NODE:9, NODE_DOCUMENT_TYPE_NODE:10, NODE_DOCUMENT_FRAGMENT_NODE:11, NODE_NOTATION_NODE:12, NODE_DOCUMENT_POSITION_PRECEDING:2, NODE_DOCUMENT_POSITION_FOLLOWING:4, 
  NODE_DOCUMENT_POSITION_CONTAINS:8, NODE_DOCUMENT_POSITION_CONTAINED_BY:16}, tab:{CHARACTER_SEQUENCE:"\u00a0\u00a0\u00a0\u00a0\u00a0"}, blockElements:{"p":true, "h1":true, "h2":true, "h3":true, "h4":true, "h5":true, "h6":true, "pre":true, "hr":true, "br":true, "li":true, "div":true, "table":true, "tr":true, "head":true, "body":true}};
})();
goog.provide("uno.BasePlugin");
goog.require("goog.debug.Logger");
goog.require("goog.editor.Plugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.BasePlugin");
  var Plugin = goog.editor.Plugin;
  var BasePlugin = uno.BasePlugin = function(trogClassId) {
    Plugin.call(this);
    this.trogClassId = trogClassId;
    this.platform = null;
  };
  goog.inherits(BasePlugin, Plugin);
  BasePlugin.prototype.getTrogClassId = function() {
    return this.trogClassId;
  };
  BasePlugin.prototype.registerFieldObject = function(fieldObject) {
    Plugin.prototype.registerFieldObject.call(this, fieldObject);
    var me = this;
    var id = this.getTrogClassId();
    var namespace = goog.getObjectByName(id.toLowerCase());
    if (namespace) {
      this.platform = namespace[fieldObject.config.platform] || namespace.generic || {};
      Object.keys(this.platform).forEach(function(key) {
        if (typeof me.platform[key] === "function") {
          me.platform[key] = me.platform[key].bind(me);
        }
      });
    }
    this.editor = this.getFieldObject();
    this.setParentEventTarget(this.editor);
  };
  BasePlugin.prototype.unregisterFieldObject = function(fieldObject) {
    Plugin.prototype.unregisterFieldObject.call(this, fieldObject);
    this.editor = null;
  };
})();
goog.provide("uno.util.objects");
(function() {
  var objects = uno.util.objects;
  objects.mergeOptions = function(options, defaultOptions) {
    var parsedOptions = goog.object.clone(options || {});
    goog.object.extend(defaultOptions, parsedOptions);
    return defaultOptions;
  };
  objects.valueOrDefault = function(val, defaultVal) {
    if (typeof val === "undefined") {
      return defaultVal;
    }
    return val;
  };
})();
goog.provide("uno.commands.Accentuate");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.objects");
(function() {
  var util = uno.util;
  var log = goog.debug.Logger.getLogger("uno.commands.Accentuate");
  var Accentuate = uno.commands.Accentuate = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Accentuate, uno.BasePlugin);
  Accentuate.CONTAINER_CLASSNAME = "accentuate-container";
  Accentuate.BOX_CLASSNAME = "en-find-result";
  Accentuate.BOX_ACTIVE_CLASSNAME = "en-find-result-active";
  Accentuate.prototype.isSupportedCommand = function(command) {
    return command === "accentuate";
  };
  Accentuate.prototype.queryCommandValue = function() {
  };
  Accentuate.prototype.execCommand = function(command, rawOptions) {
    var options = util.objects.mergeOptions(rawOptions, {boxes:[], selectedBoxIndex:-1, clearFirst:false, clearOnClickSelector:"en-note"});
    var accentuateContainer = document.querySelector("." + Accentuate.CONTAINER_CLASSNAME);
    if (options.clearFirst && accentuateContainer) {
      accentuateContainer.innerHTML = "";
    }
    if (!accentuateContainer) {
      var toolsContainer = getToolsContainer();
      accentuateContainer = goog.dom.createDom("div", {"class":Accentuate.CONTAINER_CLASSNAME});
      toolsContainer.appendChild(accentuateContainer);
    }
    var boxes = options.boxes;
    var currentIndex = accentuateContainer.querySelectorAll("." + Accentuate.BOX_CLASSNAME).length;
    for (var i = 0;i < boxes.length;i++) {
      var match = boxes[i];
      for (var j = 0;j < match.length;j++) {
        var item = match[j];
        var box = goog.dom.createDom("div", {id:Accentuate.BOX_CLASSNAME + currentIndex, "class":Accentuate.BOX_CLASSNAME, style:createStyle({position:"absolute", top:item.top + "px", left:item.left + "px", width:item.width + "px", height:item.height + "px"})});
        currentIndex++;
        accentuateContainer.appendChild(box);
      }
    }
    var newActiveBox = accentuateContainer.querySelector("#" + Accentuate.BOX_CLASSNAME + options.selectedBoxIndex);
    if (newActiveBox) {
      var oldActiveBox = accentuateContainer.querySelector("." + Accentuate.BOX_ACTIVE_CLASSNAME);
      if (oldActiveBox) {
        goog.dom.classlist.remove(oldActiveBox, Accentuate.BOX_ACTIVE_CLASSNAME);
      }
      goog.dom.classlist.add(newActiveBox, Accentuate.BOX_ACTIVE_CLASSNAME);
      newActiveBox.scrollIntoView();
    }
    return true;
  };
  function getToolsContainer() {
    var toolsContainerId = uno.defs.containers.TOOLS_SELECTOR;
    var toolsContainer = document.querySelector(toolsContainerId);
    if (!toolsContainer) {
      toolsContainer = goog.dom.createDom("div", {id:toolsContainerId, "class":toolsContainerId});
      document.body.appendChild(toolsContainer);
    }
    return toolsContainer;
  }
  function createStyle(style) {
    var finalStyle = "";
    for (var key in style) {
      if (style.hasOwnProperty(key)) {
        finalStyle += key + ":" + style[key] + ";";
      }
    }
    return finalStyle;
  }
})();
goog.provide("uno.commands.Active");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Active");
  var Active = uno.commands.Active = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Active, uno.BasePlugin);
  Active.prototype.isSupportedCommand = function(command) {
    return command === "active";
  };
  Active.prototype.activeOnUneditableFields = goog.functions.TRUE;
  Active.prototype.execCommand = function(command, makeActive) {
    if (this.editor.readOnly === makeActive) {
      this.editor.readOnly = !makeActive;
      if (!makeActive) {
        this.editor.leaveEditMode();
      }
    }
    return true;
  };
  Active.prototype.queryCommandValue = function() {
    return !this.editor.readOnly;
  };
})();
goog.provide("uno.util.dom");
goog.require("uno.defs");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.editor.node");
goog.require("goog.html.SafeHtml");
uno.util.dom.ClientRect;
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.dom");
  var dom = uno.util.dom;
  dom.isEmpty = function(node) {
    if (!node) {
      return true;
    }
    if (node.nodeType === Node.TEXT_NODE) {
      return false;
    }
    if (node.childNodes) {
      var isEmpty = true;
      Array.prototype.forEach.call(node.childNodes, function(childNode) {
        isEmpty = dom.isEmpty(childNode);
      });
      return isEmpty;
    }
    var tagName = node.tagName.toLowerCase();
    var components = ["img", "embed", "object", "input", "param", "hr", "en-media", "en-note", "en-table"];
    var isObject = components.indexOf(tagName) > -1;
    return !isObject;
  };
  dom.parent = function(node, selector, rootNode) {
    if (!rootNode) {
      rootNode = document.body;
    }
    if (node === rootNode) {
      return null;
    }
    if (dom.matches(node, selector)) {
      return node;
    }
    var parentNode = node && node.parentNode;
    if (parentNode) {
      return dom.parent(parentNode, selector, rootNode);
    }
    return null;
  };
  dom.isTextNode = function(node) {
    return !!(node && node.nodeType === Node.TEXT_NODE);
  };
  dom.inlineTagNames = ["en-media", "span"];
  dom.blockTagNames = ["en-note", "address", "article", "aside", "body", "blockquote", "caption", "center", "col", "colgroup", "dd", "details", "dir", "div", "dl", "dt", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "hr", "li", "listing", "menu", "nav", "ol", "p", "plaintext", "pre", "section", "summary", "table", "tbody", "td", "tfoot", "th", "thead", "tr", "ul", "xmp"];
  dom.isBlockNode = function(node) {
    return !!(node && (dom.blockTagNames.indexOf(dom.getTagName(node)) > -1 || node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE));
  };
  dom.isInlineNode = function(node) {
    return !!(node && !dom.isBlockNode(node));
  };
  dom.getTagName = function(node) {
    return node && node.tagName && node.tagName.toLowerCase() || "";
  };
  var createIsTagNames = function() {
    dom.blockTagNames.concat(dom.inlineTagNames).forEach(function(tagName) {
      var fnName = "is" + goog.string.capitalize(tagName.replace("-", ""));
      dom[fnName] = function(node) {
        return node && node.tagName && node.tagName.toLowerCase() === tagName ? node : null;
      };
    });
  };
  createIsTagNames();
  dom.getFirstAncestor = function(node, tagNames, includeNode) {
    return goog.dom.getAncestor(node, function(ancestor) {
      return ancestor && ancestor.tagName && tagNames.indexOf(ancestor.tagName.toLowerCase()) > -1;
    }, includeNode);
  };
  dom.ancestors = function(node) {
    var ancestors = [];
    while (node && node.parentNode) {
      ancestors.unshift(node.parentNode);
      node = node.parentNode;
    }
    return ancestors;
  };
  dom.contiguousInlineSiblings = function(node) {
    var nodes = [node];
    var sib = node.previousSibling;
    while (sib && !dom.isBlockNode(sib)) {
      nodes.unshift(sib);
      sib = sib.previousSibling;
    }
    sib = node.nextSibling;
    while (sib && !dom.isBlockNode(sib)) {
      nodes.push(sib);
      sib = sib.nextSibling;
    }
    return nodes;
  };
  var rxEscapeObj = /[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g;
  var rxEscape = function(value) {
    if (value instanceof RegExp) {
      return value.source;
    }
    return value.replace(rxEscapeObj, "\\$&");
  };
  var regexForAppDataNameCache = {};
  var regexForAppDataName = function(name) {
    var rx = regexForAppDataNameCache[name];
    if (!rx) {
      rx = new RegExp("(^|;)\\s*(" + rxEscape(name) + ")\\s*\\:\\s*(.*?)($|;)+", "gi");
      regexForAppDataName[name] = rx;
    } else {
      rx.lastIndex = 0;
    }
    return rx;
  };
  dom.fragFromString = function(html) {
    var frag = document.createDocumentFragment();
    var temp = document.createElement("div");
    temp.innerHTML = html;
    while (temp.firstChild) {
      frag.appendChild(temp.firstChild);
    }
    return frag;
  };
  dom.stringFromFrag = function(frag) {
    return goog.dom.createDom("div", null, frag).innerHTML;
  };
  dom.compareTagName = function(el, names, caseSensitive) {
    if (typeof names == "string") {
      names = [names];
    }
    if (el && el.tagName) {
      var tagName = caseSensitive ? el.tagName : el.tagName.toLowerCase();
      return names.some(function(name) {
        return caseSensitive ? tagName === name : tagName === name.toLowerCase();
      });
    }
    return false;
  };
  dom.getNodeLength = function(node) {
    if (!node) {
      return 0;
    }
    switch(node.nodeType) {
      case Node.PROCESSING_INSTRUCTION_NODE:
      ;
      case Node.DOCUMENT_TYPE_NODE:
        return 0;
      case Node.TEXT_NODE:
      ;
      case Node.COMMENT_NODE:
        return node.length;
      default:
        return node.childNodes.length;
    }
  };
  dom.nextNode = function(node) {
    if (node.hasChildNodes()) {
      return node.firstChild;
    }
    return dom.nextNodeDescendants(node);
  };
  dom.previousNode = function(node) {
    if (node.previousSibling) {
      node = node.previousSibling;
      while (node.hasChildNodes()) {
        node = node.lastChild;
      }
      return node;
    }
    if (node.parentNode && node.parentNode.nodeType === Node.ELEMENT_NODE) {
      return node.parentNode;
    }
    return null;
  };
  dom.nextNodeDescendants = function(node) {
    while (node && !node.nextSibling) {
      node = node.parentNode;
    }
    if (!node) {
      return null;
    }
    return node.nextSibling;
  };
  dom.isEditable = function(node) {
    return !!(node && dom.isInsideEditableContainer(node) && (node.nodeType === Node.ELEMENT_NODE || node.parentNode.nodeType === Node.ELEMENT_NODE));
  };
  dom.isComputedBlock = function(node) {
    var display = goog.style.getComputedStyle(node, "display");
    return !!(display === "block");
  };
  dom.hasEditableDescendants = function(node) {
    for (var i = 0;i < node.childNodes.length;i++) {
      if (dom.isEditable(node.childNodes[i]) || dom.hasEditableDescendants(node.childNodes[i])) {
        return true;
      }
    }
    return false;
  };
  dom.isFormattableNode = function(node) {
    return dom.isEditable(node) && dom.isVisible(node) && (node.nodeType === Node.TEXT_NODE || dom.isImageLikeElement(node) || dom.compareTagName(node, "BR"));
  };
  dom.moveChildren = function(srcNode, destNode) {
    while (srcNode.firstChild) {
      destNode.appendChild(srcNode.firstChild);
    }
    return destNode;
  };
  dom.replaceContainer = function(node, replacementElement) {
    node.parentNode.insertBefore(replacementElement, node);
    dom.moveChildren(node, replacementElement);
    goog.dom.removeNode(node);
    return replacementElement;
  };
  dom.setTagName = function(node, tagName) {
    tagName = tagName.toLowerCase();
    if (node.tagName.toLowerCase() === tagName || !node.parentNode) {
      return node;
    }
    var replacementElement = node.ownerDocument.createElement(tagName);
    for (var i = 0;i < node.attributes.length;i++) {
      replacementElement.setAttributeNS(node.attributes[i].namespaceURI, node.attributes[i].name, node.attributes[i].value);
    }
    return dom.replaceContainer(node, replacementElement);
  };
  dom.isVisible = function(node) {
    if (!node) {
      return false;
    }
    if (dom.isBlockNode(node) || dom.isImageLikeElement(node) || node.nodeType === Node.TEXT_NODE && !dom.isCollapsedWhitespaceNode(node) || node.tagName.toUpperCase() === "BR" && !dom.isExtraneousLineBreak(node)) {
      return true;
    }
    for (var i = 0;i < node.childNodes.length;i++) {
      if (dom.isVisible(node.childNodes[i])) {
        return true;
      }
    }
    return false;
  };
  dom.isImageLikeElement = function(node) {
    var tagName = node.tagName ? node.tagName.toLowerCase() : "";
    return !!(node && node.nodeType && node.nodeType !== Node.TEXT_NODE && (["img", "embed", "object", "input", "param", "hr"].indexOf(tagName) !== -1 || goog.dom.classes.has(node, "en-media") || goog.dom.classes.has(node, "en-module")));
  };
  dom.isCollapsedWhitespaceNode = function(node) {
    if (!dom.isWhitespaceNode(node)) {
      return false;
    }
    if (node.data === "") {
      return true;
    }
    var ancestor = node.parentNode;
    if (!ancestor) {
      return true;
    }
    while (!dom.isBlockNode(ancestor) && ancestor.parentNode) {
      ancestor = ancestor.parentNode;
    }
    var reference = node;
    while (reference != ancestor) {
      reference = dom.previousNode(reference);
      if (dom.isBlockNode(reference) || dom.isBR(reference)) {
        return true;
      }
      if (reference.nodeType == Node.TEXT_NODE && !dom.isWhitespaceNode(reference) || dom.isImageLikeElement(reference)) {
        break;
      }
    }
    reference = node;
    var stop = dom.nextNodeDescendants(ancestor);
    while (reference != stop) {
      reference = dom.nextNode(reference);
      if (dom.isBlockNode(reference) || dom.isBR(reference)) {
        return true;
      }
      if (reference && reference.nodeType == Node.TEXT_NODE && !dom.isWhitespaceNode(reference) || dom.isImageLikeElement(reference)) {
        break;
      }
    }
    return false;
  };
  dom.isWhitespaceNode = function(node) {
    dom.rxWhitespace.lastIndex = 0;
    return !!(node && node.nodeType === Node.TEXT_NODE && (node.data === "" || dom.rxWhitespace.test(node.data)));
  };
  dom.rxWhitespace = /^[\t\n\r ]+$/;
  dom.getEffectiveCssValue = function(node, propName) {
    if (node.nodeType !== Node.ELEMENT_NODE && (!node.parentNode || node.parentNode.nodeType !== Node.ELEMENT_NODE)) {
      return null;
    }
    if (node.nodeType !== Node.ELEMENT_NODE) {
      return dom.getEffectiveCssValue(node.parentNode, propName);
    }
    if (!dom.isRenderedDOMNode(node)) {
      console.warn("We are not on rendered DOM for fontSize retieval", node);
      return dom.styleInheritedForNode(node, propName, "", root);
    }
    if (node.style && node.style[propName] !== null && node.style[propName] !== "") {
      return node.style[propName];
    }
    var ret = goog.style.getComputedStyle(node, propName);
    return ret;
  };
  dom.styleInheritedForNode = function(node, styleName, defaultValue, root) {
    root = root || document.body;
    defaultValue = defaultValue || "";
    var styleValue;
    if (node == null) {
      return defaultValue;
    }
    if (!dom.isChild(node, root)) {
      do {
        if (node.nodeType && node.nodeType === Node.ELEMENT_NODE && node.hasAttribute("style")) {
          styleValue = node.style[styleName];
          if (styleValue != null) {
            break;
          }
        }
      } while ((node = node.parentNode) && root === node);
    }
    return styleValue || defaultValue;
  };
  dom.isRenderedDOMNode = function(node) {
    return !!(node && (node.isEqualNode(document.documentElement) || document.documentElement.contains(node)));
  };
  dom.isBefore = function(node1, node2) {
    return node1 != null && node2 != null && !!(node1.compareDocumentPosition(node2) & Node.DOCUMENT_POSITION_FOLLOWING);
  };
  dom.isInsideEditableContainer = function(node) {
    return true;
  };
  dom.isExtraneousLineBreak = function(br) {
    return false;
  };
  dom.firstChild = function(node) {
    if (dom.isHtmlElement(node) && node.firstChild) {
      return dom.firstChild(node.firstChild);
    } else {
      return node;
    }
  };
  dom.lastChild = function(node) {
    if (dom.isHtmlElement(node) && node.lastChild) {
      return dom.lastChild(node.lastChild);
    } else {
      return node;
    }
  };
  dom.isBeginningOfLineChild = function(node, root) {
    var beginNode = dom.firstChild(node);
    if (beginNode.parentNode !== root) {
      while (beginNode.parentNode !== root) {
        beginNode = beginNode.parentNode;
      }
      return dom.firstChild(beginNode) === dom.firstChild(node);
    } else {
      return dom.index(beginNode) === 0;
    }
  };
  dom.isPrecededByInlineContent = function(node) {
    var result = false;
    var div = goog.dom.getAncestorByTagNameAndClass(node, goog.dom.TagName.DIV);
    goog.array.some(div.childNodes, function(child) {
      if (child === node) {
        return true;
      }
      if (!dom.isBlockNode(child)) {
        if (child.nodeType === Node.TEXT_NODE && child.textContent.length === 0) {
          return false;
        } else {
          return true;
        }
      }
    });
    return result;
  };
  dom.isTypeOfElementEvery = function(node, conditionFn, optRoot) {
    if (!optRoot) {
      optRoot = node;
    }
    var walker = new TreeWalker(node, optRoot);
    do {
      if (!conditionFn(node)) {
        return false;
      }
    } while (node = walker.next());
    return true;
  };
  dom.isImageLikeElement = function(node) {
    return !!(dom.compareTagName(node, ["img", "embed", "object", "input", "param", "hr"]) || goog.dom.classes.has(node, "en-media") || goog.dom.classes.has(node, "en-module") || goog.dom.classes.has(node, "en-richlink"));
  };
  dom.index = function(node) {
    var ret = 0;
    while (node = node.previousSibling) {
      ret++;
    }
    return ret;
  };
  dom.matches = function(node, selector) {
    if (node == null || node.nodeType !== Node.ELEMENT_NODE) {
      return false;
    }
    if (goog.isString(selector)) {
      if (node.matches != null) {
        return node.matches(selector);
      } else {
        var matches = document.querySelectorAll(selector);
        var i;
        for (i = 0;i < matches.length;i += 1) {
          if (matches.item(i) === node) {
            return true;
          }
        }
      }
    } else {
      if (goog.isFunction(selector)) {
        return selector(node);
      }
    }
    return false;
  };
  dom.attributes = function(node) {
    var attrs = {};
    if (node) {
      var nodeAttrs = node.attributes;
      if (nodeAttrs) {
        for (var i = nodeAttrs.length;i--;) {
          attrs[nodeAttrs[i].name.toLowerCase()] = nodeAttrs[i].value;
        }
      }
    }
    return attrs;
  };
  dom.moveNode = function(node, newParent, newIndex, activeRange) {
    if (newParent && newIndex === -1) {
      newIndex = newParent.childNodes.length;
    }
    var oldParent = node.parentNode;
    var oldIndex = dom.index(node);
    var preserve = activeRange != null;
    if (preserve) {
      var boundaryPoints = [[activeRange.getStartNode(), activeRange.getStartOffset()], [activeRange.getEndNode(), activeRange.getEndOffset()]];
      boundaryPoints.forEach(function(boundaryPoint) {
        if (boundaryPoint[0] === newParent && boundaryPoint[1] > newIndex) {
          boundaryPoint[1]++;
        }
        if (boundaryPoint[0] === oldParent && (boundaryPoint[1] === oldIndex || boundaryPoint[1] === oldIndex + 1)) {
          if (newParent) {
            boundaryPoint[0] = newParent;
            boundaryPoint[1] += newIndex - oldIndex;
          } else {
            if (boundaryPoint[1] > oldIndex && boundaryPoint[1] > 0) {
              boundaryPoint[1] -= 1;
            }
          }
        }
        if (boundaryPoint[0] === oldParent && boundaryPoint[1] > oldIndex + 1) {
          boundaryPoint[1]--;
        }
        if (!newParent && dom.isChild(boundaryPoint[0], node)) {
          boundaryPoint[0] = node.parentNode;
          boundaryPoint[1] = dom.index(node);
        }
      });
    }
    if (!newParent) {
      goog.dom.removeNode(node);
      return;
    }
    if (newParent.childNodes.length === newIndex || newIndex === -1) {
      newParent.appendChild(node);
    } else {
      newParent.insertBefore(node, newParent.childNodes[+newIndex]);
    }
    goog.dom.Range.clearSelection();
    if (preserve) {
      goog.dom.browserrange.createRangeFromNodes(boundaryPoints[0][0], boundaryPoints[0][1], boundaryPoints[1][0], boundaryPoints[1][1]).select();
    }
  };
  dom.getNextEquivalentPoint = function(node, offset) {
    if (dom.getNodeLength(node) === 0) {
      return null;
    }
    if (offset === dom.getNodeLength(node) && node.parentNode && dom.isInlineNode(node)) {
      return [node.parentNode, 1 + dom.index(node)];
    }
    if (0 <= offset && offset < node.childNodes.length && dom.getNodeLength(node.childNodes[offset]) !== 0 && dom.isInlineNode(node.childNodes[offset])) {
      return [node.childNodes[offset], 0];
    }
    return null;
  };
  dom.getLastEquivalentPoint = function(node, offset) {
    var next;
    while (next = dom.getNextEquivalentPoint(node, offset)) {
      node = next[0];
      offset = next[1];
    }
    return [node, offset];
  };
  dom.isChild = function(node, other) {
    if (!other || !node) {
      return false;
    }
    return !!(node.compareDocumentPosition(other) & Node.DOCUMENT_POSITION_CONTAINS);
  };
  dom.isParent = function(node, other) {
    if (!other || !node) {
      return false;
    }
    return !!(node.compareDocumentPosition(other) & 16);
  };
  dom.isHtmlElement = function(node, opt_tagName) {
    if (goog.dom.isElement(node)) {
      if (opt_tagName) {
        return opt_tagName.toLowerCase() === node.tagName.toLowerCase();
      } else {
        return true;
      }
    }
    return false;
  };
  dom.isBR = function(node) {
    if (node && node.tagName) {
      return node.tagName.toUpperCase() === "BR";
    }
    return false;
  };
  dom.getStyleString = function(node) {
    if (!node || !node.getAttribute) {
      return "";
    }
    return node.getAttribute("style");
  };
  dom.removeStyleValue = function(node, name) {
    var styleString = dom.getStyleString(node);
    if (styleString == null) {
      return "";
    }
    styleString = styleString.replace(regexForAppDataName(name), "$1").trim();
    if (styleString.length > 0) {
      node.setAttribute("style", styleString);
    } else {
      node.removeAttribute("style");
    }
    return styleString || "";
  };
  dom.getContainedNodes = function(range, condition) {
    if (typeof condition == "undefined") {
      condition = function() {
        return true;
      };
    }
    var node = range.getStartNode();
    if (node.hasChildNodes() && range.getStartOffset() < node.childNodes.length) {
      node = node.childNodes[range.getStartOffset()];
    } else {
      if (range.getStartOffset() == dom.getNodeLength(node)) {
        node = dom.nextNodeDescendants(node);
      } else {
        node = dom.nextNode(node);
      }
    }
    var stop = range.getEndNode();
    if (stop.hasChildNodes() && range.getEndOffset() < stop.childNodes.length) {
      stop = stop.childNodes[range.getEndOffset()];
    } else {
      stop = dom.nextNodeDescendants(stop);
    }
    var nodeList = [];
    while (dom.isBefore(node, stop)) {
      if (range.containsNode(node) && condition(node)) {
        nodeList.push(node);
        node = dom.nextNodeDescendants(node);
        continue;
      }
      node = dom.nextNode(node);
    }
    return nodeList;
  };
  var TreeWalker = function(startNode, rootNode) {
    var node = startNode;
    function findSibling(node, startName, siblingName, shallow) {
      var sibling, parent;
      if (node) {
        if (!shallow && node[startName]) {
          return node[startName];
        }
        if (node != rootNode) {
          sibling = node[siblingName];
          if (sibling) {
            return sibling;
          }
          for (parent = node.parentNode;parent && parent != rootNode;parent = parent.parentNode) {
            sibling = parent[siblingName];
            if (sibling) {
              return sibling;
            }
          }
        }
      }
    }
    this.current = function() {
      return node;
    };
    this.next = function(shallow) {
      node = findSibling(node, "firstChild", "nextSibling", shallow);
      return node;
    };
    this.prev = function(shallow) {
      node = findSibling(node, "lastChild", "previousSibling", shallow);
      return node;
    };
  };
  dom.isBlockFormattingContext = function(node) {
    if (node.nodeType === Node.ELEMENT_NODE) {
      var style = window.getComputedStyle(node);
      if (style["float"] !== "none") {
        return true;
      }
      if (style.position !== "static" && style.position !== "relative") {
        return true;
      }
      if (["flex", "inline-block", "inline-flex", "table-caption", "table-cell"].indexOf(style.display) != -1) {
        return true;
      }
      if (style.overlfow !== "visible") {
        return true;
      }
    }
    return false;
  };
  var voidElementNames = ["area", "base", "br", "col", "command", "embed", "hr", "img", "input", "keygen", "link", "meta", "param", "source", "track", "wbr"];
  dom.allowsChildren = function(node) {
    if (node.nodeType == Node.ELEMENT_NODE) {
      if (voidElementNames.indexOf(node.tagName.toLowerCase()) != -1) {
        return true;
      }
    }
    return false;
  };
  dom.isBlockLike = function(node) {
    if (node.nodeType == Node.ELEMENT_NODE) {
      if (node.tagName === "BR") {
        return true;
      }
      if (dom.isBlockFormattingContext(node)) {
        return true;
      }
    }
    return false;
  };
  dom.parent = function(node, selector, rootNode) {
    if (!rootNode) {
      rootNode = document.body;
    }
    if (node === rootNode) {
      return null;
    }
    if (dom.matches(node, selector)) {
      return node;
    }
    var parentNode = node && node.parentNode;
    if (parentNode) {
      return dom.parent(parentNode, selector, rootNode);
    }
    return null;
  };
  dom.hasTextNextToIt = function(node) {
    var neighboringTextRegex = /[^\s]+/i;
    var leftNode = node.previousSibling;
    while (leftNode) {
      if (leftNode.nodeName && uno.defs.blockElements[leftNode.nodeName.toLowerCase()]) {
        break;
      }
      if (neighboringTextRegex.test(leftNode.textContent)) {
        return true;
      }
      leftNode = leftNode.previousSibling;
    }
    var rightNode = node.nextSibling;
    while (rightNode) {
      if (rightNode.nodeName && uno.defs.blockElements[rightNode.nodeName.toLowerCase()]) {
        break;
      }
      if (neighboringTextRegex.test(rightNode.textContent)) {
        return true;
      }
      rightNode = rightNode.nextSibling;
    }
    var parent = node.parentNode;
    if (parent && (!parent.nodeName || !uno.defs.blockElements[parent.nodeName.toLowerCase()])) {
      return dom.hasTextNextToIt(parent);
    }
    return false;
  };
  dom.isParent = function(node, other) {
    if (!other || !node) {
      return false;
    }
    return !!(node.compareDocumentPosition(other) & 16);
  };
  dom.getViewportRect = function() {
    var rect = {top:document.body.scrollTop, left:document.body.scrollLeft, width:window.innerWidth, height:window.innerHeight, bottom:0, right:0};
    rect.bottom = rect.top + rect.height;
    rect.right = rect.left + rect.width;
    return rect;
  };
  dom.rangeStartNode = function(range) {
    if (!range) {
      return null;
    }
    if (range.getBrowserRangeObject) {
      range = range.getBrowserRangeObject();
    }
    if (dom.isTextNode(range.startContainer)) {
      return range.startContainer;
    }
    return range.startContainer.childNodes[range.startOffset] || range.startContainer;
  };
  dom.rangeEndNode = function(range) {
    if (!range) {
      return null;
    }
    if (range.getBrowserRangeObject) {
      range = range.getBrowserRangeObject();
    }
    if (dom.isTextNode(range.endContainer)) {
      return range.endContainer;
    }
    return range.endContainer.childNodes[range.endOffset] || range.endContainer.lastChild || range.endContainer;
  };
  dom.makeClientRect = function(rect, opt, platform) {
    var offsetLeft;
    var offsetTop;
    if (rect == null) {
      return null;
    }
    goog.object.extend(opt, {absolute:false, zoomScale:1, ignoreOffset:false}, opt);
    if (platform === "ios") {
      if (document.body.getClientRects()[0].top < 0 === false) {
        offsetLeft = 0;
        offsetTop = 0;
      }
    }
    if (!opt.absolute && offsetLeft == null) {
      offsetLeft = document.body.scrollLeft;
      offsetTop = document.body.scrollTop;
    } else {
      offsetLeft = 0;
      offsetTop = 0;
    }
    if (platform === "android" && opt.ignoreOffset !== true) {
      var offsetElement = document.getElementById("offset");
      if (offsetElement != null) {
        offsetTop -= parseInt(offsetElement.style.height, 10);
      }
    }
    var clientRect;
    if (platform === "web") {
      clientRect = {left:Math.round(rect.left * opt.zoomScale) + offsetLeft, right:Math.round(rect.right * opt.zoomScale) + offsetLeft, top:Math.round(rect.top * opt.zoomScale) + offsetTop, bottom:Math.round(rect.bottom * opt.zoomScale) + offsetTop, width:Math.round(rect.width * opt.zoomScale), height:Math.round(rect.height * opt.zoomScale)};
    } else {
      clientRect = {left:rect.left * opt.zoomScale + offsetLeft, right:rect.right * opt.zoomScale + offsetLeft, top:rect.top * opt.zoomScale + offsetTop, bottom:rect.bottom * opt.zoomScale + offsetTop, width:rect.width * opt.zoomScale, height:rect.height * opt.zoomScale};
    }
    return clientRect;
  };
})();
goog.provide("uno.util.crypto");
goog.require("goog.dom.classlist");
goog.require("uno.defs");
goog.require("uno.util.dom");
(function() {
  var util = uno.util;
  var CRYPT_CLASS = uno.defs.crypto.CRYPT_CLASS;
  var CRYPT_HIDDEN_CLASS = uno.defs.crypto.CRYPT_HIDDEN_CLASS;
  var CRYPT_VISIBLE_CLASS = uno.defs.crypto.CRYPT_VISIBLE_CLASS;
  util.crypto.all = function(root) {
    return root.querySelectorAll("." + CRYPT_CLASS);
  };
  util.crypto.isCrypt = function(node) {
    return node && goog.dom.classlist.contains(node, CRYPT_CLASS);
  };
  util.crypto.createCryptoPlaceholder = function(cryptInfo) {
    return goog.dom.createDom("img", {id:cryptInfo.id, "class":CRYPT_CLASS + " " + CRYPT_HIDDEN_CLASS, src:uno.defs.image.TRANSPARENT_IMAGE_DATA_URL, "data-length":"128", "data-cipher":"AES", "data-hint":cryptInfo.hint || "", "data-plaintext":cryptInfo.plainText || "", "data-ciphertext":cryptInfo.cipherText || "", "data-rev":cryptInfo.rev});
  };
  util.crypto.getCryptInfoFromNode = function(node) {
    if (!node) {
      return null;
    }
    return {id:node.getAttribute("id"), rev:node.getAttribute("data-rev"), length:node.getAttribute("data-length"), cipher:node.getAttribute("data-cipher"), hint:node.getAttribute("data-hint") || "", plainText:node.getAttribute("data-plaintext") || null, cipherText:node.getAttribute("data-ciphertext") || null, boundingbox:goog.style.getBounds(node)};
  };
  util.crypto.getCryptInfoFromEmbed = function(embedId) {
    var parts = embedId.split(":");
    return {cipherText:parts[1], cipher:parts[2], length:parts[3], hint:parts[4]};
  };
  util.crypto.updateRevision = function(cryptNode) {
    if (cryptNode.getAttribute("data-plaintext") !== cryptNode.innerHTML) {
      var rev = cryptNode.getAttribute("data-rev");
      var revParts = rev.split("-");
      var revNumber = parseInt(revParts[2], 10);
      if (!isNaN(revNumber)) {
        var newRev = revParts[0] + "-" + revParts[1] + "-" + ++revNumber;
        cryptNode.setAttribute("data-rev", newRev);
        cryptNode.setAttribute("data-plaintext", cryptNode.innerHTML);
      }
    }
    return false;
  };
  util.crypto.handleClick = function(node, readOnly, dispatchEvent) {
    if (node) {
      var cryptInfo = uno.util.crypto.getCryptInfoFromNode(node);
      var hasClass = goog.dom.classlist.contains;
      util.range.selectNode(node);
      if (hasClass(node, CRYPT_HIDDEN_CLASS)) {
        dispatchEvent({type:"decrypt", cryptInfo:cryptInfo});
      } else {
        if (readOnly && hasClass(node, CRYPT_VISIBLE_CLASS)) {
          dispatchEvent({type:"encrypt", cryptInfo:cryptInfo});
        }
      }
      return true;
    }
    return false;
  };
})();
goog.provide("uno.util.canvas");
goog.require("goog.debug.Logger");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.canvas");
  var util = uno.util;
  util.canvas.create = function(opt) {
    var pixelRatio = window.devicePixelRatio;
    var canvas = goog.dom.createDom("canvas", {width:opt.width * pixelRatio, height:opt.height * pixelRatio});
    var ctx = canvas.getContext("2d");
    canvas.style.width = opt.width + "px";
    canvas.style.height = opt.height + "px";
    ctx.scale(pixelRatio, pixelRatio);
    return canvas;
  };
  util.canvas.rad = function(deg) {
    return deg * Math.PI / 180;
  };
})();
goog.provide("uno.util.resource.generic");
goog.require("uno.util.canvas");
(function() {
  var generic = uno.util.resource.generic;
  var util = uno.util;
  generic.findResourcesInPlatformHtml = function(root) {
    return [];
  };
  generic.findResourcesInClipboardHtml = function(root) {
    return [];
  };
  generic.convertMediaToSlug = function(enmedia, props, editor) {
    return enmedia;
  };
  generic.convertSlugToMedia = function(slug) {
    var enmedia = document.createElement("en-media");
    if (slug.dataset.hash != null) {
      enmedia.setAttribute("hash", slug.dataset.hash);
    }
    if (slug.dataset.type != null) {
      enmedia.setAttribute("type", slug.dataset.type);
    }
    goog.dom.replaceNode(enmedia, slug);
    return enmedia;
  };
  generic.formatForExport = function(html) {
    return html;
  };
  generic.dictFromElement = function(el) {
    return {};
  };
  generic.dictFromClipboardElement = function(el, context) {
    return {};
  };
  generic.convertFileSlugToMedia = function(slug) {
    goog.dom.removeChildren(slug);
    return slug;
  };
  generic.convertSlugToPlatformElement = function(slug) {
    return slug;
  };
  generic.convertSlugToClipboardElement = function(slug) {
    return slug;
  };
})();
goog.provide("uno.util.resource.android");
goog.require("uno.util.resource.generic");
(function() {
  var util = uno.util;
  var android = util.resource.android;
  var generic = util.resource.generic;
  android.findResourcesInPlatformHtml = function(root) {
    return [];
  };
  android.findResourcesInClipboardHtml = function(root) {
    return [];
  };
  android.convertMediaToSlug = function(enmedia, props, config) {
    if (util.resource.isImage(props.type)) {
      return util.img.convertMediaToSlug(enmedia, props, config);
    } else {
      enmedia.dataset.url = props.url;
      goog.dom.classes.add(enmedia, "en-media-file");
      goog.dom.append(enmedia, [goog.dom.createDom("span", {"class":"en-resource-icon"}, goog.dom.createDom("img", {src:props.thumbnailURL})), goog.dom.createDom("span", {"class":"en-resource-title"}, props.title), goog.dom.createDom("span", {"class":"en-resource-name"}, props.filename), goog.dom.createDom("span", {"class":"en-resource-value"}, props.filesize), goog.dom.createDom("span", {"class":"en-resource-context"}, goog.dom.createDom("img", {"class":"en-resource-context-default", src:props.defaultActionURL}), 
      goog.dom.createDom("img", {"class":"en-resource-context-overflow", src:props.contextURL}))]);
    }
    return enmedia;
  };
  android.convertSlugToMedia = function(slug) {
    if (util.resource.isImage(slug)) {
      return util.img.convertSlugToMedia(slug);
    } else {
      return generic.convertFileSlugToMedia(slug);
    }
  };
  android.dictFromElement = function(el) {
    return {};
  };
  android.dictFromClipboardElement = function(el, context) {
    return {};
  };
  android.formatForExport = function(html) {
    return html;
  };
  android.convertSlugToPlatformElement = function(slug) {
    return slug;
  };
  android.convertSlugToClipboardElement = function(slug) {
    return slug;
  };
})();
goog.provide("uno.util.resource.ios");
goog.require("uno.util.dom");
goog.require("uno.util.resource.generic");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.resource.ios");
  var util = uno.util;
  var ios = util.resource.ios;
  var generic = util.resource.generic;
  ios.findResourcesInPlatformHtml = function(root) {
    return [];
  };
  ios.findResourcesInClipboardHtml = function(root) {
    return root.querySelectorAll("img");
  };
  ios.convertMediaToSlug = function(enmedia, props, editor) {
    var slug;
    if (util.resource.isImage(props.type)) {
      slug = util.img.convertMediaToSlug(enmedia, props, editor);
    } else {
      slug = ios.convertMediaToImage(enmedia, props, editor);
    }
    return slug;
  };
  ios.convertMediaToImage = function(enmedia, props, editor) {
    var img = util.resource.findByRef(props.reference, editor.field);
    if (img == null) {
      img = new Image;
      img.width = 160;
      img.height = 120;
      img.style.width = "160px";
      img.style.height = "120px";
      img.dataset.hash = enmedia.getAttribute("hash");
      img.dataset.type = enmedia.getAttribute("type");
      Object.keys(enmedia.dataset).forEach(function(key) {
        img.dataset[key] = enmedia.dataset[key];
      });
      goog.dom.classlist.addAll(img, ["en-media", "en-media-file"]);
    }
    var canvas = util.canvas.create({width:img.width, height:img.height});
    var padding = 10;
    var ctx = canvas.getContext("2d");
    ctx.save();
    ctx.fillStyle = "#8E8E93";
    ctx.font = '12px "Helvetica Neue", Helvetica, Arial, sans';
    ctx.textAlign = "center";
    if (props.state === "unloaded") {
      if (props.title != null) {
        ctx.save();
        ctx.fillStyle = "#167EFB";
        ctx.font = '700 14px "Helvetica Neue", Helvetica, Arial, sans';
        ctx.textAlign = "center";
        ctx.fillText(props.title, img.width / 2, img.height * .25);
        ctx.restore();
      }
      if (props.filesize != null) {
        ctx.fillText(props.filesize, img.width / 2, img.height * .75 + 15);
      }
    } else {
      if (props.state === "loading") {
        if (props.downloaded != null) {
          ctx.fillText(props.downloaded, img.width / 2, img.height * .75 + 15);
        }
        ctx.save();
        var progress = Math.max(Math.min(1, props.progress), 0);
        var cx = img.width / 2;
        var cy = img.height * .25;
        var radius = 25;
        ctx.fillStyle = "#fff";
        ctx.fillRect(0, 0, img.width, img.height / 2);
        ctx.lineWidth = 3;
        ctx.strokeStyle = "#dedede";
        ctx.beginPath();
        ctx.arc(cx, cy, radius, 0, 2 * Math.PI, false);
        ctx.stroke();
        ctx.fillStyle = "#dedede";
        ctx.beginPath();
        ctx.arc(cx, cy, radius, util.canvas.rad(360 * progress - 90), util.canvas.rad(270), false);
        ctx.lineTo(cx, cy);
        ctx.closePath();
        ctx.fill();
        ctx.restore();
      } else {
        if (props.state === "loaded" || props.state == null) {
          if (props.thumbnailURL != null) {
            var thumbnail = new Image;
            thumbnail.src = props.thumbnailURL;
            thumbnail.addEventListener("load", function() {
              var dHeight = Math.min(thumbnail.height, 48);
              var dWidth = dHeight / thumbnail.height * thumbnail.width;
              var ctx = canvas.getContext("2d");
              var image = util.resource.findByRef(props.reference, editor.field);
              ctx.save();
              ctx.fillStyle = "#fff";
              ctx.fillRect(0, 0, img.width, img.height / 2);
              ctx.drawImage(thumbnail, (image.width - dWidth) / 2, padding, dWidth, dHeight);
              ctx.restore();
              var dataUrl = canvas.toDataURL();
              console.log(image);
              log.info("dataUrl: " + dataUrl);
              image.src = dataUrl;
            });
          }
        }
      }
    }
    if (props.filename != null) {
      var filename = props.filename;
      var len = filename.length - 4;
      var metrics = ctx.measureText(filename);
      while (metrics.width > img.width - padding * 2 && len > 0) {
        filename = props.filename.substring(0, len) + "...";
        len--;
        metrics = ctx.measureText(filename);
      }
      ctx.fillText(filename, img.width / 2, img.height * .75);
    }
    if (props.state === "loading") {
    } else {
      ctx.restore();
    }
    img.src = canvas.toDataURL();
    goog.dom.replaceNode(img, enmedia);
    return img;
  };
  ios.decorateMedia = function(enmedia, props) {
    enmedia.dataset.url = props.url;
    goog.dom.classes.add(enmedia, "en-media-file");
    goog.dom.append(enmedia, goog.dom.createDom("en-ux", {}, [goog.dom.createDom("span", {"class":"en-resource-progress"}, goog.dom.createDom("span", {"class":"en-resource-progress-fill"}, goog.dom.createDom("span", {"class":"en-resource-progress-mask"}))), goog.dom.createDom("span", {"class":"en-resource-icon"}, goog.dom.createDom("img", {src:props.thumbnailURL})), goog.dom.createDom("span", {"class":"en-resource-title"}, props.title), goog.dom.createDom("span", {"class":"en-resource-name"}, props.filename), 
    goog.dom.createDom("span", {"class":"en-resource-value"}, props.state == "loading" ? props.downloaded : props.filesize)]));
    if (props.state) {
      goog.dom.classes.add(enmedia, props.state);
    }
    if (props.state === "loading") {
      var value = Math.max(Math.min(1, props.progress), 0);
      var halfValue = value > .5 ? value - .5 : value;
      var progressFill = enmedia.querySelector(".en-resource-progress-fill");
      goog.style.setStyle(progressFill, "-webkit-transform", "rotate(" + 360 * value + "deg)");
      var progressMask = progressFill.children[0];
      goog.style.setStyle(progressMask, "-webkit-transform", "rotate(" + -180 * halfValue * 2 + "deg)");
      goog.style.setStyle(progressMask, "background", value * 2 <= 1 ? "#fff" : "#dedede");
    }
    if (props.overlayOpacity > 0) {
      goog.dom.classes.add(enmedia, "overlayed");
      var overlay = goog.dom.createDom("span", {"class":"en-resource-overlay"});
      overlay.style.backgroundColor = "rgba(0, 0, 0, " + props.overlayOpacity + ")";
      enmedia.appendChild(overlay);
    }
    return enmedia;
  };
  ios.convertSlugToMedia = function(slug) {
    if (util.resource.isImage(slug)) {
      return util.img.convertSlugToMedia(slug);
    } else {
      return generic.convertSlugToMedia(slug);
    }
  };
  ios.dictFromElement = function(el) {
    return {};
  };
  ios.dictFromClipboardElement = function(el, context) {
    var dict;
    if (util.dom.compareTagName(el, "img")) {
      if (el) {
        dict = context.resources[el.getAttribute("src")];
      }
    } else {
      log.severe("ios resource from clipboard is not an img");
      if (el) {
        log.info("ios.dictFromClipboardElement received " + el.tagName);
      }
    }
    return dict;
  };
  ios.formatForExport = function(html) {
    return html;
  };
  ios.convertSlugToPlatformElement = function(slug) {
    return slug;
  };
  ios.convertSlugToClipboardElement = function(slug) {
    return slug;
  };
})();
goog.provide("uno.util.resource.mac");
(function() {
  var util = uno.util;
  var mac = uno.util.resource.mac;
  var rxEmbedImplicitVoidTags = /<embed([^>]*[^/]\s*)>/g;
  mac.findResourcesInPlatformHtml = function(root) {
    return goog.array.filter(root.querySelectorAll('img:not(.en-todo), embed:not([type="evernote/x-crypto"])'), function(el) {
      return el;
    });
  };
  mac.findResourcesInClipboardHtml = function(root) {
    return mac.findResourcesInPlatformHtml(root);
  };
  mac.convertMediaToSlug = function(enmedia, props, config) {
    if (util.resource.isImage(props.type)) {
      return util.img.convertMediaToSlug(enmedia, props, config);
    } else {
      if (util.resource.isPdf(enmedia)) {
        if (enmedia.querySelector(".en-media-platform-element") == null) {
          enmedia.appendChild(mac.createElementForPdf.call(this, props));
        }
        goog.dom.classes.add(enmedia, "en-media-pdf");
      } else {
        if (enmedia.querySelector(".en-media-platform-element") == null) {
          enmedia.appendChild(mac.createElementForFile.call(this, props));
        }
        goog.dom.classes.add(enmedia, "en-media-file");
      }
    }
    return enmedia;
  };
  mac.convertSlugToMedia = function(slug) {
    if (util.resource.isImage(slug)) {
      return util.img.convertSlugToMedia(slug);
    } else {
      goog.dom.removeChildren(slug);
      return slug;
    }
  };
  mac.dictFromElement = function(el) {
    var data = (el.getAttribute("id") || ":::").split(":");
    var dict = {url:el.src, mime:data[1] || util.dom.compareTagName(el, "img") && "image/unknown", hash:data[2]};
    return dict;
  };
  mac.dictFromClipboardElement = function(el, context) {
    return mac.dictFromElement(el);
  };
  mac.formatForExport = function(html) {
    if (html == null) {
      return html;
    }
    return html.replace(rxEmbedImplicitVoidTags, "<embed $1 />");
  };
  mac.createElementForPdf = function(props) {
    var attr = {src:props.url, type:"evernote/x-pdf"};
    ["style", "width", "height"].forEach(function(name) {
      if (props[name]) {
        attr[name] = props[name];
      }
    });
    return goog.dom.createDom("embed", attr);
  };
  mac.createElementForFile = function(props) {
    var attr = {src:props.url, type:"evernote/x-attachment"};
    ["style", "width", "height"].forEach(function(name) {
      if (props[name]) {
        attr[name] = props[name];
      }
    });
    return goog.dom.createDom("embed", attr);
  };
  mac.convertSlugToPlatformElement = function(slug) {
    return slug;
  };
  mac.convertSlugToClipboardElement = function(slug) {
    return slug;
  };
})();
goog.provide("uno.util.img");
goog.require("goog.asserts");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.dom.classlist");
goog.require("goog.events");
goog.require("uno.defs");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.img");
  var defs = uno.defs;
  var util = uno.util;
  util.img.all = function(root) {
    return root.querySelectorAll("img.en-media-image");
  };
  util.img.convertMediaToSlug = function(enmedia, props, editor) {
    var img = new Image;
    goog.dom.classlist.addAll(img, ["en-media", "en-media-image"]);
    img.dataset.hash = enmedia.getAttribute("hash");
    img.dataset.type = enmedia.getAttribute("type");
    img.dataset.url = props.url;
    Object.keys(enmedia.dataset).forEach(function(key) {
      img.dataset[key] = enmedia.dataset[key];
    });
    goog.dom.replaceNode(img, enmedia);
    if (props.overlayImageURL != null) {
      img.style.backgroundImage = "url(" + props.url + ")";
      img.style.backgroundSize = "cover";
      img.src = props.overlayImageURL;
    } else {
      img.src = props.url;
    }
    return img;
  };
  util.img.decorateWithElements = function(enmedia, props, config) {
    var img;
    var toolbar;
    goog.dom.classes.add(enmedia, "en-media-image");
    img = enmedia.querySelector("img.en-media-platform-element");
    if (img == null) {
      img = goog.dom.createDom("img", {src:props.url, "class":"en-media-platform-element"});
      ["align", "alt", "longDesc", "style", "width", "height"].forEach(function(name) {
        if (props[name]) {
          img.setAttribute(name, props[name]);
        }
      });
      enmedia.appendChild(img);
    }
    img.removeAttribute("height");
    toolbar = goog.dom.createDom("div", {"class":"en-imagebar"});
    if (config.images.annotate) {
      toolbar.appendChild(goog.dom.createDom("div", {"class":"en-imagebar-button en-imagebar-annotate", "data-command":"annotate"}));
      enmedia.appendChild(toolbar);
    }
    if (config.images.preview) {
      toolbar.appendChild(goog.dom.createDom("div", {"class":"en-imagebar-button en-imagebar-preview", "data-command":"preview"}));
      enmedia.appendChild(toolbar);
    }
    if (config.images.rotate) {
      toolbar.appendChild(goog.dom.createDom("div", {"class":"en-imagebar-button en-imagebar-rotate", "data-command":"rotate"}));
      enmedia.appendChild(toolbar);
    }
    if (config.images.resize) {
      enmedia.appendChild(goog.dom.createDom("div", {"class":"img-resizer-handle"}));
    }
  };
  util.img.convertSlugToMedia = function(slug) {
    var enmedia = document.createElement("en-media");
    if (slug.dataset.hash != null) {
      enmedia.setAttribute("hash", slug.dataset.hash);
    }
    if (slug.dataset.type != null) {
      enmedia.setAttribute("type", slug.dataset.type);
    }
    goog.dom.replaceNode(enmedia, slug);
    return enmedia;
  };
  util.img.isResource = function(node) {
    return node && goog.dom.classes.has(node, "en-media-image");
  };
  util.img.isSelected = function(el) {
    var selected = false;
    if (el != null) {
      selected = goog.dom.classes.has(el, "en-media-selected");
    }
    return selected;
  };
  util.img.isToolbarButton = function(el) {
    return goog.dom.classes.has(el, "en-imagebar-button");
  };
  util.img.setHover = function(enmedia, hover) {
    if (hover) {
      goog.dom.classes.add(enmedia, "en-media-hover");
    } else {
      goog.dom.classes.remove(enmedia, "en-media-hover");
    }
  };
  util.img.removeOverlay = function(img) {
    if (util.img.isResource(img) && img.style.backgroundImage != null) {
      img.src = img.dataset.url;
      img.style.backgroundImage = null;
      img.style.backgroundSize = null;
    }
  };
})();
goog.provide("uno.util.resource.win");
goog.require("goog.array");
goog.require("uno.util.dom");
goog.require("uno.util.img");
(function() {
  var util = uno.util;
  var win = util.resource.win;
  win.findResourcesInPlatformHtml = function(root) {
    return goog.array.filter(root.querySelectorAll('img:not([src^="en-resource://database/pprotect:"]), object'), function(el) {
      return util.dom.compareTagName(el, "object") || !/\/check/i.test(el.src);
    });
  };
  win.findResourcesInClipboardHtml = function(root) {
    return win.findResourcesInPlatformHtml(root);
  };
  win.convertMediaToSlug = function(enmedia, props, config) {
    if (util.resource.isImage(props.type)) {
      return util.img.convertMediaToSlug(enmedia, props, config);
    } else {
      if (util.resource.isPdf(enmedia)) {
        goog.dom.classes.add(enmedia, "en-media-pdf");
      } else {
        goog.dom.classes.add(enmedia, "en-media-file");
      }
    }
    return enmedia;
  };
  win.convertSlugToMedia = function(slug) {
    if (util.resource.isImage(slug)) {
      return util.img.undecorate(slug);
    } else {
      goog.dom.removeChildren(slug);
      return slug;
    }
  };
  win.dictFromElement = function(el) {
    var dict = {url:el.src, mime:el.getAttribute("type") || util.dom.compareTagName(el, "img") && "image/unknown"};
    return dict;
  };
  win.dictFromClipboardElement = function(el, context) {
    return win.dictFromElement(el);
  };
  win.formatForExport = function(html) {
    return html;
  };
  win.convertSlugToPlatformElement = function(slug) {
    return slug;
  };
  win.convertSlugToClipboardElement = function(slug) {
    return slug;
  };
})();
goog.provide("uno.util.resource");
goog.require("goog.asserts");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.events");
goog.require("uno.util.dom");
goog.require("uno.util.resource.android");
goog.require("uno.util.resource.generic");
goog.require("uno.util.resource.ios");
goog.require("uno.util.resource.mac");
goog.require("uno.util.resource.win");
goog.require("uno.defs");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.resource");
  var defs = uno.defs;
  var util = uno.util;
  util.resource.counter = 0;
  var platform = uno.util.resource.generic;
  util.resource.setPlatform = function(platformName) {
    platform = uno.util.resource[platformName] || platform;
  };
  util.resource.all = function(root) {
    return root.querySelectorAll(".en-media");
  };
  util.resource.findResourcesInPlatformHtml = function(root) {
    return platform.findResourcesInPlatformHtml(root);
  };
  util.resource.findResourcesInClipboardHtml = function(root) {
    return platform.findResourcesInClipboardHtml(root);
  };
  util.resource.findByRef = function(ref, node) {
    var selector = '.en-media[data-reference="' + ref + '"]';
    var el = node.querySelector(selector);
    return el;
  };
  util.resource.findByHash = function(hash, node) {
    var selector = '.en-media[data-hash="' + hash + '"]';
    var results = node.querySelectorAll(selector);
    return results;
  };
  util.resource.createUid = function() {
    return "resource-" + util.resource.counter++;
  };
  util.resource.isResource = function(node) {
    return node && util.dom.matches(node, ".en-media");
  };
  util.resource.isImage = function(elOrMime) {
    var mime = util.resource.parseMime(elOrMime);
    return mime && mime.toLowerCase().indexOf("image/") === 0;
  };
  util.resource.isPdf = function(elOrMime) {
    var mimes = ["application/pdf", "evernote/x-pdf", "application/x-evernote-pdf"];
    var mime = util.resource.parseMime(elOrMime);
    return mime && mimes.indexOf(mime.toLowerCase()) != -1;
  };
  util.resource.isFileUI = function(el) {
    return goog.dom.classes.has(el, "en-media-file");
  };
  util.resource.createMediaFromDict = function(dict) {
    var enmedia = goog.dom.createElement("en-media");
    enmedia.setAttribute("type", dict.mime);
    enmedia.setAttribute("hash", dict.hash);
    return enmedia;
  };
  util.resource.convertPlatformElementToSlug = function(el, editor) {
    var dict = platform.dictFromElement(el);
    var enmedia = util.resource.createMediaFromDict(dict);
    goog.dom.replaceNode(enmedia, el);
    return util.resource.convertMediaToSlug(enmedia, dict, editor);
  };
  util.resource.convertClipboardElementToSlug = function(el, context, editor) {
    var enmedia;
    var dict = platform.dictFromClipboardElement(el, context);
    if (!dict) {
      log.warning("Could not find resource dictionary for image");
      goog.dom.removeNode(el);
    } else {
      enmedia = util.resource.createMediaFromDict(dict);
      goog.dom.replaceNode(enmedia, el);
      return util.resource.convertMediaToSlug(enmedia, dict, editor);
    }
  };
  util.resource.convertMediaToSlug = function(enmedia, dict, editor) {
    var props = {};
    var enmlProps = util.resource.propsFromEnml(enmedia);
    Object.keys(enmlProps).forEach(function(key) {
      if (enmlProps[key] == null) {
        delete enmlProps[key];
      }
    });
    goog.object.extend(props, util.resource.propsFromDict(dict), enmlProps);
    enmedia.dataset.reference = props.reference || util.resource.createUid();
    props.reference = enmedia.dataset.reference;
    if (props.filename != null) {
      enmedia.dataset.filename = props.filename;
    }
    if (props.filesize != null) {
      enmedia.dataset.filesize = props.filesize;
    }
    if (props.thumbnailURL != null) {
      enmedia.dataset.thumbnailUrl = props.thumbnailURL;
    }
    if (props.title != null) {
      enmedia.dataset.title = props.title;
    }
    if (props.url != null) {
      enmedia.dataset.url = props.url;
    }
    enmedia.setAttribute("contenteditable", "false");
    goog.dom.removeChildren(enmedia);
    var slug = platform.convertMediaToSlug(enmedia, props, editor);
    if (props.style != null) {
      slug.setAttribute("style", props.style);
    }
    if (props.hidden === true) {
      goog.style.setStyle(slug, "display", "none");
    }
    if (!slug.nextSibling) {
      goog.dom.insertSiblingAfter(document.createElement("br"), slug);
    }
    return slug;
  };
  util.resource.convertSlugToMedia = function(slug) {
    var enmedia = platform.convertSlugToMedia(slug);
    enmedia.removeAttribute("contenteditable");
    enmedia.removeAttribute("class");
    if (slug.getAttribute("style") != null) {
      enmedia.setAttribute("style", slug.getAttribute("style"));
    }
    Object.keys(enmedia.dataset).forEach(function(key) {
      delete enmedia.dataset[key];
    });
    return enmedia;
  };
  util.resource.createMediaFromSlug = function(slug) {
    var enmedia = goog.dom.createDom("en-media");
    enmedia.setAttribute("hash", slug.getAttribute("hash"));
    enmedia.setAttribute("type", slug.getAttribute("type"));
    ["width", "height", "align", "alt", "longdesc", "title", "lang", "dir", "border", "hspace", "vspace", "usemap"].forEach(function(name) {
      if (slug.dataset[name] != null) {
        enmedia.setAttribute(name, slug.dataset[name]);
      }
    });
    goog.dom.replaceNode(enmedia, slug);
    return enmedia;
  };
  util.resource.dictFromElement = function(el) {
    if (!el) {
      return {};
    }
    return {filename:el.dataset.filename, filesize:el.dataset.filesize, hash:el.getAttribute("hash") || el.dataset.hash, reference:el.dataset.reference, thumbnailURL:el.dataset.thumbnailUrl, title:el.dataset.title, mime:el.getAttribute("type") || el.dataset.type, url:el.dataset.url};
  };
  util.resource.propsFromEnml = function(enmedia) {
    if (!enmedia) {
      return {};
    }
    return {hash:enmedia.getAttribute("hash"), type:enmedia.getAttribute("type"), width:enmedia.getAttribute("width"), height:enmedia.getAttribute("height"), style:enmedia.getAttribute("style"), align:enmedia.getAttribute("align"), alt:enmedia.getAttribute("alt"), longdesc:enmedia.getAttribute("longdesc"), title:enmedia.getAttribute("title"), lang:enmedia.getAttribute("lang"), dir:enmedia.getAttribute("dir"), border:enmedia.getAttribute("border"), hspace:enmedia.getAttribute("hspace"), vspace:enmedia.getAttribute("vspace"), 
    usemap:enmedia.getAttribute("usemap")};
  };
  util.resource.propsFromDict = function(dict) {
    if (!dict) {
      return {};
    }
    return {contextURL:dict.contextURL, defaultActionURL:dict.defaultActionURL, downloaded:dict.downloaded, filename:dict.filename, filesize:dict.filesize, hash:dict.hash, height:dict.height, hidden:dict.hidden === true, overlayImageURL:dict.overlayImageURL, overlayColor:dict.overlayColor, overlayOpacity:dict.overlayOpacity, progress:dict.progress, reference:dict.reference, state:dict.state, thumbnailURL:dict.thumbnailURL, title:dict.title, type:dict.mime.toLowerCase(), url:dict.url, width:dict.width};
  };
  util.resource.applyProps = function(target, props) {
    target.setAttribute("hash", props.hash);
    target.setAttribute("type", props.type);
    ["reference", "width", "height", "align", "alt", "longdesc", "title", "lang", "dir", "border", "hspace", "vspace", "usemap"].forEach(function(name) {
      if (props[name]) {
        target.dataset[name] = props[name];
      }
    });
  };
  util.resource.referenceFor = function(el) {
    return el.dataset.reference;
  };
  util.resource.urlFor = function(el) {
    return el.dataset.url;
  };
  util.resource.mimeTypeFor = function(el) {
    return el.getAttribute("type") || el.dataset.type;
  };
  util.resource.parseMime = function(elOrMime) {
    var mime;
    if (elOrMime.getAttribute) {
      mime = util.resource.mimeTypeFor(elOrMime);
    } else {
      if (typeof elOrMime === "string") {
        mime = elOrMime;
      }
    }
    return mime;
  };
  util.resource.hashFor = function(el) {
    return el.getAttribute("hash") || el.dataset.hash;
  };
  util.resource.isDefaultContextButton = function(el) {
    return goog.dom.classes.has(el, "en-resource-context-default");
  };
  util.resource.isOverflowContextButton = function(el) {
    return goog.dom.classes.has(el, "en-resource-context-overflow");
  };
  util.resource.convertSlugToPlatformElement = function(slug) {
    var el = platform.convertSlugToPlatformElement(slug);
    if (el != null) {
      el.removeAttribute("class");
      goog.dom.replaceNode(el, slug);
    }
    return el;
  };
  util.resource.formatPlatformHtmlForExport = function(html) {
    return platform.formatForExport(html);
  };
  util.resource.toDict = function(el, range) {
    return {hash:el.getAttribute("hash") || el.dataset.hash, mime:el.getAttribute("type") || el.dataset.type, url:el.dataset.url, rect:goog.style.getBounds(el), reference:el.dataset.reference, selected:!!(range && !range.isCollapsed() && range.containsNode(el)), filename:el.dataset.filename, filesize:el.dataset.filesize};
  };
})();
goog.provide("uno.commands.BasicTextFormatter");
goog.require("goog.debug.Logger");
goog.require("goog.editor.Command");
goog.require("goog.functions");
goog.require("goog.labs.userAgent.browser");
goog.require("uno.BasePlugin");
goog.require("uno.util.crypto");
goog.require("uno.util.resource");
(function() {
  var util = uno.util;
  var log = goog.debug.Logger.getLogger("uno.commands.BasicTextFormatter");
  var highlightBackgroundColor = "rgb(255, 250, 165)";
  var highlightPlaceholder = "rgba(255, 255, 255, 0)";
  var BasicTextFormatter = uno.commands.BasicTextFormatter = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(BasicTextFormatter, uno.BasePlugin);
  BasicTextFormatter.GOOG_COMMAND = {highlight:"highlight", bold:goog.editor.Command.BOLD, fontname:goog.editor.Command.FONT_FACE, forecolor:goog.editor.Command.FONT_COLOR, indent:goog.editor.Command.INDENT, inserthorizontalrule:goog.editor.Command.HORIZONTAL_RULE, insertorderedlist:goog.editor.Command.ORDERED_LIST, insertunorderedlist:goog.editor.Command.UNORDERED_LIST, italic:goog.editor.Command.ITALIC, justifycenter:goog.editor.Command.JUSTIFY_CENTER, justifyfull:goog.editor.Command.JUSTIFY_FULL, 
  justifyleft:goog.editor.Command.JUSTIFY_LEFT, justifyright:goog.editor.Command.JUSTIFY_RIGHT, outdent:goog.editor.Command.OUTDENT, strikethrough:goog.editor.Command.STRIKE_THROUGH, subscript:goog.editor.Command.SUBSCRIPT, superscript:goog.editor.Command.SUPERSCRIPT, underline:goog.editor.Command.UNDERLINE};
  BasicTextFormatter.COMMANDS = Object.keys(BasicTextFormatter.GOOG_COMMAND);
  BasicTextFormatter.prototype.isSupportedCommand = function(command) {
    return BasicTextFormatter.COMMANDS.indexOf(command) > -1;
  };
  BasicTextFormatter.prototype.activeOnUneditableFields = goog.functions.TRUE;
  BasicTextFormatter.prototype.registerFieldObject = function(fieldObject) {
    uno.BasePlugin.prototype.registerFieldObject.call(this, fieldObject);
    var plugin = fieldObject.plugins_.BTF;
    plugin.activeOnUneditableFields = goog.functions.TRUE;
  };
  BasicTextFormatter.prototype.execCommand = function(command, value) {
    var styleOverride = {state:{}, value:{}, enabled:{}};
    toggleContentEditable(this.editor.field, true);
    var currentState = this.editor.context.style.state[command];
    this.editor.dispatchBeforeChange();
    execCommand.call(this, BasicTextFormatter.GOOG_COMMAND[command], value);
    this.editor.dispatchChange();
    if (command.indexOf("justify") === 0 && currentState) {
      styleOverride.state[command] = true;
    } else {
      styleOverride.state[command] = !currentState;
    }
    this.dispatchEvent({type:uno.Editor.EventType.STYLE_CHANGED, style:styleOverride});
    toggleContentEditable(this.editor.field, false);
  };
  BasicTextFormatter.prototype.queryCommandValue = function(command) {
    var result;
    switch(command) {
      case "highlight":
        var range = this.editor.getRange();
        var state = document.queryCommandValue("backColor");
        if (!range) {
          return false;
        }
        var startNode = range.getStartNode();
        var endNode = range.getEndNode();
        if (range && range.isCollapsed()) {
          if (startNode.nodeType === Node.TEXT_NODE) {
            return highlightBackgroundColor === state;
          }
        }
        if (highlightBackgroundColor === state) {
          return true;
        }
        var container = range.getContainerElement();
        var nodes = [];
        if (container === startNode && container === endNode) {
          nodes.push(container);
        } else {
          Array.prototype.forEach.call(container.childNodes || [], function(node) {
            if (range.containsNode(node, true) || node.contains(startNode) || node.contains(endNode)) {
              nodes.push(node);
            }
          });
        }
        result = isHighlighted(nodes);
        break;
      case "fontname":
        result = this.editor.queryCommandValue(goog.editor.Command.FONT_FACE);
        if (result) {
          result = result.replace(/,.*/, "").replace(/['"]/g, "");
        }
        break;
      case "insertunorderedlist":
        if (this.editor.queryCommandValue(goog.editor.Command.UNORDERED_LIST) !== false) {
          result = "ul";
        } else {
          if (this.editor.queryCommandValue(goog.editor.Command.ORDERED_LIST) !== false) {
            result = "ol";
          } else {
            result = "none";
          }
        }
        break;
      case "justifyleft":
      ;
      case "justifycenter":
      ;
      case "justifyright":
      ;
      case "justifyfull":
        if (this.editor.queryCommandValue(goog.editor.Command.JUSTIFY_LEFT) !== false) {
          result = "left";
        } else {
          if (this.editor.queryCommandValue(goog.editor.Command.JUSTIFY_CENTER) !== false) {
            result = "center";
          } else {
            if (this.editor.queryCommandValue(goog.editor.Command.JUSTIFY_RIGHT) !== false) {
              result = "right";
            } else {
              if (this.editor.queryCommandValue(goog.editor.Command.JUSTIFY_FULL) !== false) {
                result = "justify";
              }
            }
          }
        }
        break;
      default:
        result = this.editor.queryCommandValue(BasicTextFormatter.GOOG_COMMAND[command]);
    }
    return result;
  };
  BasicTextFormatter.prototype.queryCommandEnabled = function() {
    return true;
  };
  function execCommand(command, value) {
    var range = this.editor.getRange();
    var commands = BasicTextFormatter.GOOG_COMMAND;
    if (range && range.isCollapsed()) {
      var pendingCommands = [commands.highlight, commands.bold, commands.italic, commands.underline, commands.strikethrough, commands.subscript, commands.superscript];
      if (pendingCommands.indexOf(command) > -1) {
        createPendingStyle(this.editor.getRange(), this.editor.context);
      }
    }
    if (command === commands.highlight) {
      var highlighted = this.queryCommandValue(commands.highlight);
      document.execCommand("backColor", null, highlighted ? highlightPlaceholder : highlightBackgroundColor);
      cleanupHighlight([range.getContainerElement()], this.editor.getRange());
    } else {
      var shouldHighlight;
      if (command === commands.insertorderedlist || command === commands.insertunorderedlist) {
        shouldHighlight = this.queryCommandValue(commands.highlight);
      }
      this.editor.execCommand(command, value);
      if (shouldHighlight) {
        execCommand.call(this, commands.highlight);
      }
    }
    var elements = this.editor.getElement().querySelectorAll('*[style*="-webkit-text-size-adjust:"]');
    for (var i = 0;i < elements.length;i++) {
      elements[i].style.removeProperty("-webkit-text-size-adjust");
    }
  }
  function toggleContentEditable(field, on) {
    var contentEditableElements = goog.array.toArray(util.crypto.all(field)).concat(goog.array.toArray(util.resource.all(field)));
    contentEditableElements.forEach(function(el) {
      el.setAttribute("contenteditable", on);
    });
  }
  function cleanupHighlight(nodes, range) {
    Array.prototype.forEach.call(nodes || [], function(node) {
      if (range.containsNode(node, true)) {
        if (node.nodeType === Node.ELEMENT_NODE) {
          if (node.style.backgroundColor === highlightPlaceholder) {
            node.style.backgroundColor = "";
          }
          if (node.childNodes) {
            cleanupHighlight(node.childNodes, range);
          }
        }
      }
    });
  }
  function isHighlighted(nodes) {
    var result;
    Array.prototype.forEach.call(nodes || [], function(node) {
      if (result === false) {
        return;
      }
      if (node.nodeType === Node.ELEMENT_NODE) {
        var style = window.getComputedStyle(node);
        if (style.backgroundColor === highlightBackgroundColor) {
          result = true;
        } else {
          if (["rgba(0, 0, 0, 0)", "rgb(255, 255, 255)"].indexOf(style.backgroundColor) > -1) {
            result = isHighlighted(node.childNodes);
          } else {
            result = false;
          }
        }
      } else {
        result = false;
      }
    });
    return result;
  }
  function createPendingStyle(range, context) {
    var newRange;
    var node;
    if (range.isCollapsed()) {
      if (context.pendingNode) {
        node = context.pendingNode.node;
        newRange = goog.dom.Range.createFromNodes(node, 0, node, 1);
        newRange.select();
      } else {
        node = document.createTextNode("\u200b");
        range.insertNode(node);
        newRange = goog.dom.Range.createFromNodes(node, 0, node, 1);
        newRange.select();
        context.pendingNode = {node:node};
      }
    }
  }
})();
goog.provide("uno.commands.Bounds");
goog.require("goog.debug.Logger");
goog.require("goog.functions");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Bounds");
  var Bounds = uno.commands.Bounds = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Bounds, uno.BasePlugin);
  Bounds.prototype.activeOnUneditableFields = goog.functions.TRUE;
  Bounds.prototype.isSupportedCommand = function(command) {
    return command === "bounds";
  };
  Bounds.prototype.execCommandInternal = function(command, opt) {
  };
  Bounds.prototype.queryCommandValue = function(command) {
    var result = goog.style.getBounds(this.editor.field);
    result.right = result.left + result.width;
    result.bottom = result.top + result.height;
    result.x = result.left;
    result.y = document.body.scrollHeight - result.bottom;
    return result;
  };
})();
goog.provide("uno.commands.Capitalize");
goog.require("goog.debug.Logger");
goog.require("goog.iter");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Capitalize");
  var Capitalize = uno.commands.Capitalize = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Capitalize, uno.BasePlugin);
  Capitalize.prototype.isSupportedCommand = function(command) {
    return command === "capitalize";
  };
  Capitalize.prototype.execCommandInternal = function(command, opt) {
    var range = this.editor.getRange();
    var savedRange = range.saveUsingDom();
    goog.iter.forEach(range, function(element) {
      if (element.nodeType === Node.TEXT_NODE) {
        var capitalizeText = element.nodeValue.split(" ").map(function(word) {
          return word[0].toUpperCase() + word.slice(1);
        }).join(" ");
        element.nodeValue = capitalizeText;
      }
    });
    savedRange.restore().select();
  };
  Capitalize.prototype.queryCommandValue = function(command) {
  };
})();
goog.provide("uno.commands.Changes");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Changes");
  var Changes = uno.commands.Changes = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Changes, uno.BasePlugin);
  Changes.prototype.isSupportedCommand = function(command) {
    return command === "changes";
  };
  Changes.prototype.activeOnUneditableFields = function() {
    return true;
  };
  Changes.prototype.execCommandInternal = function(command, value) {
  };
  Changes.prototype.queryCommandValue = function(command) {
    return this.editor.dirty || this.editor.isModified();
  };
})();
goog.provide("uno.commands.Content");
goog.require("goog.array");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("uno.BasePlugin");
goog.require("uno.defs");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Content");
  var Content = uno.commands.Content = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Content, uno.BasePlugin);
  Content.prototype.isSupportedCommand = function(command) {
    return command === "content";
  };
  Content.prototype.activeOnUneditableFields = function() {
    return true;
  };
  Content.prototype.execCommand = function(command, value) {
    var editor = this.editor;
    var defaultContentType = editor.config.crypt.legacy ? uno.defs.format.PLATFORM_HTML : uno.defs.format.ENML;
    value = {type:value.type || defaultContentType, content:goog.isString(value.content) ? value.content : value, resources:value.resources || {}};
    var content = value.content;
    editor.context.format = value.type;
    if (editor.context.format === uno.defs.format.PLATFORM_HTML) {
      if (content && content.indexOf('<div id="en-note">') !== -1) {
        content = content.replace('<div id="en-note">', "").replace(/<\/div>\s*$/, "");
      } else {
        if (content && content.indexOf('<div id="en-note"/>') !== -1) {
          content = editor.config.defaults.html;
        }
      }
    }
    goog.object.extend(editor.context.resources, value.resources);
    editor.setHtml(false, content, true);
    editor.plugins_.UndoRedo.refreshCurrentState(editor);
    this.waitForImages();
    editor.updateEmpty();
    return true;
  };
  Content.prototype.queryCommandValue = function(command, opt) {
    var editor = this.editor;
    var value;
    if (editor.config.crypt.legacy) {
      return this.queryCommandValueLegacy(command, opt);
    }
    opt = opt || {};
    if (opt.type === "html") {
      editor.context.format = uno.defs.format.PLATFORM_HTML;
    } else {
      if (opt.type) {
        editor.context.format = opt.type;
      } else {
        if (editor.config.crypt.legacy) {
          editor.context.format = uno.defs.format.ENML;
        }
      }
    }
    if (typeof opt.resetChangesState === "undefined") {
      opt.resetChangesState = true;
    }
    value = editor.getCleanContents();
    if (editor.context.format === uno.defs.format.PLATFORM_HTML) {
      value = '<div id="en-note">' + value + "</div>";
    }
    if (opt.resetChangesState) {
      editor.dirty = false;
    }
    return {success:value != null, value:value};
  };
  Content.prototype.queryCommandValueLegacy = function(command, opt) {
    var editor = this.editor;
    var value;
    opt = opt || {};
    if (opt.type === uno.defs.format.ENML) {
      editor.context.format = uno.defs.format.ENML;
    } else {
      editor.context.format = uno.defs.format.PLATFORM_HTML;
    }
    value = editor.getCleanContents();
    if (opt.trim) {
      value = value.trim();
    }
    if (editor.context.format === uno.defs.format.PLATFORM_HTML) {
      value = '<div id="en-note">' + value + "</div>";
    }
    if (opt.resetChangesState) {
      editor.dirty = false;
    }
    return value;
  };
  Content.prototype.waitForImages = function() {
    var me = this;
    var completeImageCount = 0;
    var images = this.editor.field.querySelectorAll("img");
    if (images.length === 0) {
      return setTimeout(function() {
        if (me.editor) {
          me.dispatchContentLoaded();
        }
      }, 0);
    }
    var onImageComplete = function() {
      if (++completeImageCount === images.length) {
        return setTimeout(function() {
          if (me.editor) {
            me.dispatchContentLoaded();
          }
        }, 0);
      }
    };
    goog.array.forEach(images, function waitForImageComplete(img) {
      if (!img.naturalWidth && !img.naturalHeight) {
        goog.events.listen(img, "load", onImageComplete);
        goog.events.listen(img, "error", onImageComplete);
      } else {
        onImageComplete();
      }
    });
  };
  Content.prototype.dispatchContentLoaded = function() {
    this.dispatchEvent("contentloaded");
  };
})();
goog.provide("uno.util.todo.generic");
(function() {
  var generic = uno.util.todo.generic;
  generic.tryToInsertTodo = function() {
    EN.execCommand("insertparagraph");
    EN.execCommand("inserttodo");
    return true;
  };
  generic.findTodosInPlatformHtml = function() {
    return [];
  };
  generic.convertTodoToPlatformElement = function() {
  };
})();
goog.provide("uno.util.todo.mac");
goog.require("goog.dom");
goog.require("goog.dom.classes");
goog.require("uno.util.dom");
goog.require("uno.util.todo.generic");
(function() {
  var mac = uno.util.todo.mac;
  var util = uno.util;
  mac.tryToInsertTodo = function() {
    return util.todo.generic.tryToInsertTodo();
  };
  mac.findTodosInPlatformHtml = function(frag) {
    return frag.querySelectorAll("img.en-todo");
  };
  mac.convertPlatformElementToTodo = function(el) {
    var checked = goog.dom.classes.has(el, "en-todo-checked");
    var entodo = util.todo.create(checked);
    goog.dom.replaceNode(entodo, el);
  };
  mac.convertTodoToPlatformElement = function(todo) {
    var img = goog.dom.createDom("img", {"class":"en-todo"});
    if (util.todo.isChecked(todo)) {
      goog.dom.classes.add(img, "en-todo-checked");
    }
    goog.dom.replaceNode(img, todo);
  };
})();
goog.provide("uno.util.todo.ios");
(function() {
  var ios = uno.util.todo.ios;
  var util = uno.util;
  ios.tryToInsertTodo = function() {
    return false;
  };
  ios.findTodosInPlatformHtml = function() {
    return [];
  };
  ios.convertTodoToPlatformElement = function() {
  };
  ios.convertTodoInClipboard = function(todo) {
    return util.todo.create(todo.getAttribute("checked") === "true");
  };
  ios.convertTodoToClipboardElement = function(fragment) {
    var todo = goog.dom.createDom("input", "en-todo");
    todo.setAttribute("type", "checkbox");
    if (fragment.getAttribute("checked") === "true") {
      todo.setAttribute("checked", true);
    }
    return todo;
  };
})();
goog.provide("uno.util.todo.win");
goog.require("goog.dom");
goog.require("uno.util.todo.generic");
(function() {
  var util = uno.util;
  var win = uno.util.todo.win;
  win.tryToInsertTodo = function() {
    return util.todo.generic.tryToInsertTodo();
  };
  win.findTodosInPlatformHtml = function(frag) {
    return frag.querySelectorAll("img[src^=en-resource\\:\\/\\/database\\/check]");
  };
  win.convertPlatformElementToTodo = function(el) {
    var src = el.getAttribute("src");
    var matches = /database\/check(\d+):(\d+)/.exec(src);
    var X = parseInt(matches[1], 10);
    var checked = X == 1 || X == 3;
    var entodo = util.todo.create(checked);
    goog.dom.replaceNode(entodo, el);
  };
  win.convertTodoToPlatformElement = function(todo) {
    var src = "en-resource://database/check";
    src += util.todo.isChecked(todo) ? "1" : "0";
    src += ":0";
    var img = goog.dom.createDom("img", {"src":src});
    goog.dom.replaceNode(img, todo);
  };
})();
goog.provide("uno.util.todo");
goog.require("goog.debug.Logger");
goog.require("goog.dom.classes");
goog.require("uno.util.todo.generic");
goog.require("uno.util.todo.mac");
goog.require("uno.util.todo.ios");
goog.require("uno.util.todo.win");
goog.require("uno.defs");
(function() {
  var util = uno.util;
  var platform = uno.util.todo.generic;
  util.todo.setPlatform = function(platformName) {
    platform = uno.util.todo[platformName] || platform;
  };
  util.todo.all = function(root) {
    return root.querySelectorAll(".en-todo");
  };
  util.todo.allEnmlTodos = function(root) {
    return root.querySelectorAll("en-todo");
  };
  util.todo.isTodo = function(el) {
    return el && goog.dom.classes.has(el, "en-todo");
  };
  util.todo.create = function(checked) {
    var todo = new Image;
    todo.src = uno.defs.image.TRANSPARENT_IMAGE_DATA_URL;
    goog.dom.classes.add(todo, "en-todo");
    if (checked) {
      util.todo.toggle(todo);
    }
    return todo;
  };
  util.todo.tryToInsertTodo = function() {
    return platform.tryToInsertTodo();
  };
  util.todo.isChecked = function(todo) {
    return todo.getAttribute("checked") === "true";
  };
  util.todo.setChecked = function(todo, checked) {
    todo.setAttribute("checked", checked);
  };
  util.todo.toggle = function(todo) {
    todo.setAttribute("checked", !util.todo.isChecked(todo));
  };
  util.todo.remove = function(todo) {
    if (!todo || !todo.parentNode) {
      return;
    }
    var textNode = goog.editor.node.getNextSibling(todo);
    if (textNode && textNode.nodeType === Node.TEXT_NODE) {
      var text = textNode.textContent;
      var updated = goog.string.trimLeft(text);
      if (updated !== text) {
        if (updated.length === 0) {
          goog.dom.removeNode(textNode);
        } else {
          textNode.textContent = updated;
        }
      }
    }
    goog.dom.removeNode(todo);
  };
  util.todo.findTodosInPlatformHtml = function(root) {
    return platform.findTodosInPlatformHtml(root);
  };
  util.todo.convertPlatformElementToTodo = function(el) {
    platform.convertPlatformElementToTodo(el);
  };
  util.todo.convertTodoToPlatformElement = function(todo) {
    platform.convertTodoToPlatformElement(todo);
  };
  util.todo.convertTodoInClipboard = function(todo) {
    return platform.convertTodoInClipboard && platform.convertTodoInClipboard(todo);
  };
  util.todo.convertTodoToClipboardElement = function(todo) {
    return platform.convertTodoToClipboardElement && platform.convertTodoToClipboardElement(todo);
  };
  util.todo.decorate = function(entodo) {
    var checked = util.todo.isChecked(entodo);
    goog.dom.replaceNode(util.todo.create(checked), entodo);
  };
  util.todo.undecorate = function(todo) {
    var entodo = goog.dom.createDom("en-todo");
    entodo.setAttribute("checked", util.todo.isChecked(todo));
    goog.dom.replaceNode(entodo, todo);
  };
  util.todo.addTodoToParagraph = function(node) {
    var todo = util.todo.create();
    node.insertBefore(todo, node.firstChild);
    return node;
  };
})();
goog.provide("uno.commands.ControlTodos");
goog.require("goog.array");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.todo");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.ControlTodos");
  var util = uno.util;
  var ControlTodos = uno.commands.ControlTodos = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(ControlTodos, uno.BasePlugin);
  ControlTodos.prototype.isSupportedCommand = function(command) {
    return command === "controltodos";
  };
  ControlTodos.prototype.execCommandInternal = function(command, opt) {
    var range = this.editor.getRange();
    var todos = util.todo.all(this.editor.field);
    if (!range.isCollapsed()) {
      todos = goog.array.filter(todos, function(node) {
        return range.containsNode(node, true);
      });
    }
    goog.array.forEach(todos, function(entodo) {
      if (opt === "on") {
        util.todo.setChecked(entodo, true);
      } else {
        if (opt === "off") {
          util.todo.setChecked(entodo, false);
        } else {
          util.todo.toggle(entodo);
        }
      }
    });
  };
})();
goog.provide("uno.commands.Copy");
goog.require("goog.debug.Logger");
goog.require("goog.style");
goog.require("uno.BasePlugin");
goog.require("uno.defs");
goog.require("uno.util.todo");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Copy");
  var defs = uno.defs;
  var util = uno.util;
  var HTML_START_TAG = '<!DOCTYPE html><html><head><meta charset="utf-8"><title></title></head><body>';
  var HTML_END_TAG = "</body></html>";
  var Copy = uno.commands.Copy = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Copy, uno.BasePlugin);
  Copy.prototype.isSupportedCommand = function(command) {
    return command === "copy";
  };
  Copy.prototype.activeOnUneditableFields = goog.functions.TRUE;
  Copy.prototype.execCommandInternal = function() {
  };
  Copy.prototype.queryCommandValue = function(command, opt) {
    var options = getOptions(opt);
    this.editor.context.format = defs.format.CLIPBOARD;
    return copy(this.editor, options);
  };
  function getOptions(options) {
    return util.objects.mergeOptions(options, {html:true, raw:true, resources:true, plain:true, fullhtml:false, fullraw:false});
  }
  function cleanContent(editor, html) {
    var result = editor.getClipboardContent(html);
    var transformedFragment = goog.dom.createDom("div", null);
    transformedFragment.innerHTML = result;
    return transformedFragment;
  }
  function createClone(html) {
    var clone = goog.dom.createDom("div", null);
    if (html.nodeType === Node.TEXT_NODE) {
      clone.innerText = html.textContent;
    } else {
      clone.innerHTML = html.outerHTML;
    }
    return clone.firstChild;
  }
  function getPlainText(editor, html) {
    var clone = createClone(html);
    var resources = clone.querySelectorAll("en-media");
    Array.prototype.forEach.call(resources, function(node) {
      goog.dom.removeNode(node);
    });
    var a = clone.querySelectorAll("a");
    Array.prototype.forEach.call(a, function(node) {
      goog.dom.replaceNode(document.createTextNode(node.textContent), node);
    });
    var todos = clone.querySelectorAll(".en-todo");
    Array.prototype.forEach.call(todos, function(node) {
      var todo = document.createTextNode(node.getAttribute("checked") === "true" ? "[x] " : "[ ] ");
      goog.dom.replaceNode(todo, node);
    });
    clone = cleanContent(editor, clone);
    var plainText = clone.innerHTML;
    plainText = goog.editor.plugins.RemoveFormatting.prototype.removeFormattingWorker_(plainText);
    plainText = plainText.replace(/<br>/g, "\n").replace(/\u00A0/g, " ");
    var unescaper = document.createElement("div");
    unescaper.innerHTML = plainText;
    return unescaper.innerText;
  }
  function getResources(html) {
    return goog.array.map(util.img.all(html), function(el) {
      return util.resource.toDict(el);
    });
  }
  function getRaw(editor, html) {
    var clone = createClone(html);
    clone = cleanContent(editor, clone);
    return util.string.removeInvalidHtmlCharacters(clone.innerHTML);
  }
  function getHtml(editor, html, originalHtml) {
    var clone = createClone(html);
    clone = cleanContent(editor, clone);
    var defaultSize = goog.style.getComputedStyle(originalHtml, "font-size");
    var defaultFont = goog.style.getComputedStyle(originalHtml, "font-family");
    goog.style.setStyle(clone, {"font-size":defaultSize, "font-family":defaultFont});
    return util.string.removeInvalidHtmlCharacters(clone.innerHTML);
  }
  function getFontsFromNode(textNode) {
    var styles = {textDecoration:[]};
    var limitReached = false;
    var styleNames = ["fontWeight", "fontFamily", "backgroundColor", "fontSize", "fontStyle"];
    var clone = createClone(textNode);
    if (clone.nodeType === Node.TEXT_NODE) {
      clone = goog.dom.createDom("font");
    }
    goog.dom.getAncestor(textNode, function(node) {
      if (!limitReached) {
        if (node && node.tagName && node.tagName.toLowerCase() === "en-note") {
          limitReached = true;
        } else {
          var computedStyle = window.getComputedStyle(node);
          styleNames.forEach(function(name) {
            if (!styles[name] && computedStyle[name]) {
              styles[name] = computedStyle[name];
              goog.style.setStyle(clone, name, computedStyle[name]);
            }
          });
          if (computedStyle.textDecoration && computedStyle.textDecoration !== "none" && styles.textDecoration.indexOf(computedStyle.textDecoration) < 0) {
            styles.textDecoration.push(computedStyle.textDecoration);
            goog.style.setStyle(clone, "text-decoration", styles.textDecoration.join(" "));
          }
        }
      }
      return false;
    });
    return clone;
  }
  function copy(editor, options) {
    var range = editor.getRange();
    if (!range || range.isCollapsed()) {
      return false;
    }
    var html = goog.dom.createDom("div", null);
    var pastableHtml = range.getPastableHtml();
    html.innerHTML = pastableHtml;
    if (html.childNodes.length === 1 && html.firstChild.nodeType === Node.TEXT_NODE) {
      var fontNode = getFontsFromNode(range.getStartNode());
      fontNode.innerHTML = pastableHtml;
      html.innerHTML = fontNode.outerHTML;
    }
    if (html.querySelector("en-note")) {
      var ennote = html.querySelector("en-note");
      var div = goog.dom.createDom("div", null, ennote.childNodes);
      goog.dom.replaceNode(div, ennote);
    }
    var value = {};
    if (options.plain) {
      value.plain = getPlainText(editor, html);
    }
    if (options.resources) {
      value.resources = getResources(html);
    }
    if (options.raw || options.fullraw) {
      value.raw = getRaw(editor, html);
    }
    if (options.fullraw) {
      value.fullraw = HTML_START_TAG + value.raw + HTML_END_TAG;
    }
    if (options.html || options.fullhtml) {
      value.html = getHtml(editor, html, range.getContainerElement());
    }
    if (options.fullhtml) {
      value.fullhtml = HTML_START_TAG + value.html + HTML_END_TAG;
    }
    return value;
  }
})();
goog.provide("goog.dom.InputType");
goog.dom.InputType = {BUTTON:"button", CHECKBOX:"checkbox", COLOR:"color", DATE:"date", DATETIME:"datetime", DATETIME_LOCAL:"datetime-local", EMAIL:"email", FILE:"file", HIDDEN:"hidden", IMAGE:"image", MENU:"menu", MONTH:"month", NUMBER:"number", PASSWORD:"password", RADIO:"radio", RANGE:"range", RESET:"reset", SEARCH:"search", SELECT_MULTIPLE:"select-multiple", SELECT_ONE:"select-one", SUBMIT:"submit", TEL:"tel", TEXT:"text", TEXTAREA:"textarea", TIME:"time", URL:"url", WEEK:"week"};
goog.provide("goog.dom.selection");
goog.require("goog.dom.InputType");
goog.require("goog.string");
goog.require("goog.userAgent");
goog.dom.selection.setStart = function(textfield, pos) {
  if (goog.dom.selection.useSelectionProperties_(textfield)) {
    textfield.selectionStart = pos;
  } else {
    if (goog.userAgent.IE) {
      var tmp = goog.dom.selection.getRangeIe_(textfield);
      var range = tmp[0];
      var selectionRange = tmp[1];
      if (range.inRange(selectionRange)) {
        pos = goog.dom.selection.canonicalizePositionIe_(textfield, pos);
        range.collapse(true);
        range.move("character", pos);
        range.select();
      }
    }
  }
};
goog.dom.selection.getStart = function(textfield) {
  return goog.dom.selection.getEndPoints_(textfield, true)[0];
};
goog.dom.selection.getEndPointsTextareaIe_ = function(range, selRange, getOnlyStart) {
  var selectionRange = selRange.duplicate();
  var beforeSelectionText = range.text;
  var untrimmedBeforeSelectionText = beforeSelectionText;
  var selectionText = selectionRange.text;
  var untrimmedSelectionText = selectionText;
  var isRangeEndTrimmed = false;
  while (!isRangeEndTrimmed) {
    if (range.compareEndPoints("StartToEnd", range) == 0) {
      isRangeEndTrimmed = true;
    } else {
      range.moveEnd("character", -1);
      if (range.text == beforeSelectionText) {
        untrimmedBeforeSelectionText += "\r\n";
      } else {
        isRangeEndTrimmed = true;
      }
    }
  }
  if (getOnlyStart) {
    return [untrimmedBeforeSelectionText.length, -1];
  }
  var isSelectionRangeEndTrimmed = false;
  while (!isSelectionRangeEndTrimmed) {
    if (selectionRange.compareEndPoints("StartToEnd", selectionRange) == 0) {
      isSelectionRangeEndTrimmed = true;
    } else {
      selectionRange.moveEnd("character", -1);
      if (selectionRange.text == selectionText) {
        untrimmedSelectionText += "\r\n";
      } else {
        isSelectionRangeEndTrimmed = true;
      }
    }
  }
  return [untrimmedBeforeSelectionText.length, untrimmedBeforeSelectionText.length + untrimmedSelectionText.length];
};
goog.dom.selection.getEndPoints = function(textfield) {
  return goog.dom.selection.getEndPoints_(textfield, false);
};
goog.dom.selection.getEndPoints_ = function(textfield, getOnlyStart) {
  textfield = (textfield);
  var startPos = 0;
  var endPos = 0;
  if (goog.dom.selection.useSelectionProperties_(textfield)) {
    startPos = textfield.selectionStart;
    endPos = getOnlyStart ? -1 : textfield.selectionEnd;
  } else {
    if (goog.userAgent.IE) {
      var tmp = goog.dom.selection.getRangeIe_(textfield);
      var range = tmp[0];
      var selectionRange = tmp[1];
      if (range.inRange(selectionRange)) {
        range.setEndPoint("EndToStart", selectionRange);
        if (textfield.type == goog.dom.InputType.TEXTAREA) {
          return goog.dom.selection.getEndPointsTextareaIe_(range, selectionRange, getOnlyStart);
        }
        startPos = range.text.length;
        if (!getOnlyStart) {
          endPos = range.text.length + selectionRange.text.length;
        } else {
          endPos = -1;
        }
      }
    }
  }
  return [startPos, endPos];
};
goog.dom.selection.setEnd = function(textfield, pos) {
  if (goog.dom.selection.useSelectionProperties_(textfield)) {
    textfield.selectionEnd = pos;
  } else {
    if (goog.userAgent.IE) {
      var tmp = goog.dom.selection.getRangeIe_(textfield);
      var range = tmp[0];
      var selectionRange = tmp[1];
      if (range.inRange(selectionRange)) {
        pos = goog.dom.selection.canonicalizePositionIe_(textfield, pos);
        var startCursorPos = goog.dom.selection.canonicalizePositionIe_(textfield, goog.dom.selection.getStart(textfield));
        selectionRange.collapse(true);
        selectionRange.moveEnd("character", pos - startCursorPos);
        selectionRange.select();
      }
    }
  }
};
goog.dom.selection.getEnd = function(textfield) {
  return goog.dom.selection.getEndPoints_(textfield, false)[1];
};
goog.dom.selection.setCursorPosition = function(textfield, pos) {
  if (goog.dom.selection.useSelectionProperties_(textfield)) {
    textfield.selectionStart = pos;
    textfield.selectionEnd = pos;
  } else {
    if (goog.userAgent.IE) {
      pos = goog.dom.selection.canonicalizePositionIe_(textfield, pos);
      var sel = textfield.createTextRange();
      sel.collapse(true);
      sel.move("character", pos);
      sel.select();
    }
  }
};
goog.dom.selection.setText = function(textfield, text) {
  textfield = (textfield);
  if (goog.dom.selection.useSelectionProperties_(textfield)) {
    var value = textfield.value;
    var oldSelectionStart = textfield.selectionStart;
    var before = value.substr(0, oldSelectionStart);
    var after = value.substr(textfield.selectionEnd);
    textfield.value = before + text + after;
    textfield.selectionStart = oldSelectionStart;
    textfield.selectionEnd = oldSelectionStart + text.length;
  } else {
    if (goog.userAgent.IE) {
      var tmp = goog.dom.selection.getRangeIe_(textfield);
      var range = tmp[0];
      var selectionRange = tmp[1];
      if (!range.inRange(selectionRange)) {
        return;
      }
      var range2 = selectionRange.duplicate();
      selectionRange.text = text;
      selectionRange.setEndPoint("StartToStart", range2);
      selectionRange.select();
    } else {
      throw Error("Cannot set the selection end");
    }
  }
};
goog.dom.selection.getText = function(textfield) {
  textfield = (textfield);
  if (goog.dom.selection.useSelectionProperties_(textfield)) {
    var s = textfield.value;
    return s.substring(textfield.selectionStart, textfield.selectionEnd);
  }
  if (goog.userAgent.IE) {
    var tmp = goog.dom.selection.getRangeIe_(textfield);
    var range = tmp[0];
    var selectionRange = tmp[1];
    if (!range.inRange(selectionRange)) {
      return "";
    } else {
      if (textfield.type == goog.dom.InputType.TEXTAREA) {
        return goog.dom.selection.getSelectionRangeText_(selectionRange);
      }
    }
    return selectionRange.text;
  }
  throw Error("Cannot get the selection text");
};
goog.dom.selection.getSelectionRangeText_ = function(selRange) {
  var selectionRange = selRange.duplicate();
  var selectionText = selectionRange.text;
  var untrimmedSelectionText = selectionText;
  var isSelectionRangeEndTrimmed = false;
  while (!isSelectionRangeEndTrimmed) {
    if (selectionRange.compareEndPoints("StartToEnd", selectionRange) == 0) {
      isSelectionRangeEndTrimmed = true;
    } else {
      selectionRange.moveEnd("character", -1);
      if (selectionRange.text == selectionText) {
        untrimmedSelectionText += "\r\n";
      } else {
        isSelectionRangeEndTrimmed = true;
      }
    }
  }
  return untrimmedSelectionText;
};
goog.dom.selection.getRangeIe_ = function(el) {
  var doc = el.ownerDocument || el.document;
  var selectionRange = doc.selection.createRange();
  var range;
  if ((el).type == goog.dom.InputType.TEXTAREA) {
    range = doc.body.createTextRange();
    range.moveToElementText(el);
  } else {
    range = el.createTextRange();
  }
  return [range, selectionRange];
};
goog.dom.selection.canonicalizePositionIe_ = function(textfield, pos) {
  textfield = (textfield);
  if (textfield.type == goog.dom.InputType.TEXTAREA) {
    var value = textfield.value.substring(0, pos);
    pos = goog.string.canonicalizeNewlines(value).length;
  }
  return pos;
};
goog.dom.selection.useSelectionProperties_ = function(el) {
  try {
    return typeof el.selectionStart == "number";
  } catch (e) {
    return false;
  }
};
goog.provide("uno.util.richlink");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.dom.selection");
goog.require("goog.string");
goog.require("uno.defs");
goog.require("uno.util.dom");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.richlink");
  var defs = uno.defs;
  var util = uno.util;
  util.richlink.counter = 0;
  util.richlink.DISPLAY_TYPE = {NONE:"en_rl_none", MINIMAL:"en_rl_minimal", TEXT:"en_rl_text", SMALL:"en_rl_small"};
  util.richlink.isRichLink = function(node) {
    return node && util.dom.matches(node, "a.en-richlink");
  };
  util.richlink.componentElementFor = function(el) {
    return goog.dom.getAncestorByTagNameAndClass(el, null, "en-richlink");
  };
  util.richlink.all = function(root) {
    return root.querySelectorAll("a.en-richlink");
  };
  util.richlink.allPlain = function(root) {
    return root.querySelectorAll("a:not(.en-richlink)");
  };
  util.richlink.decorate = function(el, editor) {
    if (!el.href || util.richlink.hasNonDecoratableChildren(el)) {
      return;
    }
    editor.richlinkProviders.some(function(provider) {
      if (provider.canDecorate(el.href)) {
        el.dataset.reference = util.richlink.createUid();
        el.dataset.provider = provider.name;
        el.dataset.title = el.innerText;
        el.setAttribute("rev", util.richlink.getDisplayType(el));
        el.setAttribute("contenteditable", false);
        provider.decorate(el, editor);
        return true;
      }
    });
  };
  util.richlink.undecorate = function(el, editor) {
    editor.richlinkProviders.some(function(provider) {
      if (provider.name === el.dataset.provider) {
        provider.undecorate(el);
        el.removeAttribute("class");
        el.removeAttribute("contenteditable");
        el.innerText = goog.string.unescapeEntities(el.dataset.title);
        Object.keys(el.dataset).forEach(function(key) {
          delete el.dataset[key];
        });
        return true;
      }
    });
  };
  util.richlink.getDisplayType = function(el) {
    var parent;
    var displayType;
    if (el.rev) {
      displayType = el.rev;
    } else {
      if ((parent = util.dom.parent(el, "ul, ol, il, dl, td", null)) !== null) {
        displayType = util.richlink.DISPLAY_TYPE.MINIMAL;
      } else {
        if (util.dom.hasTextNextToIt(el)) {
          displayType = util.richlink.DISPLAY_TYPE.MINIMAL;
        } else {
          displayType = util.richlink.DISPLAY_TYPE.SMALL;
        }
      }
    }
    return displayType;
  };
  util.richlink.hasNonDecoratableChildren = function(node) {
    if (!node || !node.childNodes || node.childNodes.length == 0) {
      return false;
    }
    for (var index = 0;index < node.children.length;index++) {
      if (node.children[index].nodeName && (node.children[index].nodeName.toLowerCase() == "img" || uno.defs.blockElements[node.children[index].nodeName.toLowerCase()] && node.children[index].nodeName.toLowerCase() != "p")) {
        return true;
      }
      if (util.richlink.hasNonDecoratableChildren(node.children[index])) {
        return true;
      }
    }
    return false;
  };
  util.richlink.createUid = function() {
    return "richlink-" + ++util.richlink.counter;
  };
  util.richlink.findByRef = function(ref, node) {
    var selector = 'a[data-reference="' + ref + '"]';
    var el = node.querySelector(selector);
    return el;
  };
  util.richlink.handleClick = function(el, target, editor) {
    var result = false;
    editor.richlinkProviders.some(function(provider) {
      if (provider.name === el.dataset.provider) {
        result = provider.handleClick(el, target, editor);
      }
    });
    return result;
  };
})();
goog.provide("uno.commands.CreateLink");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.editor.plugins.BasicTextFormatter");
goog.require("goog.functions");
goog.require("uno.BasePlugin");
goog.require("uno.util.dom");
goog.require("uno.util.richlink");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.CreateLink");
  var util = uno.util;
  var CreateLink = uno.commands.CreateLink = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(CreateLink, uno.BasePlugin);
  CreateLink.prototype.isSupportedCommand = function(command) {
    return command === "createlink";
  };
  CreateLink.prototype.activeOnUneditableFields = goog.functions.TRUE;
  CreateLink.prototype.execCommandInternal = function(command, value) {
    var container;
    var url = goog.isObject(value) ? value.url : value;
    var title = goog.isObject(value) ? value.title || value.url : value;
    var range = this.editor.getRange();
    var dom = goog.dom;
    var node;
    if (range == null) {
      return;
    }
    if (url == null) {
      return;
    }
    if (!goog.editor.range.intersectsTag(range, goog.dom.TagName.A)) {
      if (range.isCollapsed()) {
        node = dom.createTextNode(title);
        range.replaceContentsWithNode(node);
        range = goog.dom.Range.createFromNodes(node, 0, node, title.length);
        range.select();
      }
      this.editor.execCommand(goog.editor.plugins.BasicTextFormatter.COMMAND.CREATE_LINK, range, url);
    }
    range = this.editor.getRange();
    container = range.getContainerElement();
    if (util.dom.compareTagName(container, "a")) {
      container.setAttribute("href", url);
    }
    goog.array.forEach(container.querySelectorAll("a"), function(a) {
      if (range.containsNode(a)) {
        a.setAttribute("href", url);
      }
    });
    this.editor.updateEmpty();
    uno.util.richlink.applyTransformToPasteAsync(container, true);
  };
  CreateLink.prototype.queryCommandValue = function(command) {
    var anchor;
    var range = this.editor.getRange();
    if (range && (range.isCollapsed() || range.getContainer() === range.getStartNode())) {
      anchor = goog.dom.getAncestorByTagNameAndClass(range.getStartNode(), "a");
      if (anchor && anchor.hasAttribute("href")) {
        return anchor.href;
      }
    } else {
    }
  };
  CreateLink.prototype.queryCommandEnabled = function(command) {
    return !this.queryCommandValue(command);
  };
})();
goog.provide("uno.commands.Crypt");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.dom.classlist");
goog.require("goog.editor.range");
goog.require("uno.defs");
goog.require("uno.util.crypto");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Crypt");
  var Crypt = uno.commands.Crypt = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Crypt, uno.BasePlugin);
  var EDITOR_CONTAINER_CLASS = uno.defs.containers.EDITOR_CONTAINER_CLASS;
  var CRYPT_CLASS = uno.defs.crypto.CRYPT_CLASS;
  var CRYPT_HIDDEN_CLASS = uno.defs.crypto.CRYPT_HIDDEN_CLASS;
  var CRYPT_VISIBLE_CLASS = uno.defs.crypto.CRYPT_VISIBLE_CLASS;
  Crypt.prototype.isSupportedCommand = function(command) {
    return command === "crypt";
  };
  Crypt.prototype.queryCommandEnabled = function(command, value) {
    if (value) {
      return true;
    }
    var range = this.editor.getRange();
    return !!(range && !range.isCollapsed() && !getCryptNodeFromRange(range));
  };
  Crypt.prototype.queryCommandValue = function(command, value) {
    var range = this.editor.getRange();
    if (range) {
      var cryptNode = getCryptNodeFromRange(range);
      var hasClass = goog.dom.classlist.contains;
      if (cryptNode) {
        if (value === "open") {
          return hasClass(cryptNode, CRYPT_VISIBLE_CLASS);
        } else {
          if (value === "closed") {
            return hasClass(cryptNode, CRYPT_HIDDEN_CLASS) || !hasClass(cryptNode, CRYPT_VISIBLE_CLASS);
          } else {
            if (value === "selected") {
              var cryptInfo = uno.util.crypto.getCryptInfoFromNode(cryptNode);
              cryptInfo.open = !!hasClass(cryptNode, CRYPT_VISIBLE_CLASS);
              return cryptInfo;
            }
          }
        }
        return true;
      }
    }
    return false;
  };
  Crypt.prototype.execCommand = function(command, options) {
    var range = this.editor.getRange();
    var dispatchEvent = this.dispatchEvent.bind(this);
    var result = false;
    if (!options) {
      result = encryptSelection(null, this.editor, range, dispatchEvent, this.editor.context.crypt);
    }
    if (options.encrypt) {
      result = encrypt(options.encrypt);
    } else {
      if (options.decrypt) {
        result = decrypt(options.decrypt, this.editor);
      } else {
        if (options.revert) {
          result = revertOrOpen(true, options.revert, false, range, dispatchEvent);
        } else {
          if (options.open) {
            result = revertOrOpen(false, options.open, !!this.editor.config.crypt.readOnly, range, dispatchEvent);
          } else {
            if (options.close) {
              result = closeCrypt(options.close, this.editor, range, dispatchEvent);
            } else {
              if (options.updateAllRevisions) {
                result = updateAllRevisions();
              } else {
                result = false;
              }
            }
          }
        }
      }
    }
    if (result) {
      if (options.revert && options.revert.cipherText && options.revert.plainText) {
        this.editor.dispatchChange();
      }
      if (options.encrypt && options.encrypt.cipherText) {
        this.editor.dispatchChange();
      }
    }
    return result;
  };
  function encryptSelection(options, editor, range, dispatchEvent, context) {
    if (!range || range.isCollapsed()) {
      return false;
    }
    var selection = editor.queryCommandValue("copy");
    if (!selection.html) {
      return false;
    }
    var newId = context.incrementUniqueId();
    var encryptedNode = uno.util.crypto.createCryptoPlaceholder({id:"crypt-" + newId, rev:"crypt-" + newId + "-0", plainText:selection.html});
    replaceRangeWith(range, encryptedNode, editor);
    var cryptInfo = uno.util.crypto.getCryptInfoFromNode(encryptedNode);
    dispatchEvent({type:"encrypt", cryptInfo:cryptInfo});
    return cryptInfo;
  }
  function encrypt(options) {
    var cryptNode = getNodeFromCryptInfo(options);
    if (!cryptNode) {
      return false;
    }
    cryptNode.setAttribute("data-ciphertext", options.cipherText);
    cryptNode.setAttribute("data-plaintext", "");
    return cryptNode;
  }
  function decrypt(options, editor) {
    var cryptNode = getNodeFromCryptInfo(options, {encryptedOnly:true});
    if (!cryptNode || !options.plainText) {
      return false;
    }
    cryptNode.setAttribute("data-plaintext", options.plainText);
    return openCrypt(cryptNode, options, options.revert, !!editor.config.crypt.readOnly);
  }
  function revertOrOpen(revert, options, readOnly, range, dispatchEvent) {
    var cryptNode = null;
    if (options.id && options.rev) {
      cryptNode = getNodeFromCryptInfo(options);
    } else {
      if (range) {
        var container = range.getContainerElement();
        cryptNode = goog.dom.classlist.contains(container, CRYPT_CLASS) ? container : container.querySelector("." + CRYPT_CLASS);
        if (cryptNode) {
          options.id = cryptNode.id;
          options.rev = cryptNode.getAttribute("data-rev");
        }
      }
    }
    if (!cryptNode) {
      return false;
    }
    if (!options.plainText) {
      options.plainText = cryptNode.getAttribute("data-plaintext");
    }
    if (options.plainText) {
      if (!revert) {
        openCrypt(cryptNode, options, false, readOnly);
      } else {
        openCrypt(cryptNode, options, true);
      }
    } else {
      var cryptInfo = uno.util.crypto.getCryptInfoFromNode(cryptNode);
      if (revert) {
        cryptInfo.revert = true;
      }
      dispatchEvent({type:"encrypt", cryptInfo:cryptInfo});
    }
    return cryptNode;
  }
  function closeCrypt(options) {
    var cryptNode = null;
    if (options.id) {
      cryptNode = getNodeFromCryptInfo(options, {decryptedOnly:true, ignoreRev:true});
    }
    if (!cryptNode) {
      return false;
    }
    uno.util.crypto.updateRevision(cryptNode);
    var cryptInfo = uno.util.crypto.getCryptInfoFromNode(cryptNode);
    var placeholder = uno.util.crypto.createCryptoPlaceholder(cryptInfo);
    return replaceNodeAndKeepSelection(cryptNode, placeholder);
  }
  function updateAllRevisions() {
    var cryptElements = document.querySelectorAll("." + CRYPT_CLASS);
    Array.prototype.forEach.call(cryptElements, function(node) {
      uno.util.crypto.updateRevision(node);
    });
  }
  function createPlainTextPlaceholder(cryptInfo, plainText, readOnly) {
    var attrs = {"class":CRYPT_CLASS + " " + CRYPT_VISIBLE_CLASS + " " + EDITOR_CONTAINER_CLASS, id:cryptInfo.id, "data-rev":cryptInfo.rev, "data-plaintext":cryptInfo.plainText, "data-length":cryptInfo.length, "data-cipher":cryptInfo.cipher, "data-hint":cryptInfo.hint, "data-ciphertext":cryptInfo.cipherText};
    var placeholder = goog.dom.createDom("span", attrs);
    placeholder.innerHTML = plainText;
    if (readOnly) {
      placeholder.setAttribute("contentEditable", false);
    }
    return placeholder;
  }
  function openCrypt(cryptNode, cryptInfo, openPermanently, readOnly) {
    var placeholder = null;
    if (openPermanently) {
      placeholder = document.createElement("span");
      placeholder.innerHTML = cryptInfo.plainText;
    } else {
      placeholder = createPlainTextPlaceholder(cryptInfo, cryptInfo.plainText, readOnly);
    }
    if (!placeholder) {
      return null;
    }
    return replaceNodeAndKeepSelection(cryptNode, placeholder);
  }
  function getCryptNodeFromRange(range) {
    var container = document.createElement("div");
    container.innerHTML = range.getValidHtml();
    return container.querySelector("." + CRYPT_CLASS);
  }
  function getNodeFromCryptInfo(cryptInfo, options) {
    var selector = "#" + cryptInfo.id;
    if (options && options.encryptedOnly) {
      selector += ":not(." + CRYPT_VISIBLE_CLASS + ")";
    }
    if (options && options.decryptedOnly) {
      selector += "." + CRYPT_VISIBLE_CLASS;
    }
    if (!options || options && !options.ignoreRev) {
      selector += "[data-rev=" + cryptInfo.rev + "]";
    }
    return document.querySelector(selector);
  }
  function replaceRangeWith(range, newNode, editor) {
    range.insertNode(newNode);
    range.select();
    editor.execCommand("delete");
    var newRange = goog.editor.range.placeCursorNextTo(newNode);
    newRange.select();
    return newRange;
  }
  function replaceNodeAndKeepSelection(oldNode, newNode) {
    goog.dom.replaceNode(newNode, oldNode);
    var range = goog.editor.range.placeCursorNextTo(newNode);
    range.select();
  }
})();
goog.provide("uno.commands.Cut");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Cut");
  var Cut = uno.commands.Cut = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Cut, uno.BasePlugin);
  Cut.prototype.isSupportedCommand = function(command) {
    return command === "cut";
  };
  Cut.prototype.execCommandInternal = function() {
  };
  Cut.prototype.queryCommandValue = function() {
    var result = this.editor.queryCommandValue("copy");
    this.editor.execCommand("delete");
    return result;
  };
})();
goog.provide("uno.commands.Delete");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("uno.BasePlugin");
goog.require("uno.util.dom");
(function() {
  var util = uno.util;
  var log = goog.debug.Logger.getLogger("uno.commands.Delete");
  var Delete = uno.commands.Delete = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Delete, uno.BasePlugin);
  Delete.WORD = "word";
  Delete.prototype.isSupportedCommand = function(command) {
    return command === "delete";
  };
  Delete.prototype.queryCommandValue = function(command) {
    return document.queryCommandValue(command);
  };
  Delete.prototype.execCommandInternal = function(command, value, options) {
    var range = this.editor.getRange();
    if (!range) {
      return false;
    }
    if (this.editor.field.childNodes.length === 0) {
      return false;
    }
    var node = range.getFocusNode();
    var offset = range.getFocusOffset();
    var forward = options ? options.forward : false;
    var native = options ? options["native"] : false;
    switch(value) {
      case Delete.WORD:
        var wordRange = getWordRange(range, offset, forward);
        selectRange(wordRange);
        deleteSelection(forward);
        break;
      default:
        var count = parseInt(value, 10);
        var result;
        count = isNaN(count) ? 1 : count;
        for (var i = 0;i < count;i++) {
          var currentNode = node.childNodes && node.childNodes[offset - 1];
          if (isAtBeginningOfCell(node, offset) && range.isCollapsed()) {
            result = true;
          } else {
            if (isCursorAfterTable(node, offset) && range.isCollapsed()) {
              result = selectTableBeforeNode(node);
            } else {
              if (isCursorOnTable(node, currentNode)) {
                result = deleteTable(currentNode);
              } else {
                if (isLastIndentation(node, offset)) {
                  result = deleteIndentation(node);
                } else {
                  if (isEditorDefaultEmpty(this.editor)) {
                    result = true;
                  } else {
                    if (isEmptyParagraph(node) && range.isCollapsed()) {
                      result = removeParagraph(node);
                    } else {
                      if (isAfterResource(node, offset, forward)) {
                        result = removeResource(node, range.isCollapsed());
                      }
                    }
                  }
                }
              }
            }
          }
          if (typeof result !== "undefined") {
            return result;
          } else {
            if (native) {
              return false;
            }
          }
          deleteSelection(forward);
        }
      ;
    }
    return true;
  };
  function isEditorDefaultEmpty(editor) {
    return editor.field.innerHTML === editor.config.defaults.html;
  }
  function removeParagraph(node) {
    var previousSibling = node.previousSibling;
    util.paragraph.remove(node);
    if (previousSibling) {
      goog.editor.range.placeCursorNextTo(previousSibling.lastChild || previousSibling);
    }
    return true;
  }
  function deleteSelection(forward) {
    var commandName = forward ? "forwarddelete" : "delete";
    return document.execCommand(commandName);
  }
  function selectRange(range) {
    var currentSelection = window.getSelection();
    currentSelection.removeAllRanges();
    currentSelection.addRange(range.getBrowserRangeObject());
  }
  function getWordRange(currentRange, offset, forward) {
    var wordRange = currentRange;
    var wordNode = currentRange.getContainer();
    if (offset && wordNode && wordNode.nodeType === Node.TEXT_NODE) {
      var found = false;
      var index = 0;
      wordNode.nodeValue.split(" ").forEach(function(word, i, arr) {
        var oldIndex = index;
        index += word.length;
        if (i < arr.length - 1) {
          index++;
        }
        if (!found) {
          if (forward && (offset === oldIndex || offset === oldIndex - 1)) {
            found = true;
          } else {
            if (!forward && (offset === index || offset === index - 1)) {
              found = true;
            } else {
              if (offset > oldIndex && offset < index) {
                found = true;
              }
            }
          }
          if (found) {
            wordRange = goog.dom.Range.createFromNodes(wordNode, oldIndex, wordNode, index);
          }
        }
      });
    }
    return wordRange;
  }
  function isCursorOnTable(node, currentNode) {
    return node.nodeType === Node.ELEMENT_NODE && util.dom.isTable(currentNode);
  }
  function isEmptyParagraph(node) {
    return node === util.paragraph["for"](node) && !util.paragraph.hasContent(node);
  }
  function isLastIndentation(node, offset) {
    if (offset) {
      return false;
    }
    if (node.nodeType === Node.ELEMENT_NODE && (util.dom.isLi(node) || util.dom.isBlockquote(node))) {
      return true;
    } else {
      if (node.nodeType === Node.TEXT_NODE && (util.dom.isLi(node.parentNode) || util.dom.isBlockquote(node.parentNode))) {
        return true;
      }
    }
    return false;
  }
  function isAtBeginningOfCell(node, offset) {
    var paragraph = uno.util.paragraph["for"](node);
    var cell = goog.dom.getAncestor(node, function(ancestor) {
      return uno.util.dom.isTd(ancestor);
    }, true);
    if (offset === 0) {
      if (uno.util.dom.isTd(paragraph) && uno.util.dom.isTd(cell)) {
        return true;
      }
      if (cell && cell.childNodes && cell.childNodes[0] === paragraph) {
        return true;
      }
    }
    return false;
  }
  function isCursorAfterTable(node, offset) {
    if (offset > 0) {
      return false;
    }
    return getRangeOfTableBeforeNode(node);
  }
  function isAfterResource(node, offset, forward) {
    if (node.nodeType === Node.TEXT_NODE) {
      if (forward && (node.length === offset || node.textContent === "\u200b")) {
        node = node.nextSibling;
      } else {
        if (offset === 0 || node.textContent === "\u200b") {
          node = node.previousSibling;
        }
      }
    }
    if (node && node.nodeType === Node.ELEMENT_NODE && node.tagName.toLowerCase() === "en-media") {
      return true;
    }
    return false;
  }
  function getRangeOfTableBeforeNode(node) {
    var previousParagraph;
    var currentParagraph = util.paragraph["for"](node);
    if (!currentParagraph) {
      return false;
    }
    while (!previousParagraph) {
      previousParagraph = util.paragraph.prevParagraph(currentParagraph);
      if (previousParagraph && !util.dom.isEnnote(previousParagraph)) {
        break;
      } else {
        if (util.dom.isEnnote(previousParagraph)) {
          previousParagraph = null;
          break;
        } else {
          currentParagraph = currentParagraph.parentNode;
        }
      }
    }
    if (previousParagraph) {
      var table = previousParagraph.querySelector("table") || util.dom.isTable(previousParagraph);
      if (table) {
        var tableRange = goog.dom.Range.createFromNodes(table, 0, table, table.childNodes.length);
        return tableRange;
      }
    }
    return false;
  }
  function selectTableBeforeNode(node) {
    var range = getRangeOfTableBeforeNode(node);
    if (range) {
      range.select();
      return true;
    }
    return false;
  }
  function deleteTable(node, forward) {
    var tableRange = goog.dom.Range.createFromNodeContents(node);
    var selection = window.getSelection();
    var currentRange = goog.dom.Range.createFromBrowserSelection(selection);
    var selectedNode = currentRange.getFocusNode();
    var selectedOffset = currentRange.getFocusOffset();
    if (selectedNode && selectedOffset && !currentRange.isCollapsed()) {
      var selectedElement = selectedNode.childNodes[selectedOffset - 1];
      if (selectedElement === node) {
        deleteSelection(forward);
        return true;
      }
    } else {
      tableRange.select();
      return true;
    }
    return false;
  }
  function removeResource(node, isCursorCollapsed, forward) {
    var enMedia = node;
    if (node.nodeType === Node.TEXT_NODE) {
      var sibling = forward ? node.nextSibling : node.previousSibling;
      if (sibling && sibling.tagName && sibling.tagName.toLowerCase() === "en-media") {
        enMedia = sibling;
      }
    }
    var previousSibling = enMedia.previousSibling;
    var nextSibling = enMedia.nextSibling;
    var startNode = enMedia.parentNode;
    var startOffset = util.dom.index(enMedia);
    if (previousSibling && previousSibling.textContent === "\u200b") {
      startNode = previousSibling;
      startOffset = 0;
    }
    var endNode = enMedia.parentNode;
    var endOffset = util.dom.index(enMedia) + 1;
    if (nextSibling && nextSibling.textContent === "\u200b") {
      endNode = nextSibling;
      endOffset = 1;
    }
    var range = goog.dom.Range.createFromNodes(startNode, startOffset, endNode, endOffset);
    if (isCursorCollapsed) {
      range.select();
    } else {
      deleteSelection(forward);
    }
    return true;
  }
  function deleteIndentation(element, forward) {
    var node = element.nodeType === Node.TEXT_NODE ? element.parentNode : element;
    var parent = node.parentNode;
    if (util.dom.isBlockquote(parent) || util.dom.isUl(parent) || util.dom.isOl(parent)) {
      var tagName = node.tagName.toLowerCase();
      var lis = parent.querySelectorAll(tagName);
      if (lis.length && lis[0] === node) {
        var grandParent = parent.parentNode;
        var line;
        var isParentAList = tagName === "li" && util.dom.isUl(grandParent) || util.dom.isOl(grandParent);
        var isParentABlockquote = tagName === "blockquote" && util.dom.isBlockquote(grandParent);
        if (grandParent && isParentAList || isParentABlockquote) {
          line = node;
        } else {
          line = document.createElement("div");
          line.innerHTML = node.innerHTML || "<br>";
        }
        if (lis.length === 0) {
          goog.dom.replaceNode(line, parent);
        } else {
          goog.dom.removeNode(node);
          grandParent.insertBefore(line, parent);
        }
        var range = goog.dom.Range.createFromNodes(line, 0, line, 0);
        range.select();
        return true;
      }
    }
    return deleteSelection(forward);
  }
})();
goog.provide("uno.commands.DeleteTable");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.editor.plugins.TableEditor");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.DeleteTable");
  var DeleteTable = uno.commands.DeleteTable = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(DeleteTable, uno.BasePlugin);
  DeleteTable.prototype.isSupportedCommand = function(command) {
    return command === "deletetable";
  };
  DeleteTable.prototype.execCommandInternal = function(command) {
    this.editor.execCommand(goog.editor.plugins.TableEditor.COMMAND.REMOVE_TABLE);
  };
  DeleteTable.prototype.queryCommandValue = function(command) {
  };
})();
goog.provide("uno.commands.DeleteTableCol");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.editor.plugins.TableEditor");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.DeleteTableCol");
  var DeleteTableCol = uno.commands.DeleteTableCol = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(DeleteTableCol, uno.BasePlugin);
  DeleteTableCol.prototype.isSupportedCommand = function(command) {
    return command === "deletetablecol";
  };
  DeleteTableCol.prototype.execCommandInternal = function(command) {
    this.editor.execCommand(goog.editor.plugins.TableEditor.COMMAND.REMOVE_COLUMNS);
  };
  DeleteTableCol.prototype.queryCommandValue = function(command) {
  };
})();
goog.provide("uno.commands.DeleteTableRow");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.editor.plugins.TableEditor");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.DeleteTableRow");
  var DeleteTableRow = uno.commands.DeleteTableRow = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(DeleteTableRow, uno.BasePlugin);
  DeleteTableRow.prototype.isSupportedCommand = function(command) {
    return command === "deletetablerow";
  };
  DeleteTableRow.prototype.execCommandInternal = function(command) {
    this.editor.execCommand(goog.editor.plugins.TableEditor.COMMAND.REMOVE_ROWS);
  };
  DeleteTableRow.prototype.queryCommandValue = function(command) {
  };
})();
goog.provide("uno.commands.searchapi");
(function() {
  var searchapi = uno.commands.searchapi;
  var DIACRITIC_CHARS = {a:"a\u24d0\uff41\u1e9a\u00e0\u00e1\u00e2\u1ea7\u1ea5\u1eab\u1ea9\u00e3\u0101\u0103\u1eb1\u1eaf\u1eb5\u1eb3\u0227\u01e1\u00e4\u01df\u1ea3\u00e5\u01fb\u01ce\u0201\u0203\u1ea1\u1ead\u1eb7\u1e01\u0105\u2c65\u0250", b:"b\u24d1\uff42\u1e03\u1e05\u1e07\u0180\u0183\u0253", c:"c\u24d2\uff43\u0107\u0109\u010b\u010d\u00e7\u1e09\u0188\u023c\ua73f\u2184", d:"d\u24d3\uff44\u1e0b\u010f\u1e0d\u1e11\u1e13\u1e0f\u0111\u018c\u0256\u0257\ua77a", e:"e\u24d4\uff45\u00e8\u00e9\u00ea\u1ec1\u1ebf\u1ec5\u1ec3\u1ebd\u0113\u1e15\u1e17\u0115\u0117\u00eb\u1ebb\u011b\u0205\u0207\u1eb9\u1ec7\u0229\u1e1d\u0119\u1e19\u1e1b\u0247\u025b\u01dd", 
  f:"f\u24d5\uff46\u1e1f\u0192\ua77c", g:"g\u24d6\uff47\u01f5\u011d\u1e21\u011f\u0121\u01e7\u0123\u01e5\u0260\ua7a1\u1d79\ua77f", h:"h\u24d7\uff48\u0125\u1e23\u1e27\u021f\u1e25\u1e29\u1e2b\u1e96\u0127\u2c68\u2c76\u0265", i:"i\u24d8\uff49\u00ec\u00ed\u00ee\u0129\u012b\u012d\u00ef\u1e2f\u1ec9\u01d0\u0209\u020b\u1ecb\u012f\u1e2d\u0268\u0131", j:"j\u24d9\uff4a\u0135\u01f0\u0249", k:"k\u24da\uff4b\u1e31\u01e9\u1e33\u0137\u1e35\u0199\u2c6a\ua741\ua743\ua745\ua7a3", l:"l\u24db\uff4c\u0140\u013a\u013e\u1e37\u1e39\u013c\u1e3d\u1e3b\u017f\u0142\u019a\u026b\u2c61\ua749\ua781\ua747", 
  m:"m\u24dc\uff4d\u1e3f\u1e41\u1e43\u0271\u026f", n:"n\u24dd\uff4e\u01f9\u0144\u00f1\u1e45\u0148\u1e47\u0146\u1e4b\u1e49\u019e\u0272\u0149\ua791\ua7a5", o:"o\u24de\uff4f\u00f2\u00f3\u00f4\u1ed3\u1ed1\u1ed7\u1ed5\u00f5\u1e4d\u022d\u1e4f\u014d\u1e51\u1e53\u014f\u022f\u0231\u00f6\u022b\u1ecf\u0151\u01d2\u020d\u020f\u01a1\u1edd\u1edb\u1ee1\u1edf\u1ee3\u1ecd\u1ed9\u01eb\u01ed\u00f8\u01ff\u0254\ua74b\ua74d\u0275", p:"p\u24df\uff50\u1e55\u1e57\u01a5\u1d7d\ua751\ua753\ua755", q:"q\u24e0\uff51\u024b\ua757\ua759", 
  r:"r\u24e1\uff52\u0155\u1e59\u0159\u0211\u0213\u1e5b\u1e5d\u0157\u1e5f\u024d\u027d\ua75b\ua7a7\ua783", s:"s\u24e2\uff53\u00df\u015b\u1e65\u015d\u1e61\u0161\u1e67\u1e63\u1e69\u0219\u015f\u023f\ua7a9\ua785\u1e9b", t:"t\u24e3\uff54\u1e6b\u1e97\u0165\u1e6d\u021b\u0163\u1e71\u1e6f\u0167\u01ad\u0288\u2c66\ua787", u:"u\u24e4\uff55\u00f9\u00fa\u00fb\u0169\u1e79\u016b\u1e7b\u016d\u00fc\u01dc\u01d8\u01d6\u01da\u1ee7\u016f\u0171\u01d4\u0215\u0217\u01b0\u1eeb\u1ee9\u1eef\u1eed\u1ef1\u1ee5\u1e73\u0173\u1e77\u1e75\u0289", 
  v:"v\u24e5\uff56\u1e7d\u1e7f\u028b\ua75f\u028c", w:"w\u24e6\uff57\u1e81\u1e83\u0175\u1e87\u1e85\u1e98\u1e89\u2c73", x:"x\u24e7\uff58\u1e8b\u1e8d", y:"y\u24e8\uff59\u1ef3\u00fd\u0177\u1ef9\u0233\u1e8f\u00ff\u1ef7\u1e99\u1ef5\u01b4\u024f\u1eff", z:"z\u24e9\uff5a\u017a\u1e91\u017c\u017e\u1e93\u1e95\u01b6\u0225\u0240\u2c6c\ua763"};
  var DIACRITICMAP = {};
  for (var s in DIACRITIC_CHARS) {
    if (DIACRITIC_CHARS.hasOwnProperty(s)) {
      var characters = DIACRITIC_CHARS[s];
      DIACRITICMAP[s] = "[" + s + characters + "]";
      for (var i = 0;i < characters.length;i++) {
        var letter = characters[i];
        if (!DIACRITICMAP[letter]) {
          DIACRITICMAP[letter] = DIACRITICMAP[s];
        }
      }
    }
  }
  var UNICODE_CJK_RANGES = "\u1100-\u11ff\u2e80-\u312f\u3130-\u31bf\u31f0-\u9fff\ua960-\ua97f\uac00-\ud7ff\uf900-\ufaff\ufe30-\ufe4f\uff61-\uffdc";
  var UNICODE_LETTER_CATEGORY_RANGES = "A-Za-z\u00aa\u00b5\u00ba\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0-\u08b4\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16f1-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2183\u2184\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005\u3006\u3031-\u3035\u303b\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fd5\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6e5\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ad\ua7b0-\ua7b7\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab65\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
  var UNICODE_MARK_CATEGORY_RANGES = "\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065f\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0c00-\u0c03\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d01-\u0d03\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f\u109a-\u109d\u135d-\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u192b\u1930-\u193b\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f\u1ab0-\u1abe\u1b00-\u1b04\u1b34-\u1b44\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1be6-\u1bf3\u1c24-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf2-\u1cf4\u1cf8\u1cf9\u1dc0-\u1df5\u1dfc-\u1dff\u20d0-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9e5\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f";
  var UNICODE_DECIMAL_DIGIT_CATEGORY_RANGES = "0-9\u0660-\u0669\u06f0-\u06f9\u07c0-\u07c9\u0966-\u096f\u09e6-\u09ef\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0be6-\u0bef\u0c66-\u0c6f\u0ce6-\u0cef\u0d66-\u0d6f\u0de6-\u0def\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f29\u1040-\u1049\u1090-\u1099\u17e0-\u17e9\u1810-\u1819\u1946-\u194f\u19d0-\u19d9\u1a80-\u1a89\u1a90-\u1a99\u1b50-\u1b59\u1bb0-\u1bb9\u1c40-\u1c49\u1c50-\u1c59\ua620-\ua629\ua8d0-\ua8d9\ua900-\ua909\ua9d0-\ua9d9\ua9f0-\ua9f9\uaa50-\uaa59\uabf0-\uabf9\uff10-\uff19";
  var UNICODE_ALPHANUM_RANGES = UNICODE_LETTER_CATEGORY_RANGES + UNICODE_MARK_CATEGORY_RANGES + UNICODE_DECIMAL_DIGIT_CATEGORY_RANGES;
  var UNDERSCORE_RANGES = "_\uff3f";
  var EN_CJK_ALPHANUM_CHARSET = "(?=[" + UNICODE_LETTER_CATEGORY_RANGES + UNICODE_MARK_CATEGORY_RANGES + UNICODE_DECIMAL_DIGIT_CATEGORY_RANGES + "])[" + UNICODE_CJK_RANGES + "]";
  var EN_CJK_ALPHANUM_REGEX = RegExp(EN_CJK_ALPHANUM_CHARSET);
  var EN_WORD_BOUNDARY_CHARSET = "(?:[^" + UNICODE_LETTER_CATEGORY_RANGES + UNICODE_MARK_CATEGORY_RANGES + UNICODE_DECIMAL_DIGIT_CATEGORY_RANGES + "]|[" + UNICODE_CJK_RANGES + "])";
  var STARTSWITH_EN_WORD_BOUNDARY_REGEX = RegExp("^" + EN_WORD_BOUNDARY_CHARSET);
  var ENDSWITH_EN_WORD_BOUNDARY_REGEX = RegExp(EN_WORD_BOUNDARY_CHARSET + "$");
  var EN_WORD_DELIMITER_CHARSET = "[^" + UNICODE_ALPHANUM_RANGES + UNDERSCORE_RANGES + "]";
  var EN_WORD_DELIMITER_REGEX = RegExp(EN_WORD_DELIMITER_CHARSET);
  var ONE_OR_MORE_EN_WORD_DELIMITER_PATTERN = EN_WORD_DELIMITER_CHARSET + "+";
  var ZERO_OR_MORE_EN_WORD_DELIMITER_PATTERN = EN_WORD_DELIMITER_CHARSET + "*";
  var EN_STOPWORDS = ["a", "an", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"];
  var EN_STOPWORDS_REGEX = RegExp("^(" + EN_STOPWORDS.join("|") + ")$", "i");
  searchapi.getNoteSearchRegex = function(rawSearchTerm) {
    var searchTerm = rawSearchTerm.trim();
    var prefixMatch = /\*$/.test(searchTerm);
    searchTerm = prefixMatch ? searchTerm.substring(0, searchTerm.length - 1) : searchTerm;
    if (searchTerm.length <= 0) {
      return null;
    }
    if (EN_STOPWORDS_REGEX.test(searchTerm)) {
      return null;
    }
    var pattern = searchTerm;
    var newValue = [];
    var prevCharDelimeter = false;
    var prevCharCJK = false;
    for (var s = 0;s < pattern.length;s++) {
      var character = pattern[s];
      if (isCharCJKAlphanum(character)) {
        if (prevCharCJK) {
          newValue.push(ZERO_OR_MORE_EN_WORD_DELIMITER_PATTERN);
        }
        newValue.push(character);
        prevCharDelimeter = false;
        prevCharCJK = true;
      } else {
        if (isCharWordDelimiter(character)) {
          if (!prevCharDelimeter) {
            newValue.push(ONE_OR_MORE_EN_WORD_DELIMITER_PATTERN);
          }
          prevCharDelimeter = true;
          prevCharCJK = false;
        } else {
          if (prevCharCJK) {
            newValue.push(ZERO_OR_MORE_EN_WORD_DELIMITER_PATTERN);
          }
          var item = DIACRITICMAP[character.toLowerCase()];
          if (item) {
            newValue.push(item);
          } else {
            newValue.push(character);
          }
          prevCharDelimeter = false;
          prevCharCJK = false;
        }
      }
    }
    pattern = newValue.join("");
    pattern = pattern.replace(/\s/g, "\\s");
    pattern = "(" + pattern + ")";
    var groupIdxForHighlight = 1;
    if (!startsWithWordBoundary(searchTerm)) {
      pattern = "(^|" + EN_WORD_BOUNDARY_CHARSET + ")" + pattern;
      groupIdxForHighlight++;
    }
    if (!prefixMatch && !endsWithWordBoundary(searchTerm)) {
      pattern = pattern + "(?:" + EN_WORD_BOUNDARY_CHARSET + "|$)";
    }
    return {regex:new RegExp(pattern, "gi"), getTextRange:function(m) {
      var startIdx = m.index;
      var endIdx = startIdx;
      for (var idx = 1;idx <= groupIdxForHighlight;idx++) {
        startIdx = endIdx;
        endIdx = startIdx + m[idx].length;
      }
      return {start:startIdx, end:endIdx};
    }};
  };
  searchapi.getFindInNoteRegex = function(searchTerm) {
    var pattern = [searchTerm].map(function(word) {
      if (word instanceof RegExp) {
        return word.source;
      }
      return word.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
    });
    return {regex:new RegExp(pattern, "gi"), getTextRange:function(m, regex) {
      return {start:m.index, end:regex.lastIndex};
    }};
  };
  var isCharCJKAlphanum = function(character) {
    return EN_CJK_ALPHANUM_REGEX.test(character);
  };
  var isCharWordDelimiter = function(character) {
    return EN_WORD_DELIMITER_REGEX.test(character);
  };
  var startsWithWordBoundary = function(sentence) {
    return STARTSWITH_EN_WORD_BOUNDARY_REGEX.test(sentence);
  };
  var endsWithWordBoundary = function(sentence) {
    return ENDSWITH_EN_WORD_BOUNDARY_REGEX.test(sentence);
  };
})();
goog.provide("uno.util.range");
goog.require("goog.debug.Logger");
goog.require("goog.editor.range");
goog.require("uno.util.dom");
(function() {
  var util = uno.util;
  var log = goog.debug.Logger.getLogger("uno.util.range");
  util.range.atBeginningOfDiv = function(range) {
    if (range && range.getStartNode() && util.dom.compareTagName(range.getStartNode(), "div") && range.isCollapsed()) {
      if (range.getStartOffset() === 0) {
        return true;
      }
      var currentChild = null;
      for (var i = 0;i < range.getStartOffset();i++) {
        currentChild = range.getStartNode().childNodes[i];
        if (currentChild.nodeType !== Node.TEXT_NODE || currentChild.textContent.length !== 0) {
          return false;
        }
      }
      return true;
    }
    return false;
  };
  util.range.selectNode = function(node) {
    var range = goog.dom.Range.createFromNodeContents(node);
    range.select();
  };
  util.range.getBoundingBoxesFromRange = function(rangeObject) {
    if (!rangeObject) {
      return null;
    }
    var boxes = rangeObject.getClientRects();
    if (!boxes || !boxes.length) {
      return null;
    }
    var lastBox = null;
    var matches = [];
    for (var i = 0;i < boxes.length;i++) {
      var match = {};
      var box = boxes[i];
      if (box.width <= 1 || box.height <= 1 || lastBox && box.left >= lastBox.left && box.top >= lastBox.top && box.right <= lastBox.right && box.bottom <= lastBox.bottom) {
        continue;
      }
      lastBox = box;
      match.top = lastBox.top;
      match.bottom = lastBox.bottom;
      match.left = lastBox.left;
      match.right = lastBox.right;
      match.width = lastBox.right - lastBox.left;
      match.height = lastBox.bottom - lastBox.top;
      var prev = matches.length - 1;
      if (prev > -1 && matches[prev].left <= match.right && match.left <= matches[prev].right && matches[prev].top <= match.bottom && match.top <= matches[prev].bottom) {
        var newMatch = {};
        newMatch.top = Math.max(matches[prev].top, match.top);
        newMatch.bottom = Math.min(matches[prev].bottom, match.bottom);
        newMatch.left = matches[prev].left;
        newMatch.right = match.right;
        newMatch.width = newMatch.right - newMatch.left;
        newMatch.height = newMatch.bottom - newMatch.top;
        matches[prev] = newMatch;
      } else {
        matches.push(match);
      }
    }
    return matches;
  };
  function scrollRectIntoView(rect, placeOnTop, margin) {
    var top = document.body.scrollTop + rect.top;
    margin = margin || 0;
    if (placeOnTop === true) {
      top = Math.max(0, top - margin);
    } else {
      top = top - window.innerHeight + rect.height + margin;
    }
    document.body.scrollTop = top;
  }
  function unionOfClientRects(rects) {
    if (rects == null || rects.length < 1) {
      return null;
    }
    var firstRect = rects[0];
    var rect = {top:firstRect.top, left:firstRect.left, right:firstRect.right, bottom:firstRect.bottom};
    for (var i = 1;i < rects.length;i++) {
      var currentRect = rects[i];
      if (currentRect.width > 0 && currentRect.height > 0) {
        rect = {top:Math.min(rect.top, currentRect.top), left:Math.min(rect.left, currentRect.left), right:Math.max(rect.right, currentRect.right), bottom:Math.max(rect.bottom, currentRect.bottom)};
      }
    }
    rect.width = rect.right - rect.left;
    rect.height = rect.bottom - rect.top;
    return rect;
  }
  util.range.scrollSelectionIntoView = function(editor) {
    var range = editor.getRange();
    if (range) {
      var rect = unionOfClientRects(range.getBrowserRangeObject().getClientRects());
      if (!rect) {
        var node = range.getFocusNode();
        rect = unionOfClientRects(node.getClientRects());
      }
      if (rect) {
        var margin = 20;
        if (rect.top > 0 && window.innerHeight - rect.top < rect.height) {
          scrollRectIntoView(rect, false, 4);
        } else {
          if (rect.top < -(rect.height + margin + 45)) {
            scrollRectIntoView(rect, true);
          }
        }
      } else {
        if (!util.paragraph.hasContent(editor.field)) {
          editor.field.scrollIntoView();
        }
      }
    }
  };
  util.range.commonAncestors = function(range, opt_selector, opt_root) {
    var startNode = range.getStartNode();
    var endNode = range.getEndNode();
    var getNonTextOrSelectorParent = function(node) {
      if (opt_selector) {
        var selectorNode = util.dom.parent(node, opt_selector, opt_root);
        if (selectorNode !== null) {
          return selectorNode;
        }
      }
      while (util.dom.isTextNode(node)) {
        node = node.parentNode;
      }
      return node;
    };
    startNode = getNonTextOrSelectorParent(startNode);
    endNode = getNonTextOrSelectorParent(endNode);
    if (startNode === endNode) {
      return [startNode, endNode];
    }
    var startParents = util.dom.ancestors(startNode);
    var endParents = util.dom.ancestors(endNode);
    if (startParents[0] !== endParents[0]) {
      return [startNode, endNode];
    }
    var i = 0;
    for (;i < startParents.length && i < endParents.length;i++) {
      if (startParents[i] !== endParents[i]) {
        break;
      }
    }
    var result = [startNode, endNode];
    if (i < startParents.length) {
      result[0] = startParents[i];
    }
    if (i < endParents.length) {
      result[1] = endParents[i];
    }
    return result;
  };
})();
goog.provide("uno.commands.Find");
goog.require("uno.commands.searchapi");
goog.require("goog.functions");
goog.require("goog.object");
goog.require("goog.debug.Logger");
goog.require("goog.iter");
goog.require("uno.BasePlugin");
goog.require("uno.util.dom");
goog.require("uno.util.range");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Find");
  var util = uno.util;
  var Find = uno.commands.Find = function() {
    uno.BasePlugin.call(this, log.getName());
    this.current = {hasMore:false, matches:[], index:-1, term:null, regex:null};
  };
  goog.inherits(Find, uno.BasePlugin);
  Find.NEXT = "next";
  Find.PREV = "prev";
  Find.FIRST = "first";
  Find.LAST = "last";
  Find.ALL = "all";
  Find.CLEAR = "clear";
  Find.prototype.isSupportedCommand = function(command) {
    return command === "find";
  };
  Find.prototype.activeOnUneditableFields = goog.functions.TRUE;
  Find.prototype.execCommand = function(command, action, rawOptions) {
    this.options = mergeOptions(this.editor.config.find, rawOptions || this.options);
    var options = this.options;
    var current = this.current;
    var newIndex = -1;
    if (action === Find.NEXT) {
      newIndex = getNewIndex(current.index + 1, current.matches);
    } else {
      if (action === Find.PREV) {
        newIndex = getNewIndex(current.index - 1, current.matches);
      } else {
        if (action === Find.FIRST) {
          newIndex = getNewIndex(0, current.matches);
        } else {
          if (action === Find.LAST) {
            newIndex = getNewIndex(-1, current.matches);
          } else {
            if (action === Find.CLEAR) {
              current.term = null;
              current.regex = null;
              current.index = -1;
              current.hasMore = false;
              current.matches = [];
              if (options.highlight === Find.ALL) {
                this.editor.execCommand("accentuate", {clearFirst:true});
              }
              return true;
            } else {
              var index = parseInt(action, 10);
              if (!isNaN(index)) {
                newIndex = getNewIndex(index, current.matches);
              }
            }
          }
        }
      }
    }
    current.index = newIndex;
    if (current.index > -1) {
      if (options.highlight === Find.ALL && current.matches) {
        this.editor.execCommand("accentuate", {boxes:current.matches, selectedBoxIndex:current.index, clearFirst:true});
      }
      return true;
    }
    return false;
  };
  Find.prototype.queryCommandValue = function(comnand, rawOptions) {
    this.options = mergeOptions(this.editor.config.find, rawOptions || this.options);
    var options = this.options;
    var current = this.current;
    var result = {limit:options.limit, hasMore:current.hasMore, count:current.matches.length, items:current.matches, index:current.index};
    if (options.value) {
      if (typeof options.value === "string" && options.value.length && options.limit) {
        var getNoteSearchRegex = uno.commands.searchapi.getNoteSearchRegex;
        var getFindInNoteRegex = uno.commands.searchapi.getFindInNoteRegex;
        var searchApi = options.noteSearchMatching ? getNoteSearchRegex(options.value) : getFindInNoteRegex(options.value);
        var searchElements = document.querySelectorAll(options.selector);
        var matches = [];
        var regexResult;
        Array.prototype.forEach.call(searchElements, function(searchElement) {
          var searchRange = goog.dom.Range.createFromNodeContents(searchElement);
          var textNodesArray = textNodesFor(searchRange);
          var rawText = textNodesArray.map(function(textNode) {
            return textNode.text;
          }).join(" ");
          while ((regexResult = searchApi.regex.exec(rawText)) && regexResult && matches.length < options.limit) {
            var textRange = searchApi.getTextRange(regexResult, searchApi.regex);
            searchApi.regex.lastIndex = textRange.end;
            var boundingBoxes = getBoundingBoxes(textNodesArray, textRange);
            if (boundingBoxes) {
              var scrollTop = document.body.scrollTop;
              if (isBoundingBoxOnScreen(boundingBoxes[0].top - scrollTop, boundingBoxes[0].bottom - scrollTop)) {
                current.index = matches.length;
              }
              matches.push(boundingBoxes);
            }
          }
        });
        current.hasMore = !!regexResult;
        current.matches = matches;
        current.term = options.value;
        current.regex = searchApi.regex;
        current.index = current.index > -1 ? current.index : 0;
      }
      result = {limit:options.limit, hasMore:current.hasMore, count:current.matches.length, items:current.matches, index:current.index};
    }
    if (options.excludeMatches) {
      delete result.items;
    }
    if (options.highlight === Find.ALL && current.matches) {
      this.editor.execCommand("accentuate", {boxes:current.matches, selectedBoxIndex:current.index, clearFirst:true});
    }
    return JSON.stringify(result);
  };
  function mergeOptions(configOptions, options) {
    var parsedOptions = {};
    var defaultOptions = {limit:100, excludeMatches:false, highlight:"none", selector:"en-note", noteSearchMatching:false};
    goog.object.extend(parsedOptions, defaultOptions || {});
    goog.object.extend(parsedOptions, configOptions || {});
    goog.object.extend(parsedOptions, options || {});
    parsedOptions.limit = isNaN(parsedOptions.limit) || parsedOptions.limit < 0 ? 100 : parseInt(parsedOptions.limit, 10);
    parsedOptions.selector = parsedOptions.selector && typeof parsedOptions.selector === "string" ? parsedOptions.selector : "en-note";
    return parsedOptions;
  }
  function getNewIndex(index, matches) {
    if (Array.isArray(matches) && matches.length > 0) {
      var newIndex = index;
      if (index >= matches.length) {
        newIndex = index - matches.length;
      } else {
        if (index < 0) {
          newIndex = index + matches.length;
        }
      }
      return Math.max(0, Math.min(matches.length - 1, newIndex));
    }
    return -1;
  }
  function textNodesFor(range) {
    var textNodesArray = [];
    var startIndex = 0;
    var isPrevCharBlock = false;
    goog.iter.forEach(range, function(node, notUsed, element) {
      if ((util.dom.isBlockNode(node) || util.dom.isBR(node)) && textNodesArray.length > 0) {
        if (!isPrevCharBlock && element.tagType === 1) {
          startIndex++;
          isPrevCharBlock = true;
        }
      } else {
        if (node.nodeType === Node.TEXT_NODE) {
          var wordOffsetInTextNode = 0;
          node.nodeValue.split(" ").forEach(function(text, i) {
            if (i > 0) {
              startIndex++;
              wordOffsetInTextNode++;
            } else {
              if (!isPrevCharBlock && textNodesArray.length) {
                startIndex++;
              }
            }
            var endIndex = startIndex + text.length;
            textNodesArray.push({wordOffsetInTextNode:wordOffsetInTextNode, node:node, text:text, startIndex:startIndex, endIndex:endIndex});
            startIndex = endIndex;
            wordOffsetInTextNode += text.length;
          });
          isPrevCharBlock = false;
        }
      }
    });
    return textNodesArray;
  }
  function getBoundingBoxes(textNodesArray, textRange) {
    var startNode = null;
    var endNode = null;
    var boundingBoxes = null;
    var searchedText = [];
    textNodesArray.some(function(textNode) {
      if (!startNode && textRange.start >= textNode.startIndex && textRange.start < textNode.endIndex) {
        startNode = textNode;
        searchedText.push(textNode.text);
      }
      if (startNode) {
        if (!endNode && textRange.end <= textNode.endIndex) {
          endNode = textNode;
        }
        if (startNode !== textNode) {
          searchedText.push(textNode.text);
        }
      }
      if (startNode && endNode) {
        var startOffset = startNode.wordOffsetInTextNode + textRange.start - startNode.startIndex;
        var endOffset = endNode.wordOffsetInTextNode + textRange.end - endNode.startIndex;
        var elementRange = goog.dom.Range.createFromNodes(startNode.node, startOffset, endNode.node, endOffset);
        boundingBoxes = util.range.getBoundingBoxesFromRange(elementRange.getBrowserRangeObject());
        if (boundingBoxes && boundingBoxes.length) {
          var match = {string:searchedText.join(" "), length:endNode.endIndex - startNode.startIndex, from:startNode.startIndex, to:endNode.endIndex};
          var adjustedScroll = document.body.scrollTop;
          boundingBoxes.forEach(function(boundingBox) {
            if (boundingBox) {
              boundingBox.top = adjustedScroll + boundingBox.top;
              boundingBox.string = match.string;
              boundingBox.length = match.length;
              boundingBox.from = match.from;
              boundingBox.to = match.to;
            }
          });
        }
        return true;
      }
      return false;
    });
    return boundingBoxes;
  }
  function isBoundingBoxOnScreen(boxTop, boxBottom, onScreenAmount) {
    var scrollTop = window.scrollY;
    var scrollBottom = scrollTop + window.innerHeight;
    onScreenAmount = onScreenAmount || 55;
    var elementTop = boxTop + scrollTop;
    var elementBottom = boxBottom + scrollTop;
    var commonTop = Math.max(scrollTop, elementTop);
    var commonBottom = Math.min(scrollBottom, elementBottom);
    var overlapPercent = Math.max(0, Math.round((commonBottom - commonTop) / (elementBottom - elementTop) * 100));
    return overlapPercent >= onScreenAmount;
  }
})();
goog.provide("uno.commands.Focus");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.range");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Focus");
  var util = uno.util;
  var Focus = uno.commands.Focus = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Focus, uno.BasePlugin);
  Focus.prototype.isSupportedCommand = function(command) {
    return command === "focus";
  };
  Focus.prototype.execCommand = function(command, value) {
    var opt = {force:false, pos:"top", scroll:false};
    goog.object.extend(opt, value || {});
    this.editor.enterEditMode(true);
    if (opt.force) {
      if (opt.pos === "top") {
        this.editor.placeCursorAtStart();
      } else {
        if (opt.pos === "bottom") {
          this.editor.placeCursorAtEnd();
        }
      }
    }
    if (opt.scroll) {
      util.range.scrollSelectionIntoView(this.editor);
    }
    return true;
  };
  Focus.prototype.queryCommandValue = function() {
    return this.editor.inEditMode();
  };
})();
goog.provide("uno.commands.FontSize");
goog.require("goog.array");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.editor.Command");
goog.require("goog.functions");
goog.require("goog.style");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.FontSize");
  var ZERO_WIDTH_SPACE = "\u200b";
  var ENDS_IN_PT_REGEX = /pt$/;
  var FontSize = uno.commands.FontSize = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(FontSize, uno.BasePlugin);
  FontSize.prototype.isSupportedCommand = function(command) {
    return command === "fontsize";
  };
  FontSize.prototype.activeOnUneditableFields = goog.functions.TRUE;
  FontSize.prototype.execCommandInternal = function(command, size) {
    var range = this.editor.getRange();
    if (goog.isString(size) && !isNaN(size) && !/pt$/.test(size)) {
      size += "pt";
    } else {
      if (typeof size === "number") {
        size += "pt";
      }
    }
    if (range && range.isCollapsed()) {
      this.setFontSizeCollapsed(size);
    } else {
      this.setFontSizeExpanded(size);
    }
  };
  FontSize.prototype.queryCommandValue = function(command, unit) {
    var range = this.editor.getRange();
    if (!range) {
      return "";
    }
    var startNode = range.getStartNode();
    var startEl = startNode.nodeType === goog.dom.NodeType.TEXT ? goog.dom.getParentElement(startNode) : startNode;
    var pxs = goog.style.getFontSize(startEl);
    var pts = pxsToPts(pxs);
    return pts.toString();
  };
  FontSize.prototype.setFontSizeCollapsed = function(size) {
    var dom = goog.dom;
    var range = this.editor.getRange();
    var container = range.getContainer();
    var parentFont = dom.getAncestorByTagNameAndClass(container, "font");
    var fontEl = dom.createDom("font", {style:"font-size:" + size}, ZERO_WIDTH_SPACE);
    if (parentFont) {
      dom.insertSiblingAfter(fontEl, parentFont);
    } else {
      range.insertNode(fontEl);
    }
    goog.dom.Range.createCaret(fontEl, 1).select();
  };
  FontSize.prototype.setFontSizeExpanded = function(size) {
    var range;
    var fontEls;
    this.editor.execCommand(goog.editor.Command.FONT_SIZE, 1);
    range = this.editor.getRange();
    fontEls = document.querySelectorAll("font[size]");
    goog.array.forEach(fontEls, function(fontEl) {
      if (range.containsNode(fontEl, true)) {
        fontEl.removeAttribute("size");
        fontEl.style.fontSize = size;
      }
    });
  };
  function pxsToPts(pxs) {
    var pts;
    if (!pxsToPts.ratio) {
      pxsToPts.div = goog.dom.createDom("div", {style:"position:absolute; bottom:-100pt; height:100pt;"});
      goog.dom.append(document.body, pxsToPts.div);
      pxsToPts.ratio = parseFloat(goog.style.getComputedStyle(pxsToPts.div, "height"));
      goog.dom.removeNode(pxsToPts.div);
    }
    pts = Math.round(pxs * 100 / pxsToPts.ratio);
    return pts;
  }
})();
goog.provide("uno.commands.ForwardDelete");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.ForwardDelete");
  var ForwardDelete = uno.commands.ForwardDelete = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(ForwardDelete, uno.BasePlugin);
  ForwardDelete.prototype.isSupportedCommand = function(command) {
    return command === "forwarddelete";
  };
  ForwardDelete.prototype.queryCommandValue = function(command) {
    return document.queryCommandValue(command);
  };
  ForwardDelete.prototype.execCommandInternal = function(command, value) {
    this.editor.execCommand("delete", value, {forward:true});
  };
})();
goog.provide("uno.commands.InsertCrypto");
goog.require("uno.util.crypto");
goog.require("goog.debug.Logger");
goog.require("goog.editor.range");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.InsertCrypto");
  var InsertCrypto = uno.commands.InsertCrypto = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(InsertCrypto, uno.BasePlugin);
  InsertCrypto.prototype.isSupportedCommand = function(command) {
    return command === "insertcrypto";
  };
  InsertCrypto.prototype.queryCommandValue = function() {
    var range = this.editor.getRange();
    if (!range || range.isCollapsed()) {
      return "";
    }
    var html = range.getValidHtml();
    return html;
  };
  InsertCrypto.prototype.execCommandInternal = function(command, value) {
    var range = this.editor.getRange();
    if (!range || !value) {
      return false;
    }
    var cryptElement = document.createElement("en-crypt");
    cryptElement.innerHTML = value;
    var cryptInfo = uno.util.crypto.getCryptInfoFromEmbed(cryptElement.firstChild.id);
    cryptElement.setAttribute("data-cipher", cryptInfo.cipher);
    cryptElement.setAttribute("data-ciphertext", cryptInfo.cipherText);
    cryptElement.setAttribute("data-hint", cryptInfo.hint);
    cryptElement.setAttribute("data-length", cryptInfo.length);
    range.replaceContentsWithNode(cryptElement);
    var newRange = goog.editor.range.placeCursorNextTo(cryptElement);
    newRange.select();
    return true;
  };
})();
goog.provide("uno.commands.InsertHtml");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.dom");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.InsertHtml");
  var util = uno.util;
  var InsertHtml = uno.commands.InsertHtml = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(InsertHtml, uno.BasePlugin);
  InsertHtml.prototype.isSupportedCommand = function(command) {
    return command === "inserthtml";
  };
  InsertHtml.prototype.execCommandInternal = function(command, html) {
    var range = this.editor.getRange();
    var frag = util.dom.fragFromString(html);
    range.replaceContentsWithNode(frag);
    this.editor.updateEmpty();
  };
  InsertHtml.prototype.queryCommandValue = function(command) {
  };
})();
goog.provide("uno.commands.InsertParagraph");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.dom");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.InsertParagraph");
  var util = uno.util;
  var InsertParagraph = uno.commands.InsertParagraph = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(InsertParagraph, uno.BasePlugin);
  InsertParagraph.prototype.isSupportedCommand = function(command) {
    return command === "insertparagraph";
  };
  InsertParagraph.prototype.execCommandInternal = function(command, html) {
    var range = this.editor.getRange();
    if (range == null) {
      return;
    }
    if (!range.isCollapsed()) {
      this.editor.execCommand("delete");
    }
    range = this.editor.getRange();
    var p = util.paragraph["for"](range.getStartNode());
    range = this.editor.getRange();
    var node = range.getStartNode();
    var offset = range.getStartOffset();
    if (node.nodeType === Node.TEXT_NODE && offset !== 0 && offset !== node.length) {
      node.splitText(offset);
    }
    var savedRange = range.saveUsingCarets();
    if (!goog.dom.contains(p, savedRange.getCaret(true))) {
      return false;
    }
    var newp = goog.editor.node.splitDomTreeAt(savedRange.getCaret(true), savedRange.getCaret(true), p);
    if (p.childNodes.length === 0 || !util.dom.compareTagName(goog.dom.getLastElementChild(p), "br")) {
      p.appendChild(document.createElement("br"));
    }
    if (newp.childNodes.length === 0 || !util.dom.compareTagName(goog.dom.getLastElementChild(newp), "br")) {
      newp.appendChild(document.createElement("br"));
    }
    goog.dom.insertSiblingAfter(newp, p);
    newp.normalize();
    savedRange.restore().select();
  };
})();
goog.provide("uno.util.table");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.editor.Table");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.table");
  var util = uno.util;
  util.table.createDomTable = function(dimensions, editor) {
    if (dimensions == null) {
      dimensions = {rows:2, columns:2};
    }
    var table = goog.editor.Table.createDomTable(document, dimensions.columns, dimensions.rows);
    util.table.initCellContent(table, editor.config.defaults.tableCellHtml);
    util.table.initStyles(table, editor);
    return table;
  };
  util.table.dimensions = function(table) {
    if (table == null || !util.dom.isHtmlElement(table) || table.tagName.toLowerCase() !== "table" || table.querySelector("table") != null) {
      return {"rows":-1, "columns":-1};
    }
    var rows = table.querySelectorAll("tr");
    if (rows.length <= 0) {
      return {"rows":0, "columns":0};
    }
    var cols = rows[0].querySelectorAll("td,th");
    return {"rows":rows.length, "columns":cols.length};
  };
  util.table["for"] = function(node) {
    if (node == null) {
      return;
    }
    var tableNode = util.dom.compareTagName(node, "table") ? node : goog.dom.getAncestorByTagNameAndClass(node, "table");
    return tableNode;
  };
  util.table.rowFor = function(node) {
    if (node == null) {
      return;
    }
    var tr = util.dom.compareTagName(node, "tr") ? node : goog.dom.getAncestorByTagNameAndClass(node, "tr");
    return tr;
  };
  util.table.cellFor = function(node) {
    if (node == null) {
      return;
    }
    var td = util.dom.compareTagName(node, "td") ? node : goog.dom.getAncestorByTagNameAndClass(node, "td");
    return td;
  };
  util.table.columns = function(tr) {
    return tr.querySelectorAll("th, td");
  };
  util.table.metrics = function(node) {
    var bounds = goog.style.getBounds(node);
    var padding = goog.style.getPaddingBox(node);
    var border = goog.style.getBorderBox(node);
    return {left:bounds.left, top:bounds.top, width:bounds.width, height:bounds.height, padding:padding, border:border};
  };
  util.table.prevRow = function(node) {
    var result;
    var tr = util.table.rowFor(node);
    if (tr != null) {
      result = goog.dom.getPreviousElementSibling(tr);
    }
    if (util.dom.compareTagName(result, "tr")) {
      return result;
    }
  };
  util.table.nextRow = function(node) {
    var result;
    var tr = util.table.rowFor(node);
    if (tr != null) {
      result = goog.dom.getNextElementSibling(tr);
    }
    if (util.dom.compareTagName(result, "tr")) {
      return result;
    }
  };
  util.table.prevCell = function(node, sameRow) {
    var result;
    var td = util.table.cellFor(node);
    var tr;
    if (td == null) {
      return;
    }
    result = goog.dom.getPreviousElementSibling(td);
    if (sameRow === true) {
      return result;
    }
    if (result == null) {
      tr = util.table.prevRow(td);
      if (tr != null) {
        result = goog.array.last(tr.querySelectorAll("td"));
      }
    }
    if (util.dom.compareTagName(td, "td")) {
      return result;
    }
  };
  util.table.nextCell = function(node) {
    var result;
    var td = util.table.cellFor(node);
    var tr;
    if (td == null) {
      return;
    }
    result = goog.dom.getNextElementSibling(td);
    if (result == null) {
      tr = util.table.nextRow(td);
      if (tr != null) {
        result = tr.querySelector("td");
      }
    }
    if (util.dom.compareTagName(td, "td")) {
      return result;
    }
  };
  util.table.initCellContent = function(tableOrCell, tableCellHtml) {
    if (util.dom.compareTagName(tableOrCell, "td")) {
      tableOrCell.innerHTML = tableCellHtml;
    } else {
      goog.array.forEach(tableOrCell.querySelectorAll("td"), function(td) {
        td.innerHTML = tableCellHtml;
      });
    }
  };
  util.table.initStyles = function(table, editor) {
    var cellWidth;
    var tds = table.querySelectorAll("td");
    var style = editor.config.style;
    var firstRow = table.querySelector("tr");
    table.setAttribute("style", "");
    table.removeAttribute("border");
    table.removeAttribute("bordercolor");
    table.removeAttribute("cellspacing");
    table.style.width = style.table.width;
    cellWidth = 100 / firstRow.querySelectorAll("td").length + "%";
    goog.array.forEach(tds, function(td) {
      td.style.borderColor = style.table.cell.borderColor;
      td.style.borderWidth = style.table.cell.borderWidth;
      td.style.borderStyle = style.table.cell.borderStyle;
      td.style.padding = style.table.cell.padding;
      td.style.margin = style.table.cell.margin;
      td.style.width = td.parentNode === firstRow ? cellWidth : "";
    });
  };
  util.table.cellIndex = function(td) {
    var tr = util.table.rowFor(td);
    var colIndex;
    goog.array.some(tr.querySelectorAll("td"), function(cell, index) {
      if (td === cell) {
        colIndex = index;
        return true;
      }
    });
    return colIndex;
  };
  util.table.cellAt = function(row, index) {
    return row.querySelectorAll("td").item(index);
  };
  util.table.alignment = function(table) {
    var alignment;
    var float = table.style["float"];
    var align = table.getAttribute("align");
    var marginLeft = table.style.marginLeft;
    var marginRight = table.style.marginRight;
    if (float && float !== "none") {
      alignment = float;
    } else {
      if (align) {
        alignment = align;
      } else {
        if (marginLeft === "auto" && marginRight === "auto") {
          alignment = "center";
        } else {
          if (marginLeft === "auto") {
            alignment = "right";
          } else {
            alignment = "left";
          }
        }
      }
    }
    return alignment;
  };
  util.table.positionInTable = function(node) {
    var failure = {"table":null, "cell":null, "row":-1, "column":-1};
    var table = util.dom.parent(node, "table");
    var tr = util.dom.parent(node, "tr");
    var cell = util.dom.parent(node, "td,th");
    if (table == null || tr == null || cell == null) {
      return failure;
    }
    var rowIndex = -1;
    var colIndex = -1;
    var trs = table.querySelectorAll("tr");
    for (var i = 0;i < trs.length;i++) {
      if (trs[i] === tr) {
        rowIndex = i;
      }
    }
    if (rowIndex === -1) {
      return failure;
    }
    var cells = tr.querySelectorAll("td,th");
    for (var i = 0;i < cells.length;i++) {
      if (cells[i] === cell) {
        colIndex = i;
      }
    }
    if (colIndex === -1) {
      return failure;
    }
    return {"table":table, "cell":cell, "row":rowIndex, "column":colIndex};
  };
})();
goog.provide("uno.commands.InsertTable");
goog.require("goog.debug.Logger");
goog.require("goog.array");
goog.require("goog.dom");
goog.require("goog.editor.Command");
goog.require("goog.functions");
goog.require("uno.BasePlugin");
goog.require("uno.util.table");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.InsertTable");
  var util = uno.util;
  var InsertTable = uno.commands.InsertTable = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(InsertTable, uno.BasePlugin);
  InsertTable.prototype.isSupportedCommand = function(command) {
    return command === "inserttable";
  };
  InsertTable.prototype.activeOnUneditableFields = goog.functions.TRUE;
  InsertTable.prototype.execCommandInternal = function(command, options) {
    var table;
    var me = this;
    var dom = goog.dom;
    var dimensions = options ? {width:options.columns, height:options.rows} : {width:2, height:2};
    this.editor.execCommand(goog.editor.Command.TABLE, dimensions);
    table = dom.getAncestorByTagNameAndClass(this.editor.getRange().getContainerElement(), goog.dom.TagName.TABLE);
    if (table) {
      util.table.initCellContent(table, this.editor.config.defaults.tableCellHtml);
      util.table.initStyles(table, this.editor);
      var br = table.querySelector("td div br");
      goog.editor.range.placeCursorNextTo(br, true);
    }
    this.editor.updateEmpty();
  };
  InsertTable.prototype.queryCommandValue = function(command) {
  };
  InsertTable.prototype.queryCommandEnabled = function(command, opt) {
    var dom = goog.dom;
    var range = this.editor.getRange();
    var enabled = true;
    if (range) {
      enabled = !dom.getAncestorByTagNameAndClass(range.getStartNode(), goog.dom.TagName.TABLE) && !dom.getAncestorByTagNameAndClass(range.getEndNode(), goog.dom.TagName.TABLE);
    }
    return enabled;
  };
})();
goog.provide("uno.commands.InsertTableCol");
goog.require("goog.array");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.editor.plugins.TableEditor");
goog.require("uno.BasePlugin");
goog.require("uno.util.table");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.InsertTableCol");
  var util = uno.util;
  var InsertTableCol = uno.commands.InsertTableCol = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(InsertTableCol, uno.BasePlugin);
  InsertTableCol.prototype.isSupportedCommand = function(command) {
    return command === "inserttablecol";
  };
  InsertTableCol.prototype.execCommandInternal = function(command, direction) {
    var colOffset;
    var editor = this.editor;
    if (direction === "before") {
      command = goog.editor.plugins.TableEditor.COMMAND.INSERT_COLUMN_BEFORE;
      colOffset = -1;
    } else {
      command = goog.editor.plugins.TableEditor.COMMAND.INSERT_COLUMN_AFTER;
      colOffset = 1;
    }
    editor.execCommand(command);
    try {
      var node = editor.getRange().getAnchorNode();
      var td = util.table.cellFor(node);
      var colIndex = util.table.cellIndex(td);
      var tr = util.table.rowFor(td);
      var style = td.getAttribute("style");
      goog.array.forEach(util.table["for"](tr).querySelectorAll("tr"), function(tr) {
        var cell = util.table.cellAt(tr, colIndex + colOffset);
        util.table.initCellContent(cell, this.editor.config.defaults.tableCellHtml);
        cell.setAttribute("style", style);
      });
    } catch (err) {
      log.warning("Unable to apply current table cell style to new column\n" + err);
    }
  };
  InsertTableCol.prototype.queryCommandValue = function(command) {
  };
})();
goog.provide("uno.commands.InsertTableRow");
goog.require("goog.array");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.editor.plugins.TableEditor");
goog.require("uno.BasePlugin");
goog.require("uno.util.table");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.InsertTableRow");
  var util = uno.util;
  var InsertTableRow = uno.commands.InsertTableRow = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(InsertTableRow, uno.BasePlugin);
  InsertTableRow.prototype.isSupportedCommand = function(command) {
    return command === "inserttablerow";
  };
  InsertTableRow.prototype.execCommandInternal = function(command, direction) {
    var editor = this.editor;
    if (direction === "before") {
      command = goog.editor.plugins.TableEditor.COMMAND.INSERT_ROW_BEFORE;
    } else {
      command = goog.editor.plugins.TableEditor.COMMAND.INSERT_ROW_AFTER;
    }
    editor.execCommand(command);
    var dom = goog.dom;
    var range = this.editor.getRange();
    try {
      var anchor = range.getAnchorNode();
      var td = util.table.cellFor(anchor);
      var newTr = direction === "before" ? util.table.prevRow(td) : util.table.nextRow(td);
      var newTds = dom.getChildren(newTr);
      var style = td.getAttribute("style");
      util.table.initCellContent(newTr, this.editor.config.defaults.tableCellHtml);
      goog.array.forEach(newTds, function(cell) {
        cell.setAttribute("style", style);
      });
    } catch (err) {
      log.error("Unable to apply current table cell style to new row\n" + err);
    }
  };
  InsertTableRow.prototype.queryCommandValue = function(command) {
  };
})();
goog.provide("uno.commands.InsertTodo");
goog.require("goog.debug.Logger");
goog.require("goog.editor.range");
goog.require("goog.editor.node");
goog.require("uno.BasePlugin");
goog.require("goog.string");
goog.require("uno.util.dom");
goog.require("uno.util.todo");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.InsertTodo");
  var util = uno.util;
  var InsertTodo = uno.commands.InsertTodo = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(InsertTodo, uno.BasePlugin);
  InsertTodo.prototype.isSupportedCommand = function(command) {
    return command === "inserttodo";
  };
  InsertTodo.prototype.execCommandInternal = function(command, value) {
    var editor = this.editor;
    var toggle = value === "toggle";
    var range = editor.getRange();
    var startNode = range.getStartNode();
    var node;
    if (toggle) {
      node = startNode;
      while (node = goog.dom.getPreviousElementSibling(node)) {
        if (util.todo.isTodo(node)) {
          util.todo.toggle(node);
          return true;
        }
      }
    } else {
      if (range.isCollapsed()) {
        node = util.todo.create();
        range.insertNode(node);
        goog.editor.range.placeCursorNextTo(node);
      } else {
        var existing = goog.array.toArray(util.todo.all(editor.field)).filter(function(node) {
          return range.containsNode(node, true);
        });
        if (existing.length > 0) {
          existing.forEach(util.todo.remove);
        } else {
          var nodes = goog.array.toArray(editor.field.querySelectorAll("div,li"));
          nodes = nodes.filter(function(node) {
            return range.containsNode(node, true) && !goog.string.isEmpty(node.textContent);
          });
          if (nodes.length > 0) {
            nodes.forEach(function(node) {
              var entodo = util.todo.create();
              var point = util.dom.getLastEquivalentPoint(node, 0);
              var parentNode = goog.dom.isElement(point[0]) ? point[0] : point[0].parentNode;
              util.dom.moveNode(entodo, parentNode, 0, range);
            });
            goog.dom.Range.createFromNodes(nodes[0], 0, range.getEndNode(), range.getEndOffset()).select();
          }
        }
      }
    }
  };
})();
goog.provide("uno.commands.Lowercase");
goog.require("goog.debug.Logger");
goog.require("goog.iter");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Lowercase");
  var Lowercase = uno.commands.Lowercase = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Lowercase, uno.BasePlugin);
  Lowercase.prototype.isSupportedCommand = function(command) {
    return command === "lowercase";
  };
  Lowercase.prototype.execCommandInternal = function(command, opt) {
    var range = this.editor.getRange();
    var savedRange = range.saveUsingDom();
    goog.iter.forEach(range, function(element) {
      if (element.nodeType === Node.TEXT_NODE) {
        element.nodeValue = element.nodeValue.toLowerCase();
      }
    });
    savedRange.restore().select();
  };
  Lowercase.prototype.queryCommandValue = function(command) {
  };
})();
goog.provide("uno.commands.Margin");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.range");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Margin");
  var util = uno.util;
  var Margin = uno.commands.Margin = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Margin, uno.BasePlugin);
  Margin.prototype.isSupportedCommand = function(command) {
    return command === "margin";
  };
  Margin.prototype.execCommand = function(command, value) {
    if (value == null || value.note == null) {
      return;
    }
    if (this.editor == null || this.editor.field == null) {
      return;
    }
    var field = this.editor.field;
    var note = value.note;
    field.style.paddingTop = toCssValue(note.top, "px");
    field.style.paddingBottom = toCssValue(note.bottom, "px");
    field.style.paddingLeft = toCssValue(note.left, "px");
    field.style.paddingRight = toCssValue(note.right, "px");
    return true;
  };
  function toCssValue(value, unit) {
    var result;
    switch(typeof value) {
      case "number":
        result = value + unit;
        break;
      case "string":
        if (value.indexOf(unit) > -1) {
          result = value;
        } else {
          result = value + unit;
        }
        break;
      case "undefined":
        result = null;
        break;
      default:
        result = value;
    }
    return result;
  }
  Margin.prototype.queryCommandValue = function() {
    return this.editor.inEditMode();
  };
})();
goog.provide("uno.util.string");
(function() {
  var util = uno.util;
  util.string.removeInvalidHtmlCharacters = function(line) {
    var invalidCharacters = /[\u0000\u0001-\u0008\u000E-\u001F\u007F-\u009F\uFDD0-\uFDEF\u000B\uFFFE\uFFFF]|[\x01-\x10][\uFFFE-\uFFFF]/g;
    return line.replace(invalidCharacters, "");
  };
})();
goog.provide("uno.util.pastepipe");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.editor.Link");
goog.require("uno.util.string");
(function() {
  var util = uno.util;
  util.pastepipe.convertStringToDom = function(line) {
    var node = goog.dom.createDom("div");
    node.innerHTML = line;
    if (node.childNodes && node.childNodes.length === 1 && util.dom.isBlockNode(node.firstChild)) {
      return node.firstChild;
    }
    return node;
  };
  util.pastepipe.removeInvalidHtmlCharacters = function(line) {
    return util.string.removeInvalidHtmlCharacters(line);
  };
  util.pastepipe.transformToUrl = function(line) {
    var url = line.trim();
    if (goog.editor.Link.isLikelyUrl(url)) {
      return '<a href="' + url + '">' + url + "</a>";
    }
    return line;
  };
  util.pastepipe.preserveWhiteSpaces = function(line) {
    return line.replace(/[ \t]{2,}/gi, function(match) {
      var nbsp = String.fromCharCode(160);
      var result = "";
      for (var i = 0;i < match.length;i++) {
        result += nbsp;
      }
      return result;
    });
  };
  util.pastepipe.wrapAroundList = function(line, paragraphInfo) {
    if (paragraphInfo.isInList) {
      return "<li>" + line + "</li>";
    }
    return line;
  };
  util.pastepipe.preserveNewLines = function(node) {
    if (!node.innerHTML) {
      return util.paragraph.create();
    }
    return node;
  };
  util.pastepipe.appendTodo = function(node, paragraphInfo, index) {
    if (paragraphInfo.hasTodo && index > 0) {
      return util.todo.addTodoToParagraph(node);
    }
    return node;
  };
  util.pastepipe.removeFormatting = function(line) {
    return goog.editor.plugins.RemoveFormatting.prototype.removeFormattingWorker_(line);
  };
  util.pastepipe.cleanEmbeddedTables = function(line, paragraphInfo) {
    var newLine = line;
    if (paragraphInfo.hasTable) {
      newLine = newLine.replace(/<td.+>|<table.+>|<th.+>|<tr.+>|<tbody.+>|<thead.+>/g, "<div>");
      newLine = newLine.replace(/<\/td>|<\/table>|<\/th>|<\/tr>|<\/tbody>|<\/thead>/g, "<div>");
    }
    return newLine;
  };
})();
goog.provide("uno.util.pastepipe.ios");
(function() {
  var util = uno.util;
  util.pastepipe.ios.removeUnnecessaryWrappers = function(line) {
    return line.replace("<html>\n\t<body>\n\t\t<div>", "").replace("<html>\n\t<body>\n\t\t<p>", "").replace("</p>\n\t</body>\n</html>", "").replace("</div>\n\t</body>\n</html>", "");
  };
})();
goog.provide("uno.util.pastepipe.win");
(function() {
  var util = uno.util;
  util.pastepipe.win.removeUnnecessaryWrappers = function(line) {
    return line.replace(/^<span><div>/, "<div>").replace(/<\/div><\/span>\n$/, "</div>");
  };
  util.pastepipe.win.convertTodos = function(line) {
    var checkedCount = 0;
    var uncheckedCount = 0;
    return line.replace(/<img class="en-todo en-todo-checked">|<img class="en-todo">/g, function(match) {
      if (match === '<img class="en-todo en-todo-checked">') {
        checkedCount++;
        return '<img src="en-resource://database/check1:' + checkedCount + '"/>';
      } else {
        uncheckedCount++;
        return '<img src="en-resource://database/check0:' + uncheckedCount + '"/>';
      }
    });
  };
})();
goog.provide("uno.util.pastepipe.generic");
(function() {
})();
goog.provide("uno.commands.Paste");
goog.require("goog.array");
goog.require("goog.debug.Logger");
goog.require("goog.editor.Command");
goog.require("uno.BasePlugin");
goog.require("uno.defs");
goog.require("uno.util.dom");
goog.require("uno.util.pastepipe");
goog.require("uno.util.pastepipe.ios");
goog.require("uno.util.pastepipe.win");
goog.require("uno.util.pastepipe.generic");
goog.require("uno.util.resource");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Paste");
  var util = uno.util;
  var platform = uno.util.pastepipe.generic;
  var Paste = uno.commands.Paste = function(config) {
    uno.BasePlugin.call(this, log.getName());
    platform = uno.util.pastepipe[config.platform] || platform;
  };
  goog.inherits(Paste, uno.BasePlugin);
  Paste.prototype.isSupportedCommand = function(command) {
    return command === "paste";
  };
  Paste.prototype.queryCommandValue = function() {
    return true;
  };
  Paste.prototype.execCommandInternal = function(command, opt) {
    var range = this.editor.getRange();
    if (!range) {
      return false;
    }
    var options = opt != null && typeof opt === "object" ? opt : {value:opt + "", type:"html", mode:"rich", resources:[]};
    var paragraphInfo = getParagraphInfo(range.getContainerElement(), this.editor.queryCommandValue.bind(this.editor));
    var type = options.type;
    var mode = options.mode;
    var filters = {};
    var filteredContent;
    var lines = {};
    var resources = {};
    this.editor.context.format = uno.defs.format.CLIPBOARD;
    if (options.resources) {
      options.resources.forEach(function(res) {
        resources[res.id] = res;
      });
    }
    goog.object.extend(this.editor.context.resources, resources);
    if (type === "plain" && ["plain", "pre", "rich"].indexOf(mode) > -1 || type === "html" && mode === "pre") {
      var value;
      var splitCharacter;
      if (type === "html") {
        value = util.pastepipe.removeFormatting(options.value);
        splitCharacter = "<br>";
      } else {
        value = options.value;
        splitCharacter = "\n";
      }
      filters = getPastePlainFilters(this.editor);
      paragraphInfo.matchStyle = true;
      filteredContent = filterContent(value.split(splitCharacter), filters, paragraphInfo);
      if (filteredContent.length) {
        lines.firstLine = filteredContent.shift();
        lines.lastLine = filteredContent.length >= 1 ? filteredContent.pop() : null;
        lines.middleLines = filteredContent;
        this.insertNode(lines, paragraphInfo);
      }
    } else {
      if (options.type === "html" && options.mode === "rich") {
        filters = getPasteHtmlFilters(this.editor);
        filteredContent = filterContent([options.value], filters, paragraphInfo)[0];
        if (filteredContent.getAttribute("style")) {
          range.insertNode(filteredContent);
        } else {
          if (filteredContent.childNodes && filteredContent.childNodes.length) {
            if (isBlockContent(filteredContent) && ["table", "ul", "ol"].indexOf(filteredContent.tagName.toLowerCase()) === -1) {
              var inlineNode;
              if (util.dom.isBlockNode(filteredContent.firstChild)) {
                lines.firstLine = filteredContent.firstChild;
              } else {
                inlineNode = filteredContent.firstChild;
                var firstLineNodes = [];
                while (inlineNode) {
                  if (!util.dom.isBlockNode(inlineNode)) {
                    firstLineNodes.push(inlineNode);
                    inlineNode = inlineNode.nextSibling;
                  } else {
                    inlineNode = false;
                  }
                }
                lines.firstLine = firstLineNodes.length > 1 ? goog.dom.createDom("span", null, firstLineNodes) : firstLineNodes[0];
              }
              if (filteredContent.childNodes.length >= 1) {
                lines.lastLine = filteredContent.lastChild;
                goog.dom.removeNode(filteredContent.lastChild);
              }
              if (filteredContent.childNodes.length >= 1) {
                lines.middleLines = [filteredContent];
              }
            } else {
              lines.firstLine = filteredContent;
            }
            this.insertNode(lines, paragraphInfo);
          }
        }
      } else {
        return false;
      }
    }
    return true;
  };
  Paste.prototype.insertNode = function(lines, paragraphInfo) {
    var range = this.editor.getRange();
    if (!range.isCollapsed()) {
      this.editor.execCommand("delete");
    }
    range = this.editor.getRange();
    var firstLine = insertFirstLine.call(this, lines.firstLine);
    var lastLine = insertLastLine.call(this, lines.lastLine, firstLine);
    insertMiddleLines.call(this, lines.middleLines, firstLine);
    var startNode = firstLine.firstNode;
    var startOffset = 0;
    var endNode = lastLine.lastNode || firstLine.lastNode;
    var endOffset = endNode.nodeType === Node.TEXT_NODE ? endNode.length : endNode.childNodes.length;
    var newRange = goog.dom.Range.createFromNodes(startNode, startOffset, endNode, endOffset);
    newRange.select();
    if (paragraphInfo.matchStyle) {
      var editor = this.editor;
      paragraphInfo.recordedStyles.forEach(function(style) {
        if (style.value) {
          editor.execCommand(style.command, style.value);
          var result = editor.queryCommandValue(style.command);
          if (result !== style.value) {
            editor.execCommand(style.command, style.value);
          }
        }
      });
    }
    goog.editor.range.placeCursorNextTo(endNode);
  };
  function isBlockContent(node) {
    if (node && node.childNodes) {
      return Array.prototype.some.call(node.childNodes, function(child) {
        return util.dom.isBlockNode(child);
      });
    }
    return false;
  }
  function insertFirstLine(line) {
    var range = this.editor.getRange();
    var firstNode = line;
    var lastNode = line;
    if (line) {
      var nodes = blockToInline(line);
      firstNode = nodes.shift();
      lastNode = firstNode;
      range.insertNode(lastNode);
      while (nodes.length) {
        var currentNode = nodes.shift();
        goog.dom.insertSiblingAfter(currentNode, lastNode);
        lastNode = currentNode;
      }
      goog.editor.range.placeCursorNextTo(lastNode);
      return {paragraph:util.paragraph["for"](lastNode), firstNode:firstNode, lastNode:lastNode};
    }
    return {paragraph:util.paragraph["for"](range.getStartNode()), firstNode:firstNode, lastNode:lastNode};
  }
  function insertLastLine(line, firstLine) {
    var range = this.editor.getRange();
    var lastNode = line;
    if (line) {
      var splitNode = goog.editor.node.splitDomTreeAt(firstLine.lastNode, null, util.paragraph["for"](firstLine.lastNode));
      if (splitNode) {
        var nodes = blockToInline(line);
        var insertionPoint = splitNode.firstChild;
        lastNode = insertionPoint;
        while (nodes.length) {
          var currentNode = nodes.shift();
          splitNode.insertBefore(currentNode, insertionPoint);
          lastNode = currentNode;
        }
        goog.dom.insertSiblingAfter(splitNode, firstLine.paragraph);
        goog.editor.range.placeCursorNextTo(lastNode);
      } else {
        range.insertNode(line);
        goog.editor.range.placeCursorNextTo(line);
      }
    }
    return {lastNode:lastNode};
  }
  function insertMiddleLines(lines, firstLine) {
    var editor = this.editor;
    if (lines) {
      if (firstLine.paragraph.nextSibling) {
        var paragraph = firstLine.paragraph;
        lines.forEach(function(node) {
          goog.dom.insertSiblingAfter(node, paragraph);
          paragraph = util.paragraph["for"](node);
        });
      } else {
        lines.forEach(function(node) {
          editor.field.appendChild(node);
        });
      }
    }
  }
  function blockToInline(node) {
    if (util.dom.isBlockNode(node) && !node.getAttribute("style") && ["table", "ul", "ol"].indexOf(node.tagName.toLowerCase()) === -1) {
      return Array.prototype.map.call(node.childNodes, function(n) {
        return n;
      });
    }
    return [node];
  }
  function getParagraphInfo(node, queryCommandValue) {
    var paragraph = util.paragraph["for"](node);
    if (!paragraph) {
      return {};
    }
    var table = util.table["for"](node);
    var isInList = paragraph.tagName.toLowerCase() === "li" || paragraph.querySelector("li");
    var recordedStyles = ["bold", "fontname", "forecolor", "italic", "strikethrough", "subscript", "underline", "superscript", "fontsize", "highlight"].map(function(command) {
      return {command:command, value:queryCommandValue(command)};
    });
    return {recordedStyles:recordedStyles, isInList:!!isInList, hasTable:!!table, hasTodo:util.paragraph.startsWithTodo(paragraph)};
  }
  function filterContent(content, filters, paragraphInfo) {
    return content.map(function(value, index) {
      var filteredContent = value;
      filters.stringFilters.forEach(function(filter) {
        if (typeof filter === "function") {
          filteredContent = filter(filteredContent, paragraphInfo, index);
        }
      });
      filteredContent = util.pastepipe.convertStringToDom(filteredContent);
      filters.domFilters.forEach(function(filter) {
        if (typeof filter === "function") {
          filteredContent = filter(filteredContent, paragraphInfo, index);
        }
      });
      return filteredContent;
    });
  }
  function getPasteHtmlFilters(editor) {
    return {stringFilters:[platform.removeUnnecessaryWrappers, util.pastepipe.removeInvalidHtmlCharacters, util.pastepipe.transformToUrl, util.pastepipe.cleanEmbeddedTables, platform.convertTodos, editor.prepareContentsDom.bind(editor)], domFilters:[util.pastepipe.appendTodo]};
  }
  function getPastePlainFilters(editor) {
    return {stringFilters:[util.pastepipe.removeInvalidHtmlCharacters, util.pastepipe.transformToUrl, util.pastepipe.preserveWhiteSpaces, util.pastepipe.wrapAroundList, editor.prepareContentsDom.bind(editor)], domFilters:[util.pastepipe.preserveNewLines, util.pastepipe.appendTodo]};
  }
})();
goog.provide("uno.commands.PlainText");
goog.require("goog.debug.Logger");
goog.require("goog.editor.Command");
goog.require("goog.editor.range");
goog.require("uno.BasePlugin");
goog.require("uno.util.objects");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.PlainText");
  var util = uno.util;
  var PlainText = uno.commands.PlainText = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(PlainText, uno.BasePlugin);
  PlainText.prototype.isSupportedCommand = function(command) {
    return command === "plaintext";
  };
  PlainText.prototype.activeOnUneditableFields = goog.functions.TRUE;
  PlainText.prototype.execCommandInternal = function(command, opt) {
    var range = this.editor.getRange();
    if (range == null) {
      this.editor.enterEditMode();
      range = this.editor.getRange();
    }
    var isCollapsed = range.isCollapsed();
    var savedRange;
    var parsedOptions = util.objects.mergeOptions(opt, {fontStyle:"fixed width"});
    if (isCollapsed) {
      this.editor.execCommand("selectall");
    }
    this.editor.execCommand(goog.editor.Command.REMOVE_FORMAT);
    if (parsedOptions.fontStyle === "none") {
      var node = goog.dom.createDom("tt", {style:"position: absolute;"});
      document.body.appendChild(node);
      var fontFamily = goog.style.getComputedStyle(node, "font-family");
      var fontSize = goog.style.getComputedStyle(node, "font-size");
      var fontWeight = goog.style.getComputedStyle(node, "font-weight");
      goog.dom.removeNode(node);
      var newRange = this.editor.getRange();
      var styles = {fontFamily:fontFamily, fontSize:fontSize, fontWeight:fontWeight};
      goog.iter.forEach(newRange, function(element) {
        if (element.nodeType === Node.TEXT_NODE) {
          var wrapper = goog.dom.createDom("span", null, element.nodeValue);
          goog.dom.replaceNode(wrapper, element);
          goog.style.setStyle(wrapper, styles);
        } else {
          goog.style.setStyle(element, styles);
        }
      });
    }
    goog.array.forEachRight(document.querySelectorAll("a"), function(anchor) {
      goog.dom.flattenElement(anchor);
    });
    goog.array.forEachRight(document.querySelectorAll("img"), function(img) {
      goog.dom.removeNode(img);
    });
    if (isCollapsed) {
      this.editor.placeCursorAtEnd();
    }
  };
})();
goog.provide("uno.commands.PrintPreview");
goog.require("goog.debug.Logger");
goog.require("goog.style");
goog.require("goog.dom");
goog.require("goog.dom.classlist");
goog.require("goog.object");
goog.require("goog.array");
goog.require("uno.BasePlugin");
goog.require("uno.defs");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.PrintPreview");
  var PrintPreview = uno.commands.PrintPreview = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(PrintPreview, uno.BasePlugin);
  PrintPreview.CONTAINER_ID = "print-container";
  PrintPreview.HEADER_TITLE_ID = "header-title";
  PrintPreview.HEADER_TABLE_ID = "header-table";
  PrintPreview.HEADER_LABEL_CLASS = "header-table-label";
  PrintPreview.HEADER_TEXT_CLASS = "header-table-text";
  PrintPreview.PRINT_INSERT_CLASS = "en-print";
  PrintPreview.CHECKBOX_CLASS = "checkbox";
  PrintPreview.CHECKED_CLASS = "checked";
  PrintPreview.PDF_CLASS = "pdf";
  PrintPreview.AUDIO_CLASS = "audio";
  PrintPreview.GENERIC_ATTACHMENT_CLASS = "generic-attachment";
  PrintPreview.prototype.isSupportedCommand = function(command) {
    return command === "printpreview";
  };
  PrintPreview.prototype.execCommandInternal = function(command, localization, options) {
    var previewContainer = goog.dom.createDom("div", {id:PrintPreview.CONTAINER_ID, "class":PrintPreview.PRINT_INSERT_CLASS});
    var parsedLocalization = parseLocalization(localization);
    if (options) {
      var parsedOptions = parseOptions(options);
      var metaDataHeader = generateMetadataHeader(parsedOptions, parsedLocalization);
      previewContainer.appendChild(metaDataHeader);
      var hr = goog.dom.createDom("hr");
      previewContainer.appendChild(hr);
      previewContainer.appendChild(createGap());
    }
    var titleText = this.editor.getTitle();
    if (titleText) {
      var title = createTitle(titleText);
      previewContainer.appendChild(title);
      previewContainer.appendChild(createGap());
    }
    var note = copyNote(document.querySelector("#" + uno.defs.containers.EDITOR_BODY_SELECTOR));
    replaceEmbeds(note, parsedLocalization);
    replaceTodos(note);
    previewContainer.innerHTML = previewContainer.innerHTML + note.innerHTML;
    var pageContainer = document.querySelector("#container");
    pageContainer.innerHTML = "";
    pageContainer.parentNode.insertBefore(previewContainer, pageContainer);
    this.editor.dispatchEvent("printready");
  };
  PrintPreview.prototype.queryCommandValue = function() {
  };
  function generateMetadataHeader(options, localization) {
    var table, tr, td, row, col, toInsert, tds, span1, span2;
    table = goog.dom.createDom("table", {id:PrintPreview.HEADER_TABLE_ID, "class":PrintPreview.PRINT_INSERT_CLASS});
    for (row = 0;row < 4;row++) {
      tr = goog.dom.createDom("tr");
      table.appendChild(tr);
      for (col = 0;col < 2;col++) {
        td = goog.dom.createDom("td");
        tr.appendChild(td);
      }
    }
    toInsert = [[localization.author, "author"], [localization.notebook, "notebook"], [localization.created, "created"], [localization.tags, "tags"], [localization.updated, "updated"], [localization.url, "url"], [localization.deleted, "deleted"], [localization.location, "location"]];
    tds = table.querySelectorAll("td");
    toInsert.forEach(function(data, i) {
      if (options[data[1]] === null) {
        return;
      }
      tds[i].innerHTML = "";
      span1 = goog.dom.createDom("span", {"class":PrintPreview.HEADER_LABEL_CLASS});
      span1.textContent = data[0];
      span2 = goog.dom.createDom("span", {"class":PrintPreview.HEADER_TEXT_CLASS});
      span2.textContent = " " + options[data[1]];
      tds[i].appendChild(span1);
      tds[i].appendChild(span2);
    });
    return table;
  }
  function parseOptions(options) {
    var defaultOptions = {title:null, notebook:null, created:null, updated:null, deleted:null, author:null, location:null, tags:null, url:null};
    var parsedOptions = goog.object.clone(options || {});
    goog.object.extend(defaultOptions, parsedOptions);
    return defaultOptions;
  }
  function parseLocalization(localization) {
    var defaultLocalization = {notebook:"Notebook:", created:"Created:", updated:"Updated:", deleted:"Deleted:", author:"Author:", location:"Location:", tags:"Tags:", url:"Source:", pdf_file:"PDF File", audio_file:"Audio File", generic_file:"Generic File"};
    var parsedLocalization = goog.object.clone(localization || {});
    goog.object.extend(defaultLocalization, parsedLocalization);
    return defaultLocalization;
  }
  function createGap() {
    return goog.dom.createDom("br", {"class":PrintPreview.PRINT_INSERT_CLASS});
  }
  function createTitle(title) {
    var header = goog.dom.createDom("div", {id:PrintPreview.HEADER_TITLE_ID, "class":PrintPreview.PRINT_INSERT_CLASS});
    header.textContent = title;
    return header;
  }
  function copyNote(noteElement) {
    if (!noteElement) {
      log.warning("Could not find note!");
      return document.createElement("div");
    }
    goog.array.forEach(noteElement.childNodes, function(node) {
      if (node.nodeType !== Node.TEXT_NODE) {
        goog.dom.classlist.add(node, PrintPreview.PRINT_INSERT_CLASS);
      }
    });
    return noteElement;
  }
  function replaceEmbeds(note, localization) {
    goog.array.forEach(note.querySelectorAll("embed"), function(embed) {
      var replacement = goog.dom.createDom("div", {"class":PrintPreview.PRINT_INSERT_CLASS});
      switch(embed.getAttribute("type")) {
        case "evernote/x-pdf":
          goog.dom.classlist.add(replacement, PrintPreview.PDF_CLASS);
          replacement.textContent = localization.pdf_file;
          break;
        case "evernote/x-attachment":
          var id = embed.getAttribute("id");
          if (id && id.match(/.*en-media:audio.*/)) {
            goog.dom.classlist.add(replacement, PrintPreview.AUDIO_CLASS);
            replacement.textContent = localization.audio_file;
          } else {
            goog.dom.classlist.add(replacement, PrintPreview.GENERIC_ATTACHMENT_CLASS);
            replacement.textContent = localization.generic_file;
          }
          break;
        default:
          log.warning("Found <embed> with unknown type! " + embed);
          goog.dom.classlist.add(replacement, PrintPreview.GENERIC_ATTACHMENT_CLASS);
          replacement.textContent = localization.generic_file;
      }
      goog.dom.replaceNode(replacement, embed);
    });
  }
  function replaceTodos(note) {
    goog.array.forEach(note.querySelectorAll("img.en-todo"), function(img) {
      var replacement = goog.dom.createDom("div", {"class":PrintPreview.PRINT_INSERT_CLASS + " " + PrintPreview.CHECKBOX_CLASS});
      if (goog.dom.classlist.contains(img, "en-todo-checked")) {
        goog.dom.classlist.add(replacement, PrintPreview.CHECKED_CLASS);
      }
      goog.dom.replaceNode(replacement, img);
    });
  }
})();
goog.provide("uno.commands.Redo");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Redo");
  var Redo = uno.commands.Redo = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Redo, uno.BasePlugin);
  Redo.prototype.isSupportedCommand = function(command) {
    return command === "redo";
  };
  Redo.prototype.execCommand = function(command, opt) {
    return this.editor.execCommand(goog.editor.Command.REDO);
  };
  Redo.prototype.queryCommandValue = function(command) {
    var hasOperations = this.editor.queryCommandValue(goog.editor.Command.REDO);
    return hasOperations ? "Changes" : "";
  };
})();
goog.provide("uno.commands.RemoveFormat");
goog.require("goog.debug.Logger");
goog.require("goog.editor.Command");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.RemoveFormat");
  var RemoveFormat = uno.commands.RemoveFormat = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(RemoveFormat, uno.BasePlugin);
  RemoveFormat.prototype.isSupportedCommand = function(command) {
    return command === "removeformat";
  };
  RemoveFormat.prototype.activeOnUneditableFields = goog.functions.TRUE;
  RemoveFormat.prototype.execCommandInternal = function(command, opt) {
    return this.editor.execCommand(goog.editor.Command.REMOVE_FORMAT);
  };
})();
goog.provide("uno.commands.Resources");
goog.require("goog.debug.Logger");
goog.require("goog.editor.range");
goog.require("goog.functions");
goog.require("uno.BasePlugin");
goog.require("uno.util.resource");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Resources");
  var util = uno.util;
  var Resources = uno.commands.Resources = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Resources, uno.BasePlugin);
  Resources.prototype.activeOnUneditableFields = goog.functions.TRUE;
  Resources.prototype.isSupportedCommand = function(command) {
    return command === "resources";
  };
  Resources.prototype.execCommand = function(command, value) {
    var me = this;
    var hasChanges;
    if (!goog.isArray(value)) {
      value = [value];
    }
    hasChanges = value.some(function(dict) {
      if (dict.action === "insert" || dict.action === "delete") {
        return true;
      } else {
        if (dict.action === "update") {
          return goog.array.some(me.findElementsForDict(dict), function(el) {
            var existing = util.resource.dictFromElement(el);
            return dict.filename != null && dict.filename !== existing.filename || dict.filesize != null && dict.filesize !== existing.filesize || dict.hash != null && dict.hash !== existing.hash || dict.mime != null && dict.mime !== existing.mime || dict.url != null && dict.url !== existing.url;
          });
        }
      }
    });
    if (hasChanges) {
      this.editor.dispatchBeforeChange();
    }
    value.forEach(function(dict) {
      if (dict.action === "insert") {
        me.add(dict);
      } else {
        if (dict.action === "update") {
          me.update(dict);
        } else {
          if (dict.action === "delete") {
            me.remove(dict);
          }
        }
      }
    });
    if (hasChanges) {
      this.editor.dispatchChange();
    }
  };
  Resources.prototype.add = function(dict) {
    var editor = this.editor;
    var enmedia = util.resource.createMediaFromDict(dict);
    var slug = util.resource.convertMediaToSlug(enmedia, dict, editor);
    var ref = dict.beforeRef || dict.afterRef;
    var refNode = dict.beforeRef || dict.afterRef ? util.resource.findByRef(ref, editor.field) : null;
    if (refNode) {
      if (dict.beforeRef) {
        goog.dom.insertSiblingBefore(slug, refNode);
      } else {
        goog.dom.insertSiblingAfter(slug, refNode);
      }
    } else {
      if (!editor.inEditMode()) {
        editor.enterEditMode(true);
      }
      this.editor.execCommand("insertparagraph");
      switch(dict.justify) {
        case "left":
        ;
        case "center":
        ;
        case "right":
          editor.execCommand("justify" + dict.justify);
      }
      var range = editor.getRange();
      range.insertNode(slug);
    }
    var parent = slug.parentElement;
    var nodeIndex = util.dom.index(slug) + 1;
    var newRange = goog.dom.Range.createFromNodes(parent, nodeIndex, parent, nodeIndex);
    newRange.select();
  };
  Resources.prototype.update = function(dict) {
    var elements;
    var enmedia;
    var slug;
    var editor = this.editor;
    elements = this.findElementsForDict(dict);
    goog.array.forEach(elements, function(el) {
      var combodict = {};
      goog.object.extend(combodict, util.resource.dictFromElement(el), dict);
      enmedia = util.resource.createMediaFromDict(combodict);
      slug = util.resource.convertMediaToSlug(enmedia, combodict, editor);
      goog.dom.replaceNode(slug, el);
    });
  };
  Resources.prototype.remove = function(dict) {
    var elements = this.findElementsForDict(dict);
    goog.array.forEach(elements, function(el) {
      var par = util.paragraph["for"](el);
      goog.dom.removeNode(el);
      if (!util.paragraph.hasContent(par) && !util.paragraph.hasBr(par)) {
        util.paragraph.appendBr(par);
      }
    });
  };
  Resources.prototype.findElementsForDict = function(dict) {
    var elements;
    var el;
    if (dict.reference) {
      el = util.resource.findByRef(dict.reference, this.editor.field);
      elements = [];
      if (el) {
        elements.push(el);
      }
    } else {
      elements = util.resource.findByHash(dict.hash, this.editor.field);
    }
    return elements;
  };
  Resources.prototype.queryCommandValue = function(command, opt) {
    var editor = this.editor;
    var range = editor.getRange();
    var sibling;
    var list = goog.array.map(util.resource.all(editor.field), function(el) {
      var dict = util.resource.toDict(el, range);
      if (opt === "neighbors") {
        sibling = el.previousElementSibling;
        if (util.resource.isResource(sibling)) {
          dict.prevNeighbour = util.resource.toDict(sibling, range);
        }
        sibling = el.nextElementSibling;
        if (util.resource.isResource(sibling)) {
          dict.nextNeighbour = util.resource.toDict(sibling, range);
        }
      }
      return dict;
    });
    return list;
  };
})();
goog.provide("uno.commands.RevealCrypto");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.RevealCrypto");
  var RevealCrypto = uno.commands.RevealCrypto = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(RevealCrypto, uno.BasePlugin);
  RevealCrypto.prototype.isSupportedCommand = function(command) {
    return command === "revealcrypto";
  };
  RevealCrypto.prototype.queryCommandValue = function() {
    var range = this.editor.getRange();
    if (!range || range.isCollapsed()) {
      return "";
    }
    var html = range.getValidHtml();
    return html;
  };
  RevealCrypto.prototype.execCommand = function(command, value) {
    var range = this.editor.getRange();
    if (!range || !value) {
      return false;
    }
    var cryptContainer = range.getContainerElement();
    var tagName = cryptContainer.tagName.toLowerCase();
    var cryptElement = tagName === "en-crypt" ? cryptContainer : cryptContainer.querySelector("en-crypt");
    if (cryptElement) {
      cryptElement.innerHTML = value;
      return true;
    }
    return false;
  };
})();
goog.provide("uno.commands.RichlinksConvert");
goog.require("uno.BasePlugin");
goog.require("uno.util.richlink");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.RichlinksConvert");
  var RichlinksConvert = uno.commands.RichlinksConvert = function(opt) {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(RichlinksConvert, uno.BasePlugin);
  RichlinksConvert.prototype.isSupportedCommand = function(command) {
    return command === "richlinks.convert";
  };
  RichlinksConvert.prototype.execCommandInternal = function(command, opt) {
    uno.util.dom.queryReverse(uno.defs.richlink.ANCHOR_ELEMENT_SELECTOR, document.body).forEach(function(node) {
      uno.util.richlink.handleLink(node, true);
      RichlinksConvert.editor.dispatchEvent({type:uno.Editor.EventType.DELAYEDCHANGE});
    });
  };
})();
goog.provide("uno.commands.RichlinksRefresh");
goog.require("uno.BasePlugin");
goog.require("uno.util.richlink");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.RichlinksRefresh");
  var RichlinksRefresh = uno.commands.RichlinksRefresh = function(opt) {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(RichlinksRefresh, uno.BasePlugin);
  RichlinksRefresh.prototype.isSupportedCommand = function(command) {
    return command === "richlinks.refresh";
  };
  RichlinksRefresh.prototype.execCommandInternal = function(command, opt) {
    util.richlink.refreshAllRichLinks();
  };
})();
goog.provide("uno.commands.SelectAll");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.dom.Range");
goog.require("goog.functions");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.SelectAll");
  var SelectAll = uno.commands.SelectAll = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(SelectAll, uno.BasePlugin);
  SelectAll.SELECTOR = "en-note";
  SelectAll.prototype.isSupportedCommand = function(command) {
    return command === "selectall";
  };
  SelectAll.prototype.activeOnUneditableFields = goog.functions.TRUE;
  SelectAll.prototype.execCommand = function() {
    var contentElement = goog.dom.getElement(SelectAll.SELECTOR);
    var range = goog.dom.Range.createFromNodeContents(contentElement);
    range.select();
  };
  SelectAll.prototype.queryCommandValue = function() {
  };
})();
goog.provide("uno.commands.Selection");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.range");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Selection");
  var util = uno.util;
  var Selection = uno.commands.Selection = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Selection, uno.BasePlugin);
  Selection.prototype.isSupportedCommand = function(command) {
    return command === "selection";
  };
  Selection.prototype.execCommand = function(command, selectionPath) {
    try {
      var path = selectionPath;
      var startNode = getNodeFromPath(this.editor.field, path.startNode);
      var endNode = getNodeFromPath(this.editor.field, path.endNode);
      var range = goog.dom.Range.createFromNodes(startNode, path.startOffset, endNode, path.endOffset);
      this.editor.restoreRange(range);
    } catch (e) {
      log.warning("could not restore the range");
    }
  };
  Selection.prototype.queryCommandValue = function() {
    var range = this.editor.getRange();
    if (range) {
      var path = {startNode:getNodePath(range.getStartNode()), endNode:getNodePath(range.getEndNode()), startOffset:range.getStartOffset(), endOffset:range.getEndOffset(), collapsed:range.isCollapsed()};
      return path;
    }
    return "";
  };
  function getNodePath(node) {
    var path = [];
    goog.dom.getAncestor(node, function(element) {
      if (util.dom.isEnnote(element)) {
        return true;
      }
      path.unshift(util.dom.index(element));
      return false;
    }, true);
    return path;
  }
  function getNodeFromPath(root, path) {
    var node = root;
    path.forEach(function(index) {
      if (node.childNodes) {
        node = node.childNodes[index];
      }
    });
    return node;
  }
})();
goog.provide("goog.dom.dataset");
goog.require("goog.string");
goog.require("goog.userAgent.product");
goog.dom.dataset.ALLOWED_ = !goog.userAgent.product.IE;
goog.dom.dataset.PREFIX_ = "data-";
goog.dom.dataset.set = function(element, key, value) {
  if (goog.dom.dataset.ALLOWED_ && element.dataset) {
    element.dataset[key] = value;
  } else {
    element.setAttribute(goog.dom.dataset.PREFIX_ + goog.string.toSelectorCase(key), value);
  }
};
goog.dom.dataset.get = function(element, key) {
  if (goog.dom.dataset.ALLOWED_ && element.dataset) {
    if (!(key in element.dataset)) {
      return null;
    }
    return element.dataset[key];
  } else {
    return element.getAttribute(goog.dom.dataset.PREFIX_ + goog.string.toSelectorCase(key));
  }
};
goog.dom.dataset.remove = function(element, key) {
  if (goog.dom.dataset.ALLOWED_ && element.dataset) {
    if (goog.dom.dataset.has(element, key)) {
      delete element.dataset[key];
    }
  } else {
    element.removeAttribute(goog.dom.dataset.PREFIX_ + goog.string.toSelectorCase(key));
  }
};
goog.dom.dataset.has = function(element, key) {
  if (goog.dom.dataset.ALLOWED_ && element.dataset) {
    return key in element.dataset;
  } else {
    if (element.hasAttribute) {
      return element.hasAttribute(goog.dom.dataset.PREFIX_ + goog.string.toSelectorCase(key));
    } else {
      return !!element.getAttribute(goog.dom.dataset.PREFIX_ + goog.string.toSelectorCase(key));
    }
  }
};
goog.dom.dataset.getAll = function(element) {
  if (goog.dom.dataset.ALLOWED_ && element.dataset) {
    return element.dataset;
  } else {
    var dataset = {};
    var attributes = element.attributes;
    for (var i = 0;i < attributes.length;++i) {
      var attribute = attributes[i];
      if (goog.string.startsWith(attribute.name, goog.dom.dataset.PREFIX_)) {
        var key = goog.string.toCamelCase(attribute.name.substr(5));
        dataset[key] = attribute.value;
      }
    }
    return dataset;
  }
};
goog.provide("uno.commands.SharedBar");
goog.require("goog.array");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.dom.classlist");
goog.require("goog.dom.dataset");
goog.require("goog.style");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.SharedBar");
  var util = uno.util;
  var firstTime = true;
  var messageNode = null;
  var businessNode = null;
  var containerNode = null;
  var SharedBar = uno.commands.SharedBar = function() {
    uno.BasePlugin.call(this, log.getName());
    containerNode = document.querySelector("#en-shared");
    if (containerNode != null) {
      goog.dom.removeNode(containerNode);
      containerNode = null;
    }
    messageNode = goog.dom.createDom("div", {"class":"en-shared-message"});
    businessNode = goog.dom.createDom("div", {"class":"en-shared-business", "style":"display:none;"});
    containerNode = goog.dom.createDom("div", {"class":"en-shared en-shared-off", "id":"en-shared", "style":"display:none;"}, [businessNode, messageNode]);
    document.body.insertBefore(containerNode, document.body.firstChild);
  };
  goog.inherits(SharedBar, uno.BasePlugin);
  SharedBar.prototype.isSupportedCommand = function(command) {
    return command === "shared";
  };
  SharedBar.prototype.execCommand = function(command, options) {
    var result = false;
    var visible = options.visible;
    if (visible != null) {
      goog.style.setElementShown(containerNode, !!visible);
      result = true;
    }
    var active = options.active;
    if (active != null) {
      goog.dom.classlist.add(containerNode, active ? "en-shared-on" : "en-shared-off");
      goog.dom.classlist.remove(containerNode, active ? "en-shared-off" : "en-shared-on");
      result = true;
    }
    var business = options.business;
    if (business != null) {
      goog.style.setElementShown(businessNode, !!business);
      result = true;
    }
    var message = options.value;
    if (goog.isString(message)) {
      if (firstTime) {
        replaceInnerHTML(message);
        firstTime = false;
      } else {
        setTimeout(function() {
          replaceInnerHTML(message);
        }.bind(this), 1E3);
      }
      result = true;
    }
    return result;
  };
  var replaceInnerHTML = function(message) {
    messageNode.innerHTML = message;
    goog.array.forEach(messageNode.querySelectorAll("a"), function(a) {
      var href = a.getAttribute("href");
      a.removeAttribute("href");
      a = util.dom.setTagName(a, "span");
      goog.dom.classlist.add(a, "en-shared-link");
      goog.dom.dataset.set(a, "href", href);
    });
  };
})();
goog.provide("uno.util.simpletext.generic");
goog.require("uno.defs");
(function() {
  var generic = uno.util.simpletext.generic;
  generic.getHighlightColor = function() {
    return uno.defs.highlight.BACKGROUND_COLOR_MAC;
  };
  generic.handlePlatformSpecificElements = function(simplifier, node) {
  };
})();
goog.provide("uno.util.simpletext.ios");
goog.require("uno.defs");
(function() {
  var ios = uno.util.simpletext.ios;
  var util = uno.util;
  ios.getHighlightColor = function() {
    return uno.defs.highlight.BACKGROUND_COLOR_IOS;
  };
  ios.handlePlatformSpecificElements = function(simplifier, node) {
  };
})();
goog.provide("uno.util.simpletext.mac");
goog.require("uno.defs");
(function() {
  var mac = uno.util.simpletext.mac;
  var util = uno.util;
  var dom = uno.util.dom;
  mac.getHighlightColor = function() {
    return uno.defs.highlight.BACKGROUND_COLOR_MAC;
  };
  mac.handlePlatformSpecificElements = function(simplifier, node) {
    var tag = node.tagName.toLowerCase();
    if (tag === "div" && /^en-revealed-crypto:\d+$/.test(node.id)) {
      simplifier.startNewBlock();
      simplifier.appendInlineElement(node, node.cloneNode(true), true);
      simplifier.startNewBlock();
      simplifier.skipNodes.push(node);
      return;
    }
    if (tag === "embed") {
      var attrs = dom.attributes(node);
      var objectType = attrs.type.toLowerCase();
      if (objectType === "evernote/x-crypto" || objectType === "evernote/x-todo" || objectType === "evernote/x-attachment" || objectType === "evernote/x-pdf") {
        simplifier.appendInlineElement(node);
      }
      return;
    }
  };
})();
goog.provide("uno.util.simpletext.win");
goog.require("uno.defs");
(function() {
  var win = uno.util.simpletext.win;
  var util = uno.util;
  var dom = uno.util.dom;
  win.getHighlightColor = function() {
    return uno.defs.highlight.BACKGROUND_COLOR_MAC;
  };
  win.handlePlatformSpecificElements = function(simplifier, node) {
    var tag = node.tagName.toLowerCase();
    if (tag === "img") {
      var attrs = dom.attributes(node);
      var src = attrs.src.toLowerCase();
      if (src.indexOf("en-resource://database/check") === 0) {
        simplifier.appendInlineElement(node);
        return;
      }
    }
    if (tag === "object") {
      var attrs = dom.attributes(node);
      var objectType = attrs.type.toLowerCase();
      if (objectType === "application/x-evernote-pdf" || objectType === "application/x-evernote-attachment" || objectType === "application/x-evernote-audio" || objectType === "") {
        simplifier.appendInlineElement(node);
      }
      return;
    }
  };
})();
goog.provide("uno.util.simpletext");
goog.require("goog.debug.Logger");
goog.require("goog.dom.classes");
goog.require("goog.editor.node");
goog.require("uno.defs");
goog.require("uno.util.crypto");
goog.require("uno.util.dom");
goog.require("uno.util.resource");
goog.require("uno.util.richlink");
goog.require("uno.util.simpletext.generic");
goog.require("uno.util.simpletext.ios");
goog.require("uno.util.simpletext.mac");
goog.require("uno.util.simpletext.win");
goog.require("uno.util.todo");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.simpletext");
  var SimpleText = uno.util.simpletext;
  var platform = uno.util.simpletext.generic;
  var util = uno.util;
  var dom = uno.util.dom;
  util.simpletext.setPlatform = function(platformName) {
    goog.asserts.assert(platformName);
    platform = uno.util.simpletext[platformName];
  };
  SimpleText.getHighlightColor = function() {
    return platform.getHighlightColor();
  };
  SimpleText.handlePlatformSpecificElements = function(simplifier, node) {
    platform.handlePlatformSpecificElements(simplifier, node);
  };
  var Simplifier = SimpleText.Simplifier = function(inputElement, outputElement, config, editor) {
    uno.BasePlugin.call(this, log.getName());
    if (editor == null) {
      log.severe("No editor instance given!");
      return;
    }
    this.editor = editor;
    if (config == null) {
      config = {};
    }
    this.config = config;
    if (this.config.cssBlockStyle != null) {
      this.cssBlockStyle = config.cssBlockStyle;
    } else {
      this.cssBlockStyle = this.EN_DEFAULT_PARAGRAPH_STYLE;
    }
    this.async = !!config.async;
    if (!inputElement) {
      inputElement = document.body;
    } else {
      if (inputElement instanceof DocumentFragment || !dom.isRenderedDOMNode(inputElement)) {
        var tmpNode = document.createElement("div");
        tmpNode.appendChild(inputElement);
        document.body.appendChild(tmpNode);
        inputElement = tmpNode;
        this.tmpNode = tmpNode;
      }
    }
    this.inputElement = inputElement;
    this.outputElement = outputElement;
    this.loopStart();
  };
  goog.inherits(Simplifier, uno.BasePlugin);
  Simplifier.prototype.EN_DEFAULT_PARAGRAPH_TAG = uno.defs.tags.BLOCK;
  Simplifier.prototype.EN_DEFAULT_PARAGRAPH_STYLE = null;
  Simplifier.prototype.EN_EMPTY_LINE_THRESHOLD_VALUE = .8;
  Simplifier.prototype.EN_TIMER_INTERRUPT = 150;
  Simplifier.prototype.EN_TIMER_DELAY = 10;
  Simplifier.prototype.EN_PROGRESS_MINIMUM_LIFETIME = 2E3;
  Simplifier.prototype.EN_INTERNAL_LINK_PREFIX = "evernote://";
  Simplifier.prototype.EN_INTERNAL_LINK_COLOR = "rgb(105, 170, 53)";
  var isParagraph = function(node) {
    var tag = node.tagName.toLowerCase();
    return tag === "p" || tag === "div";
  };
  var isListContainer = function(node) {
    var tag = node.tagName.toLowerCase();
    return tag === "ul" || tag === "ol";
  };
  var isTableElementTag = function(tag) {
    goog.asserts.assert(tag.toLowerCase() === tag, "Tag lowercase error");
    return tag === "td" || tag === "th";
  };
  var copyAttributes = function(destinationElement, sourceElement, attrName, defaultValue) {
    var value = sourceElement.getAttribute(attrName);
    if (value == null) {
      if (defaultValue == null) {
        return;
      }
      value = defaultValue;
    }
    destinationElement.setAttribute(attrName, value);
  };
  Simplifier.prototype.cancel = function() {
    this.loopCancel = true;
  };
  Simplifier.prototype.loopStart = function() {
    var self = this;
    this.block = null;
    this.blockReferenceNode = null;
    this.listReferenceNode = null;
    this.lastTableReferenceBlock = null;
    this.tableReferenceNode = null;
    this.runningTableNode = null;
    this.resultElement = document.createElement("div");
    this.lastListItem = null;
    this.lastBBox = null;
    this.requiresEmptyLine = false;
    this.skipNodes = [];
    var bodyStyle = window.getComputedStyle(document.body);
    this.thresholdForEmptyLine = bodyStyle && bodyStyle.fontSize ? +bodyStyle.fontSize.replace(/px/gi, "") * this.EN_EMPTY_LINE_THRESHOLD_VALUE : 16;
    goog.asserts.assert(this.thresholdForEmptyLine > 1, "Empty threshold error");
    if (this.async) {
      this.loopNodeCount = 0;
      this.loopCount = 0;
      this.loopProgress = 0;
      this.loopProgressStarted = false;
      this.loopStartTime = this.loopTime = (new Date).getTime();
      var iter = document.createNodeIterator(this.inputElement, uno.defs.bitfields.NODE_SHOW_ALL, null, true);
      var c = 0;
      while (iter.nextNode()) {
        ++c;
      }
      this.loopTotalCount = c;
    }
    this.treeWalker = document.createTreeWalker(this.inputElement, uno.defs.bitfields.NODE_SHOW_ALL, {"acceptNode":function(node) {
      for (var i = 0;i < self.skipNodes.length;i++) {
        if (dom.isChild(node, self.skipNodes[i])) {
          return uno.defs.bitfields.NODE_FILTER_REJECT;
        }
      }
      return uno.defs.bitfields.NODE_FILTER_ACCEPT;
    }}, true);
    this.loopContinue();
  };
  Simplifier.prototype.loopContinue = function() {
    var self = this;
    if (this.loopCancel) {
      this.cleanup();
      return;
    }
    var node;
    try {
      while (node = this.treeWalker.nextNode()) {
        if (node.nodeType === uno.defs.bitfields.NODE_TEXT_NODE) {
          this.handleText(node);
        } else {
          if (node.nodeType === uno.defs.bitfields.NODE_ELEMENT_NODE) {
            this.handleElement(node);
          }
        }
        if (this.async) {
          ++this.loopNodeCount;
          if ((new Date).getTime() - this.loopTime > this.EN_TIMER_INTERRUPT) {
            break;
          }
        }
      }
      ++this.loopCount;
    } catch (ex) {
      log.severe("Simplifier crashed on main loop! " + ex.toString(), ex);
      node = null;
    }
    if (node && this.async) {
      this.loopProgress = Math.min(1, this.loopNodeCount / this.loopTotalCount);
      if (!this.loopProgressStarted) {
        var elapsedTime = (new Date).getTime() - this.loopStartTime;
        var estimatedTime = elapsedTime / this.loopProgress;
        estimatedTime += (Math.ceil(this.loopCount / this.loopProgress) - this.loopCount) * this.EN_TIMER_DELAY;
        if (estimatedTime >= this.EN_PROGRESS_MINIMUM_LIFETIME) {
          this.loopProgressStarted = true;
        }
      }
      if (this.loopProgressStarted && this.config.onprogress) {
        this.config.onprogress(this, this.loopProgress);
      }
      setTimeout(function() {
        self.loopTime = (new Date).getTime();
        self.loopContinue();
      }, this.EN_TIMER_DELAY);
    } else {
      this.skipNodes = null;
      this.optimizeFinishedBlockElement(this.block);
      if (this.loopProgressStarted && this.config.onprogress) {
        this.config.onprogress(this, 1);
      }
      this.loopDone();
    }
  };
  Simplifier.prototype.loopDone = function() {
    if (this.outputElement) {
      goog.dom.removeChildren(this.outputElement);
      dom.moveChildren(this.resultElement, this.outputElement);
    } else {
      this.outputElement = this.resultElement;
    }
    this.cleanup();
    if (this.config.onready) {
      this.config.onready(this);
    }
  };
  Simplifier.prototype.cleanup = function() {
    if (this.tmpNode) {
      document.body.removeChild(this.tmpNode);
    }
  };
  Simplifier.prototype.stripTrailingBlanks = function(blockElement) {
    var n;
    var iter = document.createNodeIterator(blockElement, uno.defs.bitfields.NODE_SHOW_TEXT, null, true);
    while (n = iter.nextNode()) {
      n.textContent = n.textContent.replace(/^ /gi, "");
      if (n.textContent.length > 0) {
        break;
      } else {
        if (dom.isTextNode(n)) {
          n.parentNode.appendChild(document.createElement("br"));
        } else {
          n.appendChild(document.createElement("br"));
        }
      }
    }
    iter = document.createNodeIterator(blockElement, uno.defs.bitfields.NODE_SHOW_TEXT, null, true);
    var stack = [];
    while (n = iter.nextNode()) {
      stack.unshift(n);
    }
    for (var i = 0;i < stack.length;i++) {
      n = stack[i];
      n.textContent = n.textContent.replace(/\s+$/gi, "");
      if (n.textContent.length > 0) {
        break;
      } else {
        if (dom.isTextNode(n)) {
          n.parentNode.appendChild(document.createElement("br"));
        } else {
          n.appendChild(document.createElement("br"));
        }
      }
    }
  };
  Simplifier.prototype.optimizeFinishedBlockElement = function(blockElement) {
    if (!blockElement) {
      return;
    }
    this.stripTrailingBlanks(blockElement);
    blockElement.normalize();
  };
  Simplifier.prototype.createBlockElement = function(tag) {
    var el = document.createElement(!!tag ? tag : this.EN_DEFAULT_PARAGRAPH_TAG);
    if (this.cssBlockStyle) {
      el.setAttribute("style", this.cssBlockStyle);
    }
    return el;
  };
  Simplifier.prototype.appendEmptyLine = function() {
    var br = this.createBlockElement();
    br.appendChild(document.createElement("br"));
    this.resultElement.appendChild(br);
    this.requiresEmptyLine = false;
  };
  Simplifier.prototype.appendBlockElement = function(elemOrTag) {
    var el = this.createBlockElement();
    if (elemOrTag != null) {
      if (goog.isString(elemOrTag)) {
        el = this.createBlockElement(elemOrTag);
      } else {
        if (goog.dom.isElement(elemOrTag)) {
          el = elemOrTag;
        }
      }
    }
    if (this.resultElement.hasChildNodes && this.requiresEmptyLine) {
      var last = this.resultElement.lastElementChild;
      if (last && last.textContent.length && isParagraph(last) && isParagraph(el)) {
        this.appendEmptyLine();
      }
    }
    this.requiresEmptyLine = false;
    this.resultElement.appendChild(el);
    return el;
  };
  Simplifier.prototype.startNewBlock = function(keepBlockReference) {
    this.optimizeFinishedBlockElement(this.block);
    this.block = null;
    if (!keepBlockReference) {
      this.blockReferenceNode = null;
    }
  };
  Simplifier.prototype.calculateExtraBlankLines = function(node) {
    var range = document.createRange();
    range.selectNodeContents(node);
    var bbox = range.getBoundingClientRect();
    if (this.lastBBox && bbox && !dom.isChild(node, this.blockReferenceNode)) {
      var deltaY = Math.abs(bbox.top - this.lastBBox.bottom);
      if (deltaY >= this.thresholdForEmptyLine) {
        this.requiresEmptyLine = true;
      }
    }
    if (bbox) {
      this.lastBBox = bbox;
    }
  };
  Simplifier.prototype.appendInlineElementInList = function(node) {
    var elementToInsert;
    var nodeListItem = dom.parent(node, "li");
    if (nodeListItem == null) {
      this.listReferenceNode = null;
      return;
    }
    if (dom.isTextNode(node)) {
      if (node.textContent.search(/^\s*$/i) !== -1) {
        return;
      }
      elementToInsert = document.createTextNode(node.textContent.replace(/\s+/gi, " "));
    }
    if (this.lastListItem && this.listReferenceNode === nodeListItem) {
      this.block = this.lastListItem;
      if (!dom.isInlineNode(this.lastListItem.lastChild) || !dom.isInlineNode(node)) {
        this.block.appendChild(document.createElement("br"));
      }
    } else {
      var listLevel = 0;
      var listType = null;
      var cursor = nodeListItem;
      while (cursor && cursor !== this.inputElement) {
        if (isListContainer(cursor)) {
          ++listLevel;
          if (!listType) {
            listType = cursor.tagName.toLowerCase();
          }
        }
        cursor = cursor.parentNode;
      }
      listLevel = Math.max(0, listLevel);
      var lastListContainer = null;
      if (this.block && this.block.childNodes.length > 0) {
        cursor = this.block;
      } else {
        cursor = this.resultElement;
      }
      while (1) {
        cursor = cursor.lastElementChild;
        if (!cursor) {
          break;
        }
        if (isListContainer(cursor)) {
          lastListContainer = cursor;
          --listLevel;
          if (listLevel < 1) {
            break;
          }
        }
      }
      if (listLevel > 0 && lastListContainer) {
        var li = lastListContainer.lastElementChild;
        lastListContainer = this.appendBlockElement(listType || "ol");
        li.appendChild(lastListContainer);
      } else {
        if (!lastListContainer) {
          if (this.block != null) {
            lastListContainer = document.createElement(listType || "ol");
            this.block.appendChild(lastListContainer);
          } else {
            lastListContainer = this.appendBlockElement(listType || "ol");
          }
        } else {
          if (this.requiresEmptyLine || listType && listType !== lastListContainer.tagName.toLowerCase()) {
            if (this.block != null) {
              lastListContainer = document.createElement(listType || "ol");
              this.block.appendChild(lastListContainer);
            } else {
              lastListContainer = this.appendBlockElement(listType || "ol");
            }
          }
        }
      }
      if (this.block === null && listLevel > 0) {
        for (var i = listLevel - 1;i--;) {
          var newList = this.appendBlockElement(listType || "ol");
          lastListContainer.appendChild(newList);
          lastListContainer = newList;
        }
      }
      this.block = this.createBlockElement("li");
      if (nodeListItem && util.todo.isChecked(nodeListItem)) {
        util.todo.setChecked(this.block);
      }
      lastListContainer.appendChild(this.block);
      this.listReferenceNode = nodeListItem;
      this.lastListItem = this.block;
    }
  };
  Simplifier.prototype.appendInlineElementInTable = function(node) {
    var table = dom.parent(node, "table");
    if (table == null || !dom.isHtmlElement(table) || table.tagName.toLowerCase() !== "table") {
      log.warning("Couldn't simplify table. Look into this!");
      return;
    }
    var dimensions = util.table.dimensions(table);
    if (dimensions.rows === -1) {
      return;
    }
    if (this.tableReferenceNode !== table) {
      this.tableReferenceNode = table;
      this.runningTableNode = util.table.createDomTable(dimensions, this.editor);
      this.appendBlockElement(this.runningTableNode);
      this.lastTableReferenceBlock = null;
    }
    var positionInfo = util.table.positionInTable(node);
    if (positionInfo.table == null) {
      return;
    }
    var newTrs = this.runningTableNode.querySelectorAll("tr");
    var newTr = newTrs[positionInfo.row];
    var newTds = newTr.querySelectorAll("td");
    var newTd = newTds[positionInfo.column];
    var targetBlock = newTd;
    if (newTd == null) {
      log.warning("Something crazy happened with table simplify");
      return;
    }
    if (newTd.childNodes.length === 1 && newTd.childNodes[0].tagName.toLowerCase() === uno.defs.tags.BLOCK) {
      targetBlock = newTd.childNodes[0];
      if (targetBlock.childNodes.length === 1 && targetBlock.childNodes[0].tagName && targetBlock.childNodes[0].tagName.toLowerCase() === "br") {
        goog.dom.removeChildren(targetBlock);
      }
    }
    if (this.lastTableReferenceBlock && this.lastTableReferenceBlock.parentNode.tagName.toLowerCase() === "td" && this.lastTableReferenceBlock.parentNode === newTd && targetBlock.tagName.toLowerCase() !== "td" && (dom.isTextNode(node) && !dom.isInlineNode(node) && !dom.isInlineNode(node.parentNode))) {
      var newBlock = this.createBlockElement();
      var parent = dom.parent(targetBlock, "td");
      parent.appendChild(newBlock);
      targetBlock = newBlock;
    }
    this.lastTableReferenceBlock = targetBlock;
    this.block = targetBlock;
  };
  Simplifier.prototype.appendInlineElement = function(node, elementToInsert, onTopLevel, isWhiteSpace) {
    var tag;
    var isNewBlockContext = !dom.isChild(node, this.blockReferenceNode);
    if (isWhiteSpace && isNewBlockContext) {
      return null;
    }
    if (!elementToInsert) {
      elementToInsert = node.cloneNode(false);
    }
    if (node && node.tagName && node.tagName.toLowerCase() !== "br") {
      this.calculateExtraBlankLines(node);
    }
    if (isNewBlockContext) {
      if (goog.dom.isElement(this.blockReferenceNode)) {
        tag = this.blockReferenceNode.tagName.toLowerCase();
        if (isTableElementTag(tag)) {
          this.requiresEmptyLine = true;
        }
      }
      this.startNewBlock();
    }
    var container = node;
    while (container !== this.inputElement && (container = container.parentNode)) {
      this.blockReferenceNode = container;
      tag = container.tagName.toLowerCase();
      if (tag === "li") {
        break;
      }
      if (isTableElementTag(tag)) {
        break;
      }
      if (dom.isComputedBlock(container)) {
        break;
      }
    }
    if (dom.parent(node, "table")) {
      this.appendInlineElementInTable(node);
    }
    if (dom.parent(node, "li")) {
      this.appendInlineElementInList(node);
    }
    var flags = this.getStyleFlagsOfNode(node);
    if (!this.block) {
      this.block = this.appendBlockElement();
    }
    this.block.appendChild(this.sourroundNodeWithStyles(elementToInsert, flags));
    return elementToInsert;
  };
  Simplifier.prototype.handleText = function(node) {
    if (!node) {
      log.warning("Node missing", node);
      return;
    }
    var txt;
    var style = window.getComputedStyle(node.parentNode);
    if (style && /pre/gi.test(style.whiteSpace)) {
      var lines = node.textContent.split(/\n\r|\r\n|\r|\n/gi);
      if (lines && lines.length > 0) {
        txt = lines[0].replace(/\s/gi, " ").replace(/\s\s/gi, "\u00a0 ");
        var txtNode = this.appendInlineElement(node, document.createTextNode(txt));
        if (txtNode) {
          for (var i = 1;i < lines.length;i++) {
            var parent = txtNode.parentNode;
            parent.appendChild(document.createElement("br"));
            txt = lines[i].replace(/\s/gi, " ").replace(/\s\s/gi, "\u00a0 ");
            parent.appendChild(document.createTextNode(txt));
          }
        }
      }
    } else {
      txt = node.textContent.replace(/[\ \n\r\t]+/gi, " ");
      var isWhiteSpace = false;
      if (txt.search(/^[\ \t\n]*$/i) !== -1) {
        isWhiteSpace = true;
      }
      this.appendInlineElement(node, document.createTextNode(txt), false, isWhiteSpace);
    }
  };
  Simplifier.prototype.handleElement = function(node) {
    if (!node) {
      log.warning("Node missing", node);
      return;
    }
    var tag = node.tagName.toLowerCase();
    SimpleText.handlePlatformSpecificElements(this, node);
    if (tag === "script" || tag === "style") {
      this.skipNodes.push(node);
      return;
    }
    if (util.todo.isTodo(node)) {
      this.appendInlineElement(node);
      return;
    }
    if (util.resource.isResource(node) || util.crypto.isCrypt(node) || util.richlink.isRichLink(node)) {
      this.startNewBlock();
      this.appendInlineElement(node, node.cloneNode(true), true);
      this.startNewBlock();
      this.skipNodes.push(node);
      return;
    }
    if (tag === "img" && node.src) {
      this.startNewBlock();
      var img = document.createElement("img");
      copyAttributes(img, node, "src");
      copyAttributes(img, node, "alt", "");
      copyAttributes(img, node, "id");
      this.appendInlineElement(node, img, true);
      this.startNewBlock();
      return;
    }
    if (tag === "hr") {
      this.startNewBlock();
      var attrs = {};
      if (goog.style.getStyle(node, "-evernote-encp-section-break") === "true") {
        attrs = {"style":"display:none;-evernote-encp-section-break:true;"};
      }
      this.appendInlineElement(node, document.createElement("hr", attrs), true);
      this.startNewBlock();
      return;
    }
    if (tag === "br") {
      var parentLi = dom.parent(node, "li");
      if (parentLi && goog.editor.node.getRightMostLeaf(parentLi) === node) {
        return;
      } else {
        if (dom.parent(node, "table")) {
          this.startNewBlock();
          var br = this.createBlockElement();
          br.appendChild(document.createElement("br"));
          this.appendInlineElement(node, br, true);
        } else {
          this.startNewBlock();
          this.appendEmptyLine();
          return;
        }
      }
    }
    if (this.block && node && (dom.isComputedBlock(node) || !dom.isParent(this.blockReferenceNode, node))) {
      this.startNewBlock();
      return;
    }
  };
  Simplifier.prototype.getStyleFlagsOfNode = function(node) {
    var flags = {a:0, m:0, e:0, b:0, i:0, u:0, s:0};
    while (node || node === this.inputElement) {
      var tag = null;
      if (node && node.tagName) {
        tag = node.tagName.toLowerCase();
      }
      if (tag === "del" || tag === "strike" || tag === "s") {
        flags.s = 1;
      } else {
        if (tag === "mark") {
          flags.m = 1;
        } else {
          if (tag === "a") {
            var href = node.href + "";
            if (href && href.length) {
              flags.a = href;
              flags.e = href.indexOf(this.EN_INTERNAL_LINK_PREFIX) === 0;
            }
          }
        }
      }
      var style = null;
      if (goog.dom.isElement(node)) {
        style = window.getComputedStyle(node);
      }
      if (style) {
        var bgColor = style.backgroundColor.toLowerCase();
        if (bgColor === uno.defs.highlight.BACKGROUND_COLOR_IOS || bgColor === uno.defs.highlight.BACKGROUND_COLOR_MAC || bgColor === uno.defs.highlight.BACKGROUND_COLOR_CLEARLY) {
          flags.m = 1;
        }
        var fontWeight = style.fontWeight.toLowerCase();
        var fontStyle = style.fontStyle.toLowerCase();
        var textDecorations = style.textDecoration.toLowerCase();
        if (fontWeight === "bold" || fontWeight === "bolder" || fontWeight === "700") {
          flags.b = 1;
        }
        if (fontStyle === "italic" || fontStyle === "oblique") {
          flags.i = 1;
        }
        if (!flags.a && textDecorations.indexOf("underline") >= 0) {
          flags.u = 1;
        }
        if (textDecorations.indexOf("line-through") >= 0) {
          flags.s = 1;
        }
      }
      node = node.parentNode;
    }
    if (flags.a && flags.u) {
      delete flags.u;
    }
    return flags;
  };
  Simplifier.prototype.sourroundNodeWithStyles = function(node, flags) {
    var el;
    if (flags.a) {
      el = document.createElement("a");
      el.setAttribute("href", flags.a);
      if (flags.e) {
        el.setAttribute("style", "color:" + this.EN_INTERNAL_LINK_COLOR + ";");
      }
      el.appendChild(node);
      node = el;
    }
    if (flags.b) {
      el = document.createElement(uno.defs.tags.BOLD);
      el.appendChild(node);
      node = el;
    }
    if (flags.i) {
      el = document.createElement(uno.defs.tags.ITALIC);
      el.appendChild(node);
      node = el;
    }
    if (flags.u) {
      el = document.createElement(uno.defs.tags.UNDERLINE);
      el.appendChild(node);
      node = el;
    }
    if (flags.s) {
      el = document.createElement(uno.defs.tags.STRIKETHROUGH);
      el.appendChild(node);
      node = el;
    }
    if (flags.m) {
      var styleString = uno.defs.highlight.STYLE + ":true; background-color:" + util.simpletext.getHighlightColor() + ";";
      el = document.createElement("span");
      el.setAttribute("style", styleString);
      el.appendChild(node);
      node = el;
    }
    return node;
  };
})();
goog.provide("uno.commands.SimpleText");
goog.require("goog.asserts");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.editor.range");
goog.require("goog.style");
goog.require("uno.BasePlugin");
goog.require("uno.util.range");
goog.require("uno.util.todo");
goog.require("uno.util.simpletext");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.SimpleText");
  var util = uno.util;
  var dom = uno.util.dom;
  var Simplifier = uno.util.simpletext.Simplifier;
  var SimpleText = uno.commands.SimpleText = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(SimpleText, uno.BasePlugin);
  SimpleText.prototype.isSupportedCommand = function(command) {
    return command === "simpletext";
  };
  SimpleText.prototype.activeOnUneditableFields = goog.functions.TRUE;
  SimpleText.prototype.execCommand = function(command, opt) {
    var range = this.editor.getRange();
    var isCollapsed = range ? range.isCollapsed() : true;
    var savedRange;
    var frag;
    var endParent, endNode;
    var root = this.editor.getElement();
    if (range && !range.isCollapsed()) {
      var rangeAncestors = util.range.commonAncestors(range, "td", root);
      if (rangeAncestors[0] === rangeAncestors[1] && rangeAncestors[0].tagName.toLowerCase() === "td") {
        rangeAncestors = util.range.commonAncestors(range, "div", root);
      } else {
        rangeAncestors = util.range.commonAncestors(range, "table,ul,ol", root);
      }
      var startSelection = rangeAncestors[0];
      var endSelection = rangeAncestors[1];
      endNode = endSelection.nextSibling;
      endParent = endSelection.parentNode;
      if (startSelection === endSelection) {
        goog.editor.range.selectNodeStart(startSelection);
      } else {
        goog.dom.Range.createFromNodes(startSelection, 0, endSelection, endSelection.childNodes.length).select();
      }
      frag = this.editor.getRange().getBrowserRangeObject().cloneContents();
    }
    if (frag) {
      var resultNode = (new Simplifier(frag, null, null, this.editor)).outputElement;
      if (!resultNode) {
        return true;
      }
      var result = resultNode.childNodes;
      if (result.length === 0) {
        return true;
      }
      var startSelection = result[0];
      var endSelection = result[result.length - 1];
      var remainingContainer = range.getBrowserRangeObject().startContainer;
      var remainingEndContainer = range.getBrowserRangeObject().endContainer;
      if (endNode && dom.isTextNode(endNode) && endNode.length === 0) {
        endNode = null;
      }
      while (result.length > 0) {
        if (endNode !== null) {
          endParent.insertBefore(result[0], endNode);
        } else {
          endParent.appendChild(result[0]);
        }
      }
      this.editor.execCommand("delete");
      if (remainingEndContainer !== endParent && remainingEndContainer !== root && remainingEndContainer !== remainingContainer) {
        goog.dom.removeNode(remainingEndContainer);
      }
      if (remainingContainer !== root && remainingContainer !== endParent) {
        goog.dom.removeNode(remainingContainer);
      }
      var firstChild = dom.firstChild(startSelection);
      var lastChild = dom.lastChild(endSelection);
      goog.dom.Range.createFromNodes(firstChild, 0, lastChild, lastChild.length).select();
    } else {
      new Simplifier(root, root, null, this.editor);
      goog.editor.range.selectNodeStart(root);
    }
    this.editor.dispatchChange();
    return true;
  };
})();
goog.provide("uno.commands.Undo");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Undo");
  var Undo = uno.commands.Undo = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Undo, uno.BasePlugin);
  Undo.prototype.isSupportedCommand = function(command) {
    return command === "undo";
  };
  Undo.prototype.execCommand = function(command, opt) {
    return this.editor.execCommand(goog.editor.Command.UNDO);
  };
  Undo.prototype.queryCommandValue = function(command) {
    var hasOperations = this.editor.queryCommandValue(goog.editor.Command.UNDO);
    return hasOperations ? "Changes" : "";
  };
})();
goog.provide("uno.commands.Unlink");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.functions");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Unlink");
  var Unlink = uno.commands.Unlink = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Unlink, uno.BasePlugin);
  Unlink.prototype.isSupportedCommand = function(command) {
    return command === "unlink";
  };
  Unlink.prototype.activeOnUneditableFields = goog.functions.TRUE;
  Unlink.prototype.execCommandInternal = function(command) {
    var range = this.editor.getRange();
    var link = goog.dom.getAncestorByTagNameAndClass(range.getContainer(), "a");
    if (link) {
      goog.dom.flattenElement(link);
    }
  };
  Unlink.prototype.queryCommandEnabled = function(command) {
    var range = this.editor.getRange();
    var link = range && goog.dom.getAncestorByTagNameAndClass(range.getContainer(), "a");
    return link != null;
  };
})();
goog.provide("uno.commands.Uppercase");
goog.require("goog.debug.Logger");
goog.require("goog.iter");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.commands.Uppercase");
  var Uppercase = uno.commands.Uppercase = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(Uppercase, uno.BasePlugin);
  Uppercase.prototype.isSupportedCommand = function(command) {
    return command === "uppercase";
  };
  Uppercase.prototype.execCommandInternal = function(command, opt) {
    var range = this.editor.getRange();
    var savedRange = range.saveUsingDom();
    goog.iter.forEach(range, function(element) {
      if (element.nodeType === Node.TEXT_NODE) {
        element.nodeValue = element.nodeValue.toUpperCase();
      }
    });
    savedRange.restore().select();
  };
  Uppercase.prototype.queryCommandValue = function(command) {
  };
})();
goog.provide("uno.filters.cryptfilter.generic");
goog.require("uno.util.crypto");
goog.require("uno.defs");
(function() {
  var util = uno.util;
  var generic = uno.filters.cryptfilter.generic;
  var CRYPT_CLASS = uno.defs.crypto.CRYPT_CLASS;
  generic.importENML = function(fragment, context) {
    var cryptElements = fragment.querySelectorAll("en-crypt");
    Array.prototype.forEach.call(cryptElements, function(node) {
      var newId = context.crypt.incrementUniqueId();
      var cryptInfo = {id:"crypt-" + newId, rev:"crypt-" + newId + "-0"};
      cryptInfo.cipherText = node.textContent;
      cryptInfo.length = node.getAttribute("length");
      cryptInfo.cipher = node.getAttribute("cipher");
      cryptInfo.hint = node.getAttribute("hint");
      var newNode = util.crypto.createCryptoPlaceholder(cryptInfo);
      goog.dom.replaceNode(newNode, node);
    });
  };
  generic.importHTML = function(fragment, context) {
    return generic.importENML(fragment, context);
  };
  generic.exportENML = function(fragment) {
    var cryptElements = fragment.querySelectorAll("." + CRYPT_CLASS);
    Array.prototype.forEach.call(cryptElements, function(node) {
      var newNode = goog.dom.createDom("en-crypt", {cipher:node.getAttribute("data-cipher"), hint:node.getAttribute("data-hint"), length:node.getAttribute("data-length")});
      newNode.innerHTML = node.getAttribute("data-ciphertext");
      goog.dom.replaceNode(newNode, node);
    });
  };
  generic.exportHTML = function() {
  };
  generic.exportClipboard = function(fragment) {
    var cryptElements = fragment.querySelectorAll("." + CRYPT_CLASS);
    Array.prototype.forEach.call(cryptElements, function(node) {
      node.parentNode.removeChild(node);
    });
  };
})();
goog.provide("uno.filters.cryptfilter.mac");
(function() {
  var mac = uno.filters.cryptfilter.mac;
  mac.importENML = function(fragment) {
    var cryptElements = fragment.querySelectorAll("en-crypt");
    Array.prototype.forEach.call(cryptElements, function(node) {
      var cipherText = node.textContent.trim();
      var cipher = node.getAttribute("cipher");
      var length = cipher;
      var hint = node.getAttribute("hint");
      var infoArray = [];
      infoArray.push("en-crypt");
      infoArray.push(cipherText);
      infoArray.push(cipher);
      infoArray.push(length);
      infoArray.push(hint);
      var embedNode = goog.dom.createDom("embed", {type:"evernote/x-crypto", align:"absmiddle", id:infoArray.join(":")});
      var cryptElement = goog.dom.createDom("en-crypt", {cipherText:cipherText, cipher:cipher, length:length, hint:hint});
      cryptElement.appendChild(embedNode);
      goog.dom.replaceNode(cryptElement, node);
    });
    return fragment;
  };
  mac.importHTML = function(fragment) {
    var cryptElements = fragment.querySelectorAll('embed[type="evernote/x-crypto"]');
    Array.prototype.forEach.call(cryptElements, function(node) {
      var parts = node.id.split(":");
      var newNode = document.createElement("en-crypt");
      newNode.setAttribute("data-ciphertext", parts[1]);
      newNode.setAttribute("data-cipher", parts[2]);
      newNode.setAttribute("data-length", parts[3]);
      newNode.setAttribute("data-hint", parts[4]);
      newNode.innerHTML = node.outerHTML;
      goog.dom.replaceNode(newNode, node);
    });
    return fragment;
  };
  mac.exportENML = function(fragment) {
    return uno.filters.cryptfilter.generic.exportENML(fragment);
  };
  mac.exportHTML = function(fragment) {
    var cryptElements = fragment.querySelectorAll("en-crypt");
    Array.prototype.forEach.call(cryptElements, function(node) {
      var infoArray = [];
      infoArray.push("en-crypt");
      infoArray.push(node.getAttribute("data-ciphertext"));
      infoArray.push(node.getAttribute("data-cipher"));
      infoArray.push(node.getAttribute("data-length"));
      infoArray.push(node.getAttribute("data-hint"));
      var newNode = goog.dom.createDom("embed", {type:"evernote/x-crypto", align:"absmiddle", id:infoArray.join(":")});
      goog.dom.replaceNode(newNode, node);
    });
    return fragment;
  };
  mac.exportClipboard = function(fragment) {
    return uno.filters.cryptfilter.generic.exportClipboard(fragment);
  };
})();
goog.provide("uno.filters.cryptfilter.win");
goog.require("goog.dom.classlist");
goog.require("uno.defs");
(function() {
  var win = uno.filters.cryptfilter.win;
  var CRYPT_CLASS = uno.defs.crypto.CRYPT_CLASS;
  win.importENML = function() {
  };
  win.importHTML = function(fragment) {
    var cryptElements = fragment.querySelectorAll('img[src^="en-resource://database/pprotect:"]');
    Array.prototype.forEach.call(cryptElements, function(node) {
      node.setAttribute("id", node.src);
      goog.dom.classlist.add(node, CRYPT_CLASS);
    });
    return fragment;
  };
  win.exportENML = function() {
  };
  win.exportHTML = function() {
  };
  win.exportClipboard = function(fragment) {
    return uno.filters.cryptfilter.generic.exportClipboard(fragment);
  };
})();
goog.provide("uno.filters.cryptfilter.android");
(function() {
  var android = uno.filters.cryptfilter.android;
  android.importENML = function(fragment, context) {
    return uno.filters.cryptfilter.generic.importENML(fragment, context);
  };
  android.importHTML = function(fragment, context) {
    return uno.filters.cryptfilter.generic.importHTML(fragment, context);
  };
  android.exportENML = function(fragment) {
    return uno.filters.cryptfilter.generic.exportENML(fragment);
  };
  android.exportHTML = function(fragment) {
    return uno.filters.cryptfilter.generic.exportHTML(fragment);
  };
  android.exportClipboard = function(fragment) {
    return uno.filters.cryptfilter.generic.exportClipboard(fragment);
  };
})();
goog.provide("uno.filters.CryptFilter");
goog.require("uno.filters.cryptfilter.generic");
goog.require("uno.filters.cryptfilter.mac");
goog.require("uno.filters.cryptfilter.win");
goog.require("uno.filters.cryptfilter.android");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.crypto");
goog.require("uno.defs");
goog.require("uno.util.dom");
(function() {
  var log = goog.debug.Logger.getLogger("uno.filters.CryptFilter");
  var CryptFilter = uno.filters.CryptFilter = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(CryptFilter, uno.BasePlugin);
  CryptFilter.prototype.prepareContentsDom = function(fragment) {
    var context = this.editor.context;
    switch(context.format) {
      case uno.defs.format.ENML:
        return this.platform.importENML(fragment, context);
      case uno.defs.format.PLATFORM_HTML:
        return this.platform.importHTML(fragment, context);
      default:
        return fragment;
    }
  };
  CryptFilter.prototype.cleanContentsDom = function(fragment) {
    var context = this.editor.context;
    switch(context.format) {
      case uno.defs.format.ENML:
        return this.platform.exportENML(fragment);
      case uno.defs.format.PLATFORM_HTML:
        return this.platform.exportHTML(fragment);
      case uno.defs.format.CLIPBOARD:
        return this.platform.exportClipboard(fragment);
      default:
        return fragment;
    }
  };
})();
goog.provide("uno.util.emoticon");
goog.require("goog.debug.Logger");
goog.require("goog.dom.classes");
goog.require("uno.defs");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.emoticon");
  var util = uno.util;
  util.emoticon.TAG_NAME = "object";
  util.emoticon.CSS_CLASS = "en-emoticon";
  util.emoticon.ENML_TAG_NAME = "span";
  util.emoticon.ENML_STYLE_NAME = "-evernote-sentoj-emoticon";
  var colorClassNameMap = {"default":"en-emoticon-yellow", "yellow":"en-emoticon-yellow", "orange":"en-emoticon-orange", "pink":"en-emoticon-pink", "purple":"en-emoticon-purple", "dark-blue":"en-emoticon-dark-blue", "light-blue":"en-emoticon-light-blue", "green":"en-emoticon-green", "slate":"en-emoticon-slate", "brown":"en-emoticon-brown", "black":"en-emoticon-black"};
  var onceList = {"smiling face with open mouth":{"icon":"\ud83d\ude03", "keystrokes":[":)", ":=)", ":-)"], "color":"yellow"}, "pensive":{"icon":"\ud83d\ude14", "keystrokes":[":(", ":=(", ":-("]}, "grinning face":{"icon":"\ud83d\ude00", "keystrokes":[":D", ":=D", ":-D"]}, "smiling face with sunglasses":{"icon":"\ud83d\ude0e", "keystrokes":["8=)", "8-)", "B=)", "B-)"]}, "winking face":{"icon":"\ud83d\ude09", "keystrokes":[";)", ";=)", ";-)"]}, "face with open mouth":{"icon":"\ud83d\ude2e", "keystrokes":[":o", 
  ":=o", ":-o", ":O", ":=O", ":-O"]}, "crying face":{"icon":"\ud83d\ude22", "keystrokes":[";(", ";=(", ";-("]}, "smiling face with open mouth and cold sweat":{"icon":"\ud83d\ude05", "keystrokes":["(:|", ":sweat:"]}, "neutral face":{"icon":"\ud83d\ude10", "keystrokes":[":|", ":=|", ":-|", ":neutral:"]}, "kissing face with closed eyes":{"icon":"\ud83d\ude1a", "keystrokes":[":*", ":=*", ":-*", ":kiss:"]}, "face with stuck-out tongue":{"icon":"\ud83d\ude1b", "keystrokes":[":P", ":=P", ":-P", ":p", ":=p", 
  ":-p"]}, "smiling face with smiling eyes":{"icon":"\ud83d\ude0a", "keystrokes":[":$", ":-$", ":=$", ":simple_smile:"]}, "angry face":{"icon":"\ud83d\ude21", "keystrokes":[":@", ":-@", ":=@", "x(", "x-(", "x=(", "X(", "(X=(", ":angry:"]}, "smiling face with halo":{"icon":"\ud83d\ude07", "keystrokes":["O:)", "O:=)", "O:-)", "o:)", "o:=)", "o:-)", ":innocent:", ":angel:"]}, "heavy black heart":{"icon":"\u2764\ufe0f", "keystrokes":["<3", ":heart:"]}, "sleepy face":{"icon":"\ud83d\ude2a", "keystrokes":["|-)", 
  "I-)", "I=)", ":snooze:"]}, "smiling face with heart-shaped eyes":{"icon":"\ud83d\ude0d", "keystrokes":[":inlove:", ":in_love:"]}, "smiling face with horns":{"icon":"\ud83d\ude08", "keystrokes":[":devil:"]}, "ghost":{"icon":"\ud83d\udc7b", "keystrokes":[":ghost:"]}, "extraterrestrial alien":{"icon":"\ud83d\udc7d", "keystrokes":[":alien:"]}, "skull":{"icon":"\ud83d\udc80", "keystrokes":[":skull:"]}, "face screaming in fear":{"icon":"\ud83d\ude31", "keystrokes":[":scream:"]}, "slice of pizza":{"icon":"\ud83c\udf55", 
  "keystrokes":[":pizza:"]}, "purple heart":{"icon":"\ud83d\udc9c", "keystrokes":[":purple_heart:", ":purpleheart:"]}, "green heart":{"icon":"\ud83d\udc9a", "keystrokes":[":green_heart:", ":greenheart:"]}, "blue heart":{"icon":"\ud83d\udc99", "keystrokes":[":blue_heart:", ":blueheart:"]}, "yellow heart":{"icon":"\ud83d\udc9b", "keystrokes":[":yellow_heart:", ":yellowheart:"]}, "droplet":{"icon":"\ud83d\udca7", "keystrokes":[":droplet:"]}};
  util.emoticon.list = {":(=|-)?\\)":onceList["smiling face with open mouth"], ":(=|-)?\\(":onceList["pensive"], ":(=|-)?D":onceList["grinning face"], "(8|B)(=|-)\\)":onceList["smiling face with sunglasses"], ";(=|-)?\\)":onceList["winking face"], ":(=|-)?(o|O)":onceList["face with open mouth"], ";(=|-)?\\(":onceList["crying face"], "\\(:\\|":onceList["smiling face with open mouth and cold sweat"], ":sweat:":onceList["smiling face with open mouth and cold sweat"], ":(=|-)?\\|":onceList["neutral face"], 
  ":neutral:":onceList["neutral face"], ":(=|-)?\\*":onceList["kissing face with closed eyes"], ":kiss:":onceList["kissing face with closed eyes"], ":(=|-)?(P|p)":onceList["face with stuck-out tongue"], ":(-|=)?\\$":onceList["smiling face with smiling eyes"], ":simple_smile:":onceList["smiling face with smiling eyes"], "\\(?(:|x|X)(=|-)?(@|\\()":onceList["angry face"], ":angry:":onceList["angry face"], "(O|o):(=|-)?\\)":onceList["smiling face with halo"], ":innocent:":onceList["smiling face with halo"], 
  ":angel:":onceList["smiling face with halo"], "<3":onceList["heavy black heart"], ":heart:":onceList["heavy black heart"], "(\\||I)(-|=)\\)":onceList["sleepy face"], ":snooze:":onceList["sleepy face"], ":in_?love:":onceList["smiling face with heart-shaped eyes"], ":devil:":onceList["smiling face with horns"], ":ghost:":onceList["ghost"], ":alien:":onceList["extraterrestrial alien"], ":skull:":onceList["skull"], ":scream:":onceList["face screaming in fear"], ":pizza:":onceList["slice of pizza"], 
  ":purple_?heart:":onceList["purple heart"], ":green_?heart:":onceList["green heart"], ":blue_?heart:":onceList["blue heart"], ":yellow_?heart:":onceList["yellow heart"], ":droplet:":onceList["droplet"]};
  util.emoticon.fromInfo = function(info) {
    if (info == null) {
      return;
    }
    var colorClassName = colorClassNameMap[info.color] || colorClassNameMap["default"];
    var node = goog.dom.createDom(util.emoticon.TAG_NAME, {"class":util.emoticon.CSS_CLASS + " " + colorClassName, "contenteditable":"false"}, goog.dom.createTextNode(info.icon));
    return node;
  };
  util.emoticon.fromPattern = function(pattern) {
    var info = util.emoticon.list[pattern];
    return util.emoticon.fromInfo(info);
  };
  util.emoticon.fromUnicode = function(unicode) {
    var info = null;
    goog.getValues(util.emoticon.list).some(function(val) {
      if (unicode.indexOf(val.icon) !== -1 && unicode.length === val.icon.length) {
        info = val;
        return true;
      }
    });
    return util.emoticon.fromInfo(info);
  };
})();
goog.provide("uno.filters.EmoticonFilter");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.emoticon");
(function() {
  var log = goog.debug.Logger.getLogger("uno.filters.EmoticonFilter");
  var ZERO_WIDTH_SPACE = "\u200b";
  var util = uno.util;
  var EmoticonFilter = uno.filters.EmoticonFilter = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(EmoticonFilter, uno.BasePlugin);
  EmoticonFilter.prototype.prepareContentsDom = function(frag, styles) {
    goog.array.filter(frag.querySelectorAll(util.emoticon.ENML_TAG_NAME + '[style*="' + util.emoticon.ENML_STYLE_NAME + '"]'), function(node) {
      return goog.style.getStyle(node, name) === "true";
    }).forEach(function(node) {
      var madeNode = util.emoticon.fromUnicode(node.textContent);
      if (madeNode != null) {
        goog.dom.replaceNode(madeNode, node);
      }
    });
  };
  EmoticonFilter.prototype.cleanContentsDom = function(frag) {
    goog.array.forEach(frag.querySelectorAll(util.emoticon.TAG_NAME + "." + util.emoticon.CSS_CLASS), function(node) {
      var newNode = goog.dom.createDom(util.emoticon.ENML_TAG_NAME, {"style":util.emoticon.ENML_STYLE_NAME + ":" + "true"});
      newNode.innerHTML = node.textContent;
      goog.dom.replaceNode(newNode, node);
    });
  };
})();
goog.provide("uno.filters.EnmlFilter");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.defs");
goog.require("uno.util.dom");
(function() {
  var log = goog.debug.Logger.getLogger("uno.filters.EnmlFilter");
  var util = uno.util;
  var rxDocType = /^<!DOCTYPE[^>]*>\n?/g;
  var rxXhtmlNs = / +xmlns="(http:\/\/www.w3.org\/1999\/xhtml)?"/g;
  var rxInvalidHtmlChars = new RegExp(uno.defs.regex.INVALID_HTML_CHARS, "g");
  var rxEnNoteOpening = /<\s*en-note[^>]*>/;
  var rxEnNoteClosing = /<\/\s*en-note\s*>/;
  var rxEnTodoNonVoid = /<en-todo([^>]*?)><\/en-todo>/g;
  var rxEnMediaNonVoid = /<en-media([^>]*?)><\/en-media>/g;
  var EnmlFilter = uno.filters.EnmlFilter = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(EnmlFilter, uno.BasePlugin);
  EnmlFilter.prototype.prepareContentsHtml = function(html) {
    var openingMatch;
    var closingMatch;
    if (html == null || html == "") {
      return html;
    }
    if (this.editor.context.format !== uno.defs.format.ENML) {
      return html;
    }
    openingMatch = html.match(rxEnNoteOpening);
    closingMatch = html.match(rxEnNoteClosing);
    if (openingMatch && closingMatch) {
      html = html.substring(openingMatch.index + openingMatch[0].length, closingMatch.index);
    } else {
      log.info("html:");
      log.info(html);
      log.severe("Cannot find en-note node in ENML");
    }
    return html;
  };
  EnmlFilter.prototype.cleanContentsHtml = function(html) {
    if (this.editor.context.format !== uno.defs.format.ENML) {
      return html;
    }
    var liveRoot = this.editor.field;
    var enmlDTD = document.implementation.createDocumentType("en-note", "", "http://xml.evernote.com/pub/enml2.dtd");
    var enmlDocument = document.implementation.createDocument("http://www.w3.org/1999/xhtml", "en-note", enmlDTD);
    var enmlNode = enmlDocument.documentElement;
    var legalNoteAttributes = ["style", "bgcolor", "title", "lang", "dir", "text"];
    var frag = util.dom.fragFromString(html);
    if (liveRoot.hasAttributes()) {
      goog.array.forEach(liveRoot.attributes, function(a) {
        if (goog.array.contains(legalNoteAttributes, a)) {
          enmlNode.setAttribute(a.name.toLowerCase(), a.value);
        }
      });
    }
    goog.array.forEach(frag.querySelectorAll("*[id],*[class]"), function(el) {
      el.removeAttribute("id");
      el.removeAttribute("class");
      el.removeAttribute("data");
      Object.keys(el.dataset).forEach(function(key) {
        delete el.dataset[key];
      });
    });
    var clonedNode = enmlDocument.importNode(frag, true);
    enmlDocument.querySelector("en-note").appendChild(clonedNode);
    var xmlString = (new XMLSerializer).serializeToString(enmlDocument);
    xmlString = xmlString.replace(rxInvalidHtmlChars, "").replace(rxDocType, '<!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">').replace(rxXhtmlNs, "").replace(rxEnTodoNonVoid, "<en-todo$1 />").replace(rxEnMediaNonVoid, "<en-media$1 />");
    return xmlString;
  };
})();
goog.provide("uno.filters.FontSizeFilter");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.filters.FontSizeFilter");
  var ZERO_WIDTH_SPACE = "\u200b";
  var FontSizeFilter = uno.filters.FontSizeFilter = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(FontSizeFilter, uno.BasePlugin);
  FontSizeFilter.prototype.cleanContentsHtml = function(html) {
    return html.replace(ZERO_WIDTH_SPACE, "");
  };
})();
goog.provide("uno.filters.markupfilter.generic");
(function() {
  var generic = uno.filters.markupfilter.generic;
  generic.removeExtraneousMarkup = function(frag) {
  };
})();
goog.provide("uno.filters.markupfilter.ios");
goog.require("goog.dom");
(function() {
  var ios = uno.filters.markupfilter.ios;
  ios.removeExtraneousMarkup = function(frag) {
    frag.querySelectorAll('a[x-apple-data-detectors="true"]', function(el) {
      goog.dom.flattenElement(el);
    });
  };
})();
goog.provide("uno.filters.MarkupFilter");
goog.require("goog.array");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.filters.markupfilter.generic");
goog.require("uno.filters.markupfilter.ios");
goog.require("uno.util.dom");
(function() {
  var log = goog.debug.Logger.getLogger("uno.filters.MarkupFilter");
  var rxHtmlVoidTags = /<(?!area|base|br|col|command|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)([\w-]+)([^>]*)\/>/g;
  var MarkupFilter = uno.filters.MarkupFilter = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(MarkupFilter, uno.BasePlugin);
  MarkupFilter.prototype.prepareContentsHtml = function(html) {
    if (html == null || html == "") {
      return html;
    }
    return html.replace(rxHtmlVoidTags, "<$1$2></$1>");
  };
  MarkupFilter.prototype.prepareContentsDom = function(frag, styles) {
    removeUnsupportedNodes(frag);
    removeLineHeight(frag);
    removeEmptySpans(frag);
  };
  MarkupFilter.prototype.cleanContentsDom = function(frag) {
    goog.array.forEachRight(frag.querySelectorAll("html"), function(el) {
      goog.dom.removeNode(el);
    });
    goog.array.forEachRight(frag.querySelectorAll("en-note"), function(el) {
      goog.dom.removeNode(el);
    });
    this.platform.removeExtraneousMarkup(frag);
  };
  function getNodes(root, nodeFilter) {
    var iterator = root.ownerDocument.createNodeIterator(root, nodeFilter, null, false);
    var node;
    var nodeList = [];
    while (node = iterator.nextNode()) {
      nodeList.push(node);
    }
    return nodeList;
  }
  function removeUnsupportedNodes(root) {
    var nodeList = getNodes(root, 8 | 128);
    for (var i = nodeList.length - 1;i >= 0;i--) {
      var node = nodeList[i];
      var nodeType = node.nodeType;
      if (nodeType === Node.COMMENT_NODE) {
        if (node.data.indexOf("[CDATA[") == 0) {
          var nextSibling = node.nextSibling;
          var textNode = document.createTextNode(node.data.substr(7));
          goog.dom.replaceNode(textNode, node);
          node = textNode;
          if (node.data.lastIndexOf("]]") != node.data.length - 2 && nextSibling && nextSibling.nodeType == Node.TEXT_NODE) {
            nextSibling.data = nextSibling.data.replace(/^(.*?)\]\]\>(.*?)$/gi, "$1$2");
            node.data += ">";
          } else {
            node.data = node.data.replace(/^(.*?)\]\](.*?)$/gi, "$1$2");
          }
        } else {
          node.parentNode.removeChild(node);
        }
      } else {
        goog.dom.replaceNode(document.createTextNode(node.data), node);
      }
    }
  }
  function removeLineHeight(root) {
    var nodeList = root.querySelectorAll("*[style*='line-height']");
    for (var i = nodeList.length - 1;i >= 0;i--) {
      var node = nodeList[i];
      if (node.style.lineHeight) {
        uno.util.dom.removeStyleValue(node, "line-height");
      }
    }
  }
  function removeEmptySpans(root) {
    goog.array.forEachRight(root.querySelectorAll("span"), function(node) {
      if (!node.hasAttributes()) {
      }
    });
  }
})();
goog.provide("uno.filters.ResourceFilter");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("uno.BasePlugin");
goog.require("uno.defs");
goog.require("uno.util.resource");
(function() {
  var log = goog.debug.Logger.getLogger("uno.filters.ResourceFilter");
  var defs = uno.defs;
  var util = uno.util;
  var ResourceFilter = uno.filters.ResourceFilter = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(ResourceFilter, uno.BasePlugin);
  ResourceFilter.prototype.prepareContentsDom = function(frag) {
    var editor = this.editor;
    var context = this.editor.context;
    var dict;
    if (context.format === defs.format.ENML) {
      goog.array.forEach(frag.querySelectorAll("en-media"), function(enmedia) {
        dict = context.resources[enmedia.getAttribute("hash")];
        util.resource.convertMediaToSlug(enmedia, dict, editor);
      });
    } else {
      if (context.format === defs.format.PLATFORM_HTML) {
        goog.array.forEach(util.resource.findResourcesInPlatformHtml(frag), function(el) {
          if (util.dom.compareTagName(el, "en-media")) {
            dict = context.resources[el.getAttribute("hash")];
            util.resource.convertMediaToSlug(el, dict, editor);
          } else {
            util.resource.convertPlatformElementToSlug(el, editor);
          }
        });
      } else {
        goog.array.forEach(util.resource.findResourcesInClipboardHtml(frag), function(el) {
          util.resource.convertClipboardElementToSlug(el, context, editor);
        });
      }
    }
  };
  ResourceFilter.prototype.cleanContentsDom = function(frag) {
    var context = this.editor.context;
    if (context.format === defs.format.ENML) {
      goog.array.forEachRight(util.resource.all(frag), function(el) {
        util.resource.convertSlugToMedia(el);
      });
    } else {
      goog.array.forEachRight(util.resource.all(frag), function(el) {
        util.resource.convertSlugToPlatformElement(el);
      });
    }
  };
  ResourceFilter.prototype.cleanContentsHtml = function(html) {
    var ZERO_WIDTH_SPACE = "\u200b";
    if (this.editor.context.format === defs.format.PLATFORM_HTML) {
      html = util.resource.formatPlatformHtmlForExport(html);
      html = html.replace(ZERO_WIDTH_SPACE, "");
    }
    return html;
  };
})();
goog.provide("uno.filters.RichlinkFilter");
goog.require("goog.array");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.richlink");
(function() {
  var log = goog.debug.Logger.getLogger("uno.filters.RichlinkFilter");
  var util = uno.util;
  var RichlinkFilter = uno.filters.RichlinkFilter = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(RichlinkFilter, uno.BasePlugin);
  RichlinkFilter.prototype.prepareContentsDom = function(frag, styles) {
    var editor = this.editor;
    if (editor.config.richlinks.enabled) {
      goog.array.forEach(util.richlink.allPlain(frag), function(link) {
        util.richlink.decorate(link, editor);
      });
    }
  };
  RichlinkFilter.prototype.cleanContentsDom = function(frag) {
    var editor = this.editor;
    if (editor.config.richlinks.enabled) {
      goog.array.forEach(util.richlink.all(frag), function(link) {
        util.richlink.undecorate(link, editor);
      });
    }
  };
})();
goog.provide("uno.filters.TodoFilter");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("uno.BasePlugin");
goog.require("uno.defs");
goog.require("uno.util.todo");
(function() {
  var log = goog.debug.Logger.getLogger("uno.filters.TodoFilter");
  var defs = uno.defs;
  var util = uno.util;
  var TodoFilter = uno.filters.TodoFilter = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(TodoFilter, uno.BasePlugin);
  TodoFilter.prototype.prepareContentsDom = function(frag) {
    var context = this.editor.context;
    if (context.format === defs.format.ENML) {
      goog.array.forEach(util.todo.allEnmlTodos(frag), function(entodo) {
        util.todo.decorate(entodo);
      });
    } else {
      if (context.format === defs.format.CLIPBOARD) {
        var todos = util.todo.all(frag);
        Array.prototype.forEach.call(todos, function(todo) {
          var newTodo = util.todo.convertTodoInClipboard(todo);
          if (newTodo) {
            goog.dom.replaceNode(newTodo, todo);
          }
        });
      } else {
        goog.array.forEach(util.todo.findTodosInPlatformHtml(frag), function(el) {
          util.todo.convertPlatformElementToTodo(el);
        });
      }
    }
  };
  TodoFilter.prototype.cleanContentsDom = function(frag) {
    var context = this.editor.context;
    if (context.format === defs.format.ENML) {
      goog.array.forEach(util.todo.all(frag), function(entodo) {
        util.todo.undecorate(entodo);
      });
    } else {
      if (context.format === defs.format.CLIPBOARD) {
        var todos = util.todo.all(frag);
        Array.prototype.forEach.call(todos, function(todo) {
          var newTodo = util.todo.convertTodoToClipboardElement(todo);
          if (newTodo) {
            goog.dom.replaceNode(newTodo, todo);
          }
        });
      } else {
        goog.array.forEachRight(util.todo.all(frag), function(entodo) {
          util.todo.convertTodoToPlatformElement(entodo);
        });
      }
    }
  };
})();
goog.provide("uno.filters.BasicTextFormatterFilter");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("uno.BasePlugin");
goog.require("uno.defs");
(function() {
  var log = goog.debug.Logger.getLogger("uno.filters.BasicTextFormatterFilter");
  var defs = uno.defs;
  var highlightBackgroundColor = "rgb(255, 250, 165)";
  var BasicTextFormatterFilter = uno.filters.BasicTextFormatterFilter = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(BasicTextFormatterFilter, uno.BasePlugin);
  BasicTextFormatterFilter.prototype.prepareContentsDom = function(frag) {
    var context = this.editor.context;
    if (context.format === defs.format.ENML) {
      var nodes = frag.querySelectorAll('[style*="-evernote-highlight"]');
      Array.prototype.forEach.call(nodes, function(node) {
        node.style.backgroundColor = highlightBackgroundColor;
        node.style.removeProperty("-evernote-highlight");
      });
    }
  };
  BasicTextFormatterFilter.prototype.cleanContentsDom = function(frag) {
    var context = this.editor.context;
    if (context.format === defs.format.ENML) {
      var nodes = frag.querySelectorAll('[style*="background-color: ' + highlightBackgroundColor + '"]');
      Array.prototype.forEach.call(nodes, function(node) {
        var style = node.getAttribute("style");
        if (style.indexOf("-evernote-highlight") < 0) {
          node.setAttribute("style", "-evernote-highlight: true;" + style);
        }
      });
    }
  };
})();
goog.provide("uno.listeners.AccentuateListener");
goog.require("goog.debug.Logger");
goog.require("goog.iter");
goog.require("goog.dom");
goog.require("goog.events.KeyCodes");
goog.require("uno.BasePlugin");
goog.require("uno.util.img");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.AccentuateListener");
  var util = uno.util;
  var AccentuateListener = uno.listeners.AccentuateListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(AccentuateListener, uno.BasePlugin);
  AccentuateListener.CONTAINER_CLASSNAME = ".accentuate-container";
  AccentuateListener.BOX_CLASSNAME = ".en-find-result";
  AccentuateListener.prototype.handleSelectionChange = function(event) {
    var config = this.editor.config.accentuate;
    if (config.clearOnClickSelector) {
      var range = this.editor.getRange();
      if (range) {
        var focusNode = range.getFocusNode();
        var selector = document.querySelector(config.clearOnClickSelector);
        var editor = this.editor;
        if (event && goog.dom.contains(selector, focusNode)) {
          editor.execCommand("accentuate", {clearFirst:true});
        }
        goog.array.forEach(util.img.all(this.editor.field), util.img.removeOverlay);
      }
    }
  };
  AccentuateListener.prototype.handleWindowResize = function() {
    var rawFindValue = this.editor.queryCommandValue("find");
    var findValue = JSON.parse(rawFindValue);
    var isHighlighted = document.querySelector(AccentuateListener.CONTAINER_CLASSNAME + " " + AccentuateListener.BOX_CLASSNAME);
    if (isHighlighted) {
      this.editor.execCommand("accentuate", {clearFirst:true, boxes:findValue.items, selectedBoxIndex:findValue.index});
    }
  };
})();
goog.provide("uno.listeners.AttachmentListener");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.resource");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.AttachmentListener");
  var util = uno.util;
  var AttachmentListener = uno.listeners.AttachmentListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(AttachmentListener, uno.BasePlugin);
  AttachmentListener.prototype.handleClick = function(event) {
    if (!util.resource.isFileUI(event.target)) {
      return;
    }
    var target = event.target;
    var evt = {type:"linkclick", target:target, data:{action:undefined, eventType:"tap", hash:util.resource.hashFor(target), href:util.resource.urlFor(target), mime:util.resource.mimeTypeFor(target), module:"resource", reference:util.resource.referenceFor(target)}};
    if (util.resource.isDefaultContextButton(target)) {
      evt.data.action = "generic-default";
    } else {
      if (util.resource.isOverflowContextButton(target)) {
        evt.data.action = "generic-context";
      } else {
        evt.data.action = "open";
      }
    }
    this.editor.dispatchEvent(evt);
    return true;
  };
})();
goog.provide("uno.listeners.CryptListener");
goog.require("uno.defs");
goog.require("uno.BasePlugin");
goog.require("uno.util.crypto");
goog.require("goog.debug.Logger");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.CryptListener");
  var util = uno.util;
  var CryptListener = uno.listeners.CryptListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(CryptListener, uno.BasePlugin);
  CryptListener.prototype.handleClick = function(e) {
    var dispatchEvent = this.editor.dispatchEvent.bind(this);
    var readOnly = this.editor.config.crypt.readOnly;
    return util.crypto.handleClick(e.target, readOnly, dispatchEvent);
  };
})();
goog.provide("uno.util.paragraph");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
(function() {
  var util = uno.util;
  util.paragraph.create = function() {
    var div = document.createElement("div");
    div.appendChild(document.createElement("br"));
    return div;
  };
  util.paragraph["for"] = function(node) {
    if (!node) {
      return null;
    }
    if (node.tagName && node.tagName.toLowerCase() === "en-note") {
      node = node.firstChild;
    }
    var paraNode = goog.dom.getAncestor(node, function(ancestor) {
      return util.dom.isBlockNode(ancestor);
    }, true);
    if (paraNode) {
      if (paraNode.tagName.toLowerCase() === "en-note") {
        var savedRange;
        var range = goog.dom.Range.createFromWindow();
        if (range.isCollapsed() || range.containsNode(node)) {
          savedRange = range.saveUsingCarets();
        }
        while (node.parentNode !== paraNode) {
          node = node.parentNode;
        }
        var sibs = util.dom.contiguousInlineSiblings(node);
        var blockWrapper = goog.dom.createDom("div");
        goog.dom.replaceNode(blockWrapper, node);
        sibs.forEach(function(sib) {
          blockWrapper.appendChild(sib);
        });
        if (savedRange) {
          savedRange.restore().select();
        }
        return blockWrapper;
      }
    }
    return paraNode;
  };
  util.paragraph.insertAfter = function(paraNode) {
    var newParaNode = util.paragraph.create();
    goog.dom.insertSiblingAfter(newParaNode, paraNode);
    return newParaNode;
  };
  util.paragraph.startsWithTodo = function(paraNode) {
    return !!util.paragraph.leadingTodo(paraNode);
  };
  util.paragraph.leadingTodo = function(paraNode) {
    var child = paraNode;
    while (child.firstChild) {
      child = child.firstChild;
      while (child.nodeType === Node.TEXT_NODE && child.textContent.length === 0) {
        child = child.nextSibling;
      }
    }
    if (util.todo.isTodo(child)) {
      return child;
    }
  };
  util.paragraph.prevParagraph = function(paraNode) {
    return goog.dom.getPreviousElementSibling(paraNode);
  };
  util.paragraph.nextParagraph = function(paraNode) {
    return goog.dom.getNextElementSibling(paraNode);
  };
  util.paragraph.placeCursorAtStart = function(paraNode) {
    var range = goog.dom.Range.createCaret(paraNode, 0);
    range.select();
    return range;
  };
  util.paragraph.remove = function(paraNode) {
    goog.dom.removeNode(paraNode);
  };
  util.paragraph.hasContent = function(paraNode, opt) {
    if (!paraNode) {
      log.warning("hasContent paraNode is null");
      return false;
    }
    opt = opt || {};
    opt.excludingTags = opt.excludingTags || ["br", "div", "span"];
    if (paraNode.querySelectorAll("br").length > 1) {
      return true;
    }
    return goog.array.some(paraNode.childNodes, function(child) {
      if (child === opt.excluding) {
        return false;
      }
      if (child.nodeType === Node.TEXT_NODE) {
        return !util.dom.isWhitespaceNode(child);
      } else {
        if (!util.dom.compareTagName(child, opt.excludingTags)) {
          return true;
        } else {
          if (child.hasChildNodes()) {
            return util.paragraph.hasContent(child, opt);
          } else {
            if (!util.dom.compareTagName(child, ["br", "div", "span"])) {
              return true;
            }
          }
        }
      }
    });
  };
  util.paragraph.hasVisibleContent = function(paraNode, opt) {
    var contentTags = "en-media,embed,img,object";
    var result;
    if (!paraNode) {
      log.warning("hasVisibleContent paraNode is null");
      return false;
    }
    opt = opt || {};
    result = goog.array.some(paraNode.querySelectorAll(contentTags), function(el) {
      return el !== opt.excluding;
    });
    if (!result) {
      result = !goog.string.isEmptyOrWhitespace(paraNode.innerText);
    }
    return result;
  };
  util.paragraph.hasBr = function(paraNode) {
    return paraNode.querySelector("br") != null;
  };
  util.paragraph.appendBr = function(paraNode) {
    paraNode.appendChild(goog.dom.createElement("br"));
  };
})();
goog.provide("uno.listeners.DeleteListener");
goog.require("goog.debug.Logger");
goog.require("goog.editor.range");
goog.require("goog.events.KeyCodes");
goog.require("uno.BasePlugin");
goog.require("uno.util.paragraph");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.DeleteListener");
  var util = uno.util;
  var BACKSPACE = goog.events.KeyCodes.BACKSPACE;
  var DeleteListener = uno.listeners.DeleteListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(DeleteListener, uno.BasePlugin);
  DeleteListener.prototype.handleKeyDown = function(event) {
    if (event.keyCode === BACKSPACE && this.editor.execCommand("delete", null, {"native":true})) {
      event.preventDefault();
      return true;
    }
  };
})();
goog.provide("uno.listeners.EditModeListener");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.EditModeListener");
  var EditModeListener = uno.listeners.EditModeListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(EditModeListener, uno.BasePlugin);
  EditModeListener.prototype.handleClick = function() {
    if (!this.editor.readOnly) {
      this.editor.enterEditMode();
    }
  };
  EditModeListener.prototype.handleBlur = function() {
    this.editor.leaveEditMode();
  };
})();
goog.provide("uno.listeners.ForwardDeleteListener");
goog.require("goog.debug.Logger");
goog.require("goog.editor.range");
goog.require("goog.events.KeyCodes");
goog.require("uno.BasePlugin");
goog.require("uno.util.paragraph");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.ForwardDeleteListener");
  var DELETE = goog.events.KeyCodes.DELETE;
  var ForwardDeleteListener = uno.listeners.ForwardDeleteListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(ForwardDeleteListener, uno.BasePlugin);
  ForwardDeleteListener.prototype.handleKeyDown = function(event) {
    if (event.keyCode === DELETE && this.editor.execCommand("delete", null, {forward:true, "native":true})) {
      event.preventDefault();
      return true;
    }
  };
})();
goog.provide("uno.listeners.BasicTextFormatterListener");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.BasicTextFormatterListener");
  var BasicTextFormatterListener = uno.listeners.BasicTextFormatterListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(BasicTextFormatterListener, uno.BasePlugin);
  BasicTextFormatterListener.prototype.handleNativeSelectionChange = function() {
    var range = this.editor.getRange();
    var pendingNode = this.editor.context.pendingNode;
    if (pendingNode && pendingNode.node && range) {
      var node = range.getStartNode();
      if (pendingNode.node !== node && pendingNode.node.textContent === "\u200b") {
        goog.dom.removeNode(pendingNode.node);
        this.editor.context.pendingNode = null;
      } else {
        if (pendingNode.node === node && pendingNode.node.textContent === "\u200b") {
          var newRange = goog.dom.Range.createFromNodes(pendingNode.node, 1, pendingNode.node, 1);
          if (newRange) {
            newRange.select();
          }
        } else {
          if (pendingNode.node.textContent !== "\u200b") {
            var charIndex = pendingNode.node.textContent.indexOf("\u200b");
            if (charIndex > -1) {
              this.editor.context.pendingNode.node.deleteData(charIndex, 1);
              this.editor.context.pendingNode = null;
            }
          }
        }
      }
    }
  };
})();
goog.provide("uno.listeners.imglistener.generic");
goog.require("uno.util.resource");
(function() {
  var generic = uno.listeners.imglistener.generic;
  var util = uno.util;
  generic.handleImgResourceClick = function(event) {
    this.editor.dispatchEvent({type:"imageclick", name:"", src:uitl.resource.urlFor(event.target), tagname:"img"});
    return true;
  };
  generic.handleImgResourceClickUneditable = function(event, editor) {
  };
})();
goog.provide("uno.listeners.imglistener.ios");
goog.require("uno.util.resource");
(function() {
  var ios = uno.listeners.imglistener.ios;
  var util = uno.util;
  ios.handleImgResourceClick = function(event, editor) {
    var a;
    var target = event.target;
    var offsetX = event.offsetX;
    if (target.width > 150 && (offsetX < 75 || offsetX > target.offsetWidth - 75)) {
      if (editor.inEditMode()) {
        setTimeout(function() {
          goog.editor.range.placeCursorNextTo(target, offsetX < 75);
        });
      } else {
        var parent = target.parentElement;
        var offset = offsetX < 75 ? 0 : 1;
        var index = util.dom.index(target) + offset;
        var newRange = goog.dom.Range.createFromNodes(parent, index, parent, index);
        editor.enterEditMode(newRange);
      }
    } else {
      a = goog.dom.getAncestorByTagNameAndClass(target, "a");
      editor.dispatchEvent({type:"linkclick", target:event.target, data:{action:"open", eventType:"tap", hash:util.resource.hashFor(target), href:util.resource.urlFor(target), mime:util.resource.mimeTypeFor(target), module:"resource", reference:util.resource.referenceFor(target), anchorHref:a && a.href || undefined}});
    }
    return true;
  };
  ios.handleImgResourceClickUneditable = function(event, editor) {
    return ios.handleImgResourceClick(event, editor);
  };
})();
goog.provide("uno.listeners.ImgListener");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.img");
goog.require("uno.util.resource");
goog.require("uno.listeners.imglistener.generic");
goog.require("uno.listeners.imglistener.ios");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.ImgListener");
  var util = uno.util;
  var ImgListener = uno.listeners.ImgListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(ImgListener, uno.BasePlugin);
  ImgListener.prototype.handleClick = function(event) {
    if (util.img.isResource(event.target)) {
      return this.platform.handleImgResourceClick(event, this.editor);
    } else {
      if (util.img.isToolbarButton(event.target)) {
        return handleToolbarButtonClick(event, this.editor);
      }
    }
  };
  ImgListener.prototype.handleDoubleClick = function(event) {
    if (util.img.isResource(event.target)) {
      this.editor.dispatchEvent({type:"imagedoubleclick", src:util.resource.urlFor(event.target), tagname:"img"});
      return true;
    }
  };
  function inside(point, rect) {
    return point.x > rect.left && point.x < rect.right && point.y > rect.top && point.y < rect.bottom;
  }
})();
goog.provide("uno.listeners.LinkListener");
goog.require("goog.debug.Logger");
goog.require("goog.editor.range");
goog.require("goog.events.KeyCodes");
goog.require("goog.style");
goog.require("uno.BasePlugin");
goog.require("uno.util.dom");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.LinkListener");
  var util = uno.util;
  var LinkListener = uno.listeners.LinkListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(LinkListener, uno.BasePlugin);
  LinkListener.prototype.handleClick = function(event) {
    var bounds;
    var el = event.target;
    if (util.dom.compareTagName(el, "a")) {
      bounds = goog.style.getBounds(el);
      this.editor.dispatchEvent({type:"linkclick", target:el, data:{href:el.href, module:"link", left:bounds.left, top:bounds.top, width:bounds.width, height:bounds.height}});
      return true;
    }
  };
})();
goog.provide("uno.listeners.PasteListener");
goog.require("goog.debug.Logger");
goog.require("goog.editor.range");
goog.require("uno.BasePlugin");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.PasteListener");
  var PasteListener = uno.listeners.PasteListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(PasteListener, uno.BasePlugin);
  PasteListener.prototype.handlePaste = function(event) {
    event.preventDefault();
    return true;
  };
})();
goog.provide("uno.listeners.RichlinkListener");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.dom");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.RichlinkListener");
  var util = uno.util;
  var RichlinkListener = uno.listeners.RichlinkListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(RichlinkListener, uno.BasePlugin);
  RichlinkListener.prototype.handleClick = function(event) {
    var el = util.richlink.componentElementFor(event.target);
    if (el) {
      return util.richlink.handleClick(el, event, this.editor);
    }
  };
})();
goog.provide("uno.listeners.SharedBarListener");
goog.require("goog.debug.Logger");
goog.require("goog.dom.dataset");
goog.require("goog.style");
goog.require("uno.BasePlugin");
goog.require("uno.util.dom");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.SharedBarListener");
  var util = uno.util;
  var SharedBarListener = uno.listeners.SharedBarListener = function() {
    var self = this;
    uno.BasePlugin.call(this, log.getName());
    document.addEventListener("click", function(event) {
      var el = event.target;
      if (util.dom.matches(el, ".en-shared-link")) {
        var bounds = goog.style.getBounds(el);
        self.editor.dispatchEvent({type:"linkclick", target:el, data:{href:goog.dom.dataset.get(el, "href"), module:"shared", left:bounds.left, top:bounds.top, width:bounds.width, height:bounds.height}});
        return true;
      }
    });
  };
  goog.inherits(SharedBarListener, uno.BasePlugin);
})();
goog.provide("uno.listeners.SmartScrollListener");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.range");
goog.require("goog.events.KeyCodes");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.SmartScrollListener");
  var util = uno.util;
  var SmartScrollListener = uno.listeners.SmartScrollListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(SmartScrollListener, uno.BasePlugin);
  var delayedScrollTimerID = 0;
  SmartScrollListener.prototype._triggerDelayedScroll = function() {
    var editor = this.editor;
    if (delayedScrollTimerID) {
      clearTimeout(delayedScrollTimerID);
    }
    delayedScrollTimerID = setTimeout(function() {
      util.range.scrollSelectionIntoView(editor);
    });
  };
  SmartScrollListener.prototype.handleSelectionChange = function() {
    this._triggerDelayedScroll();
  };
  SmartScrollListener.prototype.handleNativeSelectionChange = function() {
    var range = this.editor.getRange();
    if (range != null && range.isCollapsed()) {
      this._triggerDelayedScroll();
    }
  };
  SmartScrollListener.prototype.handleTextInput = function(event) {
    this._triggerDelayedScroll();
  };
  SmartScrollListener.prototype.handleKeyDown = function(event) {
    var keyCode = event.keyCode;
    switch(keyCode) {
      case goog.events.KeyCodes.ENTER:
      ;
      case goog.events.KeyCodes.BACKSPACE:
      ;
      case goog.events.KeyCodes.DELETE:
        log.info("  SmartScrollListener.prototype.handleKeyUp");
        this._triggerDelayedScroll();
    }
  };
  SmartScrollListener.prototype.handleWindowResize = function() {
    util.range.scrollSelectionIntoView(this.editor);
  };
})();
goog.provide("uno.listeners.TableCellListener");
goog.require("goog.debug.Logger");
goog.require("goog.editor.range");
goog.require("goog.events.KeyCodes");
goog.require("uno.BasePlugin");
goog.require("uno.util.table");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.TableCellListener");
  var TAB_KEY = goog.events.KeyCodes.TAB;
  var UP_KEY = goog.events.KeyCodes.UP;
  var DOWN_KEY = goog.events.KeyCodes.DOWN;
  var util = uno.util;
  var TableCellListener = uno.listeners.TableCellListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(TableCellListener, uno.BasePlugin);
  TableCellListener.prototype.handleKeyDown = function(event) {
    var keyCode = event.keyCode;
    if (keyCode === TAB_KEY) {
      return this.handleTab(event);
    } else {
      if (keyCode === UP_KEY || keyCode === DOWN_KEY) {
        return this.handleUpOrDown(event);
      }
    }
  };
  TableCellListener.prototype.handleTab = function(event) {
    var nextTd;
    var td = util.table.cellFor(this.editor.getRange().getStartNode());
    if (td == null) {
      return;
    }
    if (event.shiftKey) {
      nextTd = util.table.prevCell(td);
    } else {
      nextTd = util.table.nextCell(td);
    }
    if (nextTd == null && !event.shiftKey) {
      this.editor.execCommand("inserttablerow", "after");
      nextTd = util.table.nextRow(td).querySelector("td");
    }
    if (nextTd != null) {
      goog.editor.range.placeCursorNextTo(nextTd.querySelector("div").childNodes[0]);
    }
    event.preventDefault();
    event.stopPropagation();
    return true;
  };
  TableCellListener.prototype.handleUpOrDown = function(event) {
    var nextTd;
    var td = util.table.cellFor(this.editor.getRange().getStartNode());
    var tr;
    if (td == null) {
      return;
    }
    tr = event.keyCode === UP_KEY ? util.table.prevRow(td) : util.table.nextRow(td);
    if (tr) {
      nextTd = util.table.cellAt(tr, util.table.cellIndex(td));
      if (nextTd != null) {
        goog.editor.range.placeCursorNextTo(nextTd.querySelector("div").childNodes[0]);
      }
    }
    event.preventDefault();
    event.stopPropagation();
    return true;
  };
})();
goog.provide("uno.listeners.TableResizeListener");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.table");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.TableResizeListener");
  var util = uno.util;
  var TableResizeListener = uno.listeners.TableResizeListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(TableResizeListener, uno.BasePlugin);
  TableResizeListener.prototype.handleMouseOver = function(event) {
    if (!this.table) {
      this.table = util.table["for"](event.target);
      if (this.table) {
        this.tableMetrics = util.table.metrics(this.table);
      }
    }
  };
  TableResizeListener.prototype.handleMouseOut = function(event) {
    if (!this.resizing && this.table && util.table["for"](event.relatedTarget) !== this.table) {
      this.table = null;
      this.tableMetrics = null;
    }
  };
  TableResizeListener.prototype.handleMouseMove = function(event) {
    if (this.table) {
      if (this.resizing) {
        this.resize(event);
      } else {
        this.update(event);
      }
    }
  };
  TableResizeListener.prototype.handleMouseDown = function(event) {
    if (this.enabled) {
      this.startResizing();
    }
  };
  TableResizeListener.prototype.handleMouseUp = function(event) {
    if (this.resizing) {
      this.stopResizing();
    }
  };
  TableResizeListener.prototype.startResizing = function() {
    var cell = this.cell;
    var row = util.table.rowFor(cell);
    goog.array.forEach(row.querySelectorAll("td"), function(td) {
      td.removeAttribute("width");
    });
    while (cell.previousSibling) {
      cell = cell.previousSibling;
      var cellMetrics = util.table.metrics(cell);
      goog.style.setStyle(cell, "width", cellMetrics.width / this.tableMetrics.width * 100 + "%");
    }
    goog.style.setUnselectable(this.table, true);
    this.table.setAttribute("contenteditable", false);
    this.tablePctWidth = parseFloat(this.table.style.width) || 100;
    this.resizing = true;
  };
  TableResizeListener.prototype.stopResizing = function() {
    goog.style.setUnselectable(this.table, false);
    this.table.removeAttribute("contenteditable");
    this.tablePctWidth = null;
    this.tableMetrics = util.table.metrics(this.table);
    this.resizing = false;
    this.editor.dispatchChange();
  };
  TableResizeListener.prototype.update = function(event) {
    this.cell = util.table.cellFor(event.target);
    if (!this.cell) {
      return;
    }
    this.updateEnabled();
    this.updateCell();
    this.updateCursor();
  };
  TableResizeListener.prototype.updateEnabled = function() {
    var metrics = util.table.metrics(this.cell);
    var offset = event.clientX - metrics.left;
    var alignment = util.table.alignment(this.table);
    if (this.nearLeftEdge(metrics, offset)) {
      if (this.cell.previousSibling) {
        this.onLeftEdge = false;
        this.cell = this.cell.previousSibling;
      } else {
        this.onLeftEdge = true;
      }
      this.onRightEdge = false;
      this.enabled = !(this.onLeftEdge && alignment === "left");
    } else {
      if (this.nearRightEdge(metrics, offset)) {
        if (this.cell.nextSibling) {
          this.onRightEdge = false;
        } else {
          this.onRightEdge = true;
        }
        this.onLeftEdge = false;
        this.enabled = !(this.onRightEdge && alignment === "right");
      } else {
        this.onLeftEdge = false;
        this.onRightEdge = false;
        this.enabled = false;
      }
    }
  };
  TableResizeListener.prototype.updateCell = function() {
    var firstRow = this.table.querySelector("tr");
    if (this.enabled) {
      this.cell = util.table.cellAt(firstRow, util.table.cellIndex(this.cell));
      this.cellMetrics = util.table.metrics(this.cell);
    } else {
      this.cell = null;
      this.cellMetrics = null;
    }
  };
  TableResizeListener.prototype.updateCursor = function() {
    if (this.enabled) {
      goog.style.setStyle(this.table, "cursor", "col-resize");
    } else {
      goog.style.setStyle(this.table, "cursor", "");
    }
  };
  TableResizeListener.prototype.nearLeftEdge = function(metrics, offset) {
    return offset < 5;
  };
  TableResizeListener.prototype.nearRightEdge = function(metrics, offset) {
    return offset > metrics.width - 5 && offset < metrics.width;
  };
  TableResizeListener.prototype.resize = function(event) {
    var width;
    var alignment = util.table.alignment(this.table);
    var tableMetrics = this.tableMetrics;
    if (this.onRightEdge && alignment !== "right") {
      width = Math.min(100, (event.clientX - tableMetrics.left) / tableMetrics.width * this.tablePctWidth) + "%";
      goog.style.setStyle(this.table, "width", width);
    } else {
      if (this.onLeftEdge && alignment !== "left") {
        width = Math.min(100, (tableMetrics.left + tableMetrics.width - event.clientX) / tableMetrics.width * this.tablePctWidth) + "%";
        goog.style.setStyle(this.table, "width", width);
      } else {
        width = (event.clientX - this.cellMetrics.left) / tableMetrics.width * 100 + "%";
        goog.style.setStyle(this.cell, "width", width);
      }
    }
  };
})();
goog.provide("uno.listeners.TodoListener");
goog.require("goog.debug.Logger");
goog.require("uno.BasePlugin");
goog.require("uno.util.todo");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.TodoListener");
  var util = uno.util;
  var TodoListener = uno.listeners.TodoListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(TodoListener, uno.BasePlugin);
  TodoListener.prototype.handleClick = function(event) {
    if (!this.editor.readOnly && util.todo.isTodo(event.target)) {
      util.todo.toggle(event.target);
      this.editor.dispatchChange();
      return true;
    }
    return false;
  };
})();
goog.provide("uno.listeners.TodoListListener");
goog.require("goog.debug.Logger");
goog.require("goog.editor.range");
goog.require("goog.events.KeyCodes");
goog.require("uno.BasePlugin");
goog.require("uno.util.paragraph");
goog.require("uno.util.range");
goog.require("uno.util.todo");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.TodoListListener");
  var ENTER_KEY = goog.events.KeyCodes.ENTER;
  var TAB_KEY = goog.events.KeyCodes.TAB;
  var util = uno.util;
  var TodoListListener = uno.listeners.TodoListListener = function() {
    uno.BasePlugin.call(this, log.getName());
  };
  goog.inherits(TodoListListener, uno.BasePlugin);
  TodoListListener.prototype.handleKeyPress = function(event) {
    var currentPar;
    var todo;
    if (event.keyCode === ENTER_KEY) {
      if (event.altKey) {
        this.editor.execCommand("inserttodo");
        event.preventDefault();
        event.stopPropagation();
        return true;
      }
      if ((currentPar = util.paragraph["for"](this.editor.getRange().getStartNode())) == null) {
        return;
      }
      if ((todo = util.paragraph.leadingTodo(currentPar)) == null) {
        return;
      }
      if (util.range.atBeginningOfDiv(this.editor.getRange())) {
        return;
      }
      if (util.paragraph.hasVisibleContent(currentPar, {excluding:todo})) {
        this.editor.context.pendingTodo = !util.todo.tryToInsertTodo();
      } else {
        util.todo.remove(todo);
        util.paragraph.placeCursorAtStart(currentPar);
      }
      if (!this.editor.context.pendingTodo) {
        event.preventDefault();
        event.stopPropagation();
      }
      return true;
    }
  };
  TodoListListener.prototype.handleKeyUp = function(event) {
    if ((event.keyCode === ENTER_KEY || event.keyCode === 0) && this.editor.context.pendingTodo) {
      this.editor.context.pendingTodo = false;
      this.editor.execCommand("inserttodo");
    }
  };
})();
goog.provide("uno.util.typebehind");
goog.require("goog.debug.Logger");
goog.require("goog.dom.classes");
goog.require("goog.editor.range");
goog.require("goog.events.KeyCodes");
goog.require("uno.util.dom");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.typebehind");
  var SPACE_KEY = goog.events.KeyCodes.SPACE;
  var TAB_KEY = goog.events.KeyCodes.TAB;
  var ENTER_KEY = goog.events.KeyCodes.ENTER;
  var util = uno.util;
  util.typebehind.tryReplacements = function(event, imps, checkBeginningOfLines, editor) {
    var keyCode = event.keyCode;
    var dom = goog.dom;
    var range = editor.getRange();
    if (!range || !range.isCollapsed()) {
      return false;
    }
    var startNode = range.getStartNode();
    var endNode = range.getEndNode();
    var node = endNode;
    var text = null;
    if (editor.config.typebehind.code) {
      if (goog.dom.classes.has(startNode, "en-code") || goog.dom.classes.has(dom.getParentElement(startNode), ".en-code")) {
        return false;
      }
    }
    text = node.textContent.substring(0, range.getEndOffset());
    var isBeginningOfLine = checkBeginningOfLines && !util.dom.isPrecededByInlineContent(node);
    if (text != null) {
      for (var i = 0;i < imps.length;i++) {
        var imp = imps[i];
        if (!imp.contextReplaceable(range, keyCode)) {
          continue;
        }
        if (imp.matchBeginningOfLine && !isBeginningOfLine) {
          continue;
        }
        var rxs = imp.getRegexes();
        var response = util.typebehind.isReplacementPossible(text, rxs);
        if (response.possible) {
          var result = util.typebehind.runReplacements(imp, range, response.rx, text, editor);
          if (result.node != null) {
            node = result.node;
            if (keyCode === SPACE_KEY || keyCode == ENTER_KEY || result.trimWhitespace) {
              goog.editor.range.placeCursorNextTo(node, false);
            } else {
              if (keyCode === TAB_KEY && !result.trimWhitespace) {
                var tab = dom.createDom(goog.dom.TagName.SPAN, null, "\u00a0\u00a0 \u00a0");
                goog.dom.insertSiblingBefore(tab, node.nextSibling);
                goog.editor.range.placeCursorNextTo(tab, false);
                event.preventDefault();
              }
            }
          }
          if (result.trimWhitespace) {
            event.preventDefault();
          }
          return true;
        }
      }
    }
    return false;
  };
  util.typebehind.isReplacementPossible = function(text, rxs) {
    if (text == null || !goog.isString(text) || rxs == null) {
      return {"possible":false, "rx":null};
    }
    for (var i = 0;i < rxs.length;i++) {
      if (util.typebehind.matchRegex(text, rxs[i])) {
        return {"possible":true, "rx":rxs[i]};
      }
    }
    return {"possible":false, "rx":null};
  };
  util.typebehind.matchRegex = function(text, rx) {
    if (text == null || rx == null) {
      return null;
    }
    var preRx = "(?:\\s+|\u00a0+|^)(";
    var postRx = ")(?:[\u00a0\\t ]*$)";
    var pattern = preRx + rx.source + postRx;
    var rxAtEnd = new RegExp(pattern, "gi");
    var matches = text.match(rxAtEnd);
    if (matches && matches.length > 1) {
      log.warning("Should not be multiple matches here!");
    }
    if (matches == null || matches.length <= 0) {
      return null;
    }
    var matchString = matches[0].trim();
    var index = text.lastIndexOf(matchString);
    return {"matchString":matchString, "index":index};
  };
  util.typebehind.runReplacements = function(imp, range, rx, text, editor) {
    var textNode = range.getEndNode();
    goog.asserts.assert(textNode && textNode.nodeType === Node.TEXT_NODE, "typebehind: node must be text");
    goog.asserts.assert(rx != null, "must be given a regex to work");
    var match = util.typebehind.matchRegex(text, rx);
    var matchText = match.matchString;
    var matchIndex = match.index;
    var newRange = goog.dom.Range.createFromNodes(textNode, matchIndex, textNode, matchIndex + matchText.length);
    return imp.insertReplacement(newRange, rx, matchText, editor);
  };
})();
goog.provide("uno.util.typebehind.email");
goog.require("goog.asserts");
goog.require("goog.debug.Logger");
goog.require("goog.events.KeyCodes");
goog.require("uno.defs");
(function() {
  var email = uno.util.typebehind.email;
  var log = goog.debug.Logger.getLogger("uno.util.typebehind.email");
  email.name = "email";
  email.matchBeginningOfLine = false;
  email.rxs = [new RegExp(uno.defs.regex.SIMPLE_EMAIL, "gi")];
  email.contextReplaceable = function(range, keyCode) {
    return true;
  };
  email.getRegexes = function() {
    email.rxs.forEach(function(rx) {
      rx.lastIndex = 0;
    });
    return email.rxs;
  };
  email.insertReplacement = function(range, rx, matchedText) {
    var newNode = goog.dom.createDom("a");
    if (goog.isString(matchedText)) {
      newNode.setAttribute("href", "mailto:" + matchedText);
      newNode.textContent = matchedText;
    }
    range.replaceContentsWithNode(newNode);
    return {node:newNode, trimWhitespace:false};
  };
})();
goog.provide("uno.util.typebehind.emoticon");
goog.require("goog.asserts");
goog.require("goog.debug.Logger");
goog.require("goog.events.KeyCodes");
goog.require("uno.defs");
goog.require("uno.util.emoticon");
(function() {
  var util = uno.util;
  var emoticon = uno.util.typebehind.emoticon;
  var log = goog.debug.Logger.getLogger("uno.util.typebehind.emoticon");
  emoticon.name = "emoticon";
  emoticon.matchBeginningOfLine = false;
  emoticon.rxs = Object.keys(util.emoticon.list).map(function(key) {
    return new RegExp(key, "g");
  });
  emoticon.contextReplaceable = function(range, keyCode) {
    return true;
  };
  emoticon.getRegexes = function() {
    emoticon.rxs.forEach(function(rx) {
      rx.lastIndex = 0;
    });
    return emoticon.rxs;
  };
  emoticon.insertReplacement = function(range, rx, matchedText) {
    var newNode = util.emoticon.fromPattern(rx.source);
    range.replaceContentsWithNode(newNode);
    return {node:newNode, trimWhitespace:false};
  };
})();
goog.provide("uno.util.typebehind.hr");
goog.require("goog.asserts");
goog.require("goog.debug.Logger");
goog.require("goog.events.KeyCodes");
goog.require("uno.defs");
(function() {
  var hr = uno.util.typebehind.hr;
  var log = goog.debug.Logger.getLogger("uno.util.typebehind.hr");
  var ENTER_KEY = goog.events.KeyCodes.ENTER;
  hr.name = "hr";
  hr.matchBeginningOfLine = true;
  hr.rxs = [new RegExp(uno.defs.regex.HORIZONTAL_RULE, "gi")];
  hr.contextReplaceable = function(range, keyCode) {
    return keyCode === ENTER_KEY;
  };
  hr.getRegexes = function() {
    hr.rxs.forEach(function(rx) {
      rx.lastIndex = 0;
    });
    return hr.rxs;
  };
  hr.insertReplacement = function(range, rx, matchedText) {
    var newNode = goog.dom.createDom("hr");
    range.replaceContentsWithNode(newNode);
    return {node:newNode, trimWhitespace:false};
  };
})();
goog.provide("uno.util.typebehind.list");
goog.require("goog.asserts");
goog.require("goog.debug.Logger");
goog.require("goog.events.KeyCodes");
goog.require("uno.defs");
goog.require("uno.util.paragraph");
(function() {
  var list = uno.util.typebehind.list;
  var log = goog.debug.Logger.getLogger("uno.util.typebehind.list");
  var BULLETED_LIST = uno.defs.regex.BULLETED_LIST;
  var NUMBERED_LIST = uno.defs.regex.NUMBERED_LIST;
  var util = uno.util;
  list.name = "list";
  list.matchBeginningOfLine = true;
  list.rxs = [new RegExp(BULLETED_LIST, "gi"), new RegExp(NUMBERED_LIST, "gi")];
  list.contextReplaceable = function(range, keyCode) {
    if (goog.dom.getAncestorByTagNameAndClass(range.getContainer(), "li")) {
      return false;
    }
    return true;
  };
  list.getRegexes = function() {
    list.rxs.forEach(function(rx) {
      rx.lastIndex = 0;
    });
    return list.rxs;
  };
  list.insertReplacement = function(range, rx, matchedText, editor) {
    var p = util.paragraph["for"](range.getStartNode());
    if (!util.paragraph.hasBr(p)) {
      util.paragraph.appendBr(p);
    }
    range.getStartNode().replaceData(range.getStartOffset(), matchedText.length, "");
    if (rx.source === BULLETED_LIST) {
      editor.execCommand("insertunorderedlist");
    } else {
      if (rx.source === NUMBERED_LIST) {
        editor.execCommand("insertorderedlist");
      }
    }
    return {node:null, trimWhitespace:true};
  };
})();
goog.provide("uno.util.typebehind.table");
goog.require("goog.asserts");
goog.require("goog.debug.Logger");
goog.require("goog.events.KeyCodes");
goog.require("uno.defs");
(function() {
  var table = uno.util.typebehind.table;
  var log = goog.debug.Logger.getLogger("uno.util.typebehind.table");
  table.name = "table";
  table.matchBeginningOfLine = true;
  table.rxs = [new RegExp(uno.defs.regex.TABLE, "gi")];
  table.contextReplaceable = function(range, keyCode) {
    var container = range.getContainer();
    if (goog.dom.getAncestorByTagNameAndClass(container, "table") || goog.dom.getAncestorByTagNameAndClass(container, "li")) {
      return false;
    }
    return true;
  };
  table.getRegexes = function() {
    table.rxs.forEach(function(rx) {
      rx.lastIndex = 0;
    });
    return table.rxs;
  };
  table.insertReplacement = function(range, rx, matchedText, editor) {
    range.getStartNode().replaceData(range.getStartOffset(), matchedText.length, "");
    var cols = matchedText.split("][").length;
    var rowMatch = matchedText.match(/[0-9]+$/);
    var rows = 1;
    if (rowMatch) {
      rows = parseInt(rowMatch[0], 10);
    }
    editor.execCommand("inserttable", {columns:cols, rows:rows});
    return {node:null, trimWhitespace:true};
  };
})();
goog.provide("uno.util.typebehind.todo");
goog.require("goog.asserts");
goog.require("goog.dom");
goog.require("goog.dom.classes");
goog.require("goog.debug.Logger");
goog.require("goog.editor.range");
goog.require("goog.events.KeyCodes");
goog.require("uno.defs");
goog.require("uno.util.todo");
(function() {
  var todo = uno.util.typebehind.todo;
  var log = goog.debug.Logger.getLogger("uno.util.typebehind.todo");
  var util = uno.util;
  todo.name = "todo";
  todo.matchBeginningOfLine = false;
  todo.rxs = [new RegExp(uno.defs.regex.TODO, "gi")];
  todo.contextReplaceable = function(range, keyCode) {
    return true;
  };
  todo.getRegexes = function() {
    todo.rxs.forEach(function(rx) {
      rx.lastIndex = 0;
    });
    return todo.rxs;
  };
  todo.insertReplacement = function(range, rx, matchedText) {
    var checked = matchedText.toLowerCase().indexOf("x") > 0;
    var node = util.todo.create(checked);
    range.replaceContentsWithNode(node);
    goog.dom.insertSiblingAfter(document.createElement("br"), node);
    return {node:node, trimWhitespace:true};
  };
})();
goog.provide("uno.util.typebehind.url");
goog.require("goog.asserts");
goog.require("goog.debug.Logger");
goog.require("goog.editor.Link");
goog.require("goog.events.KeyCodes");
goog.require("uno.defs");
(function() {
  var url = uno.util.typebehind.url;
  var log = goog.debug.Logger.getLogger("uno.util.typebehind.url");
  url.name = "url";
  url.matchBeginningOfLine = false;
  url.rxs = [new RegExp(uno.defs.regex.SIMPLE_URL, "gi")];
  url.contextReplaceable = function(range, keyCode) {
    return true;
  };
  url.getRegexes = function() {
    url.rxs.forEach(function(rx) {
      rx.lastIndex = 0;
    });
    return url.rxs;
  };
  url.insertReplacement = function(range, rx, matchedText) {
    var newNode;
    var url = matchedText;
    if (url.indexOf("http") != 0 && url.indexOf("ftp") != 0) {
      url = "http://" + url;
    }
    newNode = goog.dom.createDom("a", {href:url});
    newNode.textContent = matchedText;
    range.replaceContentsWithNode(newNode);
    return {node:newNode, trimWhitespace:false};
  };
})();
goog.provide("uno.listeners.TypeBehindListener");
goog.require("goog.debug.Logger");
goog.require("goog.events.KeyCodes");
goog.require("uno.BasePlugin");
goog.require("uno.util.typebehind");
goog.require("uno.util.typebehind.email");
goog.require("uno.util.typebehind.emoticon");
goog.require("uno.util.typebehind.hr");
goog.require("uno.util.typebehind.list");
goog.require("uno.util.typebehind.table");
goog.require("uno.util.typebehind.todo");
goog.require("uno.util.typebehind.url");
(function() {
  var log = goog.debug.Logger.getLogger("uno.listeners.TypeBehindListener");
  var SPACE_KEY = goog.events.KeyCodes.SPACE;
  var TAB_KEY = goog.events.KeyCodes.TAB;
  var ENTER_KEY = goog.events.KeyCodes.ENTER;
  var util = uno.util;
  var TypeBehindListener = uno.listeners.TypeBehindListener = function() {
    uno.BasePlugin.call(this, log.getName());
    this.imps = [];
    this.checkBeginningOfLines = false;
  };
  goog.inherits(TypeBehindListener, uno.BasePlugin);
  TypeBehindListener.IMPLEMENTATIONS = {"email":uno.util.typebehind.email, "emoticon":uno.util.typebehind.emoticon, "horizontalrule":uno.util.typebehind.hr, "list":uno.util.typebehind.list, "table":uno.util.typebehind.table, "todo":uno.util.typebehind.todo, "url":uno.util.typebehind.url};
  TypeBehindListener.prototype.registerFieldObject = function(fieldObject) {
    var me = this;
    uno.BasePlugin.prototype.registerFieldObject.call(this, fieldObject);
    Object.keys(TypeBehindListener.IMPLEMENTATIONS).forEach(function(name) {
      var imp;
      if (fieldObject.config.typebehind[name]) {
        imp = TypeBehindListener.IMPLEMENTATIONS[name];
        me.imps.push(imp);
        if (imp.matchBeginningOfLine) {
          me.checkBeginningOfLines = true;
        }
      }
    });
  };
  TypeBehindListener.prototype.handleKeyDown = function(event) {
    var replaced = false;
    var keyCode = event.keyCode;
    if (keyCode === SPACE_KEY || keyCode === TAB_KEY || keyCode === ENTER_KEY) {
      replaced = util.typebehind.tryReplacements(event, this.imps, this.checkBeginningOfLines, this.editor);
    }
    if (replaced) {
      this.editor.dispatchChange();
    }
    return replaced;
  };
})();
goog.provide("uno.util.classes");
goog.require("goog.dom.classes");
(function() {
  var util = uno.util;
  util.classes.conditionalToggle = function(node, className, flag) {
    if (flag == null) {
      goog.dom.classes.toggle(node, className);
    } else {
      if (flag) {
        goog.dom.classes.add(node, className);
      } else {
        goog.dom.classes.remove(node, className);
      }
    }
  };
})();
goog.provide("uno.i18n.ar");
uno.i18n.ar.textEntries = {"Not available offline":"\u0644\u0627 \u064a\u062a\u0648\u0641\u0631 \u062f\u0648\u0646 \u0627\u062a\u0635\u0627\u0644 \u0628\u0627\u0644\u0625\u0646\u062a\u0631\u0646\u062a", "Not available":"\u063a\u064a\u0631 \u0645\u062a\u0627\u062d", "Tap to request access":"\u0627\u0636\u063a\u0637 \u0644\u0637\u0644\u0628 \u0627\u0644\u0648\u0635\u0648\u0644", "Click to request access":"\u0627\u0636\u063a\u0637 \u0644\u0637\u0644\u0628 \u0627\u0644\u0648\u0635\u0648\u0644", "Open":"\u0641\u062a\u062d", 
"Google Drive":"\u062c\u0648\u062c\u0644 \u062f\u0631\u0627\u064a\u0641", "Google Docs":"\u0645\u0633\u062a\u0646\u062f\u0627\u062a \u062c\u0648\u062c\u0644", "Google Sheets":"\u0623\u0648\u0631\u0627\u0642 \u062c\u0648\u062c\u0644", "Google Slides":"\u0634\u0631\u0627\u0626\u062d \u062c\u0648\u062c\u0644", "PDF":"PDF", "Word Document":"\u0645\u0633\u062a\u0646\u062f Word", "Excel Spreadsheet":"\u062c\u062f\u0648\u0644 \u0628\u064a\u0627\u0646\u0627\u062a Excel", "Modified":"\u062a\u0645 \u062a\u0639\u062f\u064a\u0644\u0647", 
"Connect":"\u0627\u062a\u0635\u0627\u0644", "Title not available":"\u0627\u0644\u0639\u0646\u0648\u0627\u0646 \u063a\u064a\u0631 \u0645\u062a\u0627\u062d", "Open containing folder":"\u0641\u062a\u062d \u0627\u0644\u0645\u062c\u0644\u062f \u0627\u0644\u0631\u0626\u064a\u0633\u064a"};
goog.provide("uno.i18n.cs");
uno.i18n.cs.textEntries = {"Not available offline":"Offline nen\u00ed dostupn\u00fd", "Not available":"Nen\u00ed k dispozici", "Tap to request access":"Klepnut\u00edm vy\u017e\u00e1dejte p\u0159\u00edstup", "Click to request access":"Kliknut\u00edm vy\u017e\u00e1dejte p\u0159\u00edstup", "Open":"Otev\u0159\u00edt", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"Dokument aplikace Word", "Excel Spreadsheet":"Tabulka v aplikaci Excel", 
"Modified":"Zm\u011bn\u011bno", "Connect":"P\u0159ipojit", "Title not available":"N\u00e1zev nen\u00ed k dispozici", "Open containing folder":"Otev\u0159\u00edt slo\u017eku se soubory"};
goog.provide("uno.i18n.da");
uno.i18n.da.textEntries = {"Not available offline":"Ikke tilg\u00e6ngelig offline", "Not available":"Ikke tilg\u00e6ngelig", "Tap to request access":"Tryk for at anmode om adgang", "Click to request access":"Klik for at anmode om adgang", "Open":"\u00c5bn", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"Word-dokument", "Excel Spreadsheet":"Excel-regneark", "Modified":"\u00c6ndret", "Connect":"Opret forbindelse", 
"Title not available":"Titel ikke tilg\u00e6ngelig", "Open containing folder":"\u00c5bn indeholdende mappe"};
goog.provide("uno.i18n.de");
uno.i18n.de.textEntries = {"Not available offline":"Nicht offline verf\u00fcgbar", "Not available":"Nicht verf\u00fcgbar", "Tap to request access":"Zur Anforderung von Zugriff tippen", "Click to request access":"Zur Anforderung von Zugriff klicken", "Open":"\u00d6ffnen", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Tabellen", "Google Slides":"Google Pr\u00e4sentationen", "PDF":"PDF", "Word Document":"Word-Dokument", "Excel Spreadsheet":"Excel-Tabellenblatt", 
"Modified":"Ge\u00e4ndert", "Connect":"Verbinden", "Title not available":"Titel nicht verf\u00fcgbar", "Open containing folder":"\u00dcbergeordneten Ordner \u00f6ffnen"};
goog.provide("uno.i18n.en");
uno.i18n.en.textEntries = {"Not available offline":"Not available offline", "Not available":"Not available", "Tap to request access":"Tap to request access", "Click to request access":"Click to request access", "Open":"Open", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"Word Document", "Excel Spreadsheet":"Excel Spreadsheet", "Modified":"Modified", "Connect":"Connect", "Title not available":"Title not available", 
"Open containing folder":"Open containing folder"};
goog.provide("uno.i18n.es");
uno.i18n.es.textEntries = {"Not available offline":"No disponible sin conexi\u00f3n", "Not available":"No disponible", "Tap to request access":"Pulsa para solicitar acceso", "Click to request access":"Haz clic para solicitar acceso", "Open":"Abrir", "Google Drive":"Google Drive", "Google Docs":"Documentos de Google", "Google Sheets":"Hojas de c\u00e1lculo de Google", "Google Slides":"Presentaciones de Google", "PDF":"PDF", "Word Document":"Documento Word", "Excel Spreadsheet":"Hoja de c\u00e1lculo Excel", 
"Modified":"Modificado", "Connect":"Conectar", "Title not available":"T\u00edtulo no disponible", "Open containing folder":"Abrir carpeta archivadora de contenidos"};
goog.provide("uno.i18n.fi");
uno.i18n.fi.textEntries = {"Not available offline":"Ei k\u00e4ytett\u00e4viss\u00e4 offline", "Not available":"Ei k\u00e4ytett\u00e4viss\u00e4", "Tap to request access":"Pyyd\u00e4 k\u00e4ytt\u00f6oikeus napauttamalla", "Click to request access":"Napsauta pyyt\u00e4\u00e4ksesi k\u00e4ytt\u00f6oikeuksia", "Open":"Avaa", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"Word-asiakirja", "Excel Spreadsheet":"Excel-laskentataulukko", 
"Modified":"Muokattu", "Connect":"Yhdist\u00e4", "Title not available":"Otsikko ei saatavilla", "Open containing folder":"Avaa tallennuskansio"};
goog.provide("uno.i18n.fr");
uno.i18n.fr.textEntries = {"Not available offline":"Non disponible hors-ligne", "Not available":"Indisponible", "Tap to request access":"Appuyez pour demander l'acc\u00e8s", "Click to request access":"Cliquez pour demander l'acc\u00e8s", "Open":"Ouvrir", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"Document Word", "Excel Spreadsheet":"Feuille de calcul Excel", "Modified":"Modifi\u00e9", 
"Connect":"Connecter", "Title not available":"Titre non disponible", "Open containing folder":"Ouvrir le dossier conteneur"};
goog.provide("uno.i18n.id");
uno.i18n.id.textEntries = {"Not available offline":"Tidak tersedia offline", "Not available":"Tidak tersedia", "Tap to request access":"Tekan untuk meminta akses", "Click to request access":"Klik untuk meminta akses", "Open":"Buka", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"Dokumen Word", "Excel Spreadsheet":"Lembar Lajur Excel", "Modified":"Diubah", "Connect":"Sambungkan", "Title not available":"Judul tidak tersedia", 
"Open containing folder":"Buka map yang menampung"};
goog.provide("uno.i18n.it");
uno.i18n.it.textEntries = {"Not available offline":"Non disponibile offline", "Not available":"Non disponibile", "Tap to request access":"Tocca per richiedere accesso", "Click to request access":"Clicca per richiedere accesso", "Open":"Apri", "Google Drive":"Google Drive", "Google Docs":"Documenti Google", "Google Sheets":"Fogli Google", "Google Slides":"Presentazioni Google", "PDF":"PDF", "Word Document":"Documento di Word", "Excel Spreadsheet":"Foglio di lavoro di Excel", "Modified":"Modificato", 
"Connect":"Connettiti", "Title not available":"Titolo non disponibile", "Open containing folder":"Apri cartella contenente"};
goog.provide("uno.i18n.ja");
uno.i18n.ja.textEntries = {"Not available offline":"\u30aa\u30d5\u30e9\u30a4\u30f3\u3067\u306f\u5229\u7528\u3067\u304d\u307e\u305b\u3093", "Not available":"\u5229\u7528\u3067\u304d\u307e\u305b\u3093", "Tap to request access":"\u30bf\u30c3\u30d7\u3067\u30a2\u30af\u30bb\u30b9\u6a29\u3092\u30ea\u30af\u30a8\u30b9\u30c8", "Click to request access":"\u30af\u30ea\u30c3\u30af\u3067\u30a2\u30af\u30bb\u30b9\u6a29\u3092\u30ea\u30af\u30a8\u30b9\u30c8", "Open":"\u958b\u304f", "Google Drive":"Google \u30c9\u30e9\u30a4\u30d6", 
"Google Docs":"Google \u30c9\u30ad\u30e5\u30e1\u30f3\u30c8", "Google Sheets":"Google \u30b9\u30d7\u30ec\u30c3\u30c9\u30b7\u30fc\u30c8", "Google Slides":"Google \u30b9\u30e9\u30a4\u30c9", "PDF":"PDF", "Word Document":"Word \u6587\u66f8", "Excel Spreadsheet":"Excel \u30b9\u30d7\u30ec\u30c3\u30c9\u30b7\u30fc\u30c8", "Modified":"\u5909\u66f4", "Connect":"\u63a5\u7d9a", "Title not available":"\u30bf\u30a4\u30c8\u30eb\u3092\u8868\u793a\u3067\u304d\u307e\u305b\u3093", "Open containing folder":"\u30d5\u30a9\u30eb\u30c0\u3092\u958b\u304f"};
goog.provide("uno.i18n.ko");
uno.i18n.ko.textEntries = {"Not available offline":"\uc624\ud504\ub77c\uc778\uc5d0\uc11c \uc0ac\uc6a9\ud560 \uc218 \uc5c6\uc74c", "Not available":"\uc0ac\uc6a9\ud560 \uc218 \uc5c6\uc2b5\ub2c8\ub2e4", "Tap to request access":"\ub20c\ub7ec\uc11c \uc561\uc138\uc2a4 \uc694\uccad", "Click to request access":"\ud074\ub9ad\ud558\uc5ec \uc561\uc138\uc2a4 \uc694\uccad", "Open":"\uc5f4\uae30", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google \ud504\ub808\uc820\ud14c\uc774\uc158", 
"PDF":"PDF", "Word Document":"Word \ubb38\uc11c", "Excel Spreadsheet":"Excel \uc2a4\ud504\ub808\ub4dc\uc2dc\ud2b8", "Modified":"\uc218\uc815", "Connect":"\uc5f0\uacb0", "Title not available":"\uc81c\ubaa9 \uc54c \uc218 \uc5c6\uc74c", "Open containing folder":"\ud3ec\ud568 \ud3f4\ub354 \uc5f4\uae30"};
goog.provide("uno.i18n.ms");
uno.i18n.ms.textEntries = {"Not available offline":"Tidak tersedia di luar talian", "Not available":"Tidak tersedia", "Tap to request access":"Ketik untuk meminta akses", "Click to request access":"Klik untuk meminta akses", "Open":"Buka", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"Dokumen Word", "Excel Spreadsheet":"Hamparan Excel", "Modified":"Diubah suai", "Connect":"Sambung", "Title not available":"Tajuk tidak tersedia", 
"Open containing folder":"Buka folder yang mengandungi"};
goog.provide("uno.i18n.nl");
uno.i18n.nl.textEntries = {"Not available offline":"Niet offline beschikbaar", "Not available":"Niet beschikbaar", "Tap to request access":"Tik om toegang aan te vragen", "Click to request access":"Klik om toegang aan te vragen", "Open":"Open", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"Word-document", "Excel Spreadsheet":"Excel-spreadsheet", "Modified":"Aangepast", "Connect":"Koppel", 
"Title not available":"Titel niet beschikbaar", "Open containing folder":"Open bijbehorende map"};
goog.provide("uno.i18n.no");
uno.i18n.no.textEntries = {"Not available offline":"Ikke tilgjengelig offline", "Not available":"Ikke tilgjengelig", "Tap to request access":"Trykk for \u00e5 be om tilgang", "Click to request access":"Klikk for \u00e5 be om tilgang", "Open":"\u00c5pne", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"Word-dokument", "Excel Spreadsheet":"Excel regneark", "Modified":"Modifisert", "Connect":"Koble til", 
"Title not available":"Tittel ikke tilgjengelig", "Open containing folder":"\u00c5pne mappe med innhold"};
goog.provide("uno.i18n.pl");
uno.i18n.pl.textEntries = {"Not available offline":"Niedost\u0119pne w trybie offline", "Not available":"Niedost\u0119pne", "Tap to request access":"Dotknij, aby za\u017c\u0105da\u0107 dost\u0119pu", "Click to request access":"Kliknij, aby poprosi\u0107 o dost\u0119p", "Open":"Otw\u00f3rz", "Google Drive":"Dysk Google", "Google Docs":"Dokumenty Google", "Google Sheets":"Arkusze Google", "Google Slides":"Prezentacje Google", "PDF":"PDF", "Word Document":"Dokument Word", "Excel Spreadsheet":"Arkusz Excel", 
"Modified":"Edytowany", "Connect":"Po\u0142\u0105cz", "Title not available":"Nazwa jest niedost\u0119pna", "Open containing folder":"Otw\u00f3rz folder zawieraj\u0105cy"};
goog.provide("uno.i18n.pt_BR");
uno.i18n.pt_BR.textEntries = {"Not available offline":"N\u00e3o dispon\u00edvel offline", "Not available":"N\u00e3o est\u00e1 dispon\u00edvel", "Tap to request access":"Toque para solicitar acesso", "Click to request access":"Clique para solicitar acesso", "Open":"Abrir", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Planilhas do Google", "Google Slides":"Apresenta\u00e7\u00f5es do Google", "PDF":"PDF", "Word Document":"Documento do Word", "Excel Spreadsheet":"Planilha do Excel", 
"Modified":"Modificado em", "Connect":"Conectar", "Title not available":"T\u00edtulo n\u00e3o dispon\u00edvel", "Open containing folder":"Abrir pasta de destino"};
goog.provide("uno.i18n.pt");
uno.i18n.pt.textEntries = {"Not available offline":"N\u00e3o dispon\u00edvel offline", "Not available":"Indispon\u00edvel", "Tap to request access":"Toque para solicitar acesso", "Click to request access":"Clique para solicitar acesso", "Open":"Abrir", "Google Drive":"Google Drive", "Google Docs":"Documentos do Google", "Google Sheets":"Folhas de c\u00e1lculo do Google", "Google Slides":"Apresenta\u00e7\u00f5es do Google", "PDF":"PDF", "Word Document":"Documento do Word", "Excel Spreadsheet":"Tabela do Excel", 
"Modified":"Modificado em", "Connect":"Ligar", "Title not available":"T\u00edtulo indispon\u00edvel", "Open containing folder":"Abrir pasta de destino"};
goog.provide("uno.i18n.ru");
uno.i18n.ru.textEntries = {"Not available offline":"\u041d\u0435\u0442 \u043e\u0444\u043b\u0430\u0439\u043d-\u0434\u043e\u0441\u0442\u0443\u043f\u0430", "Not available":"\u041d\u0435\u0434\u043e\u0441\u0442\u0443\u043f\u0435\u043d", "Tap to request access":"\u041d\u0430\u0436\u043c\u0438\u0442\u0435 \u0434\u043b\u044f \u0437\u0430\u043f\u0440\u043e\u0441\u0430 \u0434\u043e\u0441\u0442\u0443\u043f\u0430", "Click to request access":"\u041d\u0430\u0436\u043c\u0438\u0442\u0435 \u0434\u043b\u044f \u0437\u0430\u043f\u0440\u043e\u0441\u0430 \u0434\u043e\u0441\u0442\u0443\u043f\u0430", 
"Open":"\u041e\u0442\u043a\u0440\u044b\u0442\u044c", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"\u0414\u043e\u043a\u0443\u043c\u0435\u043d\u0442 Word", "Excel Spreadsheet":"\u0422\u0430\u0431\u043b\u0438\u0446\u0430 Excel", "Modified":"\u0418\u0437\u043c\u0435\u043d\u0435\u043d", "Connect":"\u041f\u043e\u0434\u043a\u043b\u044e\u0447\u0438\u0442\u044c", "Title not available":"\u041d\u0430\u0437\u0432\u0430\u043d\u0438\u0435 \u043d\u0435\u0434\u043e\u0441\u0442\u0443\u043f\u043d\u043e", 
"Open containing folder":"\u041e\u0442\u043a\u0440\u044b\u0442\u044c \u043f\u0430\u043f\u043a\u0443"};
goog.provide("uno.i18n.sv");
uno.i18n.sv.textEntries = {"Not available offline":"Ej tillg\u00e4nglig offline", "Not available":"Ej tillg\u00e4ngligt", "Tap to request access":"Tryck f\u00f6r att beg\u00e4ra \u00e5tkomst", "Click to request access":"Klicka f\u00f6r att beg\u00e4ra \u00e5tkomst", "Open":"\u00d6ppna", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"Word-dokument", "Excel Spreadsheet":"Excel-kalkylblad", "Modified":"\u00c4ndrad", 
"Connect":"Anslut", "Title not available":"Titeln finns inte", "Open containing folder":"\u00d6ppna objektets mapp"};
goog.provide("uno.i18n.th");
uno.i18n.th.textEntries = {"Not available offline":"\u0e44\u0e21\u0e48\u0e2a\u0e32\u0e21\u0e32\u0e23\u0e16\u0e43\u0e0a\u0e49\u0e07\u0e32\u0e19\u0e15\u0e2d\u0e19\u0e2d\u0e2d\u0e1f\u0e44\u0e25\u0e19\u0e4c\u0e44\u0e14\u0e49", "Not available":"\u0e44\u0e21\u0e48\u0e21\u0e35", "Tap to request access":"\u0e41\u0e15\u0e30\u0e40\u0e1e\u0e37\u0e48\u0e2d\u0e02\u0e2d\u0e40\u0e02\u0e49\u0e32\u0e16\u0e36\u0e07", "Click to request access":"\u0e04\u0e25\u0e34\u0e4a\u0e01\u0e40\u0e1e\u0e37\u0e48\u0e2d\u0e02\u0e2d\u0e40\u0e02\u0e49\u0e32\u0e16\u0e36\u0e07", 
"Open":"\u0e40\u0e1b\u0e34\u0e14", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"\u0e40\u0e2d\u0e01\u0e2a\u0e32\u0e23 Word", "Excel Spreadsheet":"\u0e2a\u0e40\u0e1b\u0e23\u0e14\u0e0a\u0e35\u0e17 Excel", "Modified":"\u0e1b\u0e23\u0e31\u0e1a\u0e40\u0e1b\u0e25\u0e35\u0e48\u0e22\u0e19\u0e41\u0e25\u0e49\u0e27", "Connect":"\u0e40\u0e0a\u0e37\u0e48\u0e2d\u0e21\u0e15\u0e48\u0e2d", "Title not available":"\u0e44\u0e21\u0e48\u0e21\u0e35\u0e0a\u0e37\u0e48\u0e2d", 
"Open containing folder":"\u0e40\u0e1b\u0e34\u0e14\u0e41\u0e1f\u0e49\u0e21\u0e40\u0e2d\u0e01\u0e2a\u0e32\u0e23\u0e17\u0e35\u0e48\u0e40\u0e01\u0e47\u0e1a"};
goog.provide("uno.i18n.tr");
uno.i18n.tr.textEntries = {"Not available offline":"\u00c7evrimd\u0131\u015f\u0131 kullan\u0131lamaz", "Not available":"Eri\u015fim sa\u011flanam\u0131yor", "Tap to request access":"Eri\u015fim talebi i\u00e7in t\u0131klay\u0131n", "Click to request access":"Eri\u015fim talebi i\u00e7in t\u0131klay\u0131n", "Open":"A\u00e7", "Google Drive":"Google Drive", "Google Docs":"Google Dok\u00fcmanlar", "Google Sheets":"Google E-Tablolar", "Google Slides":"Google Slaytlar", "PDF":"PDF", "Word Document":"Word Belgesi", 
"Excel Spreadsheet":"Excel Tablosu", "Modified":"De\u011fi\u015ftirildi", "Connect":"Ba\u011flan", "Title not available":"Ba\u015fl\u0131\u011fa eri\u015filemiyor", "Open containing folder":"Bulundu\u011fu klas\u00f6r\u00fc a\u00e7"};
goog.provide("uno.i18n.uk");
uno.i18n.uk.textEntries = {"Not available offline":"\u041d\u0435 \u0434\u043e\u0441\u0442\u0443\u043f\u043d\u0438\u0439 \u0432 \u0430\u0432\u0442\u043e\u043d\u043e\u043c\u043d\u043e\u043c\u0443 \u0440\u0435\u0436\u0438\u043c\u0456", "Not available":"\u041d\u0435\u0434\u043e\u0441\u0442\u0443\u043f\u043d\u0438\u0439", "Tap to request access":"\u0422\u043e\u0440\u043a\u043d\u0456\u0442\u044c\u0441\u044f, \u0449\u043e\u0431 \u043e\u0442\u0440\u0438\u043c\u0430\u0442\u0438 \u0434\u043e\u0441\u0442\u0443\u043f", 
"Click to request access":"\u041d\u0430\u0442\u0438\u0441\u043d\u0456\u0442\u044c, \u0449\u043e\u0431 \u043e\u0442\u0440\u0438\u043c\u0430\u0442\u0438 \u0434\u043e\u0441\u0442\u0443\u043f", "Open":"\u0412\u0456\u0434\u043a\u0440\u0438\u0442\u0438", "Google Drive":"\u0414\u0438\u0441\u043a Google", "Google Docs":"\u0414\u043e\u043a\u0443\u043c\u0435\u043d\u0442\u0438 Google", "Google Sheets":"\u0422\u0430\u0431\u043b\u0438\u0446\u044f Google", "Google Slides":"\u041f\u0440\u0435\u0437\u0435\u043d\u0442\u0430\u0446\u0456\u044f Google", 
"PDF":"PDF", "Word Document":"\u0414\u043e\u043a\u0443\u043c\u0435\u043d\u0442 Word", "Excel Spreadsheet":"\u0422\u0430\u0431\u043b\u0438\u0446\u044f Excel", "Modified":"\u0417\u043c\u0456\u043d\u0435\u043d\u0438\u0439", "Connect":"\u041f\u0456\u0434\u043a\u043b\u044e\u0447\u0438\u0442\u0438\u0441\u044f", "Title not available":"\u041d\u0430\u0437\u0432\u0430 \u043d\u0435\u0434\u043e\u0441\u0442\u0443\u043f\u043d\u0430", "Open containing folder":"\u0412\u0456\u0434\u043a\u0440\u0438\u0442\u0438 \u043f\u0430\u043f\u043a\u0443"};
goog.provide("uno.i18n.vi");
uno.i18n.vi.textEntries = {"Not available offline":"Kh\u00f4ng kh\u1ea3 d\u1ee5ng \u1edf ch\u1ebf \u0111\u1ed9 ngo\u1ea1i tuy\u1ebfn", "Not available":"Kh\u00f4ng kh\u1ea3 d\u1ee5ng", "Tap to request access":"Nh\u1ea5p \u0111\u1ec3 y\u00eau c\u1ea7u quy\u1ec1n truy c\u1eadp", "Click to request access":"Nh\u1ea5p \u0111\u1ec3 y\u00eau c\u1ea7u quy\u1ec1n truy c\u1eadp", "Open":"M\u1edf", "Google Drive":"Google Drive", "Google Docs":"Google Docs", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", 
"PDF":"PDF", "Word Document":"T\u00e0i li\u1ec7u Word", "Excel Spreadsheet":"B\u1ea3ng t\u00ednh Excel", "Modified":"\u0110\u00e3 s\u1eeda \u0111\u1ed5i", "Connect":"K\u1ebft n\u1ed1i", "Title not available":"Ti\u00eau \u0111\u1ec1 kh\u00f4ng kh\u1ea3 d\u1ee5ng", "Open containing folder":"M\u1edf th\u01b0 m\u1ee5c ch\u1ee9a"};
goog.provide("uno.i18n.zh_CN");
uno.i18n.zh_CN.textEntries = {"Not available offline":"\u672a\u79bb\u7ebf\u7684\u7b14\u8bb0\u672c", "Not available":"\u4e0d\u53ef\u7528", "Tap to request access":"\u70b9\u51fb\u7533\u8bf7\u6743\u9650", "Click to request access":"\u70b9\u51fb\u7533\u8bf7\u6743\u9650", "Open":"\u6253\u5f00", "Google Drive":"Google Drive", "Google Docs":"Google\u6587\u6863", "Google Sheets":"Google Sheets", "Google Slides":"Google Slides", "PDF":"PDF", "Word Document":"Word\u6587\u6863", "Excel Spreadsheet":"Excel\u6570\u636e\u8868\u683c", 
"Modified":"\u5df2\u4fee\u6539", "Connect":"\u8fde\u63a5", "Title not available":"\u6807\u9898\u4e0d\u53ef\u7528", "Open containing folder":"\u6253\u5f00\u5305\u542b\u7684\u6587\u4ef6\u5939"};
goog.provide("uno.i18n.zh_TW");
uno.i18n.zh_TW.textEntries = {"Not available offline":"\u4e0d\u53ef\u96e2\u7dda\u5b58\u53d6", "Not available":"\u4e0d\u9069\u7528", "Tap to request access":"\u9ede\u64ca\u4ee5\u8acb\u6c42\u5b58\u53d6", "Click to request access":"\u9ede\u64ca\u4ee5\u8acb\u6c42\u5b58\u53d6", "Open":"\u958b\u555f", "Google Drive":"Google \u96f2\u7aef\u786c\u789f", "Google Docs":"Google \u6587\u4ef6", "Google Sheets":"Google \u8a66\u7b97\u8868", "Google Slides":"Google \u7c21\u5831", "PDF":"PDF", "Word Document":"Word \u6587\u4ef6", 
"Excel Spreadsheet":"Excel \u8a66\u7b97\u8868", "Modified":"\u5df2\u4fee\u6539", "Connect":"\u9023\u7d50", "Title not available":"\u7121\u6a19\u984c", "Open containing folder":"\u958b\u555f\u6240\u5c6c\u8cc7\u6599\u593e"};
goog.provide("uno.i18n.en_XA");
uno.i18n.en_XA.textEntries = {"Not available offline":"[Not available offline xxxxxxxxx]", "Not available":"[Not available xxxxxxxx]", "Tap to request access":"[Tap to request access xxxxxxxxx]", "Click to request access":"[Click to request access xxxxxxxxxx]", "Open":"[Open xxx]", "Google Drive":"[Google Drive xxxxxxx]", "Google Docs":"[Google Docs xxxxxx]", "Google Sheets":"[Google Sheets xxxxxxxx]", "Google Slides":"[Google Slides xxxxxxxx]", "PDF":"[PDF xx]", "Word Document":"[Word Document xxxxxxxx]", 
"Excel Spreadsheet":"[Excel Spreadsheet xxxxxxxxxx]", "Modified":"[Modified xxxxxxx]", "Connect":"[Connect xxxxxx]", "Title not available":"[Title not available xxxxxxxxxx x]", "Open containing folder":"[Open containing folder xxxxxxxxxx]"};
goog.provide("uno.i18n.all");
goog.require("uno.i18n.ar");
goog.require("uno.i18n.cs");
goog.require("uno.i18n.da");
goog.require("uno.i18n.de");
goog.require("uno.i18n.en");
goog.require("uno.i18n.es");
goog.require("uno.i18n.fi");
goog.require("uno.i18n.fr");
goog.require("uno.i18n.id");
goog.require("uno.i18n.it");
goog.require("uno.i18n.ja");
goog.require("uno.i18n.ko");
goog.require("uno.i18n.ms");
goog.require("uno.i18n.nl");
goog.require("uno.i18n.no");
goog.require("uno.i18n.pl");
goog.require("uno.i18n.pt_BR");
goog.require("uno.i18n.pt");
goog.require("uno.i18n.ru");
goog.require("uno.i18n.sv");
goog.require("uno.i18n.th");
goog.require("uno.i18n.tr");
goog.require("uno.i18n.uk");
goog.require("uno.i18n.vi");
goog.require("uno.i18n.zh_CN");
goog.require("uno.i18n.zh_TW");
goog.require("uno.i18n.en_XA");
uno.i18n.all.textEntries = {"ar":uno.i18n.ar.textEntries, "cs":uno.i18n.cs.textEntries, "da":uno.i18n.da.textEntries, "de":uno.i18n.de.textEntries, "en":uno.i18n.en.textEntries, "es":uno.i18n.es.textEntries, "fi":uno.i18n.fi.textEntries, "fr":uno.i18n.fr.textEntries, "id":uno.i18n.id.textEntries, "it":uno.i18n.it.textEntries, "ja":uno.i18n.ja.textEntries, "ko":uno.i18n.ko.textEntries, "ms":uno.i18n.ms.textEntries, "nl":uno.i18n.nl.textEntries, "no":uno.i18n.no.textEntries, "pl":uno.i18n.pl.textEntries, 
"pt_BR":uno.i18n.pt_BR.textEntries, "pt":uno.i18n.pt.textEntries, "ru":uno.i18n.ru.textEntries, "sv":uno.i18n.sv.textEntries, "th":uno.i18n.th.textEntries, "tr":uno.i18n.tr.textEntries, "uk":uno.i18n.uk.textEntries, "vi":uno.i18n.vi.textEntries, "zh_CN":uno.i18n.zh_CN.textEntries, "zh_TW":uno.i18n.zh_TW.textEntries, "en_XA":uno.i18n.en_XA.textEntries};
goog.provide("uno.util.loc");
goog.require("uno.i18n.all");
goog.require("uno.BasePlugin");
goog.require("goog.string");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.loc");
  var defs = uno.defs;
  var util = uno.util;
  util.loc.init = function(locale) {
    util.loc.locale = locale;
    if (!util.loc.locale) {
      util.loc.locale = "en";
    }
    util.loc.locale = util.loc.locale.replace(/-/g, "_");
    Object.keys(uno.i18n.all.textEntries).forEach(function(lang) {
      var value = uno.i18n.all.textEntries[lang];
      util.loc.addTranslation(lang, value);
    });
  };
  util.loc.defaultLocale = "en";
  util.loc.translation = null;
  util.loc.translations = {};
  util.loc.missingLocales = {};
  util.loc.missingStrings = {};
  util.loc.addTranslation = function(locale, translation) {
    util.loc.translations[locale] = translation;
    util.loc.missingStrings[locale] = {};
  };
  util.loc.loadTranslation = function(locale) {
    if (locale) {
      util.loc.locale = locale;
    }
    if (util.loc.locale == null) {
      console.warning("Language locale has not been configured. Defaulting to " + util.loc.defaultLocale);
      util.loc.locale = util.loc.defaultLocale;
    }
    util.loc.locale = util.loc.locale.replace(/-/g, "_");
    if (util.loc.missingLocales[util.loc.locale]) {
      return;
    }
    if (util.loc.translation !== null && util.loc.translation === util.loc.translations[util.loc.locale]) {
      return;
    }
    util.loc.translation = util.loc.translations[util.loc.locale];
    if (util.loc.translation == null) {
      console.log("There are no translations available for the " + util.loc.locale + " locale");
      util.loc.missingLocales[util.loc.locale] = true;
      if (util.loc.locale.indexOf("_") != -1) {
        util.loc.locale = util.loc.locale.substr(0, util.loc.locale.indexOf("_"));
        util.loc.translation = util.loc.translations[util.loc.locale];
        if (util.loc.translation == null) {
          console.log("There are also no translations for the fallback locale " + util.loc.locale);
          util.loc.missingLocales[util.loc.locale] = true;
        }
      }
    }
    if (util.loc.translation != null) {
      console.log("Using text for " + util.loc.locale);
      Object.keys(util.loc.translation).forEach(function(key) {
        var text = util.loc.translation[key];
        if (text == "") {
          util.loc.translation[key] = null;
        }
      });
      util.loc.missingStrings[locale] = util.loc.missingStrings[locale] || {};
    }
  };
  util.loc.t = function(text, placeholders) {
    var result;
    if (util.loc.translation == null) {
      util.loc.loadTranslation(util.loc.locale);
    }
    if (util.loc.missingLocales[util.loc.locale]) {
      result = text;
    } else {
      if (util.loc.translation[text] == null) {
        if (util.loc.missingStrings[util.loc.locale] == null) {
          console.log("No missingStrings object defined for " + util.loc.locale);
        }
        if (util.loc.missingStrings[util.loc.locale][text] == null) {
          console.log("The " + util.loc.locale + ' locale does not have a translation for "' + text + '"');
          util.loc.missingStrings[util.loc.locale][text] = true;
        }
        if (DEBUG) {
          en.assert(util.loc.translations[util.loc.defaultLocale][text] != null, "String missing from en.js");
        }
        result = text;
      } else {
        result = util.loc.translation[text];
      }
    }
    if (placeholders) {
      result = util.loc.replace(result, placeholders);
    }
    return result;
  };
  util.loc.replace = function(text, placeholders) {
    Object.keys(placeholders).forEach(function(token) {
      var value = placeholders[token];
      text = text.replace(new RegExp("{{" + token + "}}", "g"), value);
    });
    return text;
  };
})();
goog.provide("uno.util.placeholder.generic");
(function() {
  var generic = uno.util.placeholder.generic;
  var util = uno.util;
  generic.updateIfNeeded = function(editor) {
  };
})();
goog.provide("uno.util.placeholder.ios");
(function() {
  var ios = uno.util.placeholder.ios;
  var util = uno.util;
  ios.updateIfNeeded = function(editor) {
    var newPlaceholderText = editor.inEditMode() ? "" : editor.config.defaults.placeholderText;
    editor.field.setAttribute("data-en-placeholder", newPlaceholderText);
  };
})();
goog.provide("uno.util.placeholder");
goog.require("goog.debug.Logger");
goog.require("uno.util.placeholder.generic");
goog.require("uno.util.placeholder.ios");
(function() {
  var util = uno.util;
  var platform = uno.util.placeholder.generic;
  util.placeholder.setPlatform = function(platformName) {
    platform = uno.util.placeholder[platformName] || platform;
  };
  util.placeholder.updateIfNeeded = function(editor) {
    platform.updateIfNeeded(editor);
  };
})();
goog.provide("uno.util.http");
goog.require("goog.debug.Logger");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.http");
  var util = uno.util;
  util.http.fetchAsync = function(input, init) {
    log.info("Fetching : " + (input.url || input));
    return fetch(input, init).then(function(response) {
      log.info("Fetch response from : " + (input.url || input));
      log.info(response);
      if (response.status >= 200 && response.status < 300) {
        return response;
      } else {
        var error = new Error(response.statusText);
        error.response = response;
        throw error;
      }
    });
  };
})();
goog.provide("uno.util.richlink.googledrive.android");
goog.require("uno.util.loc");
(function() {
  var android = uno.util.richlink.googledrive.android;
  var util = uno.util;
  android.getAccessRequestString = function() {
    return util.loc.t("Tap to request access");
  };
})();
goog.provide("uno.util.richlink.googledrive.ios");
goog.require("uno.util.loc");
(function() {
  var ios = uno.util.richlink.googledrive.ios;
  var util = uno.util;
  ios.getAccessRequestString = function() {
    return util.loc.t("Tap to request access");
  };
})();
goog.provide("uno.util.richlink.googledrive.generic");
goog.require("uno.util.loc");
(function() {
  var generic = uno.util.richlink.googledrive.generic;
  var util = uno.util;
  generic.getAccessRequestString = function() {
    return util.loc.t("Click to request access");
  };
})();
goog.provide("uno.util.attachment");
goog.require("uno.defs");
goog.require("uno.util.loc");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.attachment");
  var defs = uno.defs;
  var util = uno.util;
  util.attachment.CLASS_PREFIX = "en-attach-icon-";
  util.attachment.getIconInfoFromFile = function(displayType, mime, fileName) {
    var fileType = "unknown";
    if (typeof mime === "string" || typeof fileName === "string") {
      if (mime) {
        mime = mime ? mime.toLowerCase() : null;
        fileType = mimeToFileType[mime];
        if (!fileType) {
          if (mime.indexOf("image/") > -1) {
            fileType = "image";
          } else {
            if (mime.indexOf("audio/") > -1) {
              fileType = "audio";
            } else {
              if (mime.indexOf("video/") > -1) {
                fileType = "video";
              }
            }
          }
        }
      }
      if (!fileType && fileName) {
        var extension = fileName.match(/^.+\.([0-9a-z]+)$/i);
        if (extension) {
          fileType = extensionToFileType[extension[1]];
        }
      }
    }
    return util.attachment.CLASS_PREFIX + fileType;
  };
  var extensionToFileType = {"pdf":"pdf", "djvu":"pdf", "wav":"audio", "aiff":"audio", "flac":"audio", "ogg":"audio", "ac3":"audio", "mp3":"audio", "avi":"video", "mp4":"video", "mpg":"video", "mpeg":"video", "vob":"video", "pptx":"ppt", "ppt":"ppt", "sdd":"ppt", "odp":"ppt", "doc":"word", "dot":"word", "docx":"word", "odt":"word", "xls":"excel", "xlsx":"excel", "ods":"excel", "csv":"excel", "zip":"zip", "zipx":"zip", "gz":"zip", "tgz":"zip", "rar":"zip", "iso":"zip", "tar":"zip", "mar":"zip", "bz2":"zip", 
  "cab":"zip", "arc":"zip", "dmg":"zip", "jar":"zip", "war":"zip", "7z":"zip", "svg":"svg", "svgz":"svg", "ai":"svg", "cdr":"svg", "wmf":"svg", "drw":"svg", "eps":"svg", "emz":"svg", "odg":"svg", "pic":"svg", "sda":"svg", "swf":"svg", "sketch":"svg", "cad":"3d", "skp":"3d", "stl":"3d", "123dx":"3d", "anim":"3d", "3d":"3d", "3dr":"3d", "3ds":"3d", "dwg":"3d", "dxf":"3d", "pfb":"font", "ttf":"font", "otf":"font", "pages":"pages", "rtf":"pages", "txt":"pages", "numbers":"num", "keynote":"keynote", "key":"keynote", 
  "psd":"edit", "ptg":"edit", "skba":"edit", "pxm":"edit", "xcf":"edit"};
  var mimeToFileType = {"application/pdf":"pdf", "application/mspowerpoint":"ppt", "application/powerpoint":"ppt", "application/vnd.ms-powerpoint":"ppt", "application/x-mspowerpoint":"ppt", "application/vnd.oasis.opendocument.presentation":"ppt", "application/vnd.openxmlformats-officedocument.presentationml.slideshow":"ppt", "application/msword":"word", "application/vnd.oasis.opendocument.text":"word", "application/vnd.openxmlformats-officedocument.wordprocessingml.document":"word", "application/excel":"excel", 
  "application/vnd.ms-excel":"excel", "application/x-excel":"excel", "text/csv":"excel", "application/vnd.oasis.opendocument.spreadsheet":"excel", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":"excel", "application/zip":"zip", "application/x-compress":"zip", "application/x-compressed":"zip", "application/x-zip-compressed":"zip", "multipart/x-zip":"zip", "application/x-gzip":"zip", "application/x-rar-compressed":"zip", "application/x-gtar":"zip", "application/vnd.ms-cab-compressed":"zip", 
  "application/x-apple-diskimage":"zip", "application/x-7z-compressed":"zip", "image/svg+xml":"svg", "application/postscript":"svg", "windows/metafile":"svg", "application/drafting":"svg", "image/pict":"svg", "application/x-shockwave-flash":"svg", "application/x-koan":"3d", "application/sla":"3d", "x-world/x-3dmf":"3d", "application/acad":"3d", "application/dxf":"3d", "application/rtf":"pages", "application/x-rtf":"pages", "text/richtext":"pages", "application/vnd.apple.pages":"pages", "application/x-iwork-pages-sffpages":"pages", 
  "application/vnd.apple.numbers":"numbers", "application/x-iwork-numbers-sffnumbers":"numbers", "application/vnd.apple.keynote":"keynote", "application/x-iwork-keynote-sffkey":"keynote", "application/vnd.google-apps.document":"gdocs", "application/vnd.google-apps.spreadsheet":"gsheets", "application/vnd.google-apps.presentation":"gslides", "unknown":"unknown"};
  util.attachment.isThumbnailableMimeType = function(mimeType) {
    if (!mimeType) {
      return false;
    }
    if (mimeType.indexOf("image/") === 0) {
      return true;
    }
    return mimeType.indexOf("video/") === 0;
  };
  util.attachment.getFileTypeDescription = function(mimeType) {
    switch(mimeType) {
      case "application/vnd.google-apps.document":
        return util.loc.t("Google Docs");
      case "application/vnd.google-apps.spreadsheet":
        return util.loc.t("Google Sheets");
      case "application/vnd.google-apps.presentation":
        return util.loc.t("Google Slides");
      case "application/pdf":
        return util.loc.t("PDF");
      default:
        return null;
    }
  };
})();
goog.provide("uno.util.richlink.googledrive");
goog.require("goog.debug.Logger");
goog.require("goog.dom");
goog.require("goog.string");
goog.require("uno.Auth");
goog.require("uno.util.http");
goog.require("uno.util.richlink");
goog.require("uno.util.richlink.googledrive.android");
goog.require("uno.util.richlink.googledrive.ios");
goog.require("uno.util.richlink.googledrive.generic");
goog.require("uno.util.attachment");
goog.require("uno.util.loc");
(function() {
  var log = goog.debug.Logger.getLogger("uno.util.richlink.googledrive");
  var defs = uno.defs;
  var util = uno.util;
  var googledrive = util.richlink.googledrive;
  var DRIVE_META_URL = "https://www.googleapis.com/drive/v2/files/";
  var DRIVE_LINK_RX = /https:\/\/(docs|drive).google.com\/[^\s\"]+[\/\=]([^\s\/<#=%&@."?]{20,120})([^\"\<\>\s&]*)/gi;
  var GOOGLE_DATE_RX = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3})Z$/;
  var THUMBNAIL_RX = /s\d+$/g;
  var platform = googledrive.generic;
  googledrive.name = "google-drive";
  googledrive.lastInfo = {};
  googledrive.lastError = {};
  googledrive.lastImageUrl = {};
  googledrive.uniqueIdCounter = 0;
  googledrive.setPlatform = function(platformName) {
    platform = googledrive[platformName] || platform;
  };
  googledrive.canDecorate = function(url) {
    DRIVE_LINK_RX.lastIndex = 0;
    return url && DRIVE_LINK_RX.test(url);
  };
  googledrive.decorate = function(el, editor) {
    var domEl;
    var cancelCachePromise = false;
    var elementInDocument = Promise.resolve().then(function() {
      domEl = util.richlink.findByRef(el.dataset.reference, editor.field);
    });
    googledrive.convertAnchorToRichlink(el);
    googledrive.injectData(el, editor.cache.readMem(el.href));
    elementInDocument.then(function() {
      return editor.cache.readDiskAsync(domEl.href);
    }).then(function(data) {
      if (!cancelCachePromise) {
        googledrive.injectData(domEl, data);
        if (data) {
          editor.cache.writeMem(domEl.href, data);
        }
      }
    });
    elementInDocument.then(function() {
      return editor.auth.getTokenAsync("google-drive");
    }).then(function(token) {
      return googledrive.getDataFromProviderAsync(domEl, token, editor);
    }).then(function(data) {
      cancelCachePromise = true;
      googledrive.injectData(domEl, data);
    })["catch"](function(error) {
      googledrive.injectError(domEl, error);
    });
  };
  googledrive.undecorate = function(el) {
  };
  googledrive.getDataFromProviderAsync = function(el, token, editor) {
    DRIVE_LINK_RX.lastIndex = 0;
    var match = DRIVE_LINK_RX.exec(el.href);
    var driveId = match[2];
    var url = DRIVE_META_URL + driveId;
    return util.http.fetchAsync(url, {headers:new Headers({"Authorization":"Bearer " + token})}).then(function(response) {
      return response.json();
    }).then(function(data) {
      data.driveId = driveId;
      if (data.parents && data.parents.length > 0) {
        data.parentFolderLink = data.parents[0].parentLink;
      }
      el.dataset.parentFolderLink = data.parentFolderLink;
      if (data.title) {
        el.dataset.title = data.title;
      }
      el.dataset.alternateLink = data.alternateLink;
      editor.cache.write(el.href, data);
      return data;
    })["catch"](function(error) {
      if (error.response) {
        error.errorCode = error.errorCode || error.response.status;
      }
      throw error;
    });
  };
  googledrive.convertAnchorToRichlink = function(el) {
    var displayType = util.richlink.getDisplayType(el);
    el.innerHTML = "";
    if (displayType === util.richlink.DISPLAY_TYPE.MINIMAL) {
      goog.dom.classlist.addAll(el, ["richlink-minimal-title", "en-attach-icon-loading"]);
    } else {
      goog.dom.classlist.add(el, "en-richlink");
      el.appendChild(goog.dom.createDom("div", {"class":"en-richlink-link-body"}, [goog.dom.createDom("div", {"class":"google-drive-container"}, [goog.dom.createDom("div", {"class":"gd-file-icon-div en-attach-img-icon"}), goog.dom.createDom("div", {"class":"google-drive-middle-text"}, [goog.dom.createDom("div", {"class":"google-drive-line1-text"}), goog.dom.createDom("div", {"class":"google-drive-line2-text"})]), goog.dom.createDom("div", {"class":"more-options", "id":googledrive.name + ++googledrive.uniqueIdCounter}, 
      goog.dom.createDom("img", {"class":"more-options-icon ", "src":defs.image.TRANSPARENT_IMAGE_DATA_URL})), goog.dom.createDom("div", {"class":"en-attach-src en-attach-src-google"}), goog.dom.createDom("div", {"class":"en-richlink-load-progress-container"}, goog.dom.createDom("div", {"class":"en-richlink-load-progress-container-inner"}, goog.dom.createDom("div", {"class":"en-richlink-load-progress"})))]), goog.dom.createDom("div", {"class":"google-drive-thumbnail-container", "style":"visibility: hidden; display: none;"}, 
      [goog.dom.createDom("img", {"class":"google-drive-thumbnail", "style":"visibility: hidden; display: none;"}), goog.dom.createDom("span", {"class":"google-drive-thumbnail-failed en-attach-img-icon", "style":"visibility: hidden; display: none;"}), goog.dom.createDom("div", {"class":"en-richlink-load-progress-container-inner en-richlink-thumbnail-progress"}, goog.dom.createDom("div", {"class":"en-richlink-load-progress"}))])]));
    }
  };
  googledrive.hideContainerProgress = function(el) {
    var progress = el.querySelector(".en-richlink-load-progress-container");
    if (progress) {
      progress.style.display = "none";
    }
  };
  googledrive.hideThumbnailProgress = function(el) {
    var thumbnailProgress = el.querySelector(".en-richlink-thumbnail-progress");
    if (thumbnailProgress) {
      thumbnailProgress.style.display = "none";
    }
  };
  googledrive.injectError = function(el, error) {
    var line1 = el.querySelector(".google-drive-line1-text");
    var line2 = el.querySelector(".google-drive-line2-text");
    googledrive.hideContainerProgress(el);
    goog.dom.classlist.add(line1, "en-richlink-disabled-state");
    switch(error.errorCode) {
      case uno.Auth.ERROR_CODE_NO_AUTH:
      ;
      case uno.Auth.ERROR_CODE_INVALID_AUTH:
      ;
      case 401:
        line2.innerHTML = util.loc.t("Google Drive") + "&#160;&#160;&#160;&#160;" + '<span class="en-connect-to-drive-text">' + util.loc.t("Connect") + "</span>";
        break;
      case uno.Auth.ERROR_CODE_NETWORK_ERROR:
      ;
      case 0:
        line2.innerHTML = util.loc.t("Google Drive") + ": " + util.loc.t("Not available offline");
        break;
      case 403:
      ;
      case 404:
        line2.innerHTML = plaform.getAccessRequestString();
        break;
      case uno.Auth.ERROR_CODE_UNKNOWN:
        line2.innerHTML = util.loc.t("Google Drive") + ": " + util.loc.t("Not available");
        break;
      default:
        line2.innerHTML = util.loc.t("Google Drive") + ": " + util.loc.t("Not available");
    }
  };
  googledrive.injectData = function(el, data) {
    if (!data) {
      return;
    }
    var line1 = el.querySelector(".google-drive-line1-text");
    var line2 = el.querySelector(".google-drive-line2-text");
    var displayType = util.richlink.getDisplayType(el);
    var url = el.href;
    var title = data.title && goog.string.unescapeEntities(data.title);
    googledrive.hideContainerProgress(el);
    goog.dom.classlist.remove(line1, "en-richlink-disabled-state");
    var mimeType = data.mimeType;
    if (!mimeType) {
      if (url.indexOf("/document/") > -1) {
        mimeType = "application/vnd.google-apps.document";
      } else {
        if (url.indexOf("/spreadsheets/") > -1) {
          mimeType = "application/vnd.google-apps.spreadsheet";
        } else {
          if (url.indexOf("/presentation/") > -1) {
            mimeType = "application/vnd.google-apps.presentation";
          }
        }
      }
    }
    if (displayType == util.richlink.DISPLAY_TYPE.MINIMAL) {
      if (title) {
        el.textContent = title;
        googledrive.fillInFileIcon(el, displayType, mimeType, title, false);
      }
    } else {
      line1.innerHTML = title || util.loc.t("Title not available");
      var fileDescription = util.attachment.getFileTypeDescription(mimeType) || util.loc.t("Google Drive");
      var dateVal = googledrive.parseGoogleDate(data.modifiedDate);
      var dateString = dateVal && dateVal.toLocaleDateString();
      var line2Text = fileDescription;
      if (dateString) {
        line2Text += ": " + util.loc.t("Modified") + " " + dateString;
      }
      line2.innerHTML = line2Text;
      googledrive.fillInFileIcon(el, displayType, mimeType, title, false);
      if (data.thumbnailLink && util.attachment.isThumbnailableMimeType(mimeType)) {
        var thumbnailView = el.querySelector("google-drive-thumbnail");
        var thumbnailContainer = el.querySelector("google-drive-thumbnail-container");
        var thumbnailFailed = el.querySelector("google-drive-thumbnail-failed");
        var width = thumbnailContainer.parentElement.getBoundingClientRect().width;
        var height = -1;
        var ratio = -1;
        thumbnailContainer.style.visibility = "visible";
        thumbnailContainer.style.display = "initial";
        thumbnailView.style.display = "block";
        var imageMeta = data.imageMediaMetadata;
        var videoMediaMetadata = data.videoMediaMetadata;
        if (imageMeta && imageMeta.width && imageMeta.height) {
          ratio = imageMeta.height / imageMeta.width;
        }
        if (window.devicePixelRatio) {
          width = Math.round(width * window.devicePixelRatio);
        }
        if (ratio < 0 || ratio > .62) {
          ratio = .62;
        }
        height = Math.round(ratio * width);
        var containerHeight = height;
        if (window.devicePixelRatio) {
          containerHeight /= Math.round(window.devicePixelRatio);
        }
        thumbnailContainer.style.height = containerHeight + "px";
        var sizeString = "w" + width + (height > 0 ? "-h" + height : "") + "-p-k-nu";
        var thumbnailUrl = fileInfo.thumbnailLink.replace(THUMBNAIL_RX, sizeString);
        thumbnailView.setAttribute("src", thumbnailUrl);
        thumbnailContainer.parentElement.style["padding-bottom"] = 0;
        googledrive.hideThumbnailProgress(el);
        thumbnailView.addEventListener("load", function() {
          thumbnailContainer.style.height = "auto";
          thumbnailView.style.visibility = "visible";
          thumbnailView.style.display = "block";
          thumbnailFailed.style.visibility = "hidden";
          thumbnailFailed.style.display = "none";
        });
        thumbnailView.addEventListener("error", function() {
          thumbnailView.style.visibility = "hidden";
          thumbnailView.style.display = "none";
          thumbnailFailed.style.visibility = "visible";
          thumbnailFailed.style.display = "block";
          var iconClassName = util.attachment.getIconInfoFromFile(displayType, mimeType, title);
          goog.dom.classlist.add(thumbnailFailed, iconClassName);
        });
      }
    }
  };
  googledrive.fillInFileIcon = function(node, displayType, mimeType, title, disabled) {
    var me = this;
    var fileIconDiv = node.getElementsByClassName("gd-file-icon-div")[0];
    var iconClass = uno.util.attachment.getIconInfoFromFile(displayType, mimeType, title);
    if (iconClass) {
      if (displayType === util.richlink.DISPLAY_TYPE.MINIMAL) {
        goog.dom.classlist.add(node, iconClass);
        goog.dom.classlist.remove(node, "en-attach-icon-loading");
        return;
      } else {
        goog.dom.classlist.add(fileIconDiv, iconClass);
      }
    }
    if (disabled) {
      goog.dom.classlist.add(fileIconDiv, "en-richlink-disabled-state");
    } else {
      goog.dom.classlist.remove(fileIconDiv, "en-richlink-disabled-state");
    }
  };
  googledrive.parseGoogleDate = function(d) {
    try {
      var m = GOOGLE_DATE_RX.exec(d);
      var year = +m[1];
      var month = +m[2];
      var day = +m[3];
      var hour = +m[4];
      var minute = +m[5];
      var second = +m[6];
      var msec = +m[7];
      var tzOffset = (new Date).getTimezoneOffset();
      return new Date(year, month - 1, day, hour, minute - tzOffset, second, msec);
    } catch (exception) {
      log.info("error parsing date: " + exception);
    }
  };
  googledrive.reloadAsync = function(el, askUserForPermission, editor) {
    return editor.auth.getTokenAsync(googledrive.name, true, !!askUserForPermission).then(function(token) {
      return googledrive.getDataFromProviderAsync(el, token, editor);
    }).then(function(data) {
      googledrive.injectData(el, data);
    })["catch"](function(error) {
      googledrive.injectError(el, error);
    });
  };
  googledrive.openDoc = function(url, target, editor) {
    editor.dispatchEvent({type:"linkclick", target:target, data:{module:"link", href:url}});
  };
  googledrive.buildOptions = function(el, optionsEl, lastErrorCode) {
    var rect = optionsEl.getBoundingClientRect();
    var options = {href:el.href, module:googledrive.name, ceOptions:{"elementId":optionsEl.id, "boundingbox":{"left":rect.left, "right":rect.right, "top":rect.top, "bottom":rect.bottom, "height":rect.height, "width":rect.width}, "optionsArray":[{"id":"open", "text":util.loc.t("Open")}]}};
    if (lastErrorCode === uno.Auth.ERROR_CODE_NO_AUTH || lastErrorCode === uno.Auth.ERROR_CODE_INVALID_AUTH || lastErrorCode === 401) {
      options.optionsArray.unshift({"id":"connect", "text":util.loc.t("Connect")});
    }
    return options;
  };
  googledrive.handleClick = function(el, event, editor) {
    var target = event.target;
    var optionsEl = goog.dom.getAncestorByClass(target, "more-options");
    if (optionsEl) {
      var lastErrorCode = editor.auth.providers[googledrive.name].errorCode;
      var options = googledrive.buildOptions(el, optionsEl, lastErrorCode);
      editor.router.toHostAsync("showOptions", options).then(function(response) {
        if (response.selectedOptionId === "open") {
          googledrive.openDoc(el.href || el.dataset.alternateLink, target, editor);
        } else {
          if (response.selectedOptionId === "folder" && el.dataset.parentFolderLink) {
            googledrive.openDoc(el.dataset.parentFolderLink, target, editor);
          } else {
            if (response.selectedOptionId === "connect") {
              googledrive.reloadAsync(el, true, editor);
            }
          }
        }
      });
      event.preventDefault();
    } else {
      if (goog.dom.classlist.contains(target, "en-connect-to-drive-text")) {
        googledrive.reloadAsync(el, true, editor);
        event.preventDefault();
      } else {
        googledrive.openDoc(el.href || el.dataset.alternateLink, target, editor);
      }
    }
    return true;
  };
})();
goog.provide("uno.util.touch");
(function() {
  var util = uno.util;
  util.touch.init = function(editor) {
    var x;
    var y;
    editor.addListener("touchstart", function(e) {
      x = e.clientX;
      y = e.clientY;
    }, false, editor);
    editor.addListener("touchend", function(e) {
      if (!editor.inEditMode() || x == null || y == null) {
        return;
      }
      if (Math.abs(x - e.clientX) < 5 && Math.abs(y - e.clientY) < 5) {
        var event = new MouseEvent("click", {touch:true, view:window, bubbles:true, cancelable:true, clientX:e.clientX, clientY:e.clientY});
        var target = e.target;
        target.dispatchEvent(event);
      }
      x = null;
      y = null;
    }, false, editor);
    editor.addListener("touchcancel", function(e) {
      x = null;
      y = null;
    }, false, editor);
  };
})();
goog.provide("uno.Editor");
goog.require("goog.dom.classes");
goog.require("goog.dom.Range");
goog.require("goog.editor.Field.EventType");
goog.require("goog.editor.SeamlessField");
goog.require("goog.editor.Plugin");
goog.require("goog.editor.plugins.BasicTextFormatter");
goog.require("goog.editor.plugins.EnterHandler");
goog.require("goog.editor.plugins.HeaderFormatter");
goog.require("goog.editor.plugins.ListTabHandler");
goog.require("goog.editor.plugins.RemoveFormatting");
goog.require("goog.editor.plugins.SpacesTabHandler");
goog.require("goog.editor.plugins.TableEditor");
goog.require("goog.editor.plugins.UndoRedo");
goog.require("uno.ConsoleLogger");
goog.require("uno.defs");
goog.require("uno.env");
goog.require("uno.commands.Accentuate");
goog.require("uno.commands.Active");
goog.require("uno.commands.BasicTextFormatter");
goog.require("uno.commands.Bounds");
goog.require("uno.commands.Capitalize");
goog.require("uno.commands.Changes");
goog.require("uno.commands.Content");
goog.require("uno.commands.ControlTodos");
goog.require("uno.commands.Copy");
goog.require("uno.commands.CreateLink");
goog.require("uno.commands.Crypt");
goog.require("uno.commands.Cut");
goog.require("uno.commands.Delete");
goog.require("uno.commands.DeleteTable");
goog.require("uno.commands.DeleteTableCol");
goog.require("uno.commands.DeleteTableRow");
goog.require("uno.commands.Find");
goog.require("uno.commands.Focus");
goog.require("uno.commands.FontSize");
goog.require("uno.commands.ForwardDelete");
goog.require("uno.commands.InsertCrypto");
goog.require("uno.commands.InsertHtml");
goog.require("uno.commands.InsertParagraph");
goog.require("uno.commands.InsertTable");
goog.require("uno.commands.InsertTableCol");
goog.require("uno.commands.InsertTableRow");
goog.require("uno.commands.InsertTodo");
goog.require("uno.commands.Lowercase");
goog.require("uno.commands.Margin");
goog.require("uno.commands.Paste");
goog.require("uno.commands.PlainText");
goog.require("uno.commands.PrintPreview");
goog.require("uno.commands.Redo");
goog.require("uno.commands.RemoveFormat");
goog.require("uno.commands.Resources");
goog.require("uno.commands.RevealCrypto");
goog.require("uno.commands.RichlinksConvert");
goog.require("uno.commands.RichlinksRefresh");
goog.require("uno.commands.SelectAll");
goog.require("uno.commands.Selection");
goog.require("uno.commands.SharedBar");
goog.require("uno.commands.SimpleText");
goog.require("uno.commands.Undo");
goog.require("uno.commands.Unlink");
goog.require("uno.commands.Uppercase");
goog.require("uno.filters.CryptFilter");
goog.require("uno.filters.EmoticonFilter");
goog.require("uno.filters.EnmlFilter");
goog.require("uno.filters.FontSizeFilter");
goog.require("uno.filters.MarkupFilter");
goog.require("uno.filters.ResourceFilter");
goog.require("uno.filters.RichlinkFilter");
goog.require("uno.filters.TodoFilter");
goog.require("uno.filters.BasicTextFormatterFilter");
goog.require("uno.listeners.AccentuateListener");
goog.require("uno.listeners.AttachmentListener");
goog.require("uno.listeners.CryptListener");
goog.require("uno.listeners.DeleteListener");
goog.require("uno.listeners.EditModeListener");
goog.require("uno.listeners.ForwardDeleteListener");
goog.require("uno.listeners.BasicTextFormatterListener");
goog.require("uno.listeners.ImgListener");
goog.require("uno.listeners.LinkListener");
goog.require("uno.listeners.PasteListener");
goog.require("uno.listeners.RichlinkListener");
goog.require("uno.listeners.SharedBarListener");
goog.require("uno.listeners.SmartScrollListener");
goog.require("uno.listeners.TableCellListener");
goog.require("uno.listeners.TableResizeListener");
goog.require("uno.listeners.TodoListener");
goog.require("uno.listeners.TodoListListener");
goog.require("uno.listeners.TypeBehindListener");
goog.require("uno.util.classes");
goog.require("uno.util.dom");
goog.require("uno.util.loc");
goog.require("uno.util.objects");
goog.require("uno.util.placeholder");
goog.require("uno.util.resource");
goog.require("uno.util.richlink.googledrive");
goog.require("uno.util.simpletext");
goog.require("uno.util.touch");
goog.require("uno.util.todo");
(function() {
  var Field = goog.editor.Field;
  var log = goog.debug.Logger.getLogger("uno.Editor");
  var SeamlessField = goog.editor.SeamlessField;
  var Plugin = goog.editor.Plugin;
  var util = uno.util;
  var Editor = uno.Editor = function(id, options) {
    SeamlessField.call(this, id || "editor");
    this.cache = options.cache;
    this.auth = options.auth;
    this.router = options.router;
    this.dirty = false;
    this.empty = true;
    this.focused = false;
    this.isSetup = false;
    this.readOnly = false;
    this.initConfig(options);
    goog.dom.classes.add(document.body, this.config.platform);
    util.placeholder.setPlatform(this.config.platform);
    util.resource.setPlatform(this.config.platform);
    util.todo.setPlatform(this.config.platform);
    util.simpletext.setPlatform(this.config.platform);
    util.richlink.googledrive.setPlatform(this.config.platform);
    this.listeners = {};
    this.handlers = [{name:"click", handler:"handleClick"}, {name:"dblclick", handler:"handleDoubleClick"}, {name:"mousedown", handler:"handleMouseDown"}, {name:"mouseup", handler:"handleMouseUp"}, {name:"mouseover", handler:"handleMouseOver"}, {name:"mouseout", handler:"handleMouseOut"}, {name:"mousemove", handler:"handleMouseMove"}, {name:"textInput", handler:"handleTextInput"}, {name:"paste", handler:"handlePaste"}, {name:"selectionchange", target:document, handler:"handleNativeSelectionChange"}, 
    {name:"resize", target:window, handler:"handleWindowResize"}];
    this.handlers.forEach(function(property) {
      this.listeners[property.name] = [];
    }.bind(this));
    this.importDomFilters = [];
    this.queryCommandEnabledPlugins = [];
    this.beforeExecCommand = [];
    this.richlinkProviders = [uno.util.richlink.googledrive];
    this.setFollowLinkInNewWindow(false);
    util.loc.init(this.config.locale);
    this.initEvents();
    this.initPlugins();
  };
  goog.inherits(Editor, SeamlessField);
  Editor.EventType = {PRINT_READY:"printready", IMAGE_CLICK:"imageclick", IMAGE_DOUBLECLICK:"imagedoubleclick", IMAGE_ANNOTATE:"annotate", IMAGE_PREVIEW:"preview", IMAGE_ROTATE:"rotate", CONTENT_LOADED:"contentloaded", LINK_CLICK:"linkclick", OPEN_LINK:"openLink", ENCRYPT:"encrypt", DECRYPT:"decrypt", STYLE_CHANGED:"stylechanged", EDIT_MODE_CHANGED:"editmodechanged"};
  Object.keys(Field.EventType).forEach(function(key) {
    if (Field.EventType.hasOwnProperty(key)) {
      Editor.EventType[key] = Field.EventType[key];
    }
  });
  Editor.prototype.setup = function() {
    var options = {type:this.config.initialContentFormat, content:this.config.initialContent || this.config.defaults.html};
    this.makeEditable();
    this.execCommand("margin", this.config.margin);
    this.execCommand("content", options);
    this.updateEmpty();
    this.isSetup = true;
  };
  Editor.prototype.initEvents = function() {
    this.listen(Editor.EventType.DELAYEDCHANGE, this.onDelayedChange);
    this.listen(Editor.EventType.LOAD, this.onLoad);
    this.listen(Editor.EventType.UNLOAD, this.onUnload);
    this.listen(Editor.EventType.FOCUS, this.onFocus);
    this.listen(Editor.EventType.BLUR, this.onBlur);
    this.listen(Editor.EventType.BEFORESELECTIONCHANGE, this.onBeforeSelectionChange);
    this.listen(Editor.EventType.SELECTIONCHANGE, this.onSelectionChange);
    this.listen(Editor.EventType.COMMAND_VALUE_CHANGE, this.onCommandValueChange);
    this.listen(Editor.EventType.EDIT_MODE_CHANGED, this.onEditModeChanged);
    this.eventRegister.listen(document, "selectionchange", this.onSelectionChange);
    this.eventRegister.listen(document.body, "textInput", this.onTextInput);
  };
  Editor.prototype.registerPlugin = function(plugin) {
    var me = this;
    SeamlessField.prototype.registerPlugin.call(me, plugin);
    me.handlers.forEach(function(property) {
      if (plugin[property.handler]) {
        me.listeners[property.name].push(plugin);
      }
    });
    if (plugin.handleBeforeExecCommand) {
      me.beforeExecCommand.push(plugin);
    }
    if (plugin.prepareContentsDom) {
      me.importDomFilters.push(plugin);
    }
    if (plugin.queryCommandEnabled) {
      me.queryCommandEnabledPlugins.push(plugin);
    }
  };
  Editor.prototype.unregisterPlugin = function(plugin) {
    var me = this;
    SeamlessField.prototype.unregisterPlugin.call(me, plugin);
    me.handlers.forEach(function(property) {
      goog.array.remove(me.listeners[property.name], plugin);
    });
    if (plugin.handleBeforeExecCommand) {
      goog.array.remove(this.beforeExecCommand, plugin);
    }
    if (plugin.prepareContentsDom) {
      goog.array.remove(this.importDomFilters, plugin);
    }
    if (plugin.queryCommandEnabled) {
      goog.array.remove(this.queryCommandEnabledPlugins, plugin);
    }
  };
  Editor.prototype.initPlugins = function() {
    this.registerPlugin(new goog.editor.plugins.BasicTextFormatter);
    this.registerPlugin(new goog.editor.plugins.HeaderFormatter);
    this.registerPlugin(new goog.editor.plugins.ListTabHandler);
    this.registerPlugin(new goog.editor.plugins.RemoveFormatting);
    this.registerPlugin(new goog.editor.plugins.UndoRedo);
    this.registerPlugin(new goog.editor.plugins.TableEditor);
    this.registerPlugin(new uno.commands.Accentuate);
    this.registerPlugin(new uno.commands.Active);
    this.registerPlugin(new uno.commands.BasicTextFormatter);
    this.registerPlugin(new uno.commands.Bounds);
    this.registerPlugin(new uno.commands.Capitalize);
    this.registerPlugin(new uno.commands.Changes);
    this.registerPlugin(new uno.commands.Content);
    this.registerPlugin(new uno.commands.ControlTodos);
    this.registerPlugin(new uno.commands.Copy);
    this.registerPlugin(new uno.commands.CreateLink);
    this.registerPlugin(new uno.commands.Crypt);
    this.registerPlugin(new uno.commands.Cut);
    this.registerPlugin(new uno.commands.Delete);
    this.registerPlugin(new uno.commands.DeleteTable);
    this.registerPlugin(new uno.commands.DeleteTableCol);
    this.registerPlugin(new uno.commands.DeleteTableRow);
    this.registerPlugin(new uno.commands.Find(this.config));
    this.registerPlugin(new uno.commands.Focus);
    this.registerPlugin(new uno.commands.FontSize);
    this.registerPlugin(new uno.commands.ForwardDelete);
    this.registerPlugin(new uno.commands.InsertCrypto);
    this.registerPlugin(new uno.commands.InsertHtml);
    this.registerPlugin(new uno.commands.InsertParagraph);
    this.registerPlugin(new uno.commands.InsertTable);
    this.registerPlugin(new uno.commands.InsertTableCol);
    this.registerPlugin(new uno.commands.InsertTableRow);
    this.registerPlugin(new uno.commands.InsertTodo);
    this.registerPlugin(new uno.commands.Lowercase);
    this.registerPlugin(new uno.commands.Margin);
    this.registerPlugin(new uno.commands.Paste(this.config));
    this.registerPlugin(new uno.commands.PlainText);
    this.registerPlugin(new uno.commands.PrintPreview);
    this.registerPlugin(new uno.commands.Redo);
    this.registerPlugin(new uno.commands.RemoveFormat);
    this.registerPlugin(new uno.commands.Resources);
    this.registerPlugin(new uno.commands.RevealCrypto);
    this.registerPlugin(new uno.commands.RichlinksConvert);
    this.registerPlugin(new uno.commands.RichlinksRefresh);
    this.registerPlugin(new uno.commands.SelectAll);
    this.registerPlugin(new uno.commands.Selection);
    this.registerPlugin(new uno.commands.SharedBar);
    this.registerPlugin(new uno.commands.SimpleText);
    this.registerPlugin(new uno.commands.Undo);
    this.registerPlugin(new uno.commands.Unlink);
    this.registerPlugin(new uno.commands.Uppercase);
    this.registerPlugin(new uno.filters.MarkupFilter);
    this.registerPlugin(new uno.filters.CryptFilter(this.config));
    this.registerPlugin(new uno.filters.EnmlFilter);
    this.registerPlugin(new uno.filters.ResourceFilter);
    this.registerPlugin(new uno.filters.RichlinkFilter);
    this.registerPlugin(new uno.filters.TodoFilter);
    this.registerPlugin(new uno.filters.BasicTextFormatterFilter);
    this.registerPlugin(new uno.filters.FontSizeFilter);
    this.registerPlugin(new goog.editor.plugins.EnterHandler);
    this.registerPlugin(new uno.listeners.AccentuateListener);
    this.registerPlugin(new uno.listeners.AttachmentListener);
    this.registerPlugin(new uno.listeners.CryptListener);
    this.registerPlugin(new uno.listeners.DeleteListener);
    this.registerPlugin(new uno.listeners.ForwardDeleteListener);
    this.registerPlugin(new uno.listeners.BasicTextFormatterListener);
    this.registerPlugin(new uno.listeners.ImgListener);
    this.registerPlugin(new uno.listeners.LinkListener);
    this.registerPlugin(new uno.listeners.PasteListener);
    this.registerPlugin(new uno.listeners.RichlinkListener);
    this.registerPlugin(new uno.listeners.SharedBarListener);
    this.registerPlugin(new uno.listeners.TableCellListener);
    this.registerPlugin(new goog.editor.plugins.SpacesTabHandler);
    this.registerPlugin(new uno.listeners.TableResizeListener);
    this.registerPlugin(new uno.listeners.TodoListener);
    this.registerPlugin(new uno.listeners.TodoListListener);
    this.registerPlugin(new uno.listeners.TypeBehindListener);
    this.registerPlugin(new uno.listeners.EditModeListener);
    this.registerPlugin(new uno.listeners.SmartScrollListener);
  };
  Editor.prototype.initConfig = function(opt) {
    var options = opt || {};
    options.env = options.env || {};
    options.rte = options.rte || {};
    options.env.margin = options.env.margin || {};
    options.rte.imageConfig = options.rte.imageConfig || {};
    options.rte.typebehind = options.rte.typebehind || {};
    options.rte.locale = options.rte.locale || "en_US";
    this.context = {style:{state:{}, value:{}, enabled:{}}, crypt:{uniqueIdCounter:0, incrementUniqueId:function() {
      return ++this.uniqueIdCounter;
    }}, pendingTodo:false, format:uno.defs.format.PLATFORM_HTML, resources:options.rte.resources || {}};
    this.config = {accentuate:options.accentuate || {clearOnClickSelector:"en-note"}, crypt:{legacy:util.objects.valueOrDefault(options.rte.cryptLegacy, true), unveilCryptElementOnClick:false, readOnly:options.rte.cryptReadOnly || false}, defaults:{html:"<div><br></div>", placeholderText:options.rte.placeholder || "Drag files here or start typing", plainTextFont:options.env.defaultPlainText || "monospace", richTextFont:options.env.defaultNoteFont || "sans-serif", selectionColor:"rgb(178, 215, 255)", 
    tableCellHtml:"<div><br></div>"}, images:{annotate:!!options.rte.imageConfig.annotate, preview:!!options.rte.imageConfig.preview, resize:!!options.rte.imageConfig.resize || !!options.rte.imageResizing, rotate:!!options.rte.imageConfig.rotate}, find:options.find || {}, initialContent:options.rte.enml || options.rte.html, initialContentFormat:options.rte.enml ? uno.defs.format.ENML : uno.defs.format.PLATFORM_HTML, locale:options.rte.locale || "en_US", margin:options.env.margin, platform:options.env.platform || 
    uno.env.getPlatform(), richlinks:{enabled:options.rte.richLinks || false, cacheSupported:options.rte.richLinkCaching || false}, style:{table:{width:"100%", cell:{borderWidth:"1px", borderColor:"#d3d3d3", borderStyle:"solid", padding:"10px", margin:"0px"}}}, typebehind:{code:options.rte.typebehind.code || false, email:options.rte.typebehind.email || false, emoticon:options.rte.typebehind.emoticon || false, horizontalrule:options.rte.typebehind.horizontalrule || false, inline:options.rte.typebehind.inline || 
    false, list:options.rte.typebehind.list || false, table:options.rte.typebehind.table || false, todo:options.rte.typebehind.todo || false, url:options.rte.typebehind.url || false}};
  };
  Editor.prototype.onLoad = function() {
    var el = this.getElement();
    var me = this;
    me.handlers.forEach(function(property) {
      me.eventRegister.listenWithScope(property.target || me.field, property.name, function(event) {
        me.listeners[property.name].some(function(plugin) {
          return plugin[property.handler](event);
        });
      }, false, me);
    });
    uno.util.touch.init(this);
    el.setAttribute("data-en-placeholder", this.config.defaults.placeholderText);
    this.updateEmpty();
    this.leaveEditMode();
  };
  Editor.prototype.onUnload = function() {
    this.isSetup = false;
  };
  Editor.prototype.inEditMode = function() {
    return this.field && this.field.getAttribute("contenteditable") === "true";
  };
  Editor.prototype.enterEditMode = function(restoreRange) {
    if (this.inEditMode() || this.readOnly) {
      return;
    }
    this.field.setAttribute("contenteditable", true);
    if (restoreRange) {
      this.restoreRange(restoreRange);
    }
    this.focus();
    this.dispatchEvent(Editor.EventType.EDIT_MODE_CHANGED);
  };
  Editor.prototype.leaveEditMode = function() {
    this.field && this.field.setAttribute("contenteditable", false);
    this.dispatchEvent(Editor.EventType.EDIT_MODE_CHANGED);
  };
  Editor.prototype.onEditModeChanged = function() {
    util.placeholder.updateIfNeeded(this);
  };
  Editor.prototype.onFocus = function() {
    this.enterEditMode();
  };
  Editor.prototype.onBlur = function() {
    this.leaveEditMode();
  };
  Editor.prototype.saveRange = function() {
    var range = this.getRange();
    if (range) {
      this.savedRange = range.saveUsingDom();
    }
  };
  Editor.prototype.restoreRange = function(range) {
    if (goog.isObject(range)) {
      range.select();
    } else {
      try {
        this.savedRange.restore().select();
      } catch (e) {
        this.placeCursorAtEnd();
      }
      this.savedRange = null;
    }
  };
  Editor.prototype.onCommandValueChange = function() {
    this.dispatchEvent(uno.Editor.EventType.STYLE_CHANGED);
  };
  Editor.prototype.onBeforeSelectionChange = function() {
  };
  Editor.prototype.onDelayedChange = function() {
    log.info("onDelayedChange");
    this.dirty = true;
  };
  Editor.prototype.onSelectionChange = function() {
    this.updateEmpty();
    if (!this.readOnly) {
      this.dispatchEvent(uno.Editor.EventType.STYLE_CHANGED);
    }
    this.saveRange();
  };
  Editor.prototype.onTextInput = function() {
    this.dispatchChange();
  };
  Editor.prototype.updateEmpty = function() {
    if (this.field == null) {
      return;
    }
    var empty = !util.paragraph.hasContent(this.field);
    if (empty && this.field.innerHTML !== this.config.defaults.html) {
      this.context.format = uno.defs.format.PLATFORM_HTML;
      this.setHtml(false, this.config.defaults.html, !this.isSetup);
      document.body.scrollLeft = 0;
      document.body.scrollTop = 0;
    }
    util.classes.conditionalToggle(this.field, "en-note-is-empty", empty);
    this.empty = empty;
  };
  Editor.prototype.queryCommandValue = function(commands, opt) {
    var isEditable = this.isLoaded() && this.isSelectionEditable();
    var result;
    if (goog.isString(commands)) {
      result = this.queryCommandValueInternal_(commands, isEditable, opt);
    } else {
      result = {};
      if (!Array.isArray(commands)) {
        throw Error("commands is null!");
      }
      commands.forEach(function(command) {
        if (goog.isString(command)) {
          result[command] = this.queryCommandValueInternal_(command, isEditable);
        } else {
          result[command] = this.queryCommandValueInternal_(command.name, isEditable, command.opt);
        }
      });
    }
    return result;
  };
  Editor.prototype.queryCommandValueInternal_ = function(command, isEditable, opt) {
    var plugins = this.indexedPlugins_[Plugin.Op.QUERY_COMMAND];
    for (var i = 0;i < plugins.length;++i) {
      var plugin = plugins[i];
      if (plugin.isEnabled(this) && plugin.isSupportedCommand(command) && (isEditable || plugin.activeOnUneditableFields())) {
        return plugin.queryCommandValue(command, opt);
      }
    }
    return isEditable ? null : false;
  };
  Editor.prototype.queryCommandEnabled = function(commands, opt) {
    var isEditable = this.isLoaded() && this.isSelectionEditable();
    var result;
    if (goog.isString(commands)) {
      result = !!this.queryCommandEnabledInternal_(commands, isEditable, opt);
    } else {
      result = {};
      commands.forEach(function(command) {
        if (goog.isString(command)) {
          result[command] = !!this.queryCommandEnabledInternal_(command, isEditable);
        } else {
          result[command] = !!this.queryCommandEnabledInternal_(command.name, isEditable, command.opt);
        }
      });
    }
    return result;
  };
  Editor.prototype.execCommand = function(commands, value, options) {
    try {
      this.beforeExecCommand.forEach(function(plugin) {
        plugin.handleBeforeExecCommand(commands, value, options);
      });
      var result = SeamlessField.prototype.execCommand.call(this, commands, value, options);
      return result;
    } catch (err) {
      log.severe(err);
      return false;
    }
  };
  Editor.prototype.queryCommandEnabledInternal_ = function(command, isEditable, opt) {
    var plugins = this.queryCommandEnabledPlugins;
    for (var i = 0;i < plugins.length;++i) {
      var plugin = plugins[i];
      if (plugin.isEnabled(this) && plugin.isSupportedCommand(command) && (isEditable || plugin.activeOnUneditableFields())) {
        return plugin.queryCommandEnabled(command, opt);
      }
    }
    return true;
  };
  Editor.prototype.invokeOp_ = function(op) {
    if (op === Plugin.Op.CLEAN_CONTENTS_DOM) {
      return this.invokeOpRight_.apply(this, arguments);
    }
    return SeamlessField.prototype.apply.invokeOp_.apply(this, arguments);
  };
  Editor.prototype.invokeOpRight_ = function(op) {
    var plugins = this.indexedPlugins_[op];
    var argList = goog.array.slice(arguments, 1);
    for (var i = plugins.length - 1;i >= 0;i--) {
      var plugin = plugins[i];
      plugin[Plugin.OPCODE[op]].apply(plugin, argList);
    }
  };
  Editor.prototype.reduceOp_ = function(op, arg, varArgs) {
    var result;
    if (op === Plugin.Op.CLEAN_CONTENTS_DOM || op === Plugin.Op.CLEAN_CONTENTS_HTML) {
      result = this.reduceOpRight_(op, arg, varArgs);
    } else {
      result = SeamlessField.prototype.reduceOp_.apply(this, arguments);
    }
    if (op === Plugin.Op.PREPARE_CONTENTS_HTML) {
      result = this.prepareContentsDom(result);
    }
    return result;
  };
  Editor.prototype.reduceOpRight_ = function(op) {
    var plugins = this.indexedPlugins_[op];
    var argList = goog.array.slice(arguments, 1);
    for (var i = plugins.length - 1;i >= 0;i--) {
      var plugin = plugins[i];
      argList[0] = plugin[Plugin.OPCODE[op]].apply(plugin, argList);
    }
    return argList[0];
  };
  Editor.prototype.prepareContentsDom = function(html) {
    if (!html) {
      return "";
    }
    var frag = util.dom.fragFromString(html);
    this.importDomFilters.forEach(function(filter) {
      filter.prepareContentsDom(frag);
    });
    return util.dom.stringFromFrag(frag);
  };
  Editor.prototype.getClipboardContent = function(frag) {
    this.context.format = uno.defs.format.CLIPBOARD;
    this.invokeOp_(goog.editor.Plugin.Op.CLEAN_CONTENTS_DOM, frag);
    return this.reduceOp_(goog.editor.Plugin.Op.CLEAN_CONTENTS_HTML, frag.innerHTML);
  };
  Editor.prototype.getTitle = function() {
    return;
  };
})();
goog.provide("uno.Router");
goog.require("goog.debug.Logger");
(function() {
  var log = goog.debug.Logger.getLogger("uno.Router");
  var Router = uno.Router = function(options) {
    this.messages = {};
    this.routesToHost = options.routesToHost;
    this.routesFromHost = options.routesFromHost;
    this.sendMessage = options.sendMessage;
  };
  Router.correlationId = 0;
  Router.getCorrelationId = function() {
    return ++Router.correlationId;
  };
  Router.prototype.toHostAsync = function(name, data) {
    var deferred;
    var me = this;
    var route = this.routesToHost[name];
    var correlationId = data[route.identifier];
    if (!correlationId) {
      correlationId = Router.getCorrelationId();
      data[route.identifier] = correlationId;
    }
    deferred = new Deferred(function() {
      me.sendMessage(name, data);
    });
    if (route.oneway) {
      deferred.resolve();
    } else {
      this.messages[correlationId] = deferred;
    }
    return deferred.promise;
  };
  Router.prototype.fromHost = function(name, data) {
    var correlationId;
    var deferred;
    if (this.routesFromHost[name]) {
      correlationId = goog.getObjectByName(this.routesFromHost[name].identifier, data);
      deferred = this.messages[correlationId];
      delete this.messages[correlationId];
      deferred.resolve(data);
      return true;
    }
    return false;
  };
  var Deferred = function(fn) {
    var me = this;
    this.promise = new Promise(function(resolve, reject) {
      me.resolve = resolve;
      me.reject = reject;
      fn();
    });
  };
})();
goog.provide("uno.api.ce");
goog.require("goog.debug.Logger");
goog.require("goog.editor.Command");
goog.require("goog.events");
goog.require("goog.object");
goog.require("uno.api.cec");
goog.require("uno.api.celogger");
goog.require("uno.Auth");
goog.require("uno.Cache");
goog.require("uno.Editor");
goog.require("uno.Router");
(function() {
  var options;
  var log = goog.debug.Logger.getLogger("uno.api.ce");
  var consoleLogger = new uno.ConsoleLogger({cachingEnabled:true});
  consoleLogger.setCapturing(true);
  var purgeLogsOnSetup = false;
  var Editor = uno.Editor;
  var rxRedundantPrefixes = /^(?:rte|content)\./;
  var needsCEC = false;
  var needsUNO = true;
  var offloadedCommands = ["context", "context-upsell", "context-info"];
  var router = new uno.Router({sendMessage:function(name, info) {
    return EN.notification(name, info);
  }, routesToHost:{"requestAuth":{identifier:"serviceName"}, "showOptions":{identifier:"correlationId"}, "getFromCache":{identifier:"correlationId"}, "saveInCache":{identifier:"correlationId", oneway:true}}, routesFromHost:{"authtoken":{identifier:"service"}, "optionselected":{identifier:"showEvent.correlationId"}, "cacheddata":{identifier:"cacheRequest.correlationId"}}});
  var cache = new uno.Cache({router:router});
  var auth = new uno.Auth({router:router});
  window.EN = {};
  EN.version = "1.5.0.452";
  EN.logs = consoleLogger;
  EN.setup = function(opt) {
    var id;
    opt = opt || {};
    options = goog.isObject(opt) ? opt : JSON.parse(opt);
    options.logging = options.logging || {};
    options.logging.consoleLogger = consoleLogger;
    configLogging(options);
    cache.diskEnabled = options.rte && options.rte.richLink && options.rte.richLinksCaching;
    goog.object.extend(options, {cache:cache, auth:auth, router:router});
    id = options.id || "en-note";
    window.ed = new Editor(id, options);
    ed.listen(Editor.EventType.DELAYEDCHANGE, onEditorDelayedChange);
    ed.listen(Editor.EventType.FOCUS, onEditorFocus);
    ed.listen(Editor.EventType.BLUR, onEditorBlur);
    ed.listen(Editor.EventType.STYLE_CHANGED, onEditorStyleChanged);
    ed.listen(Editor.EventType.PRINT_READY, onPrintReady);
    ed.listen(Editor.EventType.ENCRYPT, onEncrypt);
    ed.listen(Editor.EventType.DECRYPT, onDecrypt);
    ed.listen(Editor.EventType.CONTENT_LOADED, onEditorContentLoaded);
    if (needsUNO && options.rte != null) {
      options.rte = options.rte || {};
      options.rte.imageConfig = options.rte.imageConfig || {};
      if (options.rte.imageConfig.imageClickEvents) {
        ed.listen(Editor.EventType.IMAGE_CLICK, onImageClick);
        ed.listen(Editor.EventType.IMAGE_DOUBLECLICK, onImageDoubleClick);
      }
      if (options.rte.imageConfig.annotate) {
        ed.listen(Editor.EventType.IMAGE_ANNOTATE, onImageEvent);
      }
      if (options.rte.imageConfig.preview) {
        ed.listen(Editor.EventType.IMAGE_PREVIEW, onImageEvent);
      }
      if (options.rte.imageConfig.annotate) {
        ed.listen(Editor.EventType.IMAGE_ROTATE, onImageEvent);
      }
      ed.listen(Editor.EventType.LINK_CLICK, onLinkClick);
    }
    ed.setup();
    document.body.scrollLeft = 0;
    document.body.scrollTop = 0;
    if (options.template != null) {
      needsCEC = true;
      needsUNO = false;
    }
    if (options.context != null || options["context-upsell"] != null || options["context-info"] != null) {
      needsCEC = true;
    }
    if (needsCEC) {
      uno.api.cec.setup(options, function() {
        EN.notification("setupDone", {module:"document"});
        log.info("SETUPDONE FROM CEC");
      });
    } else {
      EN.notification("setupDone", {module:"document"});
      log.info("SETUPDONE FROM UNO");
    }
    return true;
  };
  EN.cleanup = function() {
    if (ed && goog.isFunction(ed.dispose)) {
      ed.dispose();
    }
    window.ed = null;
  };
  function configLogging(options) {
    options.logging = options.logging || {};
    var level = goog.debug.Logger.Level.getPredefinedLevel(options.logging.level) || goog.debug.Logger.Level.ALL;
    var rootLogger = goog.debug.Logger.getLogger("");
    rootLogger.setLevel(level);
    consoleLogger.configure({cachingEnabled:options.logging.cachingEnabled != null ? options.logging.cachingEnabled : true, maxEntries:typeof options.logging.maxEntries !== "undefined" ? options.logging.maxEntries : 100});
    purgeLogsOnSetup = options.logging.purgeLogsOnSetup != null ? options.logging.purgeLogsOnSetup : true;
  }
  var shouldUseCEC = function(commandType, command) {
    var normalizedCommand = filterCommandPrefix(command);
    if (needsCEC === false) {
      return false;
    }
    if (needsCEC === true && needsUNO === false) {
      return true;
    }
    if (commandType === "execCommand" && offloadedCommands.indexOf(normalizedCommand) >= 0 && (uno.api.cec.getState() === uno.api.cec.STATES.RUNNING || uno.api.cec.getState() === uno.api.cec.STATES.LOADING)) {
      return true;
    }
    if (commandType.indexOf("queryCommand") === 0 && offloadedCommands.indexOf(normalizedCommand) >= 0 && uno.api.cec.getState() === uno.api.cec.STATES.RUNNING) {
      return true;
    }
    return false;
  };
  EN.execCommand = function(command, value, options) {
    var normalizedCommand = filterCommandPrefix(command);
    var parsedValue = valueToObject(value);
    var parsedOptions = valueToObject(options);
    var result = null;
    if (router.fromHost(command, value)) {
      return true;
    }
    if (shouldUseCEC("execCommand", command)) {
      result = !!uno.api.cec.execCommand(command, value, options);
    } else {
      result = !!ed.execCommand(normalizedCommand, parsedValue, parsedOptions);
    }
    return result;
  };
  EN.queryCommandEnabled = function(command, options) {
    var normalizedCommand = filterCommandPrefix(command);
    var result = null;
    if (shouldUseCEC("queryCommandEnabled", command)) {
      result = uno.api.cec.queryCommandEnabled(command, options);
    } else {
      result = ed.queryCommandEnabled(normalizedCommand, options);
    }
    return result;
  };
  EN.queryCommandValue = function(command, options) {
    var normalizedCommand = filterCommandPrefix(command);
    var result = null;
    var value;
    var parsedOptions = valueToObject(options);
    if (shouldUseCEC("queryCommandValue", command)) {
      value = uno.api.cec.queryCommandValue(command, options);
    } else {
      value = ed.queryCommandValue(normalizedCommand, parsedOptions);
    }
    value = value != null ? value : "";
    result = goog.isString(value) ? value : JSON.stringify(value);
    return result;
  };
  EN.queryCommandState = function(command, opt) {
    return queryCommandStateInternal(command, opt);
  };
  function queryCommandStateInternal(command, opt) {
    var normalizedCommand = filterCommandPrefix(command);
    var result;
    if (shouldUseCEC("queryCommandState", command)) {
      result = uno.api.cec.queryCommandState(command, opt);
    } else {
      result = ed.queryCommandValue(normalizedCommand, opt);
      if (normalizedCommand === "justifyleft") {
        result = result === "left";
      } else {
        if (normalizedCommand === "justifycenter") {
          result = result === "center";
        } else {
          if (normalizedCommand === "justifyright") {
            result = result === "right";
          } else {
            if (normalizedCommand === "justifyfull") {
              result = result === "justify";
            }
          }
        }
      }
    }
    return !!result;
  }
  EN.fireUpAndroid = function() {
    if (document && document.body) {
      if (window.noteEditor || window.noteEditor.onWebViewLoaded) {
        en.console.error("Native did not set up `noteEditor` correctly");
      } else {
        window.noteEditor.onWebViewLoaded();
      }
    } else {
      if (window.DEBUG) {
        en.console.log("Will wait another while until document.body is ready");
      }
      window.setTimeout(EN.fireUpAndroid, 100);
    }
  };
  EN.enablePrint = function(localization, opt) {
    EN.execCommand("printpreview", localization, opt);
  };
  EN.disablePrint = function() {
    return true;
  };
  EN.getVersion = function() {
    return EN.version;
  };
  EN.notification = function(name, info) {
    setTimeout(function() {
      info = info || {};
      info.version = "1.0";
      if (window.Evernote && Evernote.handleJavascriptEvent) {
        Evernote.handleJavascriptEvent(name, JSON.stringify({name:name, info:info}));
      } else {
        if (window.evernoteClient && evernoteClient.postNotification) {
          evernoteClient.postNotification(name, JSON.stringify(info));
        } else {
          if (window.noteEditor && noteEditor.handleJavascriptEvent) {
            noteEditor.handleJavascriptEvent(name, JSON.stringify(info) || null);
          } else {
            if (window.evernoteClient && evernoteClient.handleNotificationInfo) {
              evernoteClient.handleNotificationInfo(name, info);
            }
          }
        }
      }
    }, 0);
  };
  function valueToObject(value) {
    if (typeof value === "string") {
      try {
        return JSON.parse(value);
      } catch (err) {
      }
    }
    return value;
  }
  function filterCommandPrefix(command) {
    return command.replace(rxRedundantPrefixes, "");
  }
  function onEditorDelayedChange() {
    EN.notification("contentChanged", {module:"content"});
  }
  function onEditorFocus() {
    EN.notification("focusChanged", {focus:true, module:"content"});
  }
  function onEditorBlur() {
    EN.notification("focusChanged", {focus:false, module:"content"});
  }
  function onEditorStyleChanged(e) {
    updateStyleChanges.call(this, e.style);
  }
  function onPrintReady() {
    EN.notification("printready", {module:"print"});
  }
  function onEncrypt(e) {
    EN.notification("encrypt", e.cryptInfo);
  }
  function onDecrypt(e) {
    EN.notification("decrypt", e.cryptInfo);
  }
  function onEditorContentLoaded() {
    EN.notification("contentLoaded", {module:"content"});
  }
  function onImageClick(e) {
    EN.notification("clicked", {name:e.name, src:e.src, tagname:e.tagname});
  }
  function onImageDoubleClick(e) {
    EN.notification("doubleClicked", {name:e.name, src:e.src, tagname:e.tagname});
  }
  function onImageEvent(e) {
    EN.notification(e.type, {module:e.module, src:e.src, tagname:e.tagname});
  }
  function onLinkClick(e) {
    EN.notification("openLink", e.data);
  }
  function updateStyleChanges(styleOverrides) {
    var rte = options.rte;
    var style = ed.context.style;
    var hasChanges = false;
    styleOverrides = styleOverrides || {state:{}, value:{}, enabled:{}};
    if (rte && goog.isArray(rte.trackStateChanges)) {
      rte.trackStateChanges.map(filterCommandPrefix).forEach(function(command) {
        var result = typeof styleOverrides.state[command] !== "undefined" ? styleOverrides.state[command] : queryCommandStateInternal(command);
        if (style.state[command] !== result) {
          style.state[command] = result;
          hasChanges = true;
        }
      });
    }
    if (rte && goog.isArray(rte.trackValueChanges)) {
      rte.trackValueChanges.map(filterCommandPrefix).forEach(function(command) {
        var result = typeof styleOverrides.value[command] !== "undefined" ? styleOverrides.value[command] : ed.queryCommandValue(command);
        if (style.value[command] !== result) {
          style.value[command] = result;
          hasChanges = true;
        }
      });
    }
    if (rte && goog.isArray(rte.trackEnabledChanges)) {
      rte.trackEnabledChanges.map(filterCommandPrefix).forEach(function(command) {
        var result = typeof styleOverrides.enabled[command] !== "undefined" ? styleOverrides.enabled[command] : ed.queryCommandEnabled(command);
        if (style.enabled[command] !== result) {
          style.enabled[command] = result;
          hasChanges = true;
        }
      });
    }
    if (hasChanges) {
      style.module = "content";
      EN.notification("styleChanged", style);
    }
  }
  uno.api.celogger.wrap(EN);
  (function() {
    var setup = EN.setup;
    EN.setup = function(options) {
      if (purgeLogsOnSetup) {
        consoleLogger.clear();
      }
      return setup(options);
    };
  })();
  window.enLoadState = "didLoad";
})();

