3147 lines
104 KiB
JavaScript
3147 lines
104 KiB
JavaScript
#!/usr/bin/env node
|
|
(function(){
|
|
|
|
var SHADOW_IMPORT_PATH = __dirname + '/../.shadow-cljs/builds/app/dev/out/cljs-runtime';
|
|
if (__dirname == '.') { SHADOW_IMPORT_PATH = "/home/lxsameer/.fg42/john_titor/.shadow-cljs/builds/app/dev/out/cljs-runtime"; }
|
|
global.$CLJS = global;
|
|
try {require('source-map-support').install();} catch (e) {console.warn('no "source-map-support" (run "npm install source-map-support --save-dev" to get it)');}
|
|
|
|
global.CLOSURE_NO_DEPS = true;
|
|
|
|
global.CLOSURE_DEFINES = {"shadow.cljs.devtools.client.env.repl_pprint":false,"shadow.cljs.devtools.client.env.devtools_url":"","shadow.cljs.devtools.client.env.autoload":false,"shadow.cljs.devtools.client.env.proc_id":"0893bd36-0953-4220-b00e-ea1a689dfb58","goog.ENABLE_DEBUG_LOADER":false,"shadow.cljs.devtools.client.env.server_port":9630,"shadow.cljs.devtools.client.env.use_document_host":true,"shadow.cljs.devtools.client.env.module_format":"goog","goog.LOCALE":"en","shadow.cljs.devtools.client.env.build_id":"app","shadow.cljs.devtools.client.env.ignore_warnings":false,"goog.DEBUG":true,"cljs.core._STAR_target_STAR_":"nodejs","shadow.cljs.devtools.client.env.ssl":false,"shadow.cljs.devtools.client.env.enabled":true,"shadow.cljs.devtools.client.env.server_host":"localhost","goog.TRANSPILE":"never"};
|
|
|
|
var goog = global.goog = {};
|
|
|
|
var SHADOW_IMPORTED = global.SHADOW_IMPORTED = {};
|
|
var PATH = require("path");
|
|
var VM = require("vm");
|
|
var FS = require("fs");
|
|
|
|
var SHADOW_PROVIDE = function(name) {
|
|
return goog.exportPath_(name, undefined);
|
|
};
|
|
|
|
var SHADOW_REQUIRE = function(name) {
|
|
return true;
|
|
};
|
|
|
|
var SHADOW_WRAP = function(js) {
|
|
var code = "(function (require, module, __filename, __dirname) {\n";
|
|
// this is part of goog/base.js and for some reason the only global var not on goog or goog.global
|
|
code += "var COMPILED = false;\n"
|
|
code += js;
|
|
code += "\n});";
|
|
return code;
|
|
};
|
|
|
|
var SHADOW_IMPORT = global.SHADOW_IMPORT = function(src) {
|
|
if (CLOSURE_DEFINES["shadow.debug"]) {
|
|
console.info("SHADOW load:", src);
|
|
}
|
|
|
|
SHADOW_IMPORTED[src] = true;
|
|
|
|
// SHADOW_IMPORT_PATH is an absolute path
|
|
var filePath = PATH.resolve(SHADOW_IMPORT_PATH, src);
|
|
|
|
var js = FS.readFileSync(filePath);
|
|
|
|
var code = SHADOW_WRAP(js);
|
|
|
|
var fn = VM.runInThisContext(code,
|
|
{filename: filePath,
|
|
lineOffset: -2, // see SHADOW_WRAP, adds 2 lines
|
|
displayErrors: true
|
|
});
|
|
|
|
// the comment is for source-map-support which unfortunately shows the wrong piece of code but the stack is correct
|
|
try {
|
|
/* ignore this, look at stacktrace */ fn.call(global, require, module, __filename, __dirname);
|
|
} catch (e) {
|
|
console.error("SHADOW import error", filePath);
|
|
throw e;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
global.SHADOW_NODE_EVAL = function(js, smJson) {
|
|
if (smJson) {
|
|
js += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,";
|
|
js += Buffer.from(smJson).toString('base64');
|
|
}
|
|
|
|
// console.log(js);
|
|
|
|
return VM.runInThisContext.call(global, js,
|
|
{filename: "<eval>",
|
|
lineOffset: 0,
|
|
displayErrors: true});
|
|
};
|
|
|
|
// Copyright 2006 The Closure Library Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS-IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
/**
|
|
* @fileoverview Bootstrap for the Google JS Library (Closure).
|
|
*
|
|
* In uncompiled mode base.js will attempt to load Closure's deps file, unless
|
|
* the global <code>CLOSURE_NO_DEPS</code> is set to true. This allows projects
|
|
* to include their own deps file(s) from different locations.
|
|
*
|
|
* Avoid including base.js more than once. This is strictly discouraged and not
|
|
* supported. goog.require(...) won't work properly in that case.
|
|
*
|
|
* @provideGoog
|
|
*/
|
|
|
|
|
|
/**
|
|
* @define {boolean} Overridden to true by the compiler.
|
|
*/
|
|
var COMPILED = false;
|
|
|
|
|
|
/**
|
|
* Base namespace for the Closure library. Checks to see goog is already
|
|
* defined in the current scope before assigning to prevent clobbering if
|
|
* base.js is loaded more than once.
|
|
*
|
|
* @const
|
|
*/
|
|
var goog = goog || {};
|
|
|
|
|
|
/**
|
|
* Reference to the global context. In most cases this will be 'window'.
|
|
*/
|
|
goog.global = global;
|
|
|
|
|
|
/**
|
|
* A hook for overriding the define values in uncompiled mode.
|
|
*
|
|
* In uncompiled mode, {@code CLOSURE_UNCOMPILED_DEFINES} may be defined before
|
|
* loading base.js. If a key is defined in {@code CLOSURE_UNCOMPILED_DEFINES},
|
|
* {@code goog.define} will use the value instead of the default value. This
|
|
* allows flags to be overwritten without compilation (this is normally
|
|
* accomplished with the compiler's "define" flag).
|
|
*
|
|
* Example:
|
|
* <pre>
|
|
* var CLOSURE_UNCOMPILED_DEFINES = {'goog.DEBUG': false};
|
|
* </pre>
|
|
*
|
|
* @type {Object<string, (string|number|boolean)>|undefined}
|
|
*/
|
|
goog.global.CLOSURE_UNCOMPILED_DEFINES;
|
|
|
|
|
|
/**
|
|
* A hook for overriding the define values in uncompiled or compiled mode,
|
|
* like CLOSURE_UNCOMPILED_DEFINES but effective in compiled code. In
|
|
* uncompiled code CLOSURE_UNCOMPILED_DEFINES takes precedence.
|
|
*
|
|
* Also unlike CLOSURE_UNCOMPILED_DEFINES the values must be number, boolean or
|
|
* string literals or the compiler will emit an error.
|
|
*
|
|
* While any @define value may be set, only those set with goog.define will be
|
|
* effective for uncompiled code.
|
|
*
|
|
* Example:
|
|
* <pre>
|
|
* var CLOSURE_DEFINES = {'goog.DEBUG': false} ;
|
|
* </pre>
|
|
*
|
|
* @type {Object<string, (string|number|boolean)>|undefined}
|
|
*/
|
|
goog.global.CLOSURE_DEFINES;
|
|
|
|
|
|
/**
|
|
* Returns true if the specified value is not undefined.
|
|
*
|
|
* @param {?} val Variable to test.
|
|
* @return {boolean} Whether variable is defined.
|
|
*/
|
|
goog.isDef = function(val) {
|
|
// void 0 always evaluates to undefined and hence we do not need to depend on
|
|
// the definition of the global variable named 'undefined'.
|
|
return val !== void 0;
|
|
};
|
|
|
|
/**
|
|
* Returns true if the specified value is a string.
|
|
* @param {?} val Variable to test.
|
|
* @return {boolean} Whether variable is a string.
|
|
*/
|
|
goog.isString = function(val) {
|
|
return typeof val == 'string';
|
|
};
|
|
|
|
|
|
/**
|
|
* Returns true if the specified value is a boolean.
|
|
* @param {?} val Variable to test.
|
|
* @return {boolean} Whether variable is boolean.
|
|
*/
|
|
goog.isBoolean = function(val) {
|
|
return typeof val == 'boolean';
|
|
};
|
|
|
|
|
|
/**
|
|
* Returns true if the specified value is a number.
|
|
* @param {?} val Variable to test.
|
|
* @return {boolean} Whether variable is a number.
|
|
*/
|
|
goog.isNumber = function(val) {
|
|
return typeof val == 'number';
|
|
};
|
|
|
|
|
|
/**
|
|
* Builds an object structure for the provided namespace path, ensuring that
|
|
* names that already exist are not overwritten. For example:
|
|
* "a.b.c" -> a = {};a.b={};a.b.c={};
|
|
* Used by goog.provide and goog.exportSymbol.
|
|
* @param {string} name name of the object that this file defines.
|
|
* @param {*=} opt_object the object to expose at the end of the path.
|
|
* @param {Object=} opt_objectToExportTo The object to add the path to; default
|
|
* is `goog.global`.
|
|
* @private
|
|
*/
|
|
goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
|
|
var parts = name.split('.');
|
|
var cur = opt_objectToExportTo || goog.global;
|
|
|
|
// Internet Explorer exhibits strange behavior when throwing errors from
|
|
// methods externed in this manner. See the testExportSymbolExceptions in
|
|
// base_test.html for an example.
|
|
if (!(parts[0] in cur) && cur.execScript) {
|
|
cur.execScript('var ' + parts[0]);
|
|
}
|
|
|
|
for (var part; parts.length && (part = parts.shift());) {
|
|
if (!parts.length && goog.isDef(opt_object)) {
|
|
// last part and we have an object; use it
|
|
cur[part] = opt_object;
|
|
} else if (cur[part] && cur[part] !== Object.prototype[part]) {
|
|
cur = cur[part];
|
|
} else {
|
|
cur = cur[part] = {};
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Defines a named value. In uncompiled mode, the value is retrieved from
|
|
* CLOSURE_DEFINES or CLOSURE_UNCOMPILED_DEFINES if the object is defined and
|
|
* has the property specified, and otherwise used the defined defaultValue.
|
|
* When compiled the default can be overridden using the compiler
|
|
* options or the value set in the CLOSURE_DEFINES object.
|
|
*
|
|
* @param {string} name The distinguished name to provide.
|
|
* @param {string|number|boolean} defaultValue
|
|
*/
|
|
goog.define = function(name, defaultValue) {
|
|
var value = defaultValue;
|
|
if (!COMPILED) {
|
|
if (goog.global.CLOSURE_UNCOMPILED_DEFINES &&
|
|
// Anti DOM-clobbering runtime check (b/37736576).
|
|
/** @type {?} */ (goog.global.CLOSURE_UNCOMPILED_DEFINES).nodeType ===
|
|
undefined &&
|
|
Object.prototype.hasOwnProperty.call(
|
|
goog.global.CLOSURE_UNCOMPILED_DEFINES, name)) {
|
|
value = goog.global.CLOSURE_UNCOMPILED_DEFINES[name];
|
|
} else if (
|
|
goog.global.CLOSURE_DEFINES &&
|
|
// Anti DOM-clobbering runtime check (b/37736576).
|
|
/** @type {?} */ (goog.global.CLOSURE_DEFINES).nodeType === undefined &&
|
|
Object.prototype.hasOwnProperty.call(
|
|
goog.global.CLOSURE_DEFINES, name)) {
|
|
value = goog.global.CLOSURE_DEFINES[name];
|
|
}
|
|
}
|
|
goog.exportPath_(name, value);
|
|
};
|
|
|
|
|
|
/**
|
|
* @define {boolean} DEBUG is provided as a convenience so that debugging code
|
|
* that should not be included in a production. It can be easily stripped
|
|
* by specifying --define goog.DEBUG=false to the Closure Compiler aka
|
|
* JSCompiler. For example, most toString() methods should be declared inside an
|
|
* "if (goog.DEBUG)" conditional because they are generally used for debugging
|
|
* purposes and it is difficult for the JSCompiler to statically determine
|
|
* whether they are used.
|
|
*/
|
|
goog.define('goog.DEBUG', true);
|
|
|
|
|
|
/**
|
|
* @define {string} LOCALE defines the locale being used for compilation. It is
|
|
* used to select locale specific data to be compiled in js binary. BUILD rule
|
|
* can specify this value by "--define goog.LOCALE=<locale_name>" as a compiler
|
|
* option.
|
|
*
|
|
* Take into account that the locale code format is important. You should use
|
|
* the canonical Unicode format with hyphen as a delimiter. Language must be
|
|
* lowercase, Language Script - Capitalized, Region - UPPERCASE.
|
|
* There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.
|
|
*
|
|
* See more info about locale codes here:
|
|
* http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers
|
|
*
|
|
* For language codes you should use values defined by ISO 693-1. See it here
|
|
* http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from
|
|
* this rule: the Hebrew language. For legacy reasons the old code (iw) should
|
|
* be used instead of the new code (he).
|
|
*
|
|
*/
|
|
goog.define('goog.LOCALE', 'en'); // default to en
|
|
|
|
|
|
/**
|
|
* @define {boolean} Whether this code is running on trusted sites.
|
|
*
|
|
* On untrusted sites, several native functions can be defined or overridden by
|
|
* external libraries like Prototype, Datejs, and JQuery and setting this flag
|
|
* to false forces closure to use its own implementations when possible.
|
|
*
|
|
* If your JavaScript can be loaded by a third party site and you are wary about
|
|
* relying on non-standard implementations, specify
|
|
* "--define goog.TRUSTED_SITE=false" to the compiler.
|
|
*/
|
|
goog.define('goog.TRUSTED_SITE', true);
|
|
|
|
|
|
/**
|
|
* @define {boolean} Whether a project is expected to be running in strict mode.
|
|
*
|
|
* This define can be used to trigger alternate implementations compatible with
|
|
* running in EcmaScript Strict mode or warn about unavailable functionality.
|
|
* @see https://goo.gl/PudQ4y
|
|
*
|
|
*/
|
|
goog.define('goog.STRICT_MODE_COMPATIBLE', false);
|
|
|
|
|
|
/**
|
|
* @define {boolean} Whether code that calls {@link goog.setTestOnly} should
|
|
* be disallowed in the compilation unit.
|
|
*/
|
|
goog.define('goog.DISALLOW_TEST_ONLY_CODE', COMPILED && !goog.DEBUG);
|
|
|
|
|
|
/**
|
|
* @define {boolean} Whether to use a Chrome app CSP-compliant method for
|
|
* loading scripts via goog.require. @see appendScriptSrcNode_.
|
|
*/
|
|
goog.define('goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING', false);
|
|
|
|
|
|
/**
|
|
* Defines a namespace in Closure.
|
|
*
|
|
* A namespace may only be defined once in a codebase. It may be defined using
|
|
* goog.provide() or goog.module().
|
|
*
|
|
* The presence of one or more goog.provide() calls in a file indicates
|
|
* that the file defines the given objects/namespaces.
|
|
* Provided symbols must not be null or undefined.
|
|
*
|
|
* In addition, goog.provide() creates the object stubs for a namespace
|
|
* (for example, goog.provide("goog.foo.bar") will create the object
|
|
* goog.foo.bar if it does not already exist).
|
|
*
|
|
* Build tools also scan for provide/require/module statements
|
|
* to discern dependencies, build dependency files (see deps.js), etc.
|
|
*
|
|
* @see goog.require
|
|
* @see goog.module
|
|
* @param {string} name Namespace provided by this file in the form
|
|
* "goog.package.part".
|
|
*/
|
|
goog.provide = function(name) {
|
|
if (goog.isInModuleLoader_()) {
|
|
throw Error('goog.provide can not be used within a goog.module.');
|
|
}
|
|
if (!COMPILED) {
|
|
// Ensure that the same namespace isn't provided twice.
|
|
// A goog.module/goog.provide maps a goog.require to a specific file
|
|
if (goog.isProvided_(name)) {
|
|
throw Error('Namespace "' + name + '" already declared.');
|
|
}
|
|
}
|
|
|
|
goog.constructNamespace_(name);
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {string} name Namespace provided by this file in the form
|
|
* "goog.package.part".
|
|
* @param {Object=} opt_obj The object to embed in the namespace.
|
|
* @private
|
|
*/
|
|
goog.constructNamespace_ = function(name, opt_obj) {
|
|
if (!COMPILED) {
|
|
delete goog.implicitNamespaces_[name];
|
|
|
|
var namespace = name;
|
|
while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {
|
|
if (goog.getObjectByName(namespace)) {
|
|
break;
|
|
}
|
|
goog.implicitNamespaces_[namespace] = true;
|
|
}
|
|
}
|
|
|
|
goog.exportPath_(name, opt_obj);
|
|
};
|
|
|
|
|
|
/**
|
|
* Module identifier validation regexp.
|
|
* Note: This is a conservative check, it is very possible to be more lenient,
|
|
* the primary exclusion here is "/" and "\" and a leading ".", these
|
|
* restrictions are intended to leave the door open for using goog.require
|
|
* with relative file paths rather than module identifiers.
|
|
* @private
|
|
*/
|
|
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
|
|
|
|
|
|
/**
|
|
* Defines a module in Closure.
|
|
*
|
|
* Marks that this file must be loaded as a module and claims the namespace.
|
|
*
|
|
* A namespace may only be defined once in a codebase. It may be defined using
|
|
* goog.provide() or goog.module().
|
|
*
|
|
* goog.module() has three requirements:
|
|
* - goog.module may not be used in the same file as goog.provide.
|
|
* - goog.module must be the first statement in the file.
|
|
* - only one goog.module is allowed per file.
|
|
*
|
|
* When a goog.module annotated file is loaded, it is enclosed in
|
|
* a strict function closure. This means that:
|
|
* - any variables declared in a goog.module file are private to the file
|
|
* (not global), though the compiler is expected to inline the module.
|
|
* - The code must obey all the rules of "strict" JavaScript.
|
|
* - the file will be marked as "use strict"
|
|
*
|
|
* NOTE: unlike goog.provide, goog.module does not declare any symbols by
|
|
* itself. If declared symbols are desired, use
|
|
* goog.module.declareLegacyNamespace().
|
|
*
|
|
*
|
|
* See the public goog.module proposal: http://goo.gl/Va1hin
|
|
*
|
|
* @param {string} name Namespace provided by this file in the form
|
|
* "goog.package.part", is expected but not required.
|
|
* @return {void}
|
|
*/
|
|
goog.module = function(name) {
|
|
if (!goog.isString(name) || !name ||
|
|
name.search(goog.VALID_MODULE_RE_) == -1) {
|
|
throw Error('Invalid module identifier');
|
|
}
|
|
if (!goog.isInModuleLoader_()) {
|
|
throw Error(
|
|
'Module ' + name + ' has been loaded incorrectly. 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 Error('goog.module may only be called once per module.');
|
|
}
|
|
|
|
// Store the module name for the loader.
|
|
goog.moduleLoaderState_.moduleName = name;
|
|
if (!COMPILED) {
|
|
// Ensure that the same namespace isn't provided twice.
|
|
// A goog.module/goog.provide maps a goog.require to a specific file
|
|
if (goog.isProvided_(name)) {
|
|
throw Error('Namespace "' + name + '" already declared.');
|
|
}
|
|
delete goog.implicitNamespaces_[name];
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {string} name The module identifier.
|
|
* @return {?} The module exports for an already loaded module or null.
|
|
*
|
|
* Note: This is not an alternative to goog.require, it does not
|
|
* indicate a hard dependency, instead it is used to indicate
|
|
* an optional dependency or to access the exports of a module
|
|
* that has already been loaded.
|
|
* @suppress {missingProvide}
|
|
*/
|
|
goog.module.get = function(name) {
|
|
return goog.module.getInternal_(name);
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {string} name The module identifier.
|
|
* @return {?} The module exports for an already loaded module or null.
|
|
* @private
|
|
*/
|
|
goog.module.getInternal_ = function(name) {
|
|
if (!COMPILED) {
|
|
if (name in goog.loadedModules_) {
|
|
return goog.loadedModules_[name];
|
|
} else if (!goog.implicitNamespaces_[name]) {
|
|
var ns = goog.getObjectByName(name);
|
|
return ns != null ? ns : null;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
|
|
/**
|
|
* @private {?{moduleName: (string|undefined), declareLegacyNamespace:boolean}}
|
|
*/
|
|
goog.moduleLoaderState_ = null;
|
|
|
|
|
|
/**
|
|
* @private
|
|
* @return {boolean} Whether a goog.module is currently being initialized.
|
|
*/
|
|
goog.isInModuleLoader_ = function() {
|
|
return goog.moduleLoaderState_ != null;
|
|
};
|
|
|
|
|
|
/**
|
|
* Provide the module's exports as a globally accessible object under the
|
|
* module's declared name. This is intended to ease migration to goog.module
|
|
* for files that have existing usages.
|
|
* @suppress {missingProvide}
|
|
*/
|
|
goog.module.declareLegacyNamespace = function() {
|
|
if (!COMPILED && !goog.isInModuleLoader_()) {
|
|
throw new Error(
|
|
'goog.module.declareLegacyNamespace must be called from ' +
|
|
'within a goog.module');
|
|
}
|
|
if (!COMPILED && !goog.moduleLoaderState_.moduleName) {
|
|
throw Error(
|
|
'goog.module must be called prior to ' +
|
|
'goog.module.declareLegacyNamespace.');
|
|
}
|
|
goog.moduleLoaderState_.declareLegacyNamespace = true;
|
|
};
|
|
|
|
|
|
/**
|
|
* Marks that the current file should only be used for testing, and never for
|
|
* live code in production.
|
|
*
|
|
* In the case of unit tests, the message may optionally be an exact namespace
|
|
* for the test (e.g. 'goog.stringTest'). The linter will then ignore the extra
|
|
* provide (if not explicitly defined in the code).
|
|
*
|
|
* @param {string=} opt_message Optional message to add to the error that's
|
|
* raised when used in production code.
|
|
*/
|
|
goog.setTestOnly = function(opt_message) {
|
|
if (goog.DISALLOW_TEST_ONLY_CODE) {
|
|
opt_message = opt_message || '';
|
|
throw Error(
|
|
'Importing test-only code into non-debug environment' +
|
|
(opt_message ? ': ' + opt_message : '.'));
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Forward declares a symbol. This is an indication to the compiler that the
|
|
* symbol may be used in the source yet is not required and may not be provided
|
|
* in compilation.
|
|
*
|
|
* The most common usage of forward declaration is code that takes a type as a
|
|
* function parameter but does not need to require it. By forward declaring
|
|
* instead of requiring, no hard dependency is made, and (if not required
|
|
* elsewhere) the namespace may never be required and thus, not be pulled
|
|
* into the JavaScript binary. If it is required elsewhere, it will be type
|
|
* checked as normal.
|
|
*
|
|
* Before using goog.forwardDeclare, please read the documentation at
|
|
* https://github.com/google/closure-compiler/wiki/Bad-Type-Annotation to
|
|
* understand the options and tradeoffs when working with forward declarations.
|
|
*
|
|
* @param {string} name The namespace to forward declare in the form of
|
|
* "goog.package.part".
|
|
*/
|
|
goog.forwardDeclare = function(name) {};
|
|
|
|
|
|
/**
|
|
* Forward declare type information. Used to assign types to goog.global
|
|
* referenced object that would otherwise result in unknown type references
|
|
* and thus block property disambiguation.
|
|
*/
|
|
goog.forwardDeclare('Document');
|
|
goog.forwardDeclare('HTMLScriptElement');
|
|
goog.forwardDeclare('XMLHttpRequest');
|
|
|
|
|
|
if (!COMPILED) {
|
|
/**
|
|
* Check if the given name has been goog.provided. This will return false for
|
|
* names that are available only as implicit namespaces.
|
|
* @param {string} name name of the object to look for.
|
|
* @return {boolean} Whether the name has been provided.
|
|
* @private
|
|
*/
|
|
goog.isProvided_ = function(name) {
|
|
return (name in goog.loadedModules_) ||
|
|
(!goog.implicitNamespaces_[name] &&
|
|
goog.isDefAndNotNull(goog.getObjectByName(name)));
|
|
};
|
|
|
|
/**
|
|
* Namespaces implicitly defined by goog.provide. For example,
|
|
* goog.provide('goog.events.Event') implicitly declares that 'goog' and
|
|
* 'goog.events' must be namespaces.
|
|
*
|
|
* @type {!Object<string, (boolean|undefined)>}
|
|
* @private
|
|
*/
|
|
goog.implicitNamespaces_ = {'goog.module': true};
|
|
|
|
// NOTE: We add goog.module as an implicit namespace as goog.module is defined
|
|
// here and because the existing module package has not been moved yet out of
|
|
// the goog.module namespace. This satisifies both the debug loader and
|
|
// ahead-of-time dependency management.
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns an object based on its fully qualified external name. The object
|
|
* is not found if null or undefined. If you are using a compilation pass that
|
|
* renames property names beware that using this function will not find renamed
|
|
* properties.
|
|
*
|
|
* @param {string} name The fully qualified name.
|
|
* @param {Object=} opt_obj The object within which to look; default is
|
|
* |goog.global|.
|
|
* @return {?} The value (object or primitive) or, if not found, null.
|
|
*/
|
|
goog.getObjectByName = function(name, opt_obj) {
|
|
var parts = name.split('.');
|
|
var cur = opt_obj || goog.global;
|
|
for (var part; part = parts.shift();) {
|
|
if (goog.isDefAndNotNull(cur[part])) {
|
|
cur = cur[part];
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
return cur;
|
|
};
|
|
|
|
|
|
/**
|
|
* Globalizes a whole namespace, such as goog or goog.lang.
|
|
*
|
|
* @param {!Object} obj The namespace to globalize.
|
|
* @param {Object=} opt_global The object to add the properties to.
|
|
* @deprecated Properties may be explicitly exported to the global scope, but
|
|
* this should no longer be done in bulk.
|
|
*/
|
|
goog.globalize = function(obj, opt_global) {
|
|
var global = opt_global || goog.global;
|
|
for (var x in obj) {
|
|
global[x] = obj[x];
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Adds a dependency from a file to the files it requires.
|
|
* @param {string} relPath The path to the js file.
|
|
* @param {!Array<string>} provides An array of strings with
|
|
* the names of the objects this file provides.
|
|
* @param {!Array<string>} requires An array of strings with
|
|
* the names of the objects this file requires.
|
|
* @param {boolean|!Object<string>=} opt_loadFlags Parameters indicating
|
|
* how the file must be loaded. The boolean 'true' is equivalent
|
|
* to {'module': 'goog'} for backwards-compatibility. Valid properties
|
|
* and values include {'module': 'goog'} and {'lang': 'es6'}.
|
|
*/
|
|
goog.addDependency = function(relPath, provides, requires, opt_loadFlags) {
|
|
if (goog.DEPENDENCIES_ENABLED) {
|
|
var provide, require;
|
|
var path = relPath.replace(/\\/g, '/');
|
|
var deps = goog.dependencies_;
|
|
if (!opt_loadFlags || typeof opt_loadFlags === 'boolean') {
|
|
opt_loadFlags = opt_loadFlags ? {'module': 'goog'} : {};
|
|
}
|
|
for (var i = 0; provide = provides[i]; i++) {
|
|
deps.nameToPath[provide] = path;
|
|
deps.loadFlags[path] = opt_loadFlags;
|
|
}
|
|
for (var j = 0; require = requires[j]; j++) {
|
|
if (!(path in deps.requires)) {
|
|
deps.requires[path] = {};
|
|
}
|
|
deps.requires[path][require] = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
// NOTE(nnaze): The debug DOM loader was included in base.js as an original way
|
|
// to do "debug-mode" development. The dependency system can sometimes be
|
|
// confusing, as can the debug DOM loader's asynchronous nature.
|
|
//
|
|
// With the DOM loader, a call to goog.require() is not blocking -- the script
|
|
// will not load until some point after the current script. If a namespace is
|
|
// needed at runtime, it needs to be defined in a previous script, or loaded via
|
|
// require() with its registered dependencies.
|
|
//
|
|
// User-defined namespaces may need their own deps file. For a reference on
|
|
// creating a deps file, see:
|
|
// Externally: https://developers.google.com/closure/library/docs/depswriter
|
|
//
|
|
// Because of legacy clients, the DOM loader can't be easily removed from
|
|
// base.js. Work was done to make it disableable or replaceable for
|
|
// different environments (DOM-less JavaScript interpreters like Rhino or V8,
|
|
// for example). See bootstrap/ for more information.
|
|
|
|
|
|
/**
|
|
* @define {boolean} Whether to enable the debug loader.
|
|
*
|
|
* If enabled, a call to goog.require() will attempt to load the namespace by
|
|
* appending a script tag to the DOM (if the namespace has been registered).
|
|
*
|
|
* If disabled, goog.require() will simply assert that the namespace has been
|
|
* provided (and depend on the fact that some outside tool correctly ordered
|
|
* the script).
|
|
*/
|
|
goog.define('goog.ENABLE_DEBUG_LOADER', true);
|
|
|
|
|
|
/**
|
|
* @param {string} msg
|
|
* @private
|
|
*/
|
|
goog.logToConsole_ = function(msg) {
|
|
if (goog.global.console) {
|
|
goog.global.console['error'](msg);
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Implements a system for the dynamic resolution of dependencies that works in
|
|
* parallel with the BUILD system. Note that all calls to goog.require will be
|
|
* stripped by the compiler.
|
|
* @see goog.provide
|
|
* @param {string} name Namespace to include (as was given in goog.provide()) in
|
|
* the form "goog.package.part".
|
|
* @return {?} If called within a goog.module file, the associated namespace or
|
|
* module otherwise null.
|
|
*/
|
|
goog.require = function(name) {
|
|
// If the object already exists we do not need to do anything.
|
|
if (!COMPILED) {
|
|
if (goog.ENABLE_DEBUG_LOADER && goog.IS_OLD_IE_) {
|
|
goog.maybeProcessDeferredDep_(name);
|
|
}
|
|
|
|
if (goog.isProvided_(name)) {
|
|
if (goog.isInModuleLoader_()) {
|
|
return goog.module.getInternal_(name);
|
|
}
|
|
} else if (goog.ENABLE_DEBUG_LOADER) {
|
|
var path = goog.getPathFromDeps_(name);
|
|
if (path) {
|
|
goog.writeScripts_(path);
|
|
} else {
|
|
var errorMessage = 'goog.require could not find: ' + name;
|
|
goog.logToConsole_(errorMessage);
|
|
|
|
throw Error(errorMessage);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Path for included scripts.
|
|
* @type {string}
|
|
*/
|
|
goog.basePath = '';
|
|
|
|
|
|
/**
|
|
* A hook for overriding the base path.
|
|
* @type {string|undefined}
|
|
*/
|
|
goog.global.CLOSURE_BASE_PATH;
|
|
|
|
|
|
/**
|
|
* Whether to attempt to load Closure's deps file. By default, when uncompiled,
|
|
* deps files will attempt to be loaded.
|
|
* @type {boolean|undefined}
|
|
*/
|
|
goog.global.CLOSURE_NO_DEPS;
|
|
|
|
|
|
/**
|
|
* A function to import a single script. This is meant to be overridden when
|
|
* Closure is being run in non-HTML contexts, such as web workers. It's defined
|
|
* in the global scope so that it can be set before base.js is loaded, which
|
|
* allows deps.js to be imported properly.
|
|
*
|
|
* The function is passed the script source, which is a relative URI. It should
|
|
* return true if the script was imported, false otherwise.
|
|
* @type {(function(string): boolean)|undefined}
|
|
*/
|
|
goog.global.CLOSURE_IMPORT_SCRIPT;
|
|
|
|
|
|
/**
|
|
* Null function used for default values of callbacks, etc.
|
|
* @return {void} Nothing.
|
|
*/
|
|
goog.nullFunction = function() {};
|
|
|
|
|
|
/**
|
|
* When defining a class Foo with an abstract method bar(), you can do:
|
|
* Foo.prototype.bar = goog.abstractMethod
|
|
*
|
|
* Now if a subclass of Foo fails to override bar(), an error will be thrown
|
|
* when bar() is invoked.
|
|
*
|
|
* @type {!Function}
|
|
* @throws {Error} when invoked to indicate the method should be overridden.
|
|
*/
|
|
goog.abstractMethod = function() {
|
|
throw Error('unimplemented abstract method');
|
|
};
|
|
|
|
|
|
/**
|
|
* Adds a {@code getInstance} static method that always returns the same
|
|
* instance object.
|
|
* @param {!Function} ctor The constructor for the class to add the static
|
|
* method to.
|
|
*/
|
|
goog.addSingletonGetter = function(ctor) {
|
|
// instance_ is immediately set to prevent issues with sealed constructors
|
|
// such as are encountered when a constructor is returned as the export object
|
|
// of a goog.module in unoptimized code.
|
|
ctor.instance_ = undefined;
|
|
ctor.getInstance = function() {
|
|
if (ctor.instance_) {
|
|
return ctor.instance_;
|
|
}
|
|
if (goog.DEBUG) {
|
|
// NOTE: JSCompiler can't optimize away Array#push.
|
|
goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;
|
|
}
|
|
return ctor.instance_ = new ctor;
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
* All singleton classes that have been instantiated, for testing. Don't read
|
|
* it directly, use the {@code goog.testing.singleton} module. The compiler
|
|
* removes this variable if unused.
|
|
* @type {!Array<!Function>}
|
|
* @private
|
|
*/
|
|
goog.instantiatedSingletons_ = [];
|
|
|
|
|
|
/**
|
|
* @define {boolean} Whether to load goog.modules using {@code eval} when using
|
|
* the debug loader. This provides a better debugging experience as the
|
|
* source is unmodified and can be edited using Chrome Workspaces or similar.
|
|
* However in some environments the use of {@code eval} is banned
|
|
* so we provide an alternative.
|
|
*/
|
|
goog.define('goog.LOAD_MODULE_USING_EVAL', true);
|
|
|
|
|
|
/**
|
|
* @define {boolean} Whether the exports of goog.modules should be sealed when
|
|
* possible.
|
|
*/
|
|
goog.define('goog.SEAL_MODULE_EXPORTS', goog.DEBUG);
|
|
|
|
|
|
/**
|
|
* The registry of initialized modules:
|
|
* the module identifier to module exports map.
|
|
* @private @const {!Object<string, ?>}
|
|
*/
|
|
goog.loadedModules_ = {};
|
|
|
|
|
|
/**
|
|
* True if goog.dependencies_ is available.
|
|
* @const {boolean}
|
|
*/
|
|
goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;
|
|
|
|
|
|
/**
|
|
* @define {string} How to decide whether to transpile. Valid values
|
|
* are 'always', 'never', and 'detect'. The default ('detect') is to
|
|
* use feature detection to determine which language levels need
|
|
* transpilation.
|
|
*/
|
|
// NOTE(user): we could expand this to accept a language level to bypass
|
|
// detection: e.g. goog.TRANSPILE == 'es5' would transpile ES6 files but
|
|
// would leave ES3 and ES5 files alone.
|
|
goog.define('goog.TRANSPILE', 'detect');
|
|
|
|
|
|
/**
|
|
* @define {string} Path to the transpiler. Executing the script at this
|
|
* path (relative to base.js) should define a function $jscomp.transpile.
|
|
*/
|
|
goog.define('goog.TRANSPILER', 'transpile.js');
|
|
|
|
|
|
if (goog.DEPENDENCIES_ENABLED) {
|
|
/**
|
|
* This object is used to keep track of dependencies and other data that is
|
|
* used for loading scripts.
|
|
* @private
|
|
* @type {{
|
|
* loadFlags: !Object<string, !Object<string, string>>,
|
|
* nameToPath: !Object<string, string>,
|
|
* requires: !Object<string, !Object<string, boolean>>,
|
|
* visited: !Object<string, boolean>,
|
|
* written: !Object<string, boolean>,
|
|
* deferred: !Object<string, string>
|
|
* }}
|
|
*/
|
|
goog.dependencies_ = {
|
|
loadFlags: {}, // 1 to 1
|
|
|
|
nameToPath: {}, // 1 to 1
|
|
|
|
requires: {}, // 1 to many
|
|
|
|
// Used when resolving dependencies to prevent us from visiting file twice.
|
|
visited: {},
|
|
|
|
written: {}, // Used to keep track of script files we have written.
|
|
|
|
deferred: {} // Used to track deferred module evaluations in old IEs
|
|
};
|
|
|
|
|
|
/**
|
|
* Tries to detect whether is in the context of an HTML document.
|
|
* @return {boolean} True if it looks like HTML document.
|
|
* @private
|
|
*/
|
|
goog.inHtmlDocument_ = function() {
|
|
/** @type {Document} */
|
|
var doc = goog.global.document;
|
|
return doc != null && 'write' in doc; // XULDocument misses write.
|
|
};
|
|
|
|
|
|
/**
|
|
* Tries to detect the base path of base.js script that bootstraps Closure.
|
|
* @private
|
|
*/
|
|
goog.findBasePath_ = function() {
|
|
if (goog.isDef(goog.global.CLOSURE_BASE_PATH) &&
|
|
// Anti DOM-clobbering runtime check (b/37736576).
|
|
goog.isString(goog.global.CLOSURE_BASE_PATH)) {
|
|
goog.basePath = goog.global.CLOSURE_BASE_PATH;
|
|
return;
|
|
} else if (!goog.inHtmlDocument_()) {
|
|
return;
|
|
}
|
|
/** @type {Document} */
|
|
var doc = goog.global.document;
|
|
// If we have a currentScript available, use it exclusively.
|
|
var currentScript = doc.currentScript;
|
|
if (currentScript) {
|
|
var scripts = [currentScript];
|
|
} else {
|
|
var scripts = doc.getElementsByTagName('SCRIPT');
|
|
}
|
|
// Search backwards since the current script is in almost all cases the one
|
|
// that has base.js.
|
|
for (var i = scripts.length - 1; i >= 0; --i) {
|
|
var script = /** @type {!HTMLScriptElement} */ (scripts[i]);
|
|
var src = script.src;
|
|
var qmark = src.lastIndexOf('?');
|
|
var l = qmark == -1 ? src.length : qmark;
|
|
if (src.substr(l - 7, 7) == 'base.js') {
|
|
goog.basePath = src.substr(0, l - 7);
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Imports a script if, and only if, that script hasn't already been imported.
|
|
* (Must be called at execution time)
|
|
* @param {string} src Script source.
|
|
* @param {string=} opt_sourceText The optionally source text to evaluate
|
|
* @private
|
|
*/
|
|
goog.importScript_ = function(src, opt_sourceText) {
|
|
var importScript =
|
|
goog.global.CLOSURE_IMPORT_SCRIPT || goog.writeScriptTag_;
|
|
if (importScript(src, opt_sourceText)) {
|
|
goog.dependencies_.written[src] = true;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Whether the browser is IE9 or earlier, which needs special handling
|
|
* for deferred modules.
|
|
* @const @private {boolean}
|
|
*/
|
|
goog.IS_OLD_IE_ =
|
|
!!(!goog.global.atob && goog.global.document && goog.global.document.all);
|
|
|
|
|
|
/**
|
|
* Whether IE9 or earlier is waiting on a dependency. This ensures that
|
|
* deferred modules that have no non-deferred dependencies actually get
|
|
* loaded, since if we defer them and then never pull in a non-deferred
|
|
* script, then `goog.loadQueuedModules_` will never be called. Instead,
|
|
* if not waiting on anything we simply don't defer in the first place.
|
|
* @private {boolean}
|
|
*/
|
|
goog.oldIeWaiting_ = false;
|
|
|
|
|
|
/**
|
|
* Given a URL initiate retrieval and execution of a script that needs
|
|
* pre-processing.
|
|
* @param {string} src Script source URL.
|
|
* @param {boolean} isModule Whether this is a goog.module.
|
|
* @param {boolean} needsTranspile Whether this source needs transpilation.
|
|
* @private
|
|
*/
|
|
goog.importProcessedScript_ = function(src, isModule, needsTranspile) {
|
|
// In an attempt to keep browsers from timing out loading scripts using
|
|
// synchronous XHRs, put each load in its own script block.
|
|
var bootstrap = 'goog.retrieveAndExec_("' + src + '", ' + isModule + ', ' +
|
|
needsTranspile + ');';
|
|
|
|
goog.importScript_('', bootstrap);
|
|
};
|
|
|
|
|
|
/** @private {!Array<string>} */
|
|
goog.queuedModules_ = [];
|
|
|
|
|
|
/**
|
|
* Return an appropriate module text. Suitable to insert into
|
|
* a script tag (that is unescaped).
|
|
* @param {string} srcUrl
|
|
* @param {string} scriptText
|
|
* @return {string}
|
|
* @private
|
|
*/
|
|
goog.wrapModule_ = function(srcUrl, scriptText) {
|
|
if (!goog.LOAD_MODULE_USING_EVAL || !goog.isDef(goog.global.JSON)) {
|
|
return '' +
|
|
'goog.loadModule(function(exports) {' +
|
|
'"use strict";' + scriptText +
|
|
'\n' + // terminate any trailing single line comment.
|
|
';return exports' +
|
|
'});' +
|
|
'\n//# sourceURL=' + srcUrl + '\n';
|
|
} else {
|
|
return '' +
|
|
'goog.loadModule(' +
|
|
goog.global.JSON.stringify(
|
|
scriptText + '\n//# sourceURL=' + srcUrl + '\n') +
|
|
');';
|
|
}
|
|
};
|
|
|
|
// On IE9 and earlier, it is necessary to handle
|
|
// deferred module loads. In later browsers, the
|
|
// code to be evaluated is simply inserted as a script
|
|
// block in the correct order. To eval deferred
|
|
// code at the right time, we piggy back on goog.require to call
|
|
// goog.maybeProcessDeferredDep_.
|
|
//
|
|
// The goog.requires are used both to bootstrap
|
|
// the loading process (when no deps are available) and
|
|
// declare that they should be available.
|
|
//
|
|
// Here we eval the sources, if all the deps are available
|
|
// either already eval'd or goog.require'd. This will
|
|
// be the case when all the dependencies have already
|
|
// been loaded, and the dependent module is loaded.
|
|
//
|
|
// But this alone isn't sufficient because it is also
|
|
// necessary to handle the case where there is no root
|
|
// that is not deferred. For that there we register for an event
|
|
// and trigger goog.loadQueuedModules_ handle any remaining deferred
|
|
// evaluations.
|
|
|
|
/**
|
|
* Handle any remaining deferred goog.module evals.
|
|
* @private
|
|
*/
|
|
goog.loadQueuedModules_ = function() {
|
|
var count = goog.queuedModules_.length;
|
|
if (count > 0) {
|
|
var queue = goog.queuedModules_;
|
|
goog.queuedModules_ = [];
|
|
for (var i = 0; i < count; i++) {
|
|
var path = queue[i];
|
|
goog.maybeProcessDeferredPath_(path);
|
|
}
|
|
}
|
|
goog.oldIeWaiting_ = false;
|
|
};
|
|
|
|
|
|
/**
|
|
* Eval the named module if its dependencies are
|
|
* available.
|
|
* @param {string} name The module to load.
|
|
* @private
|
|
*/
|
|
goog.maybeProcessDeferredDep_ = function(name) {
|
|
if (goog.isDeferredModule_(name) && goog.allDepsAreAvailable_(name)) {
|
|
var path = goog.getPathFromDeps_(name);
|
|
goog.maybeProcessDeferredPath_(goog.basePath + path);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @param {string} name The module to check.
|
|
* @return {boolean} Whether the name represents a
|
|
* module whose evaluation has been deferred.
|
|
* @private
|
|
*/
|
|
goog.isDeferredModule_ = function(name) {
|
|
var path = goog.getPathFromDeps_(name);
|
|
var loadFlags = path && goog.dependencies_.loadFlags[path] || {};
|
|
var languageLevel = loadFlags['lang'] || 'es3';
|
|
if (path && (loadFlags['module'] == 'goog' ||
|
|
goog.needsTranspile_(languageLevel))) {
|
|
var abspath = goog.basePath + path;
|
|
return (abspath) in goog.dependencies_.deferred;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* @param {string} name The module to check.
|
|
* @return {boolean} Whether the name represents a
|
|
* module whose declared dependencies have all been loaded
|
|
* (eval'd or a deferred module load)
|
|
* @private
|
|
*/
|
|
goog.allDepsAreAvailable_ = function(name) {
|
|
var path = goog.getPathFromDeps_(name);
|
|
if (path && (path in goog.dependencies_.requires)) {
|
|
for (var requireName in goog.dependencies_.requires[path]) {
|
|
if (!goog.isProvided_(requireName) &&
|
|
!goog.isDeferredModule_(requireName)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {string} abspath
|
|
* @private
|
|
*/
|
|
goog.maybeProcessDeferredPath_ = function(abspath) {
|
|
if (abspath in goog.dependencies_.deferred) {
|
|
var src = goog.dependencies_.deferred[abspath];
|
|
delete goog.dependencies_.deferred[abspath];
|
|
goog.globalEval(src);
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Load a goog.module from the provided URL. This is not a general purpose
|
|
* code loader and does not support late loading code, that is it should only
|
|
* be used during page load. This method exists to support unit tests and
|
|
* "debug" loaders that would otherwise have inserted script tags. Under the
|
|
* hood this needs to use a synchronous XHR and is not recommeneded for
|
|
* production code.
|
|
*
|
|
* The module's goog.requires must have already been satisified; an exception
|
|
* will be thrown if this is not the case. This assumption is that no
|
|
* "deps.js" file exists, so there is no way to discover and locate the
|
|
* module-to-be-loaded's dependencies and no attempt is made to do so.
|
|
*
|
|
* There should only be one attempt to load a module. If
|
|
* "goog.loadModuleFromUrl" is called for an already loaded module, an
|
|
* exception will be throw.
|
|
*
|
|
* @param {string} url The URL from which to attempt to load the goog.module.
|
|
*/
|
|
goog.loadModuleFromUrl = function(url) {
|
|
// Because this executes synchronously, we don't need to do any additional
|
|
// bookkeeping. When "goog.loadModule" the namespace will be marked as
|
|
// having been provided which is sufficient.
|
|
goog.retrieveAndExec_(url, true, false);
|
|
};
|
|
|
|
|
|
/**
|
|
* Writes a new script pointing to {@code src} directly into the DOM.
|
|
*
|
|
* NOTE: This method is not CSP-compliant. @see goog.appendScriptSrcNode_ for
|
|
* the fallback mechanism.
|
|
*
|
|
* @param {string} src The script URL.
|
|
* @private
|
|
*/
|
|
goog.writeScriptSrcNode_ = function(src) {
|
|
goog.global.document.write(
|
|
'<script type="text/javascript" src="' + src + '"></' +
|
|
'script>');
|
|
};
|
|
|
|
|
|
/**
|
|
* Appends a new script node to the DOM using a CSP-compliant mechanism. This
|
|
* method exists as a fallback for document.write (which is not allowed in a
|
|
* strict CSP context, e.g., Chrome apps).
|
|
*
|
|
* NOTE: This method is not analogous to using document.write to insert a
|
|
* <script> tag; specifically, the user agent will execute a script added by
|
|
* document.write immediately after the current script block finishes
|
|
* executing, whereas the DOM-appended script node will not be executed until
|
|
* the entire document is parsed and executed. That is to say, this script is
|
|
* added to the end of the script execution queue.
|
|
*
|
|
* The page must not attempt to call goog.required entities until after the
|
|
* document has loaded, e.g., in or after the window.onload callback.
|
|
*
|
|
* @param {string} src The script URL.
|
|
* @private
|
|
*/
|
|
goog.appendScriptSrcNode_ = function(src) {
|
|
/** @type {Document} */
|
|
var doc = goog.global.document;
|
|
var scriptEl =
|
|
/** @type {HTMLScriptElement} */ (doc.createElement('script'));
|
|
scriptEl.type = 'text/javascript';
|
|
scriptEl.src = src;
|
|
scriptEl.defer = false;
|
|
scriptEl.async = false;
|
|
doc.head.appendChild(scriptEl);
|
|
};
|
|
|
|
|
|
/**
|
|
* The default implementation of the import function. Writes a script tag to
|
|
* import the script.
|
|
*
|
|
* @param {string} src The script url.
|
|
* @param {string=} opt_sourceText The optionally source text to evaluate
|
|
* @return {boolean} True if the script was imported, false otherwise.
|
|
* @private
|
|
*/
|
|
goog.writeScriptTag_ = function(src, opt_sourceText) {
|
|
if (goog.inHtmlDocument_()) {
|
|
/** @type {!HTMLDocument} */
|
|
var doc = goog.global.document;
|
|
|
|
// If the user tries to require a new symbol after document load,
|
|
// something has gone terribly wrong. Doing a document.write would
|
|
// wipe out the page. This does not apply to the CSP-compliant method
|
|
// of writing script tags.
|
|
if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
|
|
doc.readyState == 'complete') {
|
|
// Certain test frameworks load base.js multiple times, which tries
|
|
// to write deps.js each time. If that happens, just fail silently.
|
|
// These frameworks wipe the page between each load of base.js, so this
|
|
// is OK.
|
|
var isDeps = /\bdeps.js$/.test(src);
|
|
if (isDeps) {
|
|
return false;
|
|
} else {
|
|
throw Error('Cannot write "' + src + '" after document load');
|
|
}
|
|
}
|
|
|
|
if (opt_sourceText === undefined) {
|
|
if (!goog.IS_OLD_IE_) {
|
|
if (goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {
|
|
goog.appendScriptSrcNode_(src);
|
|
} else {
|
|
goog.writeScriptSrcNode_(src);
|
|
}
|
|
} else {
|
|
goog.oldIeWaiting_ = true;
|
|
var state = ' onreadystatechange=\'goog.onScriptLoad_(this, ' +
|
|
++goog.lastNonModuleScriptIndex_ + ')\' ';
|
|
doc.write(
|
|
'<script type="text/javascript" src="' + src + '"' + state +
|
|
'></' +
|
|
'script>');
|
|
}
|
|
} else {
|
|
doc.write(
|
|
'<script type="text/javascript">' +
|
|
goog.protectScriptTag_(opt_sourceText) + '</' +
|
|
'script>');
|
|
}
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Rewrites closing script tags in input to avoid ending an enclosing script
|
|
* tag.
|
|
*
|
|
* @param {string} str
|
|
* @return {string}
|
|
* @private
|
|
*/
|
|
goog.protectScriptTag_ = function(str) {
|
|
return str.replace(/<\/(SCRIPT)/ig, '\\x3c/$1');
|
|
};
|
|
|
|
/**
|
|
* Determines whether the given language needs to be transpiled.
|
|
* @param {string} lang
|
|
* @return {boolean}
|
|
* @private
|
|
*/
|
|
goog.needsTranspile_ = function(lang) {
|
|
if (goog.TRANSPILE == 'always') {
|
|
return true;
|
|
} else if (goog.TRANSPILE == 'never') {
|
|
return false;
|
|
} else if (!goog.requiresTranspilation_) {
|
|
goog.requiresTranspilation_ = goog.createRequiresTranspilation_();
|
|
}
|
|
if (lang in goog.requiresTranspilation_) {
|
|
return goog.requiresTranspilation_[lang];
|
|
} else {
|
|
throw new Error('Unknown language mode: ' + lang);
|
|
}
|
|
};
|
|
|
|
/** @private {?Object<string, boolean>} */
|
|
goog.requiresTranspilation_ = null;
|
|
|
|
|
|
/** @private {number} */
|
|
goog.lastNonModuleScriptIndex_ = 0;
|
|
|
|
|
|
/**
|
|
* A readystatechange handler for legacy IE
|
|
* @param {?} script
|
|
* @param {number} scriptIndex
|
|
* @return {boolean}
|
|
* @private
|
|
*/
|
|
goog.onScriptLoad_ = function(script, scriptIndex) {
|
|
// for now load the modules when we reach the last script,
|
|
// later allow more inter-mingling.
|
|
if (script.readyState == 'complete' &&
|
|
goog.lastNonModuleScriptIndex_ == scriptIndex) {
|
|
goog.loadQueuedModules_();
|
|
}
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* Resolves dependencies based on the dependencies added using addDependency
|
|
* and calls importScript_ in the correct order.
|
|
* @param {string} pathToLoad The path from which to start discovering
|
|
* dependencies.
|
|
* @private
|
|
*/
|
|
goog.writeScripts_ = function(pathToLoad) {
|
|
/** @type {!Array<string>} The scripts we need to write this time. */
|
|
var scripts = [];
|
|
var seenScript = {};
|
|
var deps = goog.dependencies_;
|
|
|
|
/** @param {string} path */
|
|
function visitNode(path) {
|
|
if (path in deps.written) {
|
|
return;
|
|
}
|
|
|
|
// We have already visited this one. We can get here if we have cyclic
|
|
// dependencies.
|
|
if (path in deps.visited) {
|
|
return;
|
|
}
|
|
|
|
deps.visited[path] = true;
|
|
|
|
if (path in deps.requires) {
|
|
for (var requireName in deps.requires[path]) {
|
|
// If the required name is defined, we assume that it was already
|
|
// bootstrapped by other means.
|
|
if (!goog.isProvided_(requireName)) {
|
|
if (requireName in deps.nameToPath) {
|
|
visitNode(deps.nameToPath[requireName]);
|
|
} else {
|
|
throw Error('Undefined nameToPath for ' + requireName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!(path in seenScript)) {
|
|
seenScript[path] = true;
|
|
scripts.push(path);
|
|
}
|
|
}
|
|
|
|
visitNode(pathToLoad);
|
|
|
|
// record that we are going to load all these scripts.
|
|
for (var i = 0; i < scripts.length; i++) {
|
|
var path = scripts[i];
|
|
goog.dependencies_.written[path] = true;
|
|
}
|
|
|
|
// If a module is loaded synchronously then we need to
|
|
// clear the current inModuleLoader value, and restore it when we are
|
|
// done loading the current "requires".
|
|
var moduleState = goog.moduleLoaderState_;
|
|
goog.moduleLoaderState_ = null;
|
|
|
|
for (var i = 0; i < scripts.length; i++) {
|
|
var path = scripts[i];
|
|
if (path) {
|
|
var loadFlags = deps.loadFlags[path] || {};
|
|
var languageLevel = loadFlags['lang'] || 'es3';
|
|
var needsTranspile = goog.needsTranspile_(languageLevel);
|
|
if (loadFlags['module'] == 'goog' || needsTranspile) {
|
|
goog.importProcessedScript_(
|
|
goog.basePath + path, loadFlags['module'] == 'goog',
|
|
needsTranspile);
|
|
} else {
|
|
goog.importScript_(goog.basePath + path);
|
|
}
|
|
} else {
|
|
goog.moduleLoaderState_ = moduleState;
|
|
throw Error('Undefined script input');
|
|
}
|
|
}
|
|
|
|
// restore the current "module loading state"
|
|
goog.moduleLoaderState_ = moduleState;
|
|
};
|
|
|
|
|
|
/**
|
|
* Looks at the dependency rules and tries to determine the script file that
|
|
* fulfills a particular rule.
|
|
* @param {string} rule In the form goog.namespace.Class or project.script.
|
|
* @return {?string} Url corresponding to the rule, or null.
|
|
* @private
|
|
*/
|
|
goog.getPathFromDeps_ = function(rule) {
|
|
if (rule in goog.dependencies_.nameToPath) {
|
|
return goog.dependencies_.nameToPath[rule];
|
|
} else {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
goog.findBasePath_();
|
|
|
|
// Allow projects to manage the deps files themselves.
|
|
if (!goog.global.CLOSURE_NO_DEPS) {
|
|
goog.importScript_(goog.basePath + 'deps.js');
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @package {?boolean}
|
|
* Visible for testing.
|
|
*/
|
|
goog.hasBadLetScoping = null;
|
|
|
|
|
|
/**
|
|
* @return {boolean}
|
|
* @package Visible for testing.
|
|
*/
|
|
goog.useSafari10Workaround = function() {
|
|
if (goog.hasBadLetScoping == null) {
|
|
var hasBadLetScoping;
|
|
try {
|
|
hasBadLetScoping = !eval(
|
|
'"use strict";' +
|
|
'let x = 1; function f() { return typeof x; };' +
|
|
'f() == "number";');
|
|
} catch (e) {
|
|
// Assume that ES6 syntax isn't supported.
|
|
hasBadLetScoping = false;
|
|
}
|
|
goog.hasBadLetScoping = hasBadLetScoping;
|
|
}
|
|
return goog.hasBadLetScoping;
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {string} moduleDef
|
|
* @return {string}
|
|
* @package Visible for testing.
|
|
*/
|
|
goog.workaroundSafari10EvalBug = function(moduleDef) {
|
|
return '(function(){' + moduleDef +
|
|
'\n' + // Terminate any trailing single line comment.
|
|
';' + // Terminate any trailing expression.
|
|
'})();\n';
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {function(?):?|string} moduleDef The module definition.
|
|
*/
|
|
goog.loadModule = function(moduleDef) {
|
|
// NOTE: we allow function definitions to be either in the from
|
|
// of a string to eval (which keeps the original source intact) or
|
|
// in a eval forbidden environment (CSP) we allow a function definition
|
|
// which in its body must call {@code goog.module}, and return the exports
|
|
// of the module.
|
|
var previousState = goog.moduleLoaderState_;
|
|
try {
|
|
goog.moduleLoaderState_ = {
|
|
moduleName: undefined,
|
|
declareLegacyNamespace: false
|
|
};
|
|
var exports;
|
|
if (goog.isFunction(moduleDef)) {
|
|
exports = moduleDef.call(undefined, {});
|
|
} else if (goog.isString(moduleDef)) {
|
|
if (goog.useSafari10Workaround()) {
|
|
moduleDef = goog.workaroundSafari10EvalBug(moduleDef);
|
|
}
|
|
|
|
exports = goog.loadModuleFromSource_.call(undefined, moduleDef);
|
|
} else {
|
|
throw Error('Invalid module definition');
|
|
}
|
|
|
|
var moduleName = goog.moduleLoaderState_.moduleName;
|
|
if (!goog.isString(moduleName) || !moduleName) {
|
|
throw Error('Invalid module name \"' + moduleName + '\"');
|
|
}
|
|
|
|
// Don't seal legacy namespaces as they may be uses as a parent of
|
|
// another namespace
|
|
if (goog.moduleLoaderState_.declareLegacyNamespace) {
|
|
goog.constructNamespace_(moduleName, exports);
|
|
} else if (
|
|
goog.SEAL_MODULE_EXPORTS && Object.seal && typeof exports == 'object' &&
|
|
exports != null) {
|
|
Object.seal(exports);
|
|
}
|
|
|
|
goog.loadedModules_[moduleName] = exports;
|
|
} finally {
|
|
goog.moduleLoaderState_ = previousState;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* @private @const
|
|
*/
|
|
goog.loadModuleFromSource_ = /** @type {function(string):?} */ (function() {
|
|
// NOTE: we avoid declaring parameters or local variables here to avoid
|
|
// masking globals or leaking values into the module definition.
|
|
'use strict';
|
|
var exports = {};
|
|
eval(arguments[0]);
|
|
return exports;
|
|
});
|
|
|
|
|
|
/**
|
|
* Normalize a file path by removing redundant ".." and extraneous "." file
|
|
* path components.
|
|
* @param {string} path
|
|
* @return {string}
|
|
* @private
|
|
*/
|
|
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('/');
|
|
};
|
|
|
|
|
|
/**
|
|
* Provides a hook for loading a file when using Closure's goog.require() API
|
|
* with goog.modules. In particular this hook is provided to support Node.js.
|
|
*
|
|
* @type {(function(string):string)|undefined}
|
|
*/
|
|
goog.global.CLOSURE_LOAD_FILE_SYNC;
|
|
|
|
|
|
/**
|
|
* Loads file by synchronous XHR. Should not be used in production environments.
|
|
* @param {string} src Source URL.
|
|
* @return {?string} File contents, or null if load failed.
|
|
* @private
|
|
*/
|
|
goog.loadFileSync_ = function(src) {
|
|
if (goog.global.CLOSURE_LOAD_FILE_SYNC) {
|
|
return goog.global.CLOSURE_LOAD_FILE_SYNC(src);
|
|
} else {
|
|
try {
|
|
/** @type {XMLHttpRequest} */
|
|
var xhr = new goog.global['XMLHttpRequest']();
|
|
xhr.open('get', src, false);
|
|
xhr.send();
|
|
// NOTE: Successful http: requests have a status of 200, but successful
|
|
// file: requests may have a status of zero. Any other status, or a
|
|
// thrown exception (particularly in case of file: requests) indicates
|
|
// some sort of error, which we treat as a missing or unavailable file.
|
|
return xhr.status == 0 || xhr.status == 200 ? xhr.responseText : null;
|
|
} catch (err) {
|
|
// No need to rethrow or log, since errors should show up on their own.
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Retrieve and execute a script that needs some sort of wrapping.
|
|
* @param {string} src Script source URL.
|
|
* @param {boolean} isModule Whether to load as a module.
|
|
* @param {boolean} needsTranspile Whether to transpile down to ES3.
|
|
* @private
|
|
*/
|
|
goog.retrieveAndExec_ = function(src, isModule, needsTranspile) {
|
|
if (!COMPILED) {
|
|
// The full but non-canonicalized URL for later use.
|
|
var originalPath = src;
|
|
// Canonicalize the path, removing any /./ or /../ since Chrome's debugging
|
|
// console doesn't auto-canonicalize XHR loads as it does <script> srcs.
|
|
src = goog.normalizePath_(src);
|
|
|
|
var importScript =
|
|
goog.global.CLOSURE_IMPORT_SCRIPT || goog.writeScriptTag_;
|
|
|
|
var scriptText = goog.loadFileSync_(src);
|
|
if (scriptText == null) {
|
|
throw new Error('Load of "' + src + '" failed');
|
|
}
|
|
|
|
if (needsTranspile) {
|
|
scriptText = goog.transpile_.call(goog.global, scriptText, src);
|
|
}
|
|
|
|
if (isModule) {
|
|
scriptText = goog.wrapModule_(src, scriptText);
|
|
} else {
|
|
scriptText += '\n//# sourceURL=' + src;
|
|
}
|
|
var isOldIE = goog.IS_OLD_IE_;
|
|
if (isOldIE && goog.oldIeWaiting_) {
|
|
goog.dependencies_.deferred[originalPath] = scriptText;
|
|
goog.queuedModules_.push(originalPath);
|
|
} else {
|
|
importScript(src, scriptText);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Lazily retrieves the transpiler and applies it to the source.
|
|
* @param {string} code JS code.
|
|
* @param {string} path Path to the code.
|
|
* @return {string} The transpiled code.
|
|
* @private
|
|
*/
|
|
goog.transpile_ = function(code, path) {
|
|
var jscomp = goog.global['$jscomp'];
|
|
if (!jscomp) {
|
|
goog.global['$jscomp'] = jscomp = {};
|
|
}
|
|
var transpile = jscomp.transpile;
|
|
if (!transpile) {
|
|
var transpilerPath = goog.basePath + goog.TRANSPILER;
|
|
var transpilerCode = goog.loadFileSync_(transpilerPath);
|
|
if (transpilerCode) {
|
|
// This must be executed synchronously, since by the time we know we
|
|
// need it, we're about to load and write the ES6 code synchronously,
|
|
// so a normal script-tag load will be too slow.
|
|
eval(transpilerCode + '\n//# sourceURL=' + transpilerPath);
|
|
// Even though the transpiler is optional, if $gwtExport is found, it's
|
|
// a sign the transpiler was loaded and the $jscomp.transpile *should*
|
|
// be there.
|
|
if (goog.global['$gwtExport'] && goog.global['$gwtExport']['$jscomp'] &&
|
|
!goog.global['$gwtExport']['$jscomp']['transpile']) {
|
|
throw new Error(
|
|
'The transpiler did not properly export the "transpile" ' +
|
|
'method. $gwtExport: ' + JSON.stringify(goog.global['$gwtExport']));
|
|
}
|
|
// transpile.js only exports a single $jscomp function, transpile. We
|
|
// grab just that and add it to the existing definition of $jscomp which
|
|
// contains the polyfills.
|
|
goog.global['$jscomp'].transpile =
|
|
goog.global['$gwtExport']['$jscomp']['transpile'];
|
|
jscomp = goog.global['$jscomp'];
|
|
transpile = jscomp.transpile;
|
|
}
|
|
}
|
|
if (!transpile) {
|
|
// The transpiler is an optional component. If it's not available then
|
|
// replace it with a pass-through function that simply logs.
|
|
var suffix = ' requires transpilation but no transpiler was found.';
|
|
transpile = jscomp.transpile = function(code, path) {
|
|
// TODO(user): figure out some way to get this error to show up
|
|
// in test results, noting that the failure may occur in many
|
|
// different ways, including in loadModule() before the test
|
|
// runner even comes up.
|
|
goog.logToConsole_(path + suffix);
|
|
return code;
|
|
};
|
|
}
|
|
// Note: any transpilation errors/warnings will be logged to the console.
|
|
return transpile(code, path);
|
|
};
|
|
|
|
|
|
//==============================================================================
|
|
// Language Enhancements
|
|
//==============================================================================
|
|
|
|
|
|
/**
|
|
* This is a "fixed" version of the typeof operator. It differs from the typeof
|
|
* operator in such a way that null returns 'null' and arrays return 'array'.
|
|
* @param {?} value The value to get the type of.
|
|
* @return {string} The name of the type.
|
|
*/
|
|
goog.typeOf = function(value) {
|
|
var s = typeof value;
|
|
if (s == 'object') {
|
|
if (value) {
|
|
// Check these first, so we can avoid calling Object.prototype.toString if
|
|
// possible.
|
|
//
|
|
// IE improperly marshals typeof across execution contexts, but a
|
|
// cross-context object will still return false for "instanceof Object".
|
|
if (value instanceof Array) {
|
|
return 'array';
|
|
} else if (value instanceof Object) {
|
|
return s;
|
|
}
|
|
|
|
// HACK: In order to use an Object prototype method on the arbitrary
|
|
// value, the compiler requires the value be cast to type Object,
|
|
// even though the ECMA spec explicitly allows it.
|
|
var className = Object.prototype.toString.call(
|
|
/** @type {!Object} */ (value));
|
|
// In Firefox 3.6, attempting to access iframe window objects' length
|
|
// property throws an NS_ERROR_FAILURE, so we need to special-case it
|
|
// here.
|
|
if (className == '[object Window]') {
|
|
return 'object';
|
|
}
|
|
|
|
// We cannot always use constructor == Array or instanceof Array because
|
|
// different frames have different Array objects. In IE6, if the iframe
|
|
// where the array was created is destroyed, the array loses its
|
|
// prototype. Then dereferencing val.splice here throws an exception, so
|
|
// we can't use goog.isFunction. Calling typeof directly returns 'unknown'
|
|
// so that will work. In this case, this function will return false and
|
|
// most array functions will still work because the array is still
|
|
// array-like (supports length and []) even though it has lost its
|
|
// prototype.
|
|
// Mark Miller noticed that Object.prototype.toString
|
|
// allows access to the unforgeable [[Class]] property.
|
|
// 15.2.4.2 Object.prototype.toString ( )
|
|
// When the toString method is called, the following steps are taken:
|
|
// 1. Get the [[Class]] property of this object.
|
|
// 2. Compute a string value by concatenating the three strings
|
|
// "[object ", Result(1), and "]".
|
|
// 3. Return Result(2).
|
|
// and this behavior survives the destruction of the execution context.
|
|
if ((className == '[object Array]' ||
|
|
// In IE all non value types are wrapped as objects across window
|
|
// boundaries (not iframe though) so we have to do object detection
|
|
// for this edge case.
|
|
typeof value.length == 'number' &&
|
|
typeof value.splice != 'undefined' &&
|
|
typeof value.propertyIsEnumerable != 'undefined' &&
|
|
!value.propertyIsEnumerable('splice')
|
|
|
|
)) {
|
|
return 'array';
|
|
}
|
|
// HACK: There is still an array case that fails.
|
|
// function ArrayImpostor() {}
|
|
// ArrayImpostor.prototype = [];
|
|
// var impostor = new ArrayImpostor;
|
|
// this can be fixed by getting rid of the fast path
|
|
// (value instanceof Array) and solely relying on
|
|
// (value && Object.prototype.toString.vall(value) === '[object Array]')
|
|
// but that would require many more function calls and is not warranted
|
|
// unless closure code is receiving objects from untrusted sources.
|
|
|
|
// IE in cross-window calls does not correctly marshal the function type
|
|
// (it appears just as an object) so we cannot use just typeof val ==
|
|
// 'function'. However, if the object has a call property, it is a
|
|
// function.
|
|
if ((className == '[object Function]' ||
|
|
typeof value.call != 'undefined' &&
|
|
typeof value.propertyIsEnumerable != 'undefined' &&
|
|
!value.propertyIsEnumerable('call'))) {
|
|
return 'function';
|
|
}
|
|
|
|
} else {
|
|
return 'null';
|
|
}
|
|
|
|
} else if (s == 'function' && typeof value.call == 'undefined') {
|
|
// In Safari typeof nodeList returns 'function', and on Firefox typeof
|
|
// behaves similarly for HTML{Applet,Embed,Object}, Elements and RegExps. We
|
|
// would like to return object for those and we can detect an invalid
|
|
// function by making sure that the function object has a call method.
|
|
return 'object';
|
|
}
|
|
return s;
|
|
};
|
|
|
|
|
|
/**
|
|
* Returns true if the specified value is null.
|
|
* @param {?} val Variable to test.
|
|
* @return {boolean} Whether variable is null.
|
|
*/
|
|
goog.isNull = function(val) {
|
|
return val === null;
|
|
};
|
|
|
|
|
|
/**
|
|
* Returns true if the specified value is defined and not null.
|
|
* @param {?} val Variable to test.
|
|
* @return {boolean} Whether variable is defined and not null.
|
|
*/
|
|
goog.isDefAndNotNull = function(val) {
|
|
// Note that undefined == null.
|
|
return val != null;
|
|
};
|
|
|
|
|
|
/**
|
|
* Returns true if the specified value is an array.
|
|
* @param {?} val Variable to test.
|
|
* @return {boolean} Whether variable is an array.
|
|
*/
|
|
goog.isArray = function(val) {
|
|
return goog.typeOf(val) == 'array';
|
|
};
|
|
|
|
|
|
/**
|
|
* Returns true if the object looks like an array. To qualify as array like
|
|
* the value needs to be either a NodeList or an object with a Number length
|
|
* property. As a special case, a function value is not array like, because its
|
|
* length property is fixed to correspond to the number of expected arguments.
|
|
* @param {?} val Variable to test.
|
|
* @return {boolean} Whether variable is an array.
|
|
*/
|
|
goog.isArrayLike = function(val) {
|
|
var type = goog.typeOf(val);
|
|
// We do not use goog.isObject here in order to exclude function values.
|
|
return type == 'array' || type == 'object' && typeof val.length == 'number';
|
|
};
|
|
|
|
|
|
/**
|
|
* Returns true if the object looks like a Date. To qualify as Date-like the
|
|
* value needs to be an object and have a getFullYear() function.
|
|
* @param {?} val Variable to test.
|
|
* @return {boolean} Whether variable is a like a Date.
|
|
*/
|
|
goog.isDateLike = function(val) {
|
|
return goog.isObject(val) && typeof val.getFullYear == 'function';
|
|
};
|
|
|
|
|
|
/**
|
|
* Returns true if the specified value is a function.
|
|
* @param {?} val Variable to test.
|
|
* @return {boolean} Whether variable is a function.
|
|
*/
|
|
goog.isFunction = function(val) {
|
|
return goog.typeOf(val) == 'function';
|
|
};
|
|
|
|
|
|
/**
|
|
* Returns true if the specified value is an object. This includes arrays and
|
|
* functions.
|
|
* @param {?} val Variable to test.
|
|
* @return {boolean} Whether variable is an object.
|
|
*/
|
|
goog.isObject = function(val) {
|
|
var type = typeof val;
|
|
return type == 'object' && val != null || type == 'function';
|
|
// return Object(val) === val also works, but is slower, especially if val is
|
|
// not an object.
|
|
};
|
|
|
|
|
|
/**
|
|
* Gets a unique ID for an object. This mutates the object so that further calls
|
|
* with the same object as a parameter returns the same value. The unique ID is
|
|
* guaranteed to be unique across the current session amongst objects that are
|
|
* passed into {@code getUid}. There is no guarantee that the ID is unique or
|
|
* consistent across sessions. It is unsafe to generate unique ID for function
|
|
* prototypes.
|
|
*
|
|
* @param {Object} obj The object to get the unique ID for.
|
|
* @return {number} The unique ID for the object.
|
|
*/
|
|
goog.getUid = function(obj) {
|
|
// TODO(arv): Make the type stricter, do not accept null.
|
|
|
|
// In Opera window.hasOwnProperty exists but always returns false so we avoid
|
|
// using it. As a consequence the unique ID generated for BaseClass.prototype
|
|
// and SubClass.prototype will be the same.
|
|
return obj[goog.UID_PROPERTY_] ||
|
|
(obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
|
|
};
|
|
|
|
|
|
/**
|
|
* Whether the given object is already assigned a unique ID.
|
|
*
|
|
* This does not modify the object.
|
|
*
|
|
* @param {!Object} obj The object to check.
|
|
* @return {boolean} Whether there is an assigned unique id for the object.
|
|
*/
|
|
goog.hasUid = function(obj) {
|
|
return !!obj[goog.UID_PROPERTY_];
|
|
};
|
|
|
|
|
|
/**
|
|
* Removes the unique ID from an object. This is useful if the object was
|
|
* previously mutated using {@code goog.getUid} in which case the mutation is
|
|
* undone.
|
|
* @param {Object} obj The object to remove the unique ID field from.
|
|
*/
|
|
goog.removeUid = function(obj) {
|
|
// TODO(arv): Make the type stricter, do not accept null.
|
|
|
|
// In IE, DOM nodes are not instances of Object and throw an exception if we
|
|
// try to delete. Instead we try to use removeAttribute.
|
|
if (obj !== null && 'removeAttribute' in obj) {
|
|
obj.removeAttribute(goog.UID_PROPERTY_);
|
|
}
|
|
|
|
try {
|
|
delete obj[goog.UID_PROPERTY_];
|
|
} catch (ex) {
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Name for unique ID property. Initialized in a way to help avoid collisions
|
|
* with other closure JavaScript on the same page.
|
|
* @type {string}
|
|
* @private
|
|
*/
|
|
goog.UID_PROPERTY_ = 'closure_uid_' + ((Math.random() * 1e9) >>> 0);
|
|
|
|
|
|
/**
|
|
* Counter for UID.
|
|
* @type {number}
|
|
* @private
|
|
*/
|
|
goog.uidCounter_ = 0;
|
|
|
|
|
|
/**
|
|
* Adds a hash code field to an object. The hash code is unique for the
|
|
* given object.
|
|
* @param {Object} obj The object to get the hash code for.
|
|
* @return {number} The hash code for the object.
|
|
* @deprecated Use goog.getUid instead.
|
|
*/
|
|
goog.getHashCode = goog.getUid;
|
|
|
|
|
|
/**
|
|
* Removes the hash code field from an object.
|
|
* @param {Object} obj The object to remove the field from.
|
|
* @deprecated Use goog.removeUid instead.
|
|
*/
|
|
goog.removeHashCode = goog.removeUid;
|
|
|
|
|
|
/**
|
|
* Clones a value. The input may be an Object, Array, or basic type. Objects and
|
|
* arrays will be cloned recursively.
|
|
*
|
|
* WARNINGS:
|
|
* <code>goog.cloneObject</code> does not detect reference loops. Objects that
|
|
* refer to themselves will cause infinite recursion.
|
|
*
|
|
* <code>goog.cloneObject</code> is unaware of unique identifiers, and copies
|
|
* UIDs created by <code>getUid</code> into cloned results.
|
|
*
|
|
* @param {*} obj The value to clone.
|
|
* @return {*} A clone of the input value.
|
|
* @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.
|
|
*/
|
|
goog.cloneObject = function(obj) {
|
|
var type = goog.typeOf(obj);
|
|
if (type == 'object' || type == 'array') {
|
|
if (obj.clone) {
|
|
return obj.clone();
|
|
}
|
|
var clone = type == 'array' ? [] : {};
|
|
for (var key in obj) {
|
|
clone[key] = goog.cloneObject(obj[key]);
|
|
}
|
|
return clone;
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
|
|
/**
|
|
* A native implementation of goog.bind.
|
|
* @param {?function(this:T, ...)} fn A function to partially apply.
|
|
* @param {T} selfObj Specifies the object which this should point to when the
|
|
* function is run.
|
|
* @param {...*} var_args Additional arguments that are partially applied to the
|
|
* function.
|
|
* @return {!Function} A partially-applied form of the function goog.bind() was
|
|
* invoked as a method of.
|
|
* @template T
|
|
* @private
|
|
*/
|
|
goog.bindNative_ = function(fn, selfObj, var_args) {
|
|
return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));
|
|
};
|
|
|
|
|
|
/**
|
|
* A pure-JS implementation of goog.bind.
|
|
* @param {?function(this:T, ...)} fn A function to partially apply.
|
|
* @param {T} selfObj Specifies the object which this should point to when the
|
|
* function is run.
|
|
* @param {...*} var_args Additional arguments that are partially applied to the
|
|
* function.
|
|
* @return {!Function} A partially-applied form of the function goog.bind() was
|
|
* invoked as a method of.
|
|
* @template T
|
|
* @private
|
|
*/
|
|
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() {
|
|
// Prepend the bound arguments to the current arguments.
|
|
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);
|
|
};
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Partially applies this function to a particular 'this object' and zero or
|
|
* more arguments. The result is a new function with some arguments of the first
|
|
* function pre-filled and the value of this 'pre-specified'.
|
|
*
|
|
* Remaining arguments specified at call-time are appended to the pre-specified
|
|
* ones.
|
|
*
|
|
* Also see: {@link #partial}.
|
|
*
|
|
* Usage:
|
|
* <pre>var barMethBound = goog.bind(myFunction, myObj, 'arg1', 'arg2');
|
|
* barMethBound('arg3', 'arg4');</pre>
|
|
*
|
|
* @param {?function(this:T, ...)} fn A function to partially apply.
|
|
* @param {T} selfObj Specifies the object which this should point to when the
|
|
* function is run.
|
|
* @param {...*} var_args Additional arguments that are partially applied to the
|
|
* function.
|
|
* @return {!Function} A partially-applied form of the function goog.bind() was
|
|
* invoked as a method of.
|
|
* @template T
|
|
* @suppress {deprecated} See above.
|
|
*/
|
|
goog.bind = function(fn, selfObj, var_args) {
|
|
// TODO(nicksantos): narrow the type signature.
|
|
if (Function.prototype.bind &&
|
|
// NOTE(nicksantos): Somebody pulled base.js into the default Chrome
|
|
// extension environment. This means that for Chrome extensions, they get
|
|
// the implementation of Function.prototype.bind that calls goog.bind
|
|
// instead of the native one. Even worse, we don't want to introduce a
|
|
// circular dependency between goog.bind and Function.prototype.bind, so
|
|
// we have to hack this to make sure it works correctly.
|
|
Function.prototype.bind.toString().indexOf('native code') != -1) {
|
|
goog.bind = goog.bindNative_;
|
|
} else {
|
|
goog.bind = goog.bindJs_;
|
|
}
|
|
return goog.bind.apply(null, arguments);
|
|
};
|
|
|
|
|
|
/**
|
|
* Like goog.bind(), except that a 'this object' is not required. Useful when
|
|
* the target function is already bound.
|
|
*
|
|
* Usage:
|
|
* var g = goog.partial(f, arg1, arg2);
|
|
* g(arg3, arg4);
|
|
*
|
|
* @param {Function} fn A function to partially apply.
|
|
* @param {...*} var_args Additional arguments that are partially applied to fn.
|
|
* @return {!Function} A partially-applied form of the function goog.partial()
|
|
* was invoked as a method of.
|
|
*/
|
|
goog.partial = function(fn, var_args) {
|
|
var args = Array.prototype.slice.call(arguments, 1);
|
|
return function() {
|
|
// Clone the array (with slice()) and append additional arguments
|
|
// to the existing arguments.
|
|
var newArgs = args.slice();
|
|
newArgs.push.apply(newArgs, arguments);
|
|
return fn.apply(this, newArgs);
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
* Copies all the members of a source object to a target object. This method
|
|
* does not work on all browsers for all objects that contain keys such as
|
|
* toString or hasOwnProperty. Use goog.object.extend for this purpose.
|
|
* @param {Object} target Target.
|
|
* @param {Object} source Source.
|
|
*/
|
|
goog.mixin = function(target, source) {
|
|
for (var x in source) {
|
|
target[x] = source[x];
|
|
}
|
|
|
|
// For IE7 or lower, the for-in-loop does not contain any properties that are
|
|
// not enumerable on the prototype object (for example, isPrototypeOf from
|
|
// Object.prototype) but also it will not include 'replace' on objects that
|
|
// extend String and change 'replace' (not that it is common for anyone to
|
|
// extend anything except Object).
|
|
};
|
|
|
|
|
|
/**
|
|
* @return {number} An integer value representing the number of milliseconds
|
|
* between midnight, January 1, 1970 and the current time.
|
|
*/
|
|
goog.now = (goog.TRUSTED_SITE && Date.now) || (function() {
|
|
// Unary plus operator converts its operand to a number which in
|
|
// the case of
|
|
// a date is done by calling getTime().
|
|
return +new Date();
|
|
});
|
|
|
|
|
|
/**
|
|
* Evals JavaScript in the global scope. In IE this uses execScript, other
|
|
* browsers use goog.global.eval. If goog.global.eval does not evaluate in the
|
|
* global scope (for example, in Safari), appends a script tag instead.
|
|
* Throws an exception if neither execScript or eval is defined.
|
|
* @param {string} script JavaScript string.
|
|
*/
|
|
goog.globalEval = function(script) {
|
|
if (goog.global.execScript) {
|
|
goog.global.execScript(script, 'JavaScript');
|
|
} else if (goog.global.eval) {
|
|
// Test to see if eval works
|
|
if (goog.evalWorksForGlobals_ == null) {
|
|
goog.global.eval('var _evalTest_ = 1;');
|
|
if (typeof goog.global['_evalTest_'] != 'undefined') {
|
|
try {
|
|
delete goog.global['_evalTest_'];
|
|
} catch (ignore) {
|
|
// Microsoft edge fails the deletion above in strict mode.
|
|
}
|
|
goog.evalWorksForGlobals_ = true;
|
|
} else {
|
|
goog.evalWorksForGlobals_ = false;
|
|
}
|
|
}
|
|
|
|
if (goog.evalWorksForGlobals_) {
|
|
goog.global.eval(script);
|
|
} else {
|
|
/** @type {Document} */
|
|
var doc = goog.global.document;
|
|
var scriptElt =
|
|
/** @type {!HTMLScriptElement} */ (doc.createElement('SCRIPT'));
|
|
scriptElt.type = 'text/javascript';
|
|
scriptElt.defer = false;
|
|
// Note(user): can't use .innerHTML since "t('<test>')" will fail and
|
|
// .text doesn't work in Safari 2. Therefore we append a text node.
|
|
scriptElt.appendChild(doc.createTextNode(script));
|
|
doc.body.appendChild(scriptElt);
|
|
doc.body.removeChild(scriptElt);
|
|
}
|
|
} else {
|
|
throw Error('goog.globalEval not available');
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Indicates whether or not we can call 'eval' directly to eval code in the
|
|
* global scope. Set to a Boolean by the first call to goog.globalEval (which
|
|
* empirically tests whether eval works for globals). @see goog.globalEval
|
|
* @type {?boolean}
|
|
* @private
|
|
*/
|
|
goog.evalWorksForGlobals_ = null;
|
|
|
|
|
|
/**
|
|
* Optional map of CSS class names to obfuscated names used with
|
|
* goog.getCssName().
|
|
* @private {!Object<string, string>|undefined}
|
|
* @see goog.setCssNameMapping
|
|
*/
|
|
goog.cssNameMapping_;
|
|
|
|
|
|
/**
|
|
* Optional obfuscation style for CSS class names. Should be set to either
|
|
* 'BY_WHOLE' or 'BY_PART' if defined.
|
|
* @type {string|undefined}
|
|
* @private
|
|
* @see goog.setCssNameMapping
|
|
*/
|
|
goog.cssNameMappingStyle_;
|
|
|
|
|
|
|
|
/**
|
|
* A hook for modifying the default behavior goog.getCssName. The function
|
|
* if present, will recieve the standard output of the goog.getCssName as
|
|
* its input.
|
|
*
|
|
* @type {(function(string):string)|undefined}
|
|
*/
|
|
goog.global.CLOSURE_CSS_NAME_MAP_FN;
|
|
|
|
|
|
/**
|
|
* Handles strings that are intended to be used as CSS class names.
|
|
*
|
|
* This function works in tandem with @see goog.setCssNameMapping.
|
|
*
|
|
* Without any mapping set, the arguments are simple joined with a hyphen and
|
|
* passed through unaltered.
|
|
*
|
|
* When there is a mapping, there are two possible styles in which these
|
|
* mappings are used. In the BY_PART style, each part (i.e. in between hyphens)
|
|
* of the passed in css name is rewritten according to the map. In the BY_WHOLE
|
|
* style, the full css name is looked up in the map directly. If a rewrite is
|
|
* not specified by the map, the compiler will output a warning.
|
|
*
|
|
* When the mapping is passed to the compiler, it will replace calls to
|
|
* goog.getCssName with the strings from the mapping, e.g.
|
|
* var x = goog.getCssName('foo');
|
|
* var y = goog.getCssName(this.baseClass, 'active');
|
|
* becomes:
|
|
* var x = 'foo';
|
|
* var y = this.baseClass + '-active';
|
|
*
|
|
* If one argument is passed it will be processed, if two are passed only the
|
|
* modifier will be processed, as it is assumed the first argument was generated
|
|
* as a result of calling goog.getCssName.
|
|
*
|
|
* @param {string} className The class name.
|
|
* @param {string=} opt_modifier A modifier to be appended to the class name.
|
|
* @return {string} The class name or the concatenation of the class name and
|
|
* the modifier.
|
|
*/
|
|
goog.getCssName = function(className, opt_modifier) {
|
|
// String() is used for compatibility with compiled soy where the passed
|
|
// className can be non-string objects.
|
|
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) {
|
|
// Remap all the parts individually.
|
|
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);
|
|
|
|
// The special CLOSURE_CSS_NAME_MAP_FN allows users to specify further
|
|
// processing of the class name.
|
|
if (goog.global.CLOSURE_CSS_NAME_MAP_FN) {
|
|
return goog.global.CLOSURE_CSS_NAME_MAP_FN(result);
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
|
|
/**
|
|
* Sets the map to check when returning a value from goog.getCssName(). Example:
|
|
* <pre>
|
|
* goog.setCssNameMapping({
|
|
* "goog": "a",
|
|
* "disabled": "b",
|
|
* });
|
|
*
|
|
* var x = goog.getCssName('goog');
|
|
* // The following evaluates to: "a a-b".
|
|
* goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')
|
|
* </pre>
|
|
* When declared as a map of string literals to string literals, the JSCompiler
|
|
* will replace all calls to goog.getCssName() using the supplied map if the
|
|
* --process_closure_primitives flag is set.
|
|
*
|
|
* @param {!Object} mapping A map of strings to strings where keys are possible
|
|
* arguments to goog.getCssName() and values are the corresponding values
|
|
* that should be returned.
|
|
* @param {string=} opt_style The style of css name mapping. There are two valid
|
|
* options: 'BY_PART', and 'BY_WHOLE'.
|
|
* @see goog.getCssName for a description.
|
|
*/
|
|
goog.setCssNameMapping = function(mapping, opt_style) {
|
|
goog.cssNameMapping_ = mapping;
|
|
goog.cssNameMappingStyle_ = opt_style;
|
|
};
|
|
|
|
|
|
/**
|
|
* To use CSS renaming in compiled mode, one of the input files should have a
|
|
* call to goog.setCssNameMapping() with an object literal that the JSCompiler
|
|
* can extract and use to replace all calls to goog.getCssName(). In uncompiled
|
|
* mode, JavaScript code should be loaded before this base.js file that declares
|
|
* a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is
|
|
* to ensure that the mapping is loaded before any calls to goog.getCssName()
|
|
* are made in uncompiled mode.
|
|
*
|
|
* A hook for overriding the CSS name mapping.
|
|
* @type {!Object<string, string>|undefined}
|
|
*/
|
|
goog.global.CLOSURE_CSS_NAME_MAPPING;
|
|
|
|
|
|
if (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {
|
|
// This does not call goog.setCssNameMapping() because the JSCompiler
|
|
// requires that goog.setCssNameMapping() be called with an object literal.
|
|
goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets a localized message.
|
|
*
|
|
* This function is a compiler primitive. If you give the compiler a localized
|
|
* message bundle, it will replace the string at compile-time with a localized
|
|
* version, and expand goog.getMsg call to a concatenated string.
|
|
*
|
|
* Messages must be initialized in the form:
|
|
* <code>
|
|
* var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});
|
|
* </code>
|
|
*
|
|
* This function produces a string which should be treated as plain text. Use
|
|
* {@link goog.html.SafeHtmlFormatter} in conjunction with goog.getMsg to
|
|
* produce SafeHtml.
|
|
*
|
|
* @param {string} str Translatable string, places holders in the form {$foo}.
|
|
* @param {Object<string, string>=} opt_values Maps place holder name to value.
|
|
* @return {string} message with placeholders filled.
|
|
*/
|
|
goog.getMsg = function(str, opt_values) {
|
|
if (opt_values) {
|
|
str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
|
|
return (opt_values != null && key in opt_values) ? opt_values[key] :
|
|
match;
|
|
});
|
|
}
|
|
return str;
|
|
};
|
|
|
|
|
|
/**
|
|
* Gets a localized message. If the message does not have a translation, gives a
|
|
* fallback message.
|
|
*
|
|
* This is useful when introducing a new message that has not yet been
|
|
* translated into all languages.
|
|
*
|
|
* This function is a compiler primitive. Must be used in the form:
|
|
* <code>var x = goog.getMsgWithFallback(MSG_A, MSG_B);</code>
|
|
* where MSG_A and MSG_B were initialized with goog.getMsg.
|
|
*
|
|
* @param {string} a The preferred message.
|
|
* @param {string} b The fallback message.
|
|
* @return {string} The best translated message.
|
|
*/
|
|
goog.getMsgWithFallback = function(a, b) {
|
|
return a;
|
|
};
|
|
|
|
|
|
/**
|
|
* Exposes an unobfuscated global namespace path for the given object.
|
|
* Note that fields of the exported object *will* be obfuscated, unless they are
|
|
* exported in turn via this function or goog.exportProperty.
|
|
*
|
|
* Also handy for making public items that are defined in anonymous closures.
|
|
*
|
|
* ex. goog.exportSymbol('public.path.Foo', Foo);
|
|
*
|
|
* ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);
|
|
* public.path.Foo.staticFunction();
|
|
*
|
|
* ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',
|
|
* Foo.prototype.myMethod);
|
|
* new public.path.Foo().myMethod();
|
|
*
|
|
* @param {string} publicPath Unobfuscated name to export.
|
|
* @param {*} object Object the name should point to.
|
|
* @param {Object=} opt_objectToExportTo The object to add the path to; default
|
|
* is goog.global.
|
|
*/
|
|
goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
|
|
goog.exportPath_(publicPath, object, opt_objectToExportTo);
|
|
};
|
|
|
|
|
|
/**
|
|
* Exports a property unobfuscated into the object's namespace.
|
|
* ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);
|
|
* ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);
|
|
* @param {Object} object Object whose static property is being exported.
|
|
* @param {string} publicName Unobfuscated name to export.
|
|
* @param {*} symbol Object the name should point to.
|
|
*/
|
|
goog.exportProperty = function(object, publicName, symbol) {
|
|
object[publicName] = symbol;
|
|
};
|
|
|
|
|
|
/**
|
|
* Inherit the prototype methods from one constructor into another.
|
|
*
|
|
* Usage:
|
|
* <pre>
|
|
* function ParentClass(a, b) { }
|
|
* ParentClass.prototype.foo = function(a) { };
|
|
*
|
|
* function ChildClass(a, b, c) {
|
|
* ChildClass.base(this, 'constructor', a, b);
|
|
* }
|
|
* goog.inherits(ChildClass, ParentClass);
|
|
*
|
|
* var child = new ChildClass('a', 'b', 'see');
|
|
* child.foo(); // This works.
|
|
* </pre>
|
|
*
|
|
* @param {!Function} childCtor Child class.
|
|
* @param {!Function} parentCtor Parent class.
|
|
*/
|
|
goog.inherits = function(childCtor, parentCtor) {
|
|
/** @constructor */
|
|
function tempCtor() {}
|
|
tempCtor.prototype = parentCtor.prototype;
|
|
childCtor.superClass_ = parentCtor.prototype;
|
|
childCtor.prototype = new tempCtor();
|
|
/** @override */
|
|
childCtor.prototype.constructor = childCtor;
|
|
|
|
/**
|
|
* Calls superclass constructor/method.
|
|
*
|
|
* This function is only available if you use goog.inherits to
|
|
* express inheritance relationships between classes.
|
|
*
|
|
* NOTE: This is a replacement for goog.base and for superClass_
|
|
* property defined in childCtor.
|
|
*
|
|
* @param {!Object} me Should always be "this".
|
|
* @param {string} methodName The method name to call. Calling
|
|
* superclass constructor can be done with the special string
|
|
* 'constructor'.
|
|
* @param {...*} var_args The arguments to pass to superclass
|
|
* method/constructor.
|
|
* @return {*} The return value of the superclass method/constructor.
|
|
*/
|
|
childCtor.base = function(me, methodName, var_args) {
|
|
// Copying using loop to avoid deop due to passing arguments object to
|
|
// function. This is faster in many JS engines as of late 2014.
|
|
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);
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
* Call up to the superclass.
|
|
*
|
|
* If this is called from a constructor, then this calls the superclass
|
|
* constructor with arguments 1-N.
|
|
*
|
|
* If this is called from a prototype method, then you must pass the name of the
|
|
* method as the second argument to this function. If you do not, you will get a
|
|
* runtime error. This calls the superclass' method with arguments 2-N.
|
|
*
|
|
* This function only works if you use goog.inherits to express inheritance
|
|
* relationships between your classes.
|
|
*
|
|
* This function is a compiler primitive. At compile-time, the compiler will do
|
|
* macro expansion to remove a lot of the extra overhead that this function
|
|
* introduces. The compiler will also enforce a lot of the assumptions that this
|
|
* function makes, and treat it as a compiler error if you break them.
|
|
*
|
|
* @param {!Object} me Should always be "this".
|
|
* @param {*=} opt_methodName The method name if calling a super method.
|
|
* @param {...*} var_args The rest of the arguments.
|
|
* @return {*} The return value of the superclass method.
|
|
* @suppress {es5Strict} This method can not be used in strict mode, but
|
|
* all Closure Library consumers must depend on this file.
|
|
* @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.
|
|
*/
|
|
goog.base = function(me, opt_methodName, var_args) {
|
|
var caller = arguments.callee.caller;
|
|
|
|
if (goog.STRICT_MODE_COMPATIBLE || (goog.DEBUG && !caller)) {
|
|
throw Error(
|
|
'arguments.caller not defined. goog.base() cannot be used ' +
|
|
'with strict mode code. See ' +
|
|
'http://www.ecma-international.org/ecma-262/5.1/#sec-C');
|
|
}
|
|
|
|
if (caller.superClass_) {
|
|
// Copying using loop to avoid deop due to passing arguments object to
|
|
// function. This is faster in many JS engines as of late 2014.
|
|
var ctorArgs = new Array(arguments.length - 1);
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
ctorArgs[i - 1] = arguments[i];
|
|
}
|
|
// This is a constructor. Call the superclass constructor.
|
|
return caller.superClass_.constructor.apply(me, ctorArgs);
|
|
}
|
|
|
|
// Copying using loop to avoid deop due to passing arguments object to
|
|
// function. This is faster in many JS engines as of late 2014.
|
|
var args = new Array(arguments.length - 2);
|
|
for (var i = 2; i < arguments.length; i++) {
|
|
args[i - 2] = arguments[i];
|
|
}
|
|
var foundCaller = false;
|
|
for (var ctor = me.constructor; ctor;
|
|
ctor = ctor.superClass_ && ctor.superClass_.constructor) {
|
|
if (ctor.prototype[opt_methodName] === caller) {
|
|
foundCaller = true;
|
|
} else if (foundCaller) {
|
|
return ctor.prototype[opt_methodName].apply(me, args);
|
|
}
|
|
}
|
|
|
|
// If we did not find the caller in the prototype chain, then one of two
|
|
// things happened:
|
|
// 1) The caller is an instance method.
|
|
// 2) This method was not called by the right caller.
|
|
if (me[opt_methodName] === caller) {
|
|
return me.constructor.prototype[opt_methodName].apply(me, args);
|
|
} else {
|
|
throw Error(
|
|
'goog.base called from a method of one name ' +
|
|
'to a method of a different name');
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Allow for aliasing within scope functions. This function exists for
|
|
* uncompiled code - in compiled code the calls will be inlined and the aliases
|
|
* applied. In uncompiled code the function is simply run since the aliases as
|
|
* written are valid JavaScript.
|
|
*
|
|
*
|
|
* @param {function()} fn Function to call. This function can contain aliases
|
|
* to namespaces (e.g. "var dom = goog.dom") or classes
|
|
* (e.g. "var Timer = goog.Timer").
|
|
*/
|
|
goog.scope = function(fn) {
|
|
if (goog.isInModuleLoader_()) {
|
|
throw Error('goog.scope is not supported within a goog.module.');
|
|
}
|
|
fn.call(goog.global);
|
|
};
|
|
|
|
|
|
/*
|
|
* To support uncompiled, strict mode bundles that use eval to divide source
|
|
* like so:
|
|
* eval('someSource;//# sourceUrl sourcefile.js');
|
|
* We need to export the globally defined symbols "goog" and "COMPILED".
|
|
* Exporting "goog" breaks the compiler optimizations, so we required that
|
|
* be defined externally.
|
|
* NOTE: We don't use goog.exportSymbol here because we don't want to trigger
|
|
* extern generation when that compiler option is enabled.
|
|
*/
|
|
if (!COMPILED) {
|
|
goog.global['COMPILED'] = COMPILED;
|
|
}
|
|
|
|
|
|
//==============================================================================
|
|
// goog.defineClass implementation
|
|
//==============================================================================
|
|
|
|
|
|
/**
|
|
* Creates a restricted form of a Closure "class":
|
|
* - from the compiler's perspective, the instance returned from the
|
|
* constructor is sealed (no new properties may be added). This enables
|
|
* better checks.
|
|
* - the compiler will rewrite this definition to a form that is optimal
|
|
* for type checking and optimization (initially this will be a more
|
|
* traditional form).
|
|
*
|
|
* @param {Function} superClass The superclass, Object or null.
|
|
* @param {goog.defineClass.ClassDescriptor} def
|
|
* An object literal describing
|
|
* the class. It may have the following properties:
|
|
* "constructor": the constructor function
|
|
* "statics": an object literal containing methods to add to the constructor
|
|
* as "static" methods or a function that will receive the constructor
|
|
* function as its only parameter to which static properties can
|
|
* be added.
|
|
* all other properties are added to the prototype.
|
|
* @return {!Function} The class constructor.
|
|
*/
|
|
goog.defineClass = function(superClass, def) {
|
|
// TODO(johnlenz): consider making the superClass an optional parameter.
|
|
var constructor = def.constructor;
|
|
var statics = def.statics;
|
|
// Wrap the constructor prior to setting up the prototype and static methods.
|
|
if (!constructor || constructor == Object.prototype.constructor) {
|
|
constructor = function() {
|
|
throw Error('cannot instantiate an interface (no constructor defined).');
|
|
};
|
|
}
|
|
|
|
var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
|
|
if (superClass) {
|
|
goog.inherits(cls, superClass);
|
|
}
|
|
|
|
// Remove all the properties that should not be copied to the prototype.
|
|
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;
|
|
};
|
|
|
|
|
|
/**
|
|
* @typedef {{
|
|
* constructor: (!Function|undefined),
|
|
* statics: (Object|undefined|function(Function):void)
|
|
* }}
|
|
*/
|
|
goog.defineClass.ClassDescriptor;
|
|
|
|
|
|
/**
|
|
* @define {boolean} Whether the instances returned by goog.defineClass should
|
|
* be sealed when possible.
|
|
*
|
|
* When sealing is disabled the constructor function will not be wrapped by
|
|
* goog.defineClass, making it incompatible with ES6 class methods.
|
|
*/
|
|
goog.define('goog.defineClass.SEAL_CLASS_INSTANCES', goog.DEBUG);
|
|
|
|
|
|
/**
|
|
* If goog.defineClass.SEAL_CLASS_INSTANCES is enabled and Object.seal is
|
|
* defined, this function will wrap the constructor in a function that seals the
|
|
* results of the provided constructor function.
|
|
*
|
|
* @param {!Function} ctr The constructor whose results maybe be sealed.
|
|
* @param {Function} superClass The superclass constructor.
|
|
* @return {!Function} The replacement constructor.
|
|
* @private
|
|
*/
|
|
goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
|
|
if (!goog.defineClass.SEAL_CLASS_INSTANCES) {
|
|
// Do now wrap the constructor when sealing is disabled. Angular code
|
|
// depends on this for injection to work properly.
|
|
return ctr;
|
|
}
|
|
|
|
// Compute whether the constructor is sealable at definition time, rather
|
|
// than when the instance is being constructed.
|
|
var superclassSealable = !goog.defineClass.isUnsealable_(superClass);
|
|
|
|
/**
|
|
* @this {Object}
|
|
* @return {?}
|
|
*/
|
|
var wrappedCtr = function() {
|
|
// Don't seal an instance of a subclass when it calls the constructor of
|
|
// its super class as there is most likely still setup to do.
|
|
var instance = ctr.apply(this, arguments) || this;
|
|
instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];
|
|
|
|
if (this.constructor === wrappedCtr && superclassSealable &&
|
|
Object.seal instanceof Function) {
|
|
Object.seal(instance);
|
|
}
|
|
return instance;
|
|
};
|
|
|
|
return wrappedCtr;
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {Function} ctr The constructor to test.
|
|
* @return {boolean} Whether the constructor has been tagged as unsealable
|
|
* using goog.tagUnsealableClass.
|
|
* @private
|
|
*/
|
|
goog.defineClass.isUnsealable_ = function(ctr) {
|
|
return ctr && ctr.prototype &&
|
|
ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];
|
|
};
|
|
|
|
|
|
// TODO(johnlenz): share these values with the goog.object
|
|
/**
|
|
* The names of the fields that are defined on Object.prototype.
|
|
* @type {!Array<string>}
|
|
* @private
|
|
* @const
|
|
*/
|
|
goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [
|
|
'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
|
|
'toLocaleString', 'toString', 'valueOf'
|
|
];
|
|
|
|
|
|
// TODO(johnlenz): share this function with the goog.object
|
|
/**
|
|
* @param {!Object} target The object to add properties to.
|
|
* @param {!Object} source The object to copy properties from.
|
|
* @private
|
|
*/
|
|
goog.defineClass.applyProperties_ = function(target, source) {
|
|
// TODO(johnlenz): update this to support ES5 getters/setters
|
|
|
|
var key;
|
|
for (key in source) {
|
|
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
|
|
// For IE the for-in-loop does not contain any properties that are not
|
|
// enumerable on the prototype object (for example isPrototypeOf from
|
|
// Object.prototype) and it will also not include 'replace' on objects that
|
|
// extend String and change 'replace' (not that it is common for anyone to
|
|
// extend anything except Object).
|
|
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];
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Sealing classes breaks the older idiom of assigning properties on the
|
|
* prototype rather than in the constructor. As such, goog.defineClass
|
|
* must not seal subclasses of these old-style classes until they are fixed.
|
|
* Until then, this marks a class as "broken", instructing defineClass
|
|
* not to seal subclasses.
|
|
* @param {!Function} ctr The legacy constructor to tag as unsealable.
|
|
*/
|
|
goog.tagUnsealableClass = function(ctr) {
|
|
if (!COMPILED && goog.defineClass.SEAL_CLASS_INSTANCES) {
|
|
ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = true;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Name for unsealable tag property.
|
|
* @const @private {string}
|
|
*/
|
|
goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = 'goog_defineClass_legacy_unsealable';
|
|
|
|
|
|
/**
|
|
* Returns a newly created map from language mode string to a boolean
|
|
* indicating whether transpilation should be done for that mode.
|
|
*
|
|
* Guaranteed invariant:
|
|
* For any two modes, l1 and l2 where l2 is a newer mode than l1,
|
|
* `map[l1] == true` implies that `map[l2] == true`.
|
|
* @private
|
|
* @return {!Object<string, boolean>}
|
|
*/
|
|
goog.createRequiresTranspilation_ = function() {
|
|
var /** !Object<string, boolean> */ requiresTranspilation = {'es3': false};
|
|
var transpilationRequiredForAllLaterModes = false;
|
|
|
|
/**
|
|
* Adds an entry to requiresTranspliation for the given language mode.
|
|
*
|
|
* IMPORTANT: Calls must be made in order from oldest to newest language
|
|
* mode.
|
|
* @param {string} modeName
|
|
* @param {function(): boolean} isSupported Returns true if the JS engine
|
|
* supports the given mode.
|
|
*/
|
|
function addNewerLanguageTranspilationCheck(modeName, isSupported) {
|
|
if (transpilationRequiredForAllLaterModes) {
|
|
requiresTranspilation[modeName] = true;
|
|
} else if (isSupported()) {
|
|
requiresTranspilation[modeName] = false;
|
|
} else {
|
|
requiresTranspilation[modeName] = true;
|
|
transpilationRequiredForAllLaterModes = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Does the given code evaluate without syntax errors and return a truthy
|
|
* result?
|
|
*/
|
|
function /** boolean */ evalCheck(/** string */ code) {
|
|
try {
|
|
return !!eval(code);
|
|
} catch (ignored) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
var userAgent = goog.global.navigator && goog.global.navigator.userAgent ?
|
|
goog.global.navigator.userAgent :
|
|
'';
|
|
|
|
// Identify ES3-only browsers by their incorrect treatment of commas.
|
|
addNewerLanguageTranspilationCheck('es5', function() {
|
|
return evalCheck('[1,].length==1');
|
|
});
|
|
addNewerLanguageTranspilationCheck('es6', function() {
|
|
// Edge has a non-deterministic (i.e., not reproducible) bug with ES6:
|
|
// https://github.com/Microsoft/ChakraCore/issues/1496.
|
|
var re = /Edge\/(\d+)(\.\d)*/i;
|
|
var edgeUserAgent = userAgent.match(re);
|
|
if (edgeUserAgent && Number(edgeUserAgent[1]) < 15) {
|
|
return false;
|
|
}
|
|
// Test es6: [FF50 (?), Edge 14 (?), Chrome 50]
|
|
// (a) default params (specifically shadowing locals),
|
|
// (b) destructuring, (c) block-scoped functions,
|
|
// (d) for-of (const), (e) new.target/Reflect.construct
|
|
var es6fullTest =
|
|
'class X{constructor(){if(new.target!=String)throw 1;this.x=42}}' +
|
|
'let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof ' +
|
|
'String))throw 1;for(const a of[2,3]){if(a==2)continue;function ' +
|
|
'f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()' +
|
|
'==3}';
|
|
|
|
return evalCheck('(()=>{"use strict";' + es6fullTest + '})()');
|
|
});
|
|
// TODO(joeltine): Remove es6-impl references for b/31340605.
|
|
// Consider es6-impl (widely-implemented es6 features) to be supported
|
|
// whenever es6 is supported. Technically es6-impl is a lower level of
|
|
// support than es6, but we don't have tests specifically for it.
|
|
addNewerLanguageTranspilationCheck('es6-impl', function() {
|
|
return true;
|
|
});
|
|
// ** and **= are the only new features in 'es7'
|
|
addNewerLanguageTranspilationCheck('es7', function() {
|
|
return evalCheck('2 ** 2 == 4');
|
|
});
|
|
// async functions are the only new features in 'es8'
|
|
addNewerLanguageTranspilationCheck('es8', function() {
|
|
return evalCheck('async () => 1, true');
|
|
});
|
|
return requiresTranspilation;
|
|
};
|
|
|
|
goog.provide = SHADOW_PROVIDE;
|
|
goog.require = SHADOW_REQUIRE;
|
|
SHADOW_IMPORT("goog.debug.error.js");
|
|
SHADOW_IMPORT("goog.dom.nodetype.js");
|
|
SHADOW_IMPORT("goog.string.string.js");
|
|
SHADOW_IMPORT("goog.asserts.asserts.js");
|
|
SHADOW_IMPORT("goog.reflect.reflect.js");
|
|
SHADOW_IMPORT("goog.math.long.js");
|
|
SHADOW_IMPORT("goog.math.integer.js");
|
|
SHADOW_IMPORT("goog.object.object.js");
|
|
SHADOW_IMPORT("goog.array.array.js");
|
|
SHADOW_IMPORT("goog.structs.structs.js");
|
|
SHADOW_IMPORT("goog.functions.functions.js");
|
|
SHADOW_IMPORT("goog.math.math.js");
|
|
SHADOW_IMPORT("goog.iter.iter.js");
|
|
SHADOW_IMPORT("goog.structs.map.js");
|
|
SHADOW_IMPORT("goog.uri.utils.js");
|
|
SHADOW_IMPORT("goog.uri.uri.js");
|
|
SHADOW_IMPORT("goog.string.stringbuffer.js");
|
|
SHADOW_IMPORT("cljs.core.js");
|
|
SHADOW_IMPORT("clojure.walk.js");
|
|
SHADOW_IMPORT("cljs.spec.gen.alpha.js");
|
|
SHADOW_IMPORT("clojure.string.js");
|
|
SHADOW_IMPORT("cljs.spec.alpha.js");
|
|
SHADOW_IMPORT("cljs.repl.js");
|
|
SHADOW_IMPORT("cljs.user.js");
|
|
SHADOW_IMPORT("cljs.tools.reader.impl.utils.js");
|
|
SHADOW_IMPORT("cljs.tools.reader.reader_types.js");
|
|
SHADOW_IMPORT("cljs.tools.reader.impl.inspect.js");
|
|
SHADOW_IMPORT("cljs.tools.reader.impl.errors.js");
|
|
SHADOW_IMPORT("cljs.tools.reader.impl.commons.js");
|
|
SHADOW_IMPORT("cljs.tools.reader.js");
|
|
SHADOW_IMPORT("cljs.pprint.js");
|
|
SHADOW_IMPORT("shadow.cljs.devtools.client.env.js");
|
|
SHADOW_IMPORT("shadow.js.shim.module$ws.js");
|
|
SHADOW_IMPORT("cljs.tools.reader.edn.js");
|
|
SHADOW_IMPORT("cljs.reader.js");
|
|
SHADOW_IMPORT("shadow.cljs.devtools.client.node.js");
|
|
SHADOW_IMPORT("shadow.js.shim.module$xhr2.js");
|
|
SHADOW_IMPORT("shadow.js.shim.module$elrpc.js");
|
|
SHADOW_IMPORT("john_titor.commands.protocols.js");
|
|
SHADOW_IMPORT("john_titor.commands.echo.js");
|
|
SHADOW_IMPORT("goog.net.eventtype.js");
|
|
SHADOW_IMPORT("goog.net.errorcode.js");
|
|
SHADOW_IMPORT("goog.promise.thenable.js");
|
|
SHADOW_IMPORT("goog.async.freelist.js");
|
|
SHADOW_IMPORT("goog.async.workqueue.js");
|
|
SHADOW_IMPORT("goog.debug.entrypointregistry.js");
|
|
SHADOW_IMPORT("goog.dom.htmlelement.js");
|
|
SHADOW_IMPORT("goog.dom.tagname.js");
|
|
SHADOW_IMPORT("goog.labs.useragent.util.js");
|
|
SHADOW_IMPORT("goog.labs.useragent.browser.js");
|
|
SHADOW_IMPORT("goog.labs.useragent.engine.js");
|
|
SHADOW_IMPORT("goog.async.nexttick.js");
|
|
SHADOW_IMPORT("goog.async.run.js");
|
|
SHADOW_IMPORT("goog.promise.resolver.js");
|
|
SHADOW_IMPORT("goog.promise.promise.js");
|
|
SHADOW_IMPORT("goog.disposable.idisposable.js");
|
|
SHADOW_IMPORT("goog.disposable.disposable.js");
|
|
SHADOW_IMPORT("goog.labs.useragent.platform.js");
|
|
SHADOW_IMPORT("goog.useragent.useragent.js");
|
|
SHADOW_IMPORT("goog.events.browserfeature.js");
|
|
SHADOW_IMPORT("goog.events.eventid.js");
|
|
SHADOW_IMPORT("goog.events.event.js");
|
|
SHADOW_IMPORT("goog.events.eventtype.js");
|
|
SHADOW_IMPORT("goog.events.browserevent.js");
|
|
SHADOW_IMPORT("goog.events.listenable.js");
|
|
SHADOW_IMPORT("goog.events.listener.js");
|
|
SHADOW_IMPORT("goog.events.listenermap.js");
|
|
SHADOW_IMPORT("goog.events.events.js");
|
|
SHADOW_IMPORT("goog.events.eventtarget.js");
|
|
SHADOW_IMPORT("goog.timer.timer.js");
|
|
SHADOW_IMPORT("goog.json.json.js");
|
|
SHADOW_IMPORT("goog.json.hybrid.js");
|
|
SHADOW_IMPORT("goog.debug.errorcontext.js");
|
|
SHADOW_IMPORT("goog.debug.debug.js");
|
|
SHADOW_IMPORT("goog.debug.logrecord.js");
|
|
SHADOW_IMPORT("goog.debug.logbuffer.js");
|
|
SHADOW_IMPORT("goog.debug.logger.js");
|
|
SHADOW_IMPORT("goog.log.log.js");
|
|
SHADOW_IMPORT("goog.net.httpstatus.js");
|
|
SHADOW_IMPORT("goog.net.xhrlike.js");
|
|
SHADOW_IMPORT("goog.net.xmlhttpfactory.js");
|
|
SHADOW_IMPORT("goog.net.wrapperxmlhttpfactory.js");
|
|
SHADOW_IMPORT("goog.net.xmlhttp.js");
|
|
SHADOW_IMPORT("goog.net.xhrio.js");
|
|
SHADOW_IMPORT("goog.dom.tags.js");
|
|
SHADOW_IMPORT("goog.string.typedstring.js");
|
|
SHADOW_IMPORT("goog.string.const.js");
|
|
SHADOW_IMPORT("goog.html.safescript.js");
|
|
SHADOW_IMPORT("goog.fs.url.js");
|
|
SHADOW_IMPORT("goog.i18n.bidi.js");
|
|
SHADOW_IMPORT("goog.html.trustedresourceurl.js");
|
|
SHADOW_IMPORT("goog.html.safeurl.js");
|
|
SHADOW_IMPORT("goog.html.safestyle.js");
|
|
SHADOW_IMPORT("goog.html.safestylesheet.js");
|
|
SHADOW_IMPORT("goog.html.safehtml.js");
|
|
SHADOW_IMPORT("goog.html.legacyconversions.js");
|
|
SHADOW_IMPORT("goog.mochikit.async.deferred.js");
|
|
SHADOW_IMPORT("goog.dom.browserfeature.js");
|
|
SHADOW_IMPORT("goog.dom.asserts.js");
|
|
SHADOW_IMPORT("goog.dom.safe.js");
|
|
SHADOW_IMPORT("goog.html.uncheckedconversions.js");
|
|
SHADOW_IMPORT("goog.math.coordinate.js");
|
|
SHADOW_IMPORT("goog.math.size.js");
|
|
SHADOW_IMPORT("goog.dom.dom.js");
|
|
SHADOW_IMPORT("goog.net.jsloader.js");
|
|
SHADOW_IMPORT("goog.net.jsonp.js");
|
|
SHADOW_IMPORT("com.cognitect.transit.util.js");
|
|
SHADOW_IMPORT("com.cognitect.transit.delimiters.js");
|
|
SHADOW_IMPORT("com.cognitect.transit.caching.js");
|
|
SHADOW_IMPORT("com.cognitect.transit.eq.js");
|
|
SHADOW_IMPORT("com.cognitect.transit.types.js");
|
|
SHADOW_IMPORT("com.cognitect.transit.impl.decoder.js");
|
|
SHADOW_IMPORT("com.cognitect.transit.impl.reader.js");
|
|
SHADOW_IMPORT("com.cognitect.transit.handlers.js");
|
|
SHADOW_IMPORT("com.cognitect.transit.impl.writer.js");
|
|
SHADOW_IMPORT("com.cognitect.transit.js");
|
|
SHADOW_IMPORT("cognitect.transit.js");
|
|
SHADOW_IMPORT("goog.crypt.crypt.js");
|
|
SHADOW_IMPORT("goog.useragent.product.js");
|
|
SHADOW_IMPORT("goog.crypt.base64.js");
|
|
SHADOW_IMPORT("no.en.core.js");
|
|
SHADOW_IMPORT("cljs_http.util.js");
|
|
SHADOW_IMPORT("cljs.core.async.impl.protocols.js");
|
|
SHADOW_IMPORT("cljs.core.async.impl.buffers.js");
|
|
SHADOW_IMPORT("cljs.core.async.impl.dispatch.js");
|
|
SHADOW_IMPORT("cljs.core.async.impl.channels.js");
|
|
SHADOW_IMPORT("cljs.core.async.impl.timers.js");
|
|
SHADOW_IMPORT("cljs.core.async.impl.ioc_helpers.js");
|
|
SHADOW_IMPORT("cljs.core.async.js");
|
|
SHADOW_IMPORT("cljs_http.core.js");
|
|
SHADOW_IMPORT("cljs_http.client.js");
|
|
SHADOW_IMPORT("john_titor.github.core.js");
|
|
SHADOW_IMPORT("john_titor.github.js");
|
|
SHADOW_IMPORT("shadow.js.shim.module$bluebird.js");
|
|
SHADOW_IMPORT("john_titor.utils.js");
|
|
SHADOW_IMPORT("john_titor.commands.github.js");
|
|
SHADOW_IMPORT("john_titor.commands.js");
|
|
SHADOW_IMPORT("john_titor.core.js");
|
|
SHADOW_IMPORT("shadow.module.main.append.js");
|
|
|
|
})();
|