1242 lines
43 KiB
JavaScript
1242 lines
43 KiB
JavaScript
var COMPILED = false;
|
|
var goog = goog || {};
|
|
goog.global = this || self;
|
|
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(/</g, "\x3c").replace(/>/g, "\x3e").replace(/'/g, "'").replace(/"/g, '"').replace(/&/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
|