@p4ulcristian/iris-layout 0.2.10 → 0.2.11

package/dist/cljs-runtime/goog.base.js

@@ -1,1261 +0,0 @@
-import "./cljs_env.js";
-
-var COMPILED = false;
-var goog = goog || {};
-goog.global = globalThis;
-goog.global.CLOSURE_UNCOMPILED_DEFINES;
-goog.global.CLOSURE_DEFINES;
-goog.exportPath_ = function(name, object, overwriteImplicit, objectToExportTo) {
-  var parts = name.split(".");
-  var cur = objectToExportTo || goog.global;
-  if (!(parts[0] in cur) && typeof cur.execScript != "undefined") {
-    cur.execScript("var " + parts[0]);
-  }
-  var part;
-  for (; parts.length && (part = parts.shift());) {
-    if (!parts.length && object !== undefined) {
-      if (!overwriteImplicit && goog.isObject(object) && goog.isObject(cur[part])) {
-        var prop;
-        for (prop in object) {
-          if (object.hasOwnProperty(prop)) {
-            cur[part][prop] = object[prop];
-          }
-        }
-      } else {
-        cur[part] = object;
-      }
-    } else if (cur[part] && cur[part] !== Object.prototype[part]) {
-      cur = cur[part];
-    } else {
-      cur = cur[part] = {};
-    }
-  }
-};
-goog.define = function(name, defaultValue) {
-  var value = defaultValue;
-  if (!COMPILED) {
-    var uncompiledDefines = goog.global.CLOSURE_UNCOMPILED_DEFINES;
-    var defines = goog.global.CLOSURE_DEFINES;
-    if (uncompiledDefines && uncompiledDefines.nodeType === undefined && Object.prototype.hasOwnProperty.call(uncompiledDefines, name)) {
-      value = uncompiledDefines[name];
-    } else if (defines && defines.nodeType === undefined && Object.prototype.hasOwnProperty.call(defines, name)) {
-      value = defines[name];
-    }
-  }
-  return value;
-};
-goog.FEATURESET_YEAR = goog.define("goog.FEATURESET_YEAR", 2012);
-goog.DEBUG = goog.define("goog.DEBUG", true);
-goog.LOCALE = goog.define("goog.LOCALE", "en");
-goog.TRUSTED_SITE = goog.define("goog.TRUSTED_SITE", true);
-goog.DISALLOW_TEST_ONLY_CODE = goog.define("goog.DISALLOW_TEST_ONLY_CODE", COMPILED && !goog.DEBUG);
-goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING = goog.define("goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING", false);
-goog.provide = function(name) {
-  if (goog.isInModuleLoader_()) {
-    throw new Error("goog.provide cannot be used within a module.");
-  }
-  if (!COMPILED) {
-    if (goog.isProvided_(name)) {
-      throw new Error('Namespace "' + name + '" already declared.');
-    }
-  }
-  goog.constructNamespace_(name);
-};
-goog.constructNamespace_ = function(name, object, overwriteImplicit) {
-  if (!COMPILED) {
-    delete goog.implicitNamespaces_[name];
-    var namespace = name;
-    for (; namespace = namespace.substring(0, namespace.lastIndexOf("."));) {
-      if (goog.getObjectByName(namespace)) {
-        break;
-      }
-      goog.implicitNamespaces_[namespace] = true;
-    }
-  }
-  goog.exportPath_(name, object, overwriteImplicit);
-};
-goog.NONCE_PATTERN_ = /^[\w+/_-]+[=]{0,2}$/;
-goog.getScriptNonce_ = function(opt_window) {
-  var doc = (opt_window || goog.global).document;
-  var script = doc.querySelector && doc.querySelector("script[nonce]");
-  if (script) {
-    var nonce = script["nonce"] || script.getAttribute("nonce");
-    if (nonce && goog.NONCE_PATTERN_.test(nonce)) {
-      return nonce;
-    }
-  }
-  return "";
-};
-goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
-goog.module = function(name) {
-  if (typeof name !== "string" || !name || name.search(goog.VALID_MODULE_RE_) == -1) {
-    throw new Error("Invalid module identifier");
-  }
-  if (!goog.isInGoogModuleLoader_()) {
-    throw new Error("Module " + name + " has been loaded incorrectly. Note, " + "modules cannot be loaded as normal scripts. They require some kind of " + "pre-processing step. You're likely trying to load a module via a " + "script tag or as a part of a concatenated bundle without rewriting the " + "module. For more info see: " + "https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.");
-  }
-  if (goog.moduleLoaderState_.moduleName) {
-    throw new Error("goog.module may only be called once per module.");
-  }
-  goog.moduleLoaderState_.moduleName = name;
-  if (!COMPILED) {
-    if (goog.isProvided_(name)) {
-      throw new 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 (name in goog.loadedModules_) {
-      return goog.loadedModules_[name].exports;
-    } else if (!goog.implicitNamespaces_[name]) {
-      var ns = goog.getObjectByName(name);
-      return ns != null ? ns : null;
-    }
-  }
-  return null;
-};
-goog.ModuleType = {ES6:"es6", GOOG:"goog"};
-goog.moduleLoaderState_ = null;
-goog.isInModuleLoader_ = function() {
-  return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();
-};
-goog.isInGoogModuleLoader_ = function() {
-  return !!goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.GOOG;
-};
-goog.isInEs6ModuleLoader_ = function() {
-  var inLoader = !!goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.ES6;
-  if (inLoader) {
-    return true;
-  }
-  var jscomp = goog.global["$jscomp"];
-  if (jscomp) {
-    if (typeof jscomp.getCurrentModulePath != "function") {
-      return false;
-    }
-    return !!jscomp.getCurrentModulePath();
-  }
-  return false;
-};
-goog.module.declareLegacyNamespace = function() {
-  if (!COMPILED && !goog.isInGoogModuleLoader_()) {
-    throw new Error("goog.module.declareLegacyNamespace must be called from " + "within a goog.module");
-  }
-  if (!COMPILED && !goog.moduleLoaderState_.moduleName) {
-    throw new Error("goog.module must be called prior to " + "goog.module.declareLegacyNamespace.");
-  }
-  goog.moduleLoaderState_.declareLegacyNamespace = true;
-};
-goog.declareModuleId = function(namespace) {
-  if (!COMPILED) {
-    if (!goog.isInEs6ModuleLoader_()) {
-      throw new Error("goog.declareModuleId may only be called from " + "within an ES6 module");
-    }
-    if (goog.moduleLoaderState_ && goog.moduleLoaderState_.moduleName) {
-      throw new Error("goog.declareModuleId may only be called once per module.");
-    }
-    if (namespace in goog.loadedModules_) {
-      throw new Error('Module with namespace "' + namespace + '" already exists.');
-    }
-  }
-  if (goog.moduleLoaderState_) {
-    goog.moduleLoaderState_.moduleName = namespace;
-  } else {
-    var jscomp = goog.global["$jscomp"];
-    if (!jscomp || typeof jscomp.getCurrentModulePath != "function") {
-      throw new Error('Module with namespace "' + namespace + '" has been loaded incorrectly.');
-    }
-    var exports = jscomp.require(jscomp.getCurrentModulePath());
-    goog.loadedModules_[namespace] = {exports:exports, type:goog.ModuleType.ES6, moduleId:namespace};
-  }
-};
-goog.setTestOnly = function(opt_message) {
-  if (goog.DISALLOW_TEST_ONLY_CODE) {
-    opt_message = opt_message || "";
-    throw new 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.getObjectByName(name) != null;
-  };
-  goog.implicitNamespaces_ = {"goog.module":true};
-}
-goog.getObjectByName = function(name, opt_obj) {
-  var parts = name.split(".");
-  var cur = opt_obj || goog.global;
-  var i = 0;
-  for (; i < parts.length; i++) {
-    cur = cur[parts[i]];
-    if (cur == null) {
-      return null;
-    }
-  }
-  return cur;
-};
-goog.addDependency = function(relPath, provides, requires, opt_loadFlags) {
-  if (!COMPILED && goog.DEPENDENCIES_ENABLED) {
-    goog.debugLoader_.addDependency(relPath, provides, requires, opt_loadFlags);
-  }
-};
-goog.ENABLE_DEBUG_LOADER = goog.define("goog.ENABLE_DEBUG_LOADER", true);
-goog.logToConsole_ = function(msg) {
-  if (goog.global.console) {
-    goog.global.console["error"](msg);
-  }
-};
-goog.require = function(namespace) {
-  if (!COMPILED) {
-    if (goog.ENABLE_DEBUG_LOADER) {
-      goog.debugLoader_.requested(namespace);
-    }
-    if (goog.isProvided_(namespace)) {
-      if (goog.isInModuleLoader_()) {
-        return goog.module.getInternal_(namespace);
-      }
-    } else if (goog.ENABLE_DEBUG_LOADER) {
-      var moduleLoaderState = goog.moduleLoaderState_;
-      goog.moduleLoaderState_ = null;
-      try {
-        goog.debugLoader_.load_(namespace);
-      } finally {
-        goog.moduleLoaderState_ = moduleLoaderState;
-      }
-    }
-    return null;
-  }
-};
-goog.requireType = function(namespace) {
-  return {};
-};
-goog.basePath = "";
-goog.global.CLOSURE_BASE_PATH;
-goog.global.CLOSURE_NO_DEPS;
-goog.global.CLOSURE_IMPORT_SCRIPT;
-goog.abstractMethod = function() {
-  throw new Error("unimplemented abstract method");
-};
-goog.addSingletonGetter = function(ctor) {
-  ctor.instance_ = undefined;
-  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.LOAD_MODULE_USING_EVAL = goog.define("goog.LOAD_MODULE_USING_EVAL", true);
-goog.SEAL_MODULE_EXPORTS = goog.define("goog.SEAL_MODULE_EXPORTS", goog.DEBUG);
-goog.loadedModules_ = {};
-goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;
-goog.TRANSPILE = goog.define("goog.TRANSPILE", "detect");
-goog.ASSUME_ES_MODULES_TRANSPILED = goog.define("goog.ASSUME_ES_MODULES_TRANSPILED", false);
-goog.TRUSTED_TYPES_POLICY_NAME = goog.define("goog.TRUSTED_TYPES_POLICY_NAME", "goog");
-goog.hasBadLetScoping = null;
-goog.loadModule = function(moduleDef) {
-  var previousState = goog.moduleLoaderState_;
-  try {
-    goog.moduleLoaderState_ = {moduleName:"", declareLegacyNamespace:false, type:goog.ModuleType.GOOG};
-    var origExports = {};
-    var exports = origExports;
-    if (typeof moduleDef === "function") {
-      exports = moduleDef.call(undefined, exports);
-    } else if (typeof moduleDef === "string") {
-      exports = goog.loadModuleFromSource_.call(undefined, exports, moduleDef);
-    } else {
-      throw new Error("Invalid module definition");
-    }
-    var moduleName = goog.moduleLoaderState_.moduleName;
-    if (typeof moduleName === "string" && moduleName) {
-      if (goog.moduleLoaderState_.declareLegacyNamespace) {
-        var isDefaultExport = origExports !== exports;
-        goog.constructNamespace_(moduleName, exports, isDefaultExport);
-      } else if (goog.SEAL_MODULE_EXPORTS && Object.seal && typeof exports == "object" && exports != null) {
-        Object.seal(exports);
-      }
-      var data = {exports:exports, type:goog.ModuleType.GOOG, moduleId:goog.moduleLoaderState_.moduleName};
-      goog.loadedModules_[moduleName] = data;
-    } else {
-      throw new Error('Invalid module name "' + moduleName + '"');
-    }
-  } finally {
-    goog.moduleLoaderState_ = previousState;
-  }
-};
-goog.loadModuleFromSource_ = function(exports) {
-  eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(arguments[1]));
-  return exports;
-};
-goog.normalizePath_ = function(path) {
-  var components = path.split("/");
-  var i = 0;
-  for (; 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.global.CLOSURE_LOAD_FILE_SYNC;
-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.typeOf = function(value) {
-  var s = typeof value;
-  if (s != "object") {
-    return s;
-  }
-  if (!value) {
-    return "null";
-  }
-  if (Array.isArray(value)) {
-    return "array";
-  }
-  return s;
-};
-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.isObject = function(val) {
-  var type = typeof val;
-  return type == "object" && val != null || type == "function";
-};
-goog.getUid = function(obj) {
-  return Object.prototype.hasOwnProperty.call(obj, goog.UID_PROPERTY_) && 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.cloneObject = function(obj) {
-  var type = goog.typeOf(obj);
-  if (type == "object" || type == "array") {
-    if (typeof obj.clone === "function") {
-      return obj.clone();
-    }
-    if (typeof Map !== "undefined" && obj instanceof Map) {
-      return new Map(obj);
-    } else if (typeof Set !== "undefined" && obj instanceof Set) {
-      return new Set(obj);
-    }
-    var clone = type == "array" ? [] : {};
-    var key;
-    for (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.now = function() {
-  return Date.now();
-};
-goog.globalEval = function(script) {
-  (0,eval)(script);
-};
-goog.cssNameMapping_;
-goog.cssNameMappingStyle_;
-goog.global.CLOSURE_CSS_NAME_MAP_FN;
-goog.getCssName = function(className, opt_modifier) {
-  if (String(className).charAt(0) == ".") {
-    throw new Error('className passed in goog.getCssName must not start with ".".' + " You passed: " + className);
-  }
-  var getMapping = function(cssName) {
-    return goog.cssNameMapping_[cssName] || cssName;
-  };
-  var renameByParts = function(cssName) {
-    var parts = cssName.split("-");
-    var mapped = [];
-    var i = 0;
-    for (; 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;
-    };
-  }
-  var result = opt_modifier ? className + "-" + rename(opt_modifier) : rename(className);
-  if (goog.global.CLOSURE_CSS_NAME_MAP_FN) {
-    return goog.global.CLOSURE_CSS_NAME_MAP_FN(result);
-  }
-  return result;
-};
-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.GetMsgOptions = function() {
-};
-goog.GetMsgOptions.prototype.html;
-goog.GetMsgOptions.prototype.unescapeHtmlEntities;
-goog.GetMsgOptions.prototype.original_code;
-goog.GetMsgOptions.prototype.example;
-goog.getMsg = function(str, opt_values, opt_options) {
-  if (opt_options && opt_options.html) {
-    str = str.replace(/</g, "\x26lt;");
-  }
-  if (opt_options && opt_options.unescapeHtmlEntities) {
-    str = str.replace(/&lt;/g, "\x3c").replace(/&gt;/g, "\x3e").replace(/&apos;/g, "'").replace(/&quot;/g, '"').replace(/&amp;/g, "\x26");
-  }
-  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, objectToExportTo) {
-  goog.exportPath_(publicPath, object, true, 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);
-    var i = 2;
-    for (; i < arguments.length; i++) {
-      args[i - 2] = arguments[i];
-    }
-    return parentCtor.prototype[methodName].apply(me, args);
-  };
-};
-goog.scope = function(fn) {
-  if (goog.isInModuleLoader_()) {
-    throw new Error("goog.scope is not supported within a 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 new 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.defineClass.SEAL_CLASS_INSTANCES = goog.define("goog.defineClass.SEAL_CLASS_INSTANCES", goog.DEBUG);
-goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
-  if (!goog.defineClass.SEAL_CLASS_INSTANCES) {
-    return ctr;
-  }
-  var wrappedCtr = function() {
-    var instance = ctr.apply(this, arguments) || this;
-    instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];
-    return instance;
-  };
-  return wrappedCtr;
-};
-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];
-    }
-  }
-  var i = 0;
-  for (; 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.identity_ = function(s) {
-  return s;
-};
-goog.createTrustedTypesPolicy = function(name) {
-  var policy = null;
-  var policyFactory = goog.global.trustedTypes;
-  if (!policyFactory || !policyFactory.createPolicy) {
-    return policy;
-  }
-  try {
-    policy = policyFactory.createPolicy(name, {createHTML:goog.identity_, createScript:goog.identity_, createScriptURL:goog.identity_});
-  } catch (e) {
-    goog.logToConsole_(e.message);
-  }
-  return policy;
-};
-if (!COMPILED && goog.DEPENDENCIES_ENABLED) {
-  goog.isEdge_ = function() {
-    var userAgent = goog.global.navigator && goog.global.navigator.userAgent ? goog.global.navigator.userAgent : "";
-    var edgeRe = /Edge\/(\d+)(\.\d)*/i;
-    return !!userAgent.match(edgeRe);
-  };
-  goog.inHtmlDocument_ = function() {
-    var doc = goog.global.document;
-    return doc != null && "write" in doc;
-  };
-  goog.isDocumentLoading_ = function() {
-    var doc = goog.global.document;
-    return doc.attachEvent ? doc.readyState != "complete" : doc.readyState == "loading";
-  };
-  goog.findBasePath_ = function() {
-    if (goog.global.CLOSURE_BASE_PATH != undefined && typeof goog.global.CLOSURE_BASE_PATH === "string") {
-      goog.basePath = goog.global.CLOSURE_BASE_PATH;
-      return;
-    } else if (!goog.inHtmlDocument_()) {
-      return;
-    }
-    var doc = goog.global.document;
-    var currentScript = doc.currentScript;
-    if (currentScript) {
-      var scripts = [currentScript];
-    } else {
-      scripts = doc.getElementsByTagName("SCRIPT");
-    }
-    var i = scripts.length - 1;
-    for (; i >= 0; --i) {
-      var script = scripts[i];
-      var src = script.src;
-      var qmark = src.lastIndexOf("?");
-      var l = qmark == -1 ? src.length : qmark;
-      if (src.slice(l - 7, l) == "base.js") {
-        goog.basePath = src.slice(0, l - 7);
-        return;
-      }
-    }
-  };
-  goog.findBasePath_();
-  goog.protectScriptTag_ = function(str) {
-    return str.replace(/<\/(SCRIPT)/ig, "\\x3c/$1");
-  };
-  goog.DebugLoader_ = function() {
-    this.dependencies_ = {};
-    this.idToPath_ = {};
-    this.written_ = {};
-    this.loadingDeps_ = [];
-    this.depsToLoad_ = [];
-    this.paused_ = false;
-    this.factory_ = new goog.DependencyFactory();
-    this.deferredCallbacks_ = {};
-    this.deferredQueue_ = [];
-  };
-  goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {
-    function resolve() {
-      if (cb) {
-        goog.global.setTimeout(cb, 0);
-        cb = null;
-      }
-    }
-    var cb = callback;
-    if (!namespaces.length) {
-      resolve();
-      return;
-    }
-    var deps = [];
-    var i = 0;
-    for (; i < namespaces.length; i++) {
-      var path = this.getPathFromDeps_(namespaces[i]);
-      if (!path) {
-        throw new Error("Unregonized namespace: " + namespaces[i]);
-      }
-      deps.push(this.dependencies_[path]);
-    }
-    var require = goog.require;
-    var loaded = 0;
-    i = 0;
-    for (; i < namespaces.length; i++) {
-      require(namespaces[i]);
-      deps[i].onLoad(function() {
-        if (++loaded == namespaces.length) {
-          resolve();
-        }
-      });
-    }
-  };
-  goog.DebugLoader_.prototype.loadClosureDeps = function() {
-    var relPath = "deps.js";
-    this.depsToLoad_.push(this.factory_.createDependency(goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {}));
-    this.loadDeps_();
-  };
-  goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {
-    var path = this.getPathFromDeps_(absPathOrId);
-    if (path && (opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {
-      var callback = this.deferredCallbacks_[path];
-      if (callback) {
-        delete this.deferredCallbacks_[path];
-        callback();
-      }
-    }
-  };
-  goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {
-    this.factory_ = factory;
-  };
-  goog.DebugLoader_.prototype.load_ = function(namespace) {
-    if (!this.getPathFromDeps_(namespace)) {
-      var errorMessage = "goog.require could not find: " + namespace;
-      goog.logToConsole_(errorMessage);
-    } else {
-      var loader = this;
-      var deps = [];
-      var visit = function(namespace) {
-        var path = loader.getPathFromDeps_(namespace);
-        if (!path) {
-          throw new Error("Bad dependency path or symbol: " + namespace);
-        }
-        if (loader.written_[path]) {
-          return;
-        }
-        loader.written_[path] = true;
-        var dep = loader.dependencies_[path];
-        var i = 0;
-        for (; i < dep.requires.length; i++) {
-          if (!goog.isProvided_(dep.requires[i])) {
-            visit(dep.requires[i]);
-          }
-        }
-        deps.push(dep);
-      };
-      visit(namespace);
-      var wasLoading = !!this.depsToLoad_.length;
-      this.depsToLoad_ = this.depsToLoad_.concat(deps);
-      if (!this.paused_ && !wasLoading) {
-        this.loadDeps_();
-      }
-    }
-  };
-  goog.DebugLoader_.prototype.loadDeps_ = function() {
-    var loader = this;
-    var paused = this.paused_;
-    for (; this.depsToLoad_.length && !paused;) {
-      (function() {
-        var loadCallDone = false;
-        var dep = loader.depsToLoad_.shift();
-        var loaded = false;
-        loader.loading_(dep);
-        var controller = {pause:function() {
-          if (loadCallDone) {
-            throw new Error("Cannot call pause after the call to load.");
-          } else {
-            paused = true;
-          }
-        }, resume:function() {
-          if (loadCallDone) {
-            loader.resume_();
-          } else {
-            paused = false;
-          }
-        }, loaded:function() {
-          if (loaded) {
-            throw new Error("Double call to loaded.");
-          }
-          loaded = true;
-          loader.loaded_(dep);
-        }, pending:function() {
-          var pending = [];
-          var i = 0;
-          for (; i < loader.loadingDeps_.length; i++) {
-            pending.push(loader.loadingDeps_[i]);
-          }
-          return pending;
-        }, setModuleState:function(type) {
-          goog.moduleLoaderState_ = {type:type, moduleName:"", declareLegacyNamespace:false};
-        }, registerEs6ModuleExports:function(path, exports, opt_closureNamespace) {
-          if (opt_closureNamespace) {
-            goog.loadedModules_[opt_closureNamespace] = {exports:exports, type:goog.ModuleType.ES6, moduleId:opt_closureNamespace || ""};
-          }
-        }, registerGoogModuleExports:function(moduleId, exports) {
-          goog.loadedModules_[moduleId] = {exports:exports, type:goog.ModuleType.GOOG, moduleId:moduleId};
-        }, clearModuleState:function() {
-          goog.moduleLoaderState_ = null;
-        }, defer:function(callback) {
-          if (loadCallDone) {
-            throw new Error("Cannot register with defer after the call to load.");
-          }
-          loader.defer_(dep, callback);
-        }, areDepsLoaded:function() {
-          return loader.areDepsLoaded_(dep.requires);
-        }};
-        try {
-          dep.load(controller);
-        } finally {
-          loadCallDone = true;
-        }
-      })();
-    }
-    if (paused) {
-      this.pause_();
-    }
-  };
-  goog.DebugLoader_.prototype.pause_ = function() {
-    this.paused_ = true;
-  };
-  goog.DebugLoader_.prototype.resume_ = function() {
-    if (this.paused_) {
-      this.paused_ = false;
-      this.loadDeps_();
-    }
-  };
-  goog.DebugLoader_.prototype.loading_ = function(dep) {
-    this.loadingDeps_.push(dep);
-  };
-  goog.DebugLoader_.prototype.loaded_ = function(dep) {
-    var i = 0;
-    for (; i < this.loadingDeps_.length; i++) {
-      if (this.loadingDeps_[i] == dep) {
-        this.loadingDeps_.splice(i, 1);
-        break;
-      }
-    }
-    i = 0;
-    for (; i < this.deferredQueue_.length; i++) {
-      if (this.deferredQueue_[i] == dep.path) {
-        this.deferredQueue_.splice(i, 1);
-        break;
-      }
-    }
-    if (this.loadingDeps_.length == this.deferredQueue_.length && !this.depsToLoad_.length) {
-      for (; this.deferredQueue_.length;) {
-        this.requested(this.deferredQueue_.shift(), true);
-      }
-    }
-    dep.loaded();
-  };
-  goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {
-    var i = 0;
-    for (; i < pathsOrIds.length; i++) {
-      var path = this.getPathFromDeps_(pathsOrIds[i]);
-      if (!path || !(path in this.deferredCallbacks_) && !goog.isProvided_(pathsOrIds[i])) {
-        return false;
-      }
-    }
-    return true;
-  };
-  goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {
-    if (absPathOrId in this.idToPath_) {
-      return this.idToPath_[absPathOrId];
-    } else if (absPathOrId in this.dependencies_) {
-      return absPathOrId;
-    } else {
-      return null;
-    }
-  };
-  goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {
-    this.deferredCallbacks_[dependency.path] = callback;
-    this.deferredQueue_.push(dependency.path);
-  };
-  goog.LoadController = function() {
-  };
-  goog.LoadController.prototype.pause = function() {
-  };
-  goog.LoadController.prototype.resume = function() {
-  };
-  goog.LoadController.prototype.loaded = function() {
-  };
-  goog.LoadController.prototype.pending = function() {
-  };
-  goog.LoadController.prototype.registerEs6ModuleExports = function(path, exports, opt_closureNamespace) {
-  };
-  goog.LoadController.prototype.setModuleState = function(type) {
-  };
-  goog.LoadController.prototype.clearModuleState = function() {
-  };
-  goog.LoadController.prototype.defer = function(callback) {
-  };
-  goog.LoadController.prototype.areDepsLoaded = function() {
-  };
-  goog.Dependency = function(path, relativePath, provides, requires, loadFlags) {
-    this.path = path;
-    this.relativePath = relativePath;
-    this.provides = provides;
-    this.requires = requires;
-    this.loadFlags = loadFlags;
-    this.loaded_ = false;
-    this.loadCallbacks_ = [];
-  };
-  goog.Dependency.prototype.getPathName = function() {
-    var pathName = this.path;
-    var protocolIndex = pathName.indexOf("://");
-    if (protocolIndex >= 0) {
-      pathName = pathName.substring(protocolIndex + 3);
-      var slashIndex = pathName.indexOf("/");
-      if (slashIndex >= 0) {
-        pathName = pathName.substring(slashIndex + 1);
-      }
-    }
-    return pathName;
-  };
-  goog.Dependency.prototype.onLoad = function(callback) {
-    if (this.loaded_) {
-      callback();
-    } else {
-      this.loadCallbacks_.push(callback);
-    }
-  };
-  goog.Dependency.prototype.loaded = function() {
-    this.loaded_ = true;
-    var callbacks = this.loadCallbacks_;
-    this.loadCallbacks_ = [];
-    var i = 0;
-    for (; i < callbacks.length; i++) {
-      callbacks[i]();
-    }
-  };
-  goog.Dependency.defer_ = false;
-  goog.Dependency.callbackMap_ = {};
-  goog.Dependency.registerCallback_ = function(callback) {
-    var key = Math.random().toString(32);
-    goog.Dependency.callbackMap_[key] = callback;
-    return key;
-  };
-  goog.Dependency.unregisterCallback_ = function(key) {
-    delete goog.Dependency.callbackMap_[key];
-  };
-  goog.Dependency.callback_ = function(key, var_args) {
-    if (key in goog.Dependency.callbackMap_) {
-      var callback = goog.Dependency.callbackMap_[key];
-      var args = [];
-      var i = 1;
-      for (; i < arguments.length; i++) {
-        args.push(arguments[i]);
-      }
-      callback.apply(undefined, args);
-    } else {
-      var errorMessage = "Callback key " + key + " does not exist (was base.js loaded more than once?).";
-      throw Error(errorMessage);
-    }
-  };
-  goog.Dependency.prototype.load = function(controller) {
-    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
-      if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
-        controller.loaded();
-      } else {
-        controller.pause();
-      }
-      return;
-    }
-    if (!goog.inHtmlDocument_()) {
-      goog.logToConsole_("Cannot use default debug loader outside of HTML documents.");
-      if (this.relativePath == "deps.js") {
-        goog.logToConsole_("Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, " + "or setting CLOSURE_NO_DEPS to true.");
-        controller.loaded();
-      } else {
-        controller.pause();
-      }
-      return;
-    }
-    var doc = goog.global.document;
-    if (doc.readyState == "complete" && !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {
-      var isDeps = /\bdeps.js$/.test(this.path);
-      if (isDeps) {
-        controller.loaded();
-        return;
-      } else {
-        throw Error('Cannot write "' + this.path + '" after document load');
-      }
-    }
-    var nonce = goog.getScriptNonce_();
-    if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING && goog.isDocumentLoading_()) {
-      var key;
-      var callback = function(script) {
-        if (script.readyState && script.readyState != "complete") {
-          script.onload = callback;
-          return;
-        }
-        goog.Dependency.unregisterCallback_(key);
-        controller.loaded();
-      };
-      key = goog.Dependency.registerCallback_(callback);
-      var defer = goog.Dependency.defer_ ? " defer" : "";
-      var nonceAttr = nonce ? ' nonce\x3d"' + nonce + '"' : "";
-      var script = '\x3cscript src\x3d"' + this.path + '"' + nonceAttr + defer + ' id\x3d"script-' + key + '"\x3e\x3c/script\x3e';
-      script = script + ("\x3cscript" + nonceAttr + "\x3e");
-      if (goog.Dependency.defer_) {
-        script = script + ("document.getElementById('script-" + key + "').onload \x3d function() {\n" + "  goog.Dependency.callback_('" + key + "', this);\n" + "};\n");
-      } else {
-        script = script + ("goog.Dependency.callback_('" + key + "', document.getElementById('script-" + key + "'));");
-      }
-      script = script + "\x3c/script\x3e";
-      doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);
-    } else {
-      var scriptEl = doc.createElement("script");
-      scriptEl.defer = goog.Dependency.defer_;
-      scriptEl.async = false;
-      if (nonce) {
-        scriptEl.nonce = nonce;
-      }
-      scriptEl.onload = function() {
-        scriptEl.onload = null;
-        controller.loaded();
-      };
-      scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path) : this.path;
-      doc.head.appendChild(scriptEl);
-    }
-  };
-  goog.Es6ModuleDependency = function(path, relativePath, provides, requires, loadFlags) {
-    goog.Es6ModuleDependency.base(this, "constructor", path, relativePath, provides, requires, loadFlags);
-  };
-  goog.inherits(goog.Es6ModuleDependency, goog.Dependency);
-  goog.Es6ModuleDependency.prototype.load = function(controller) {
-    function write(src, contents) {
-      var nonceAttr = "";
-      var nonce = goog.getScriptNonce_();
-      if (nonce) {
-        nonceAttr = ' nonce\x3d"' + nonce + '"';
-      }
-      if (contents) {
-        var script = '\x3cscript type\x3d"module" crossorigin' + nonceAttr + "\x3e" + contents + "\x3c/" + "script\x3e";
-        doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);
-      } else {
-        script = '\x3cscript type\x3d"module" crossorigin src\x3d"' + src + '"' + nonceAttr + "\x3e\x3c/" + "script\x3e";
-        doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);
-      }
-    }
-    function append(src, contents) {
-      var scriptEl = doc.createElement("script");
-      scriptEl.defer = true;
-      scriptEl.async = false;
-      scriptEl.type = "module";
-      scriptEl.setAttribute("crossorigin", true);
-      var nonce = goog.getScriptNonce_();
-      if (nonce) {
-        scriptEl.nonce = nonce;
-      }
-      if (contents) {
-        scriptEl.text = goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createScript(contents) : contents;
-      } else {
-        scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createScriptURL(src) : src;
-      }
-      doc.head.appendChild(scriptEl);
-    }
-    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
-      if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
-        controller.loaded();
-      } else {
-        controller.pause();
-      }
-      return;
-    }
-    if (!goog.inHtmlDocument_()) {
-      goog.logToConsole_("Cannot use default debug loader outside of HTML documents.");
-      controller.pause();
-      return;
-    }
-    var doc = goog.global.document;
-    var dep = this;
-    var create;
-    if (goog.isDocumentLoading_()) {
-      create = write;
-      goog.Dependency.defer_ = true;
-    } else {
-      create = append;
-    }
-    var beforeKey = goog.Dependency.registerCallback_(function() {
-      goog.Dependency.unregisterCallback_(beforeKey);
-      controller.setModuleState(goog.ModuleType.ES6);
-    });
-    create(undefined, 'goog.Dependency.callback_("' + beforeKey + '")');
-    create(this.path, undefined);
-    var registerKey = goog.Dependency.registerCallback_(function(exports) {
-      goog.Dependency.unregisterCallback_(registerKey);
-      controller.registerEs6ModuleExports(dep.path, exports, goog.moduleLoaderState_.moduleName);
-    });
-    create(undefined, 'import * as m from "' + this.path + '"; goog.Dependency.callback_("' + registerKey + '", m)');
-    var afterKey = goog.Dependency.registerCallback_(function() {
-      goog.Dependency.unregisterCallback_(afterKey);
-      controller.clearModuleState();
-      controller.loaded();
-    });
-    create(undefined, 'goog.Dependency.callback_("' + afterKey + '")');
-  };
-  goog.TransformedDependency = function(path, relativePath, provides, requires, loadFlags) {
-    goog.TransformedDependency.base(this, "constructor", path, relativePath, provides, requires, loadFlags);
-    this.contents_ = null;
-    this.lazyFetch_ = !goog.inHtmlDocument_() || !("noModule" in goog.global.document.createElement("script"));
-  };
-  goog.inherits(goog.TransformedDependency, goog.Dependency);
-  goog.TransformedDependency.prototype.load = function(controller) {
-    function fetch() {
-      dep.contents_ = goog.loadFileSync_(dep.path);
-      if (dep.contents_) {
-        dep.contents_ = dep.transform(dep.contents_);
-        if (dep.contents_) {
-          dep.contents_ += "\n//# sourceURL\x3d" + dep.path;
-        }
-      }
-    }
-    function load() {
-      if (dep.lazyFetch_) {
-        fetch();
-      }
-      if (!dep.contents_) {
-        return;
-      }
-      if (isEs6) {
-        controller.setModuleState(goog.ModuleType.ES6);
-      }
-      var namespace;
-      try {
-        var contents = dep.contents_;
-        dep.contents_ = null;
-        goog.globalEval(goog.CLOSURE_EVAL_PREFILTER_.createScript(contents));
-        if (isEs6) {
-          namespace = goog.moduleLoaderState_.moduleName;
-        }
-      } finally {
-        if (isEs6) {
-          controller.clearModuleState();
-        }
-      }
-      if (isEs6) {
-        goog.global["$jscomp"]["require"]["ensure"]([dep.getPathName()], function() {
-          controller.registerEs6ModuleExports(dep.path, goog.global["$jscomp"]["require"](dep.getPathName()), namespace);
-        });
-      }
-      controller.loaded();
-    }
-    function fetchInOwnScriptThenLoad() {
-      var doc = goog.global.document;
-      var key = goog.Dependency.registerCallback_(function() {
-        goog.Dependency.unregisterCallback_(key);
-        load();
-      });
-      var nonce = goog.getScriptNonce_();
-      var nonceAttr = nonce ? ' nonce\x3d"' + nonce + '"' : "";
-      var script = "\x3cscript" + nonceAttr + "\x3e" + goog.protectScriptTag_('goog.Dependency.callback_("' + key + '");') + "\x3c/" + "script\x3e";
-      doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);
-    }
-    var dep = this;
-    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
-      fetch();
-      if (this.contents_ && goog.global.CLOSURE_IMPORT_SCRIPT("", this.contents_)) {
-        this.contents_ = null;
-        controller.loaded();
-      } else {
-        controller.pause();
-      }
-      return;
-    }
-    var isEs6 = this.loadFlags["module"] == goog.ModuleType.ES6;
-    if (!this.lazyFetch_) {
-      fetch();
-    }
-    var anythingElsePending = controller.pending().length > 1;
-    var needsAsyncLoading = goog.Dependency.defer_ && (anythingElsePending || goog.isDocumentLoading_());
-    if (needsAsyncLoading) {
-      controller.defer(function() {
-        load();
-      });
-      return;
-    }
-    var doc = goog.global.document;
-    var isInternetExplorerOrEdge = goog.inHtmlDocument_() && ("ActiveXObject" in goog.global || goog.isEdge_());
-    if (isEs6 && goog.inHtmlDocument_() && goog.isDocumentLoading_() && !isInternetExplorerOrEdge) {
-      goog.Dependency.defer_ = true;
-      controller.pause();
-      var oldCallback = doc.onreadystatechange;
-      doc.onreadystatechange = function() {
-        if (doc.readyState == "interactive") {
-          doc.onreadystatechange = oldCallback;
-          load();
-          controller.resume();
-        }
-        if (typeof oldCallback === "function") {
-          oldCallback.apply(undefined, arguments);
-        }
-      };
-    } else {
-      if (!goog.inHtmlDocument_() || !goog.isDocumentLoading_()) {
-        load();
-      } else {
-        fetchInOwnScriptThenLoad();
-      }
-    }
-  };
-  goog.TransformedDependency.prototype.transform = function(contents) {
-  };
-  goog.PreTranspiledEs6ModuleDependency = function(path, relativePath, provides, requires, loadFlags) {
-    goog.PreTranspiledEs6ModuleDependency.base(this, "constructor", path, relativePath, provides, requires, loadFlags);
-  };
-  goog.inherits(goog.PreTranspiledEs6ModuleDependency, goog.TransformedDependency);
-  goog.PreTranspiledEs6ModuleDependency.prototype.transform = function(contents) {
-    return contents;
-  };
-  goog.GoogModuleDependency = function(path, relativePath, provides, requires, loadFlags) {
-    goog.GoogModuleDependency.base(this, "constructor", path, relativePath, provides, requires, loadFlags);
-  };
-  goog.inherits(goog.GoogModuleDependency, goog.TransformedDependency);
-  goog.GoogModuleDependency.prototype.transform = function(contents) {
-    if (!goog.LOAD_MODULE_USING_EVAL || goog.global.JSON === undefined) {
-      return "" + "goog.loadModule(function(exports) {" + '"use strict";' + contents + "\n" + ";return exports" + "});" + "\n//# sourceURL\x3d" + this.path + "\n";
-    } else {
-      return "" + "goog.loadModule(" + goog.global.JSON.stringify(contents + "\n//# sourceURL\x3d" + this.path + "\n") + ");";
-    }
-  };
-  goog.DebugLoader_.prototype.addDependency = function(relPath, provides, requires, opt_loadFlags) {
-    provides = provides || [];
-    relPath = relPath.replace(/\\/g, "/");
-    var path = goog.normalizePath_(goog.basePath + relPath);
-    if (!opt_loadFlags || typeof opt_loadFlags === "boolean") {
-      opt_loadFlags = opt_loadFlags ? {"module":goog.ModuleType.GOOG} : {};
-    }
-    var dep = this.factory_.createDependency(path, relPath, provides, requires, opt_loadFlags);
-    this.dependencies_[path] = dep;
-    var i = 0;
-    for (; i < provides.length; i++) {
-      this.idToPath_[provides[i]] = path;
-    }
-    this.idToPath_[relPath] = path;
-  };
-  goog.DependencyFactory = function() {
-  };
-  goog.DependencyFactory.prototype.createDependency = function(path, relativePath, provides, requires, loadFlags) {
-    if (loadFlags["module"] == goog.ModuleType.GOOG) {
-      return new goog.GoogModuleDependency(path, relativePath, provides, requires, loadFlags);
-    } else {
-      if (loadFlags["module"] == goog.ModuleType.ES6) {
-        if (goog.ASSUME_ES_MODULES_TRANSPILED) {
-          return new goog.PreTranspiledEs6ModuleDependency(path, relativePath, provides, requires, loadFlags);
-        } else {
-          return new goog.Es6ModuleDependency(path, relativePath, provides, requires, loadFlags);
-        }
-      } else {
-        return new goog.Dependency(path, relativePath, provides, requires, loadFlags);
-      }
-    }
-  };
-  goog.debugLoader_ = new goog.DebugLoader_();
-  goog.loadClosureDeps = function() {
-    goog.debugLoader_.loadClosureDeps();
-  };
-  goog.setDependencyFactory = function(factory) {
-    goog.debugLoader_.setDependencyFactory(factory);
-  };
-  goog.TRUSTED_TYPES_POLICY_ = goog.TRUSTED_TYPES_POLICY_NAME ? goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME + "#base") : null;
-  if (!goog.global.CLOSURE_NO_DEPS) {
-    goog.debugLoader_.loadClosureDeps();
-  }
-  goog.bootstrap = function(namespaces, callback) {
-    goog.debugLoader_.bootstrap(namespaces, callback);
-  };
-}
-if (!COMPILED) {
-  var isChrome87 = false;
-  try {
-    isChrome87 = eval(goog.global.trustedTypes.emptyScript) !== goog.global.trustedTypes.emptyScript;
-  } catch (err) {
-  }
-  goog.CLOSURE_EVAL_PREFILTER_ = goog.global.trustedTypes && isChrome87 && goog.createTrustedTypesPolicy("goog#base#devonly#eval") || {createScript:goog.identity_};
-}
-
-//# sourceMappingURL=goog.base.js.map