mini-program-cljs/.shadow-cljs/builds/node-repl/dev/goog-js/goog.base.js

["^ ","~:resource-id",["~:shadow.build.classpath/resource","goog/base.js"],"~:js","/** @define {boolean} */ var COMPILED = false;\n/** @const */ var goog = goog || {};\n/**\n * @const\n * @type {!Global}\n * @suppress {undefinedVars}\n */\ngoog.global = global;\n/** @type {(Object<string,(string|number|boolean)>|undefined)} */ goog.global.CLOSURE_UNCOMPILED_DEFINES;\n/** @type {(Object<string,(string|number|boolean)>|undefined)} */ goog.global.CLOSURE_DEFINES;\n/**\n * @param {?} val\n * @return {boolean}\n * @deprecated Use `val !== undefined` instead.\n */\ngoog.isDef = function(val) {\n  return val !== void 0;\n};\n/**\n * @param {?} val\n * @return {boolean}\n * @deprecated Use `typeof val === 'string'` instead.\n */\ngoog.isString = function(val) {\n  return typeof val == \"string\";\n};\n/**\n * @param {?} val\n * @return {boolean}\n * @deprecated Use `typeof val === 'boolean'` instead.\n */\ngoog.isBoolean = function(val) {\n  return typeof val == \"boolean\";\n};\n/**\n * @param {?} val\n * @return {boolean}\n * @deprecated Use `typeof val === 'number'` instead.\n */\ngoog.isNumber = function(val) {\n  return typeof val == \"number\";\n};\n/**\n * @private\n * @param {string} name\n * @param {*=} opt_object\n * @param {Object=} opt_objectToExportTo\n */\ngoog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {\n  var parts = name.split(\".\");\n  var cur = opt_objectToExportTo || goog.global;\n  if (!(parts[0] in cur) && typeof cur.execScript != \"undefined\") {\n    cur.execScript(\"var \" + parts[0]);\n  }\n  for (var part; parts.length && (part = parts.shift());) {\n    if (!parts.length && opt_object !== undefined) {\n      cur[part] = opt_object;\n    } else {\n      if (cur[part] && cur[part] !== Object.prototype[part]) {\n        cur = cur[part];\n      } else {\n        cur = cur[part] = {};\n      }\n    }\n  }\n};\n/**\n * @param {string} name\n * @param {T} defaultValue\n * @return {T}\n * @template T\n */\ngoog.define = function(name, defaultValue) {\n  var value = defaultValue;\n  if (!COMPILED) {\n    var uncompiledDefines = goog.global.CLOSURE_UNCOMPILED_DEFINES;\n    var defines = goog.global.CLOSURE_DEFINES;\n    if (uncompiledDefines && /** @type {?} */ (uncompiledDefines).nodeType === undefined && Object.prototype.hasOwnProperty.call(uncompiledDefines, name)) {\n      value = uncompiledDefines[name];\n    } else {\n      if (defines && /** @type {?} */ (defines).nodeType === undefined && Object.prototype.hasOwnProperty.call(defines, name)) {\n        value = defines[name];\n      }\n    }\n  }\n  return value;\n};\n/** @define {number} */ goog.FEATURESET_YEAR = goog.define(\"goog.FEATURESET_YEAR\", 2012);\n/** @define {boolean} */ goog.DEBUG = goog.define(\"goog.DEBUG\", true);\n/** @define {string} */ goog.LOCALE = goog.define(\"goog.LOCALE\", \"en\");\n/** @define {boolean} */ goog.TRUSTED_SITE = goog.define(\"goog.TRUSTED_SITE\", true);\n/** @define {boolean} */ goog.STRICT_MODE_COMPATIBLE = goog.define(\"goog.STRICT_MODE_COMPATIBLE\", false);\n/** @define {boolean} */ goog.DISALLOW_TEST_ONLY_CODE = goog.define(\"goog.DISALLOW_TEST_ONLY_CODE\", COMPILED && !goog.DEBUG);\n/** @define {boolean} */ goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING = goog.define(\"goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING\", false);\n/**\n * @param {string} name\n */\ngoog.provide = function(name) {\n  if (goog.isInModuleLoader_()) {\n    throw new Error(\"goog.provide cannot be used within a module.\");\n  }\n  if (!COMPILED) {\n    if (goog.isProvided_(name)) {\n      throw new Error('Namespace \"' + name + '\" already declared.');\n    }\n  }\n  goog.constructNamespace_(name);\n};\n/**\n * @private\n * @param {string} name\n * @param {Object=} opt_obj\n */\ngoog.constructNamespace_ = function(name, opt_obj) {\n  if (!COMPILED) {\n    delete goog.implicitNamespaces_[name];\n    var namespace = name;\n    while (namespace = namespace.substring(0, namespace.lastIndexOf(\".\"))) {\n      if (goog.getObjectByName(namespace)) {\n        break;\n      }\n      goog.implicitNamespaces_[namespace] = true;\n    }\n  }\n  goog.exportPath_(name, opt_obj);\n};\n/**\n * @param {?Window=} opt_window\n * @return {string}\n */\ngoog.getScriptNonce = function(opt_window) {\n  if (opt_window && opt_window != goog.global) {\n    return goog.getScriptNonce_(opt_window.document);\n  }\n  if (goog.cspNonce_ === null) {\n    goog.cspNonce_ = goog.getScriptNonce_(goog.global.document);\n  }\n  return goog.cspNonce_;\n};\n/** @private @const */ goog.NONCE_PATTERN_ = /^[\\w+/_-]+[=]{0,2}$/;\n/** @private @type {?string} */ goog.cspNonce_ = null;\n/**\n * @private\n * @param {!Document} doc\n * @return {string}\n */\ngoog.getScriptNonce_ = function(doc) {\n  var script = doc.querySelector && doc.querySelector(\"script[nonce]\");\n  if (script) {\n    var nonce = script[\"nonce\"] || script.getAttribute(\"nonce\");\n    if (nonce && goog.NONCE_PATTERN_.test(nonce)) {\n      return nonce;\n    }\n  }\n  return \"\";\n};\n/** @private */ goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;\n/**\n * @param {string} name\n * @return {void}\n */\ngoog.module = function(name) {\n  if (typeof name !== \"string\" || !name || name.search(goog.VALID_MODULE_RE_) == -1) {\n    throw new Error(\"Invalid module identifier\");\n  }\n  if (!goog.isInGoogModuleLoader_()) {\n    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.\");\n  }\n  if (goog.moduleLoaderState_.moduleName) {\n    throw new Error(\"goog.module may only be called once per module.\");\n  }\n  goog.moduleLoaderState_.moduleName = name;\n  if (!COMPILED) {\n    if (goog.isProvided_(name)) {\n      throw new Error('Namespace \"' + name + '\" already declared.');\n    }\n    delete goog.implicitNamespaces_[name];\n  }\n};\n/**\n * @param {string} name\n * @return {?}\n * @suppress {missingProvide}\n */\ngoog.module.get = function(name) {\n  return goog.module.getInternal_(name);\n};\n/**\n * @private\n * @param {string} name\n * @return {?}\n */\ngoog.module.getInternal_ = function(name) {\n  if (!COMPILED) {\n    if (name in goog.loadedModules_) {\n      return goog.loadedModules_[name].exports;\n    } else {\n      if (!goog.implicitNamespaces_[name]) {\n        var ns = goog.getObjectByName(name);\n        return ns != null ? ns : null;\n      }\n    }\n  }\n  return null;\n};\n/** @enum {string} */ goog.ModuleType = {ES6:\"es6\", GOOG:\"goog\"};\n/** @private @type {?{moduleName:(string|undefined),declareLegacyNamespace:boolean,type:?goog.ModuleType}} */ goog.moduleLoaderState_ = null;\n/**\n * @private\n * @return {boolean}\n */\ngoog.isInModuleLoader_ = function() {\n  return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();\n};\n/**\n * @private\n * @return {boolean}\n */\ngoog.isInGoogModuleLoader_ = function() {\n  return !!goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.GOOG;\n};\n/**\n * @private\n * @return {boolean}\n */\ngoog.isInEs6ModuleLoader_ = function() {\n  var inLoader = !!goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.ES6;\n  if (inLoader) {\n    return true;\n  }\n  var jscomp = goog.global[\"$jscomp\"];\n  if (jscomp) {\n    if (typeof jscomp.getCurrentModulePath != \"function\") {\n      return false;\n    }\n    return !!jscomp.getCurrentModulePath();\n  }\n  return false;\n};\n/**\n * @suppress {missingProvide}\n */\ngoog.module.declareLegacyNamespace = function() {\n  if (!COMPILED && !goog.isInGoogModuleLoader_()) {\n    throw new Error(\"goog.module.declareLegacyNamespace must be called from \" + \"within a goog.module\");\n  }\n  if (!COMPILED && !goog.moduleLoaderState_.moduleName) {\n    throw new Error(\"goog.module must be called prior to \" + \"goog.module.declareLegacyNamespace.\");\n  }\n  goog.moduleLoaderState_.declareLegacyNamespace = true;\n};\n/**\n * @param {string} namespace\n * @suppress {missingProvide}\n */\ngoog.declareModuleId = function(namespace) {\n  if (!COMPILED) {\n    if (!goog.isInEs6ModuleLoader_()) {\n      throw new Error(\"goog.declareModuleId may only be called from \" + \"within an ES6 module\");\n    }\n    if (goog.moduleLoaderState_ && goog.moduleLoaderState_.moduleName) {\n      throw new Error(\"goog.declareModuleId may only be called once per module.\");\n    }\n    if (namespace in goog.loadedModules_) {\n      throw new Error('Module with namespace \"' + namespace + '\" already exists.');\n    }\n  }\n  if (goog.moduleLoaderState_) {\n    goog.moduleLoaderState_.moduleName = namespace;\n  } else {\n    var jscomp = goog.global[\"$jscomp\"];\n    if (!jscomp || typeof jscomp.getCurrentModulePath != \"function\") {\n      throw new Error('Module with namespace \"' + namespace + '\" has been loaded incorrectly.');\n    }\n    var exports = jscomp.require(jscomp.getCurrentModulePath());\n    goog.loadedModules_[namespace] = {exports:exports, type:goog.ModuleType.ES6, moduleId:namespace};\n  }\n};\n/**\n * @param {string=} opt_message\n */\ngoog.setTestOnly = function(opt_message) {\n  if (goog.DISALLOW_TEST_ONLY_CODE) {\n    opt_message = opt_message || \"\";\n    throw new Error(\"Importing test-only code into non-debug environment\" + (opt_message ? \": \" + opt_message : \".\"));\n  }\n};\n/**\n * @param {string} name\n */\ngoog.forwardDeclare = function(name) {\n};\ngoog.forwardDeclare(\"Document\");\ngoog.forwardDeclare(\"HTMLScriptElement\");\ngoog.forwardDeclare(\"XMLHttpRequest\");\nif (!COMPILED) {\n  /**\n   * @private\n   * @param {string} name\n   * @return {boolean}\n   */\n  goog.isProvided_ = function(name) {\n    return name in goog.loadedModules_ || !goog.implicitNamespaces_[name] && goog.getObjectByName(name) != null;\n  };\n  /** @private @type {!Object<string,(boolean|undefined)>} */ goog.implicitNamespaces_ = {\"goog.module\":true};\n}\n/**\n * @param {string} name\n * @param {Object=} opt_obj\n * @return {?}\n */\ngoog.getObjectByName = function(name, opt_obj) {\n  var parts = name.split(\".\");\n  var cur = opt_obj || goog.global;\n  for (var i = 0; i < parts.length; i++) {\n    cur = cur[parts[i]];\n    if (cur == null) {\n      return null;\n    }\n  }\n  return cur;\n};\n/**\n * @param {!Object} obj\n * @param {Object=} opt_global\n * @deprecated Properties may be explicitly exported to the global scope, but this should no longer be done in bulk.\n */\ngoog.globalize = function(obj, opt_global) {\n  var global = opt_global || goog.global;\n  for (var x in obj) {\n    global[x] = obj[x];\n  }\n};\n/**\n * @param {string} relPath\n * @param {!Array<string>} provides\n * @param {!Array<string>} requires\n * @param {(boolean|!Object<?,string>)=} opt_loadFlags\n */\ngoog.addDependency = function(relPath, provides, requires, opt_loadFlags) {\n  if (!COMPILED && goog.DEPENDENCIES_ENABLED) {\n    goog.debugLoader_.addDependency(relPath, provides, requires, opt_loadFlags);\n  }\n};\n/** @define {boolean} */ goog.ENABLE_DEBUG_LOADER = goog.define(\"goog.ENABLE_DEBUG_LOADER\", true);\n/**\n * @private\n * @param {string} msg\n */\ngoog.logToConsole_ = function(msg) {\n  if (goog.global.console) {\n    goog.global.console[\"error\"](msg);\n  }\n};\n/**\n * @param {string} namespace\n * @return {?}\n */\ngoog.require = function(namespace) {\n  if (!COMPILED) {\n    if (goog.ENABLE_DEBUG_LOADER) {\n      goog.debugLoader_.requested(namespace);\n    }\n    if (goog.isProvided_(namespace)) {\n      if (goog.isInModuleLoader_()) {\n        return goog.module.getInternal_(namespace);\n      }\n    } else {\n      if (goog.ENABLE_DEBUG_LOADER) {\n        var moduleLoaderState = goog.moduleLoaderState_;\n        goog.moduleLoaderState_ = null;\n        try {\n          goog.debugLoader_.load_(namespace);\n        } finally {\n          goog.moduleLoaderState_ = moduleLoaderState;\n        }\n      }\n    }\n    return null;\n  }\n};\n/**\n * @param {string} namespace\n * @return {?}\n */\ngoog.requireType = function(namespace) {\n  return {};\n};\n/** @type {string} */ goog.basePath = \"\";\n/** @type {(string|undefined)} */ goog.global.CLOSURE_BASE_PATH;\n/** @type {(boolean|undefined)} */ goog.global.CLOSURE_NO_DEPS;\n/** @type {(function(string,string=):boolean|undefined)} */ goog.global.CLOSURE_IMPORT_SCRIPT;\n/**\n * @return {void}\n */\ngoog.nullFunction = function() {\n};\n/**\n * @type {!Function}\n * @deprecated Use \"@abstract\" annotation instead of goog.abstractMethod in new code. See https://github.com/google/closure-compiler/wiki/@abstract-classes-and-methods\n */\ngoog.abstractMethod = function() {\n  throw new Error(\"unimplemented abstract method\");\n};\n/**\n * @param {!Function} ctor\n * @suppress {missingProperties}\n */\ngoog.addSingletonGetter = function(ctor) {\n  /**\n   * @type {(undefined|!Object)}\n   * @suppress {underscore}\n   */\n  ctor.instance_ = undefined;\n  ctor.getInstance = function() {\n    if (ctor.instance_) {\n      return ctor.instance_;\n    }\n    if (goog.DEBUG) {\n      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;\n    }\n    return /** @type {(!Object|undefined)} */ (ctor.instance_) = new ctor;\n  };\n};\n/** @private @type {!Array<!Function>} */ goog.instantiatedSingletons_ = [];\n/** @define {boolean} */ goog.LOAD_MODULE_USING_EVAL = goog.define(\"goog.LOAD_MODULE_USING_EVAL\", true);\n/** @define {boolean} */ goog.SEAL_MODULE_EXPORTS = goog.define(\"goog.SEAL_MODULE_EXPORTS\", goog.DEBUG);\n/** @private @const @type {!Object<string,{exports:?,type:string,moduleId:string}>} */ goog.loadedModules_ = {};\n/** @const @type {boolean} */ goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;\n/** @define {string} */ goog.TRANSPILE = goog.define(\"goog.TRANSPILE\", \"detect\");\n/** @define {boolean} */ goog.ASSUME_ES_MODULES_TRANSPILED = goog.define(\"goog.ASSUME_ES_MODULES_TRANSPILED\", false);\n/** @define {string} */ goog.TRANSPILE_TO_LANGUAGE = goog.define(\"goog.TRANSPILE_TO_LANGUAGE\", \"\");\n/** @define {string} */ goog.TRANSPILER = goog.define(\"goog.TRANSPILER\", \"transpile.js\");\n/** @package @type {?boolean} */ goog.hasBadLetScoping = null;\n/**\n * @package\n * @return {boolean}\n */\ngoog.useSafari10Workaround = function() {\n  if (goog.hasBadLetScoping == null) {\n    var hasBadLetScoping;\n    try {\n      hasBadLetScoping = !eval('\"use strict\";' + \"let x \\x3d 1; function f() { return typeof x; };\" + 'f() \\x3d\\x3d \"number\";');\n    } catch (e) {\n      hasBadLetScoping = false;\n    }\n    goog.hasBadLetScoping = hasBadLetScoping;\n  }\n  return goog.hasBadLetScoping;\n};\n/**\n * @package\n * @param {string} moduleDef\n * @return {string}\n */\ngoog.workaroundSafari10EvalBug = function(moduleDef) {\n  return \"(function(){\" + moduleDef + \"\\n\" + \";\" + \"})();\\n\";\n};\n/**\n * @param {(function(?):?|string)} moduleDef\n */\ngoog.loadModule = function(moduleDef) {\n  var previousState = goog.moduleLoaderState_;\n  try {\n    goog.moduleLoaderState_ = {moduleName:\"\", declareLegacyNamespace:false, type:goog.ModuleType.GOOG};\n    var exports;\n    if (goog.isFunction(moduleDef)) {\n      exports = moduleDef.call(undefined, {});\n    } else {\n      if (typeof moduleDef === \"string\") {\n        if (goog.useSafari10Workaround()) {\n          moduleDef = goog.workaroundSafari10EvalBug(moduleDef);\n        }\n        exports = goog.loadModuleFromSource_.call(undefined, moduleDef);\n      } else {\n        throw new Error(\"Invalid module definition\");\n      }\n    }\n    var moduleName = goog.moduleLoaderState_.moduleName;\n    if (typeof moduleName === \"string\" && moduleName) {\n      if (goog.moduleLoaderState_.declareLegacyNamespace) {\n        goog.constructNamespace_(moduleName, exports);\n      } else {\n        if (goog.SEAL_MODULE_EXPORTS && Object.seal && typeof exports == \"object\" && exports != null) {\n          Object.seal(exports);\n        }\n      }\n      var data = {exports:exports, type:goog.ModuleType.GOOG, moduleId:goog.moduleLoaderState_.moduleName};\n      goog.loadedModules_[moduleName] = data;\n    } else {\n      throw new Error('Invalid module name \"' + moduleName + '\"');\n    }\n  } finally {\n    goog.moduleLoaderState_ = previousState;\n  }\n};\n/** @private @const */ goog.loadModuleFromSource_ = /** @type {function(string):?} */ (function() {\n  var exports = {};\n  eval(arguments[0]);\n  return exports;\n});\n/**\n * @private\n * @param {string} path\n * @return {string}\n */\ngoog.normalizePath_ = function(path) {\n  var components = path.split(\"/\");\n  var i = 0;\n  while (i < components.length) {\n    if (components[i] == \".\") {\n      components.splice(i, 1);\n    } else {\n      if (i && components[i] == \"..\" && components[i - 1] && components[i - 1] != \"..\") {\n        components.splice(--i, 2);\n      } else {\n        i++;\n      }\n    }\n  }\n  return components.join(\"/\");\n};\n/** @type {(function(string):string|undefined)} */ goog.global.CLOSURE_LOAD_FILE_SYNC;\n/**\n * @private\n * @param {string} src\n * @return {?string}\n */\ngoog.loadFileSync_ = function(src) {\n  if (goog.global.CLOSURE_LOAD_FILE_SYNC) {\n    return goog.global.CLOSURE_LOAD_FILE_SYNC(src);\n  } else {\n    try {\n      /** @type {XMLHttpRequest} */ var xhr = new goog.global[\"XMLHttpRequest\"];\n      xhr.open(\"get\", src, false);\n      xhr.send();\n      return xhr.status == 0 || xhr.status == 200 ? xhr.responseText : null;\n    } catch (err) {\n      return null;\n    }\n  }\n};\n/**\n * @private\n * @param {string} code\n * @param {string} path\n * @param {string} target\n * @return {string}\n */\ngoog.transpile_ = function(code, path, target) {\n  var jscomp = goog.global[\"$jscomp\"];\n  if (!jscomp) {\n    goog.global[\"$jscomp\"] = jscomp = {};\n  }\n  var transpile = jscomp.transpile;\n  if (!transpile) {\n    var transpilerPath = goog.basePath + goog.TRANSPILER;\n    var transpilerCode = goog.loadFileSync_(transpilerPath);\n    if (transpilerCode) {\n      (function() {\n        (0, eval)(transpilerCode + \"\\n//# sourceURL\\x3d\" + transpilerPath);\n      }).call(goog.global);\n      if (goog.global[\"$gwtExport\"] && goog.global[\"$gwtExport\"][\"$jscomp\"] && !goog.global[\"$gwtExport\"][\"$jscomp\"][\"transpile\"]) {\n        throw new Error('The transpiler did not properly export the \"transpile\" ' + \"method. $gwtExport: \" + JSON.stringify(goog.global[\"$gwtExport\"]));\n      }\n      goog.global[\"$jscomp\"].transpile = goog.global[\"$gwtExport\"][\"$jscomp\"][\"transpile\"];\n      jscomp = goog.global[\"$jscomp\"];\n      transpile = jscomp.transpile;\n    }\n  }\n  if (!transpile) {\n    var suffix = \" requires transpilation but no transpiler was found.\";\n    transpile = jscomp.transpile = function(code, path) {\n      goog.logToConsole_(path + suffix);\n      return code;\n    };\n  }\n  return transpile(code, path, target);\n};\n/**\n * @param {?} value\n * @return {string}\n */\ngoog.typeOf = function(value) {\n  var s = typeof value;\n  if (s == \"object\") {\n    if (value) {\n      if (value instanceof Array) {\n        return \"array\";\n      } else {\n        if (value instanceof Object) {\n          return s;\n        }\n      }\n      var className = Object.prototype.toString.call(/** @type {!Object} */ (value));\n      if (className == \"[object Window]\") {\n        return \"object\";\n      }\n      if (className == \"[object Array]\" || typeof value.length == \"number\" && typeof value.splice != \"undefined\" && typeof value.propertyIsEnumerable != \"undefined\" && !value.propertyIsEnumerable(\"splice\")) {\n        return \"array\";\n      }\n      if (className == \"[object Function]\" || typeof value.call != \"undefined\" && typeof value.propertyIsEnumerable != \"undefined\" && !value.propertyIsEnumerable(\"call\")) {\n        return \"function\";\n      }\n    } else {\n      return \"null\";\n    }\n  } else {\n    if (s == \"function\" && typeof value.call == \"undefined\") {\n      return \"object\";\n    }\n  }\n  return s;\n};\n/**\n * @param {?} val\n * @return {boolean}\n * @deprecated Use `val === null` instead.\n */\ngoog.isNull = function(val) {\n  return val === null;\n};\n/**\n * @param {?} val\n * @return {boolean}\n * @deprecated Use `val != null` instead.\n */\ngoog.isDefAndNotNull = function(val) {\n  return val != null;\n};\n/**\n * @param {?} val\n * @return {boolean}\n */\ngoog.isArray = function(val) {\n  return goog.typeOf(val) == \"array\";\n};\n/**\n * @param {?} val\n * @return {boolean}\n */\ngoog.isArrayLike = function(val) {\n  var type = goog.typeOf(val);\n  return type == \"array\" || type == \"object\" && typeof val.length == \"number\";\n};\n/**\n * @param {?} val\n * @return {boolean}\n */\ngoog.isDateLike = function(val) {\n  return goog.isObject(val) && typeof val.getFullYear == \"function\";\n};\n/**\n * @param {?} val\n * @return {boolean}\n */\ngoog.isFunction = function(val) {\n  return goog.typeOf(val) == \"function\";\n};\n/**\n * @param {?} val\n * @return {boolean}\n */\ngoog.isObject = function(val) {\n  var type = typeof val;\n  return type == \"object\" && val != null || type == \"function\";\n};\n/**\n * @param {Object} obj\n * @return {number}\n */\ngoog.getUid = function(obj) {\n  return obj[goog.UID_PROPERTY_] || (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);\n};\n/**\n * @param {!Object} obj\n * @return {boolean}\n */\ngoog.hasUid = function(obj) {\n  return !!obj[goog.UID_PROPERTY_];\n};\n/**\n * @param {Object} obj\n */\ngoog.removeUid = function(obj) {\n  if (obj !== null && \"removeAttribute\" in obj) {\n    obj.removeAttribute(goog.UID_PROPERTY_);\n  }\n  try {\n    delete obj[goog.UID_PROPERTY_];\n  } catch (ex) {\n  }\n};\n/** @private @type {string} */ goog.UID_PROPERTY_ = \"closure_uid_\" + (Math.random() * 1e9 >>> 0);\n/** @private @type {number} */ goog.uidCounter_ = 0;\n/**\n * @param {Object} obj\n * @return {number}\n * @deprecated Use goog.getUid instead.\n */\ngoog.getHashCode = goog.getUid;\n/**\n * @param {Object} obj\n * @deprecated Use goog.removeUid instead.\n */\ngoog.removeHashCode = goog.removeUid;\n/**\n * @param {*} obj\n * @return {*}\n * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.\n */\ngoog.cloneObject = function(obj) {\n  var type = goog.typeOf(obj);\n  if (type == \"object\" || type == \"array\") {\n    if (typeof obj.clone === \"function\") {\n      return obj.clone();\n    }\n    var clone = type == \"array\" ? [] : {};\n    for (var key in obj) {\n      clone[key] = goog.cloneObject(obj[key]);\n    }\n    return clone;\n  }\n  return obj;\n};\n/**\n * @private\n * @param {?function(this:T,...)} fn\n * @param {T} selfObj\n * @param {...*} var_args\n * @return {!Function}\n * @template T\n */\ngoog.bindNative_ = function(fn, selfObj, var_args) {\n  return (/** @type {!Function} */ (fn.call.apply(fn.bind, arguments)));\n};\n/**\n * @private\n * @param {?function(this:T,...)} fn\n * @param {T} selfObj\n * @param {...*} var_args\n * @return {!Function}\n * @template T\n */\ngoog.bindJs_ = function(fn, selfObj, var_args) {\n  if (!fn) {\n    throw new Error;\n  }\n  if (arguments.length > 2) {\n    var boundArgs = Array.prototype.slice.call(arguments, 2);\n    return function() {\n      var newArgs = Array.prototype.slice.call(arguments);\n      Array.prototype.unshift.apply(newArgs, boundArgs);\n      return fn.apply(selfObj, newArgs);\n    };\n  } else {\n    return function() {\n      return fn.apply(selfObj, arguments);\n    };\n  }\n};\n/**\n * @param {?function(this:T,...)} fn\n * @param {T} selfObj\n * @param {...*} var_args\n * @return {!Function}\n * @template T\n * @suppress {deprecated}\n */\ngoog.bind = function(fn, selfObj, var_args) {\n  if (Function.prototype.bind && Function.prototype.bind.toString().indexOf(\"native code\") != -1) {\n    goog.bind = goog.bindNative_;\n  } else {\n    goog.bind = goog.bindJs_;\n  }\n  return goog.bind.apply(null, arguments);\n};\n/**\n * @param {Function} fn\n * @param {...*} var_args\n * @return {!Function}\n */\ngoog.partial = function(fn, var_args) {\n  var args = Array.prototype.slice.call(arguments, 1);\n  return function() {\n    var newArgs = args.slice();\n    newArgs.push.apply(newArgs, arguments);\n    return fn.apply(/** @type {?} */ (this), newArgs);\n  };\n};\n/**\n * @param {Object} target\n * @param {Object} source\n * @deprecated Prefer Object.assign\n */\ngoog.mixin = function(target, source) {\n  for (var x in source) {\n    target[x] = source[x];\n  }\n};\n/**\n * @return {number}\n * @deprecated Use Date.now\n */\ngoog.now = goog.TRUSTED_SITE && Date.now || function() {\n  return +new Date;\n};\n/**\n * @param {string} script\n */\ngoog.globalEval = function(script) {\n  if (goog.global.execScript) {\n    goog.global.execScript(script, \"JavaScript\");\n  } else {\n    if (goog.global.eval) {\n      if (goog.evalWorksForGlobals_ == null) {\n        try {\n          goog.global.eval(\"var _evalTest_ \\x3d 1;\");\n        } catch (ignore) {\n        }\n        if (typeof goog.global[\"_evalTest_\"] != \"undefined\") {\n          try {\n            delete goog.global[\"_evalTest_\"];\n          } catch (ignore$0) {\n          }\n          goog.evalWorksForGlobals_ = true;\n        } else {\n          goog.evalWorksForGlobals_ = false;\n        }\n      }\n      if (goog.evalWorksForGlobals_) {\n        goog.global.eval(script);\n      } else {\n        /** @type {!Document} */ var doc = goog.global.document;\n        var scriptElt = /** @type {!HTMLScriptElement} */ (doc.createElement(\"script\"));\n        scriptElt.type = \"text/javascript\";\n        scriptElt.defer = false;\n        scriptElt.appendChild(doc.createTextNode(script));\n        doc.head.appendChild(scriptElt);\n        doc.head.removeChild(scriptElt);\n      }\n    } else {\n      throw new Error(\"goog.globalEval not available\");\n    }\n  }\n};\n/** @private @type {?boolean} */ goog.evalWorksForGlobals_ = null;\n/** @private @type {(!Object<string,string>|undefined)} */ goog.cssNameMapping_;\n/** @private @type {(string|undefined)} */ goog.cssNameMappingStyle_;\n/** @type {(function(string):string|undefined)} */ goog.global.CLOSURE_CSS_NAME_MAP_FN;\n/**\n * @param {string} className\n * @param {string=} opt_modifier\n * @return {string}\n */\ngoog.getCssName = function(className, opt_modifier) {\n  if (String(className).charAt(0) == \".\") {\n    throw new Error('className passed in goog.getCssName must not start with \".\".' + \" You passed: \" + className);\n  }\n  var getMapping = function(cssName) {\n    return goog.cssNameMapping_[cssName] || cssName;\n  };\n  var renameByParts = function(cssName) {\n    var parts = cssName.split(\"-\");\n    var mapped = [];\n    for (var i = 0; i < parts.length; i++) {\n      mapped.push(getMapping(parts[i]));\n    }\n    return mapped.join(\"-\");\n  };\n  var rename;\n  if (goog.cssNameMapping_) {\n    rename = goog.cssNameMappingStyle_ == \"BY_WHOLE\" ? getMapping : renameByParts;\n  } else {\n    rename = function(a) {\n      return a;\n    };\n  }\n  var result = opt_modifier ? className + \"-\" + rename(opt_modifier) : rename(className);\n  if (goog.global.CLOSURE_CSS_NAME_MAP_FN) {\n    return goog.global.CLOSURE_CSS_NAME_MAP_FN(result);\n  }\n  return result;\n};\n/**\n * @param {!Object} mapping\n * @param {string=} opt_style\n */\ngoog.setCssNameMapping = function(mapping, opt_style) {\n  goog.cssNameMapping_ = mapping;\n  goog.cssNameMappingStyle_ = opt_style;\n};\n/** @type {(!Object<string,string>|undefined)} */ goog.global.CLOSURE_CSS_NAME_MAPPING;\nif (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {\n  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;\n}\n/**\n * @param {string} str\n * @param {Object<string,string>=} opt_values\n * @param {{html:boolean}=} opt_options\n * @return {string}\n */\ngoog.getMsg = function(str, opt_values, opt_options) {\n  if (opt_options && opt_options.html) {\n    str = str.replace(/</g, \"\\x26lt;\");\n  }\n  if (opt_values) {\n    str = str.replace(/\\{\\$([^}]+)}/g, function(match, key) {\n      return opt_values != null && key in opt_values ? opt_values[key] : match;\n    });\n  }\n  return str;\n};\n/**\n * @param {string} a\n * @param {string} b\n * @return {string}\n */\ngoog.getMsgWithFallback = function(a, b) {\n  return a;\n};\n/**\n * @param {string} publicPath\n * @param {*} object\n * @param {Object=} opt_objectToExportTo\n */\ngoog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {\n  goog.exportPath_(publicPath, object, opt_objectToExportTo);\n};\n/**\n * @param {Object} object\n * @param {string} publicName\n * @param {*} symbol\n */\ngoog.exportProperty = function(object, publicName, symbol) {\n  object[publicName] = symbol;\n};\n/**\n * @param {!Function} childCtor\n * @param {!Function} parentCtor\n * @suppress {strictMissingProperties}\n */\ngoog.inherits = function(childCtor, parentCtor) {\n  /** @constructor */ function tempCtor() {\n  }\n  tempCtor.prototype = parentCtor.prototype;\n  childCtor.superClass_ = parentCtor.prototype;\n  childCtor.prototype = new tempCtor;\n  /** @override */ childCtor.prototype.constructor = childCtor;\n  /**\n   * @param {!Object} me\n   * @param {string} methodName\n   * @param {...*} var_args\n   * @return {*}\n   */\n  childCtor.base = function(me, methodName, var_args) {\n    var args = new Array(arguments.length - 2);\n    for (var i = 2; i < arguments.length; i++) {\n      args[i - 2] = arguments[i];\n    }\n    return parentCtor.prototype[methodName].apply(me, args);\n  };\n};\n/**\n * @param {!Object} me\n * @param {*=} opt_methodName\n * @param {...*} var_args\n * @return {*}\n * @suppress {es5Strict}\n * @deprecated goog.base is not strict mode compatible.  Prefer the static \"base\" method added to the constructor by goog.inherits or ES6 classes and the \"super\" keyword.\n */\ngoog.base = function(me, opt_methodName, var_args) {\n  var caller = arguments.callee.caller;\n  if (goog.STRICT_MODE_COMPATIBLE || goog.DEBUG && !caller) {\n    throw new 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\");\n  }\n  if (typeof caller.superClass_ !== \"undefined\") {\n    var ctorArgs = new Array(arguments.length - 1);\n    for (var i = 1; i < arguments.length; i++) {\n      ctorArgs[i - 1] = arguments[i];\n    }\n    return /** @type {!Function} */ (caller.superClass_).constructor.apply(me, ctorArgs);\n  }\n  if (typeof opt_methodName != \"string\" && typeof opt_methodName != \"symbol\") {\n    throw new Error(\"method names provided to goog.base must be a string or a symbol\");\n  }\n  var args = new Array(arguments.length - 2);\n  for (var i = 2; i < arguments.length; i++) {\n    args[i - 2] = arguments[i];\n  }\n  var foundCaller = false;\n  for (var proto = me.constructor.prototype; proto; proto = Object.getPrototypeOf(proto)) {\n    if (proto[opt_methodName] === caller) {\n      foundCaller = true;\n    } else {\n      if (foundCaller) {\n        return proto[opt_methodName].apply(me, args);\n      }\n    }\n  }\n  if (me[opt_methodName] === caller) {\n    return me.constructor.prototype[opt_methodName].apply(me, args);\n  } else {\n    throw new Error(\"goog.base called from a method of one name \" + \"to a method of a different name\");\n  }\n};\n/**\n * @param {function()} fn\n */\ngoog.scope = function(fn) {\n  if (goog.isInModuleLoader_()) {\n    throw new Error(\"goog.scope is not supported within a module.\");\n  }\n  fn.call(goog.global);\n};\nif (!COMPILED) {\n  goog.global[\"COMPILED\"] = COMPILED;\n}\n/**\n * @param {Function} superClass\n * @param {goog.defineClass.ClassDescriptor} def\n * @return {!Function}\n * @deprecated Use ES6 class syntax instead.\n */\ngoog.defineClass = function(superClass, def) {\n  var constructor = def.constructor;\n  var statics = def.statics;\n  if (!constructor || constructor == Object.prototype.constructor) {\n    constructor = function() {\n      throw new Error(\"cannot instantiate an interface (no constructor defined).\");\n    };\n  }\n  var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);\n  if (superClass) {\n    goog.inherits(cls, superClass);\n  }\n  delete def.constructor;\n  delete def.statics;\n  goog.defineClass.applyProperties_(cls.prototype, def);\n  if (statics != null) {\n    if (statics instanceof Function) {\n      statics(cls);\n    } else {\n      goog.defineClass.applyProperties_(cls, statics);\n    }\n  }\n  return cls;\n};\n/** @typedef {{constructor:(!Function|undefined),statics:(Object|undefined|function(Function):void)}} */ goog.defineClass.ClassDescriptor;\n/** @define {boolean} */ goog.defineClass.SEAL_CLASS_INSTANCES = goog.define(\"goog.defineClass.SEAL_CLASS_INSTANCES\", goog.DEBUG);\n/**\n * @private\n * @param {!Function} ctr\n * @param {Function} superClass\n * @return {!Function}\n */\ngoog.defineClass.createSealingConstructor_ = function(ctr, superClass) {\n  if (!goog.defineClass.SEAL_CLASS_INSTANCES) {\n    return ctr;\n  }\n  var superclassSealable = !goog.defineClass.isUnsealable_(superClass);\n  /**\n   * @this {Object}\n   * @return {?}\n   */\n  var wrappedCtr = function() {\n    var instance = ctr.apply(this, arguments) || this;\n    instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];\n    if (this.constructor === wrappedCtr && superclassSealable && Object.seal instanceof Function) {\n      Object.seal(instance);\n    }\n    return instance;\n  };\n  return wrappedCtr;\n};\n/**\n * @private\n * @param {Function} ctr\n * @return {boolean}\n */\ngoog.defineClass.isUnsealable_ = function(ctr) {\n  return ctr && ctr.prototype && ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];\n};\n/** @private @const @type {!Array<string>} */ goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [\"constructor\", \"hasOwnProperty\", \"isPrototypeOf\", \"propertyIsEnumerable\", \"toLocaleString\", \"toString\", \"valueOf\"];\n/**\n * @private\n * @param {!Object} target\n * @param {!Object} source\n */\ngoog.defineClass.applyProperties_ = function(target, source) {\n  var key;\n  for (key in source) {\n    if (Object.prototype.hasOwnProperty.call(source, key)) {\n      target[key] = source[key];\n    }\n  }\n  for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {\n    key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];\n    if (Object.prototype.hasOwnProperty.call(source, key)) {\n      target[key] = source[key];\n    }\n  }\n};\n/**\n * @param {!Function} ctr\n */\ngoog.tagUnsealableClass = function(ctr) {\n  if (!COMPILED && goog.defineClass.SEAL_CLASS_INSTANCES) {\n    ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = true;\n  }\n};\n/** @private @const @type {string} */ goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = \"goog_defineClass_legacy_unsealable\";\nif (!COMPILED && goog.DEPENDENCIES_ENABLED) {\n  /**\n   * @private\n   * @return {boolean}\n   */\n  goog.inHtmlDocument_ = function() {\n    /** @type {!Document} */ var doc = goog.global.document;\n    return doc != null && \"write\" in doc;\n  };\n  /**\n   * @private\n   * @return {boolean}\n   */\n  goog.isDocumentLoading_ = function() {\n    /** @type {!HTMLDocument} */ var doc = goog.global.document;\n    return doc.attachEvent ? doc.readyState != \"complete\" : doc.readyState == \"loading\";\n  };\n  /** @private */ goog.findBasePath_ = function() {\n    if (goog.global.CLOSURE_BASE_PATH != undefined && typeof goog.global.CLOSURE_BASE_PATH === \"string\") {\n      goog.basePath = goog.global.CLOSURE_BASE_PATH;\n      return;\n    } else {\n      if (!goog.inHtmlDocument_()) {\n        return;\n      }\n    }\n    /** @type {!Document} */ var doc = goog.global.document;\n    var currentScript = doc.currentScript;\n    if (currentScript) {\n      var scripts = [currentScript];\n    } else {\n      var scripts = doc.getElementsByTagName(\"SCRIPT\");\n    }\n    for (var i = scripts.length - 1; i >= 0; --i) {\n      var script = /** @type {!HTMLScriptElement} */ (scripts[i]);\n      var src = script.src;\n      var qmark = src.lastIndexOf(\"?\");\n      var l = qmark == -1 ? src.length : qmark;\n      if (src.substr(l - 7, 7) == \"base.js\") {\n        goog.basePath = src.substr(0, l - 7);\n        return;\n      }\n    }\n  };\n  goog.findBasePath_();\n  /** @final @struct @constructor */ goog.Transpiler = function() {\n    /** @private @type {?Object<string,boolean>} */ this.requiresTranspilation_ = null;\n    /** @private @type {string} */ this.transpilationTarget_ = goog.TRANSPILE_TO_LANGUAGE;\n  };\n  /**\n   * @private\n   * @return {{target:string,map:!Object<string,boolean>}}\n   */\n  goog.Transpiler.prototype.createRequiresTranspilation_ = function() {\n    var transpilationTarget = \"es3\";\n    var /** !Object<string,boolean> */ requiresTranspilation = {\"es3\":false};\n    var transpilationRequiredForAllLaterModes = false;\n    /**\n     * @param {string} modeName\n     * @param {function():boolean} isSupported\n     */\n    function addNewerLanguageTranspilationCheck(modeName, isSupported) {\n      if (transpilationRequiredForAllLaterModes) {\n        requiresTranspilation[modeName] = true;\n      } else {\n        if (isSupported()) {\n          transpilationTarget = modeName;\n          requiresTranspilation[modeName] = false;\n        } else {\n          requiresTranspilation[modeName] = true;\n          transpilationRequiredForAllLaterModes = true;\n        }\n      }\n    }\n    function/** boolean */ evalCheck(/** string */ code) {\n      try {\n        return !!eval(code);\n      } catch (ignored) {\n        return false;\n      }\n    }\n    var userAgent = goog.global.navigator && goog.global.navigator.userAgent ? goog.global.navigator.userAgent : \"\";\n    addNewerLanguageTranspilationCheck(\"es5\", function() {\n      return evalCheck(\"[1,].length\\x3d\\x3d1\");\n    });\n    addNewerLanguageTranspilationCheck(\"es6\", function() {\n      var re = /Edge\\/(\\d+)(\\.\\d)*/i;\n      var edgeUserAgent = userAgent.match(re);\n      if (edgeUserAgent) {\n        return false;\n      }\n      var es6fullTest = \"class X{constructor(){if(new.target!\\x3dString)throw 1;this.x\\x3d42}}\" + \"let q\\x3dReflect.construct(X,[],String);if(q.x!\\x3d42||!(q instanceof \" + \"String))throw 1;for(const a of[2,3]){if(a\\x3d\\x3d2)continue;function \" + \"f(z\\x3d{a}){let a\\x3d0;return z.a}{function f(){return 0;}}return f()\" + \"\\x3d\\x3d3}\";\n      return evalCheck('(()\\x3d\\x3e{\"use strict\";' + es6fullTest + \"})()\");\n    });\n    addNewerLanguageTranspilationCheck(\"es7\", function() {\n      return evalCheck(\"2 ** 2 \\x3d\\x3d 4\");\n    });\n    addNewerLanguageTranspilationCheck(\"es8\", function() {\n      return evalCheck(\"async () \\x3d\\x3e 1, true\");\n    });\n    addNewerLanguageTranspilationCheck(\"es9\", function() {\n      return evalCheck(\"({...rest} \\x3d {}), true\");\n    });\n    addNewerLanguageTranspilationCheck(\"es_next\", function() {\n      return false;\n    });\n    return {target:transpilationTarget, map:requiresTranspilation};\n  };\n  /**\n   * @param {string} lang\n   * @param {(string|undefined)} module\n   * @return {boolean}\n   */\n  goog.Transpiler.prototype.needsTranspile = function(lang, module) {\n    if (goog.TRANSPILE == \"always\") {\n      return true;\n    } else {\n      if (goog.TRANSPILE == \"never\") {\n        return false;\n      } else {\n        if (!this.requiresTranspilation_) {\n          var obj = this.createRequiresTranspilation_();\n          this.requiresTranspilation_ = obj.map;\n          this.transpilationTarget_ = this.transpilationTarget_ || obj.target;\n        }\n      }\n    }\n    if (lang in this.requiresTranspilation_) {\n      if (this.requiresTranspilation_[lang]) {\n        return true;\n      } else {\n        if (goog.inHtmlDocument_() && module == \"es6\" && !(\"noModule\" in goog.global.document.createElement(\"script\"))) {\n          return true;\n        } else {\n          return false;\n        }\n      }\n    } else {\n      throw new Error(\"Unknown language mode: \" + lang);\n    }\n  };\n  /**\n   * @param {string} code\n   * @param {string} path\n   * @return {string}\n   */\n  goog.Transpiler.prototype.transpile = function(code, path) {\n    return goog.transpile_(code, path, this.transpilationTarget_);\n  };\n  /** @private @final @type {!goog.Transpiler} */ goog.transpiler_ = new goog.Transpiler;\n  /**\n   * @private\n   * @param {string} str\n   * @return {string}\n   */\n  goog.protectScriptTag_ = function(str) {\n    return str.replace(/<\\/(SCRIPT)/ig, \"\\\\x3c/$1\");\n  };\n  /** @private @final @struct @constructor */ goog.DebugLoader_ = function() {\n    /** @private @const @type {!Object<string,!goog.Dependency>} */ this.dependencies_ = {};\n    /** @private @const @type {!Object<string,string>} */ this.idToPath_ = {};\n    /** @private @const @type {!Object<string,boolean>} */ this.written_ = {};\n    /** @private @const @type {!Array<!goog.Dependency>} */ this.loadingDeps_ = [];\n    /** @private @type {!Array<!goog.Dependency>} */ this.depsToLoad_ = [];\n    /** @private @type {boolean} */ this.paused_ = false;\n    /** @private @type {!goog.DependencyFactory} */ this.factory_ = new goog.DependencyFactory(goog.transpiler_);\n    /** @private @const @type {!Object<string,!Function>} */ this.deferredCallbacks_ = {};\n    /** @private @const @type {!Array<string>} */ this.deferredQueue_ = [];\n  };\n  /**\n   * @param {!Array<string>} namespaces\n   * @param {function():undefined} callback\n   */\n  goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {\n    var cb = callback;\n    function resolve() {\n      if (cb) {\n        goog.global.setTimeout(cb, 0);\n        cb = null;\n      }\n    }\n    if (!namespaces.length) {\n      resolve();\n      return;\n    }\n    var deps = [];\n    for (var i = 0; i < namespaces.length; i++) {\n      var path = this.getPathFromDeps_(namespaces[i]);\n      if (!path) {\n        throw new Error(\"Unregonized namespace: \" + namespaces[i]);\n      }\n      deps.push(this.dependencies_[path]);\n    }\n    var require = goog.require;\n    var loaded = 0;\n    for (var i = 0; i < namespaces.length; i++) {\n      require(namespaces[i]);\n      deps[i].onLoad(function() {\n        if (++loaded == namespaces.length) {\n          resolve();\n        }\n      });\n    }\n  };\n  goog.DebugLoader_.prototype.loadClosureDeps = function() {\n    var relPath = \"deps.js\";\n    this.depsToLoad_.push(this.factory_.createDependency(goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {}, false));\n    this.loadDeps_();\n  };\n  /**\n   * @param {string} absPathOrId\n   * @param {boolean=} opt_force\n   */\n  goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {\n    var path = this.getPathFromDeps_(absPathOrId);\n    if (path && (opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {\n      var callback = this.deferredCallbacks_[path];\n      if (callback) {\n        delete this.deferredCallbacks_[path];\n        callback();\n      }\n    }\n  };\n  /**\n   * @param {!goog.DependencyFactory} factory\n   */\n  goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {\n    this.factory_ = factory;\n  };\n  /**\n   * @private\n   * @param {string} namespace\n   */\n  goog.DebugLoader_.prototype.load_ = function(namespace) {\n    if (!this.getPathFromDeps_(namespace)) {\n      var errorMessage = \"goog.require could not find: \" + namespace;\n      goog.logToConsole_(errorMessage);\n      throw Error(errorMessage);\n    } else {\n      var loader = this;\n      var deps = [];\n      /**\n       * @param {string} namespace\n       */\n      var visit = function(namespace) {\n        var path = loader.getPathFromDeps_(namespace);\n        if (!path) {\n          throw new Error(\"Bad dependency path or symbol: \" + namespace);\n        }\n        if (loader.written_[path]) {\n          return;\n        }\n        loader.written_[path] = true;\n        var dep = loader.dependencies_[path];\n        for (var i = 0; i < dep.requires.length; i++) {\n          if (!goog.isProvided_(dep.requires[i])) {\n            visit(dep.requires[i]);\n          }\n        }\n        deps.push(dep);\n      };\n      visit(namespace);\n      var wasLoading = !!this.depsToLoad_.length;\n      this.depsToLoad_ = this.depsToLoad_.concat(deps);\n      if (!this.paused_ && !wasLoading) {\n        this.loadDeps_();\n      }\n    }\n  };\n  /** @private */ goog.DebugLoader_.prototype.loadDeps_ = function() {\n    var loader = this;\n    var paused = this.paused_;\n    while (this.depsToLoad_.length && !paused) {\n      (function() {\n        var loadCallDone = false;\n        var dep = loader.depsToLoad_.shift();\n        var loaded = false;\n        loader.loading_(dep);\n        var controller = {pause:function() {\n          if (loadCallDone) {\n            throw new Error(\"Cannot call pause after the call to load.\");\n          } else {\n            paused = true;\n          }\n        }, resume:function() {\n          if (loadCallDone) {\n            loader.resume_();\n          } else {\n            paused = false;\n          }\n        }, loaded:function() {\n          if (loaded) {\n            throw new Error(\"Double call to loaded.\");\n          }\n          loaded = true;\n          loader.loaded_(dep);\n        }, pending:function() {\n          var pending = [];\n          for (var i = 0; i < loader.loadingDeps_.length; i++) {\n            pending.push(loader.loadingDeps_[i]);\n          }\n          return pending;\n        }, /**\n         * @param {goog.ModuleType} type\n         */\n        setModuleState:function(type) {\n          goog.moduleLoaderState_ = {type:type, moduleName:\"\", declareLegacyNamespace:false};\n        }, /** @type {function(string,string,string=)} */ registerEs6ModuleExports:function(path, exports, opt_closureNamespace) {\n          if (opt_closureNamespace) {\n            goog.loadedModules_[opt_closureNamespace] = {exports:exports, type:goog.ModuleType.ES6, moduleId:opt_closureNamespace || \"\"};\n          }\n        }, /** @type {function(string,?)} */ registerGoogModuleExports:function(moduleId, exports) {\n          goog.loadedModules_[moduleId] = {exports:exports, type:goog.ModuleType.GOOG, moduleId:moduleId};\n        }, clearModuleState:function() {\n          goog.moduleLoaderState_ = null;\n        }, defer:function(callback) {\n          if (loadCallDone) {\n            throw new Error(\"Cannot register with defer after the call to load.\");\n          }\n          loader.defer_(dep, callback);\n        }, areDepsLoaded:function() {\n          return loader.areDepsLoaded_(dep.requires);\n        }};\n        try {\n          dep.load(controller);\n        } finally {\n          loadCallDone = true;\n        }\n      })();\n    }\n    if (paused) {\n      this.pause_();\n    }\n  };\n  /** @private */ goog.DebugLoader_.prototype.pause_ = function() {\n    this.paused_ = true;\n  };\n  /** @private */ goog.DebugLoader_.prototype.resume_ = function() {\n    if (this.paused_) {\n      this.paused_ = false;\n      this.loadDeps_();\n    }\n  };\n  /**\n   * @private\n   * @param {!goog.Dependency} dep\n   */\n  goog.DebugLoader_.prototype.loading_ = function(dep) {\n    this.loadingDeps_.push(dep);\n  };\n  /**\n   * @private\n   * @param {!goog.Dependency} dep\n   */\n  goog.DebugLoader_.prototype.loaded_ = function(dep) {\n    for (var i = 0; i < this.loadingDeps_.length; i++) {\n      if (this.loadingDeps_[i] == dep) {\n        this.loadingDeps_.splice(i, 1);\n        break;\n      }\n    }\n    for (var i = 0; i < this.deferredQueue_.length; i++) {\n      if (this.deferredQueue_[i] == dep.path) {\n        this.deferredQueue_.splice(i, 1);\n        break;\n      }\n    }\n    if (this.loadingDeps_.length == this.deferredQueue_.length && !this.depsToLoad_.length) {\n      while (this.deferredQueue_.length) {\n        this.requested(this.deferredQueue_.shift(), true);\n      }\n    }\n    dep.loaded();\n  };\n  /**\n   * @private\n   * @param {!Array<string>} pathsOrIds\n   * @return {boolean}\n   */\n  goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {\n    for (var i = 0; i < pathsOrIds.length; i++) {\n      var path = this.getPathFromDeps_(pathsOrIds[i]);\n      if (!path || !(path in this.deferredCallbacks_) && !goog.isProvided_(pathsOrIds[i])) {\n        return false;\n      }\n    }\n    return true;\n  };\n  /**\n   * @private\n   * @param {string} absPathOrId\n   * @return {?string}\n   */\n  goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {\n    if (absPathOrId in this.idToPath_) {\n      return this.idToPath_[absPathOrId];\n    } else {\n      if (absPathOrId in this.dependencies_) {\n        return absPathOrId;\n      } else {\n        return null;\n      }\n    }\n  };\n  /**\n   * @private\n   * @param {!goog.Dependency} dependency\n   * @param {!Function} callback\n   */\n  goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {\n    this.deferredCallbacks_[dependency.path] = callback;\n    this.deferredQueue_.push(dependency.path);\n  };\n  /** @record */ goog.LoadController = function() {\n  };\n  goog.LoadController.prototype.pause = function() {\n  };\n  goog.LoadController.prototype.resume = function() {\n  };\n  goog.LoadController.prototype.loaded = function() {\n  };\n  /**\n   * @return {!Array<!goog.Dependency>}\n   */\n  goog.LoadControll