longdown 2023.4.18

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

@@ -0,0 +1,1242 @@
+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]);
+  }
+  for (var part; parts.length && (part = parts.shift());) {
+    if (!parts.length && object !== undefined) {
+      if (!overwriteImplicit && goog.isObject(object) && goog.isObject(cur[part])) {
+        for (var 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;
+    while (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;
+  for (var i = 0; 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;
+  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.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" ? [] : {};
+    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.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 = [];
+    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;
+    };
+  }
+  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);
+    for (var i = 2; 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];
+    }
+  }
+  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.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 {
+      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.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) {
+    var cb = callback;
+    function resolve() {
+      if (cb) {
+        goog.global.setTimeout(cb, 0);
+        cb = null;
+      }
+    }
+    if (!namespaces.length) {
+      resolve();
+      return;
+    }
+    var deps = [];
+    for (var i = 0; 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;
+    for (var i = 0; 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];
+        for (var i = 0; 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_;
+    while (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 = [];
+          for (var i = 0; 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) {
+    for (var i = 0; i < this.loadingDeps_.length; i++) {
+      if (this.loadingDeps_[i] == dep) {
+        this.loadingDeps_.splice(i, 1);
+        break;
+      }
+    }
+    for (var i = 0; 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) {
+      while (this.deferredQueue_.length) {
+        this.requested(this.deferredQueue_.shift(), true);
+      }
+    }
+    dep.loaded();
+  };
+  goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {
+    for (var i = 0; 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_ = [];
+    for (var i = 0; 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 = [];
+      for (var i = 1; 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 += "\x3cscript" + nonceAttr + "\x3e";
+      if (goog.Dependency.defer_) {
+        script += "document.getElementById('script-" + key + "').onload \x3d function() {\n" + "  goog.Dependency.callback_('" + key + "', this);\n" + "};\n";
+      } else {
+        script += "goog.Dependency.callback_('" + key + "', document.getElementById('script-" + key + "'));";
+      }
+      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) {
+    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;
+    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 {
+        var 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);
+    }
+    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) {
+    var dep = this;
+    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;
+        }
+      }
+    }
+    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();
+    }
+    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 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;
+    for (var i = 0; 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