2018-09-13 16:49:56 +01:00
#!/usr/bin/env node
( function ( ) {
var SHADOW _IMPORT _PATH = _ _dirname + '/../.shadow-cljs/builds/app/dev/out/cljs-runtime' ;
2018-12-25 12:22:52 +00:00
if ( _ _dirname == '.' ) { SHADOW _IMPORT _PATH = "/home/lxsameer/.fg42/john_titor/.shadow-cljs/builds/app/dev/out/cljs-runtime" ; }
2018-09-13 16:49:56 +01:00
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 ;
2018-12-25 12:22:52 +00:00
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" : "0f38fe63-c013-429e-93ab-1c6a32c04ef0" , "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" } ;
2018-09-13 16:49:56 +01:00
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 < / c o d e > i s s e t t o t r u e . T h i s a l l o w s p r o j e c t s
* 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 } ;
* < / p r e >
*
* @ 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 } ;
* < / p r e >
*
* @ 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 < / c o d e > d o e s n o t d e t e c t r e f e r e n c e l o o p s . O b j e c t s t h a t
* refer to themselves will cause infinite recursion .
*
* < code > goog . cloneObject < / c o d e > i s u n a w a r e o f u n i q u e i d e n t i f i e r s , a n d c o p i e s
* UIDs created by < code > getUid < / c o d e > i n t o c l o n e d r e s u l t s .
*
* @ 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' ) ; < / p r e >
*
* @ 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' )
* < / p r e >
* 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' } ) ;
* < / c o d e >
*
* 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 ) ; < / c o d e >
* 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.
* < / p r e >
*
* @ 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 ( "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.core.js" ) ;
SHADOW _IMPORT ( "shadow.module.main.append.js" ) ;
} ) ( ) ;