Classes

goog.Delay
A deprecated alias.
goog.Disposable
Class that provides the basic implementation for disposable objects. If your class holds one or more references to COM objects, DOM nodes, or other disposable objects, it should extend this class or implement the disposable interface (defined in goog.disposable.IDisposable).
goog.History
A history management object. Can be instantiated in user-visible mode (uses the address fragment to manage state) or in hidden mode. This object should be created from a script in the document body before the document has finished loading. To store the hidden states in browsers other than IE, a hidden iframe is used. It must point to a valid html page on the same domain (which can and probably should be blank.) Sample instantiation and usage:
// Instantiate history to use the address bar for state.
var h = new goog.History();
goog.events.listen(h, goog.history.EventType.NAVIGATE, navCallback);
h.setEnabled(true);

// Any changes to the location hash will call the following function.
function navCallback(e) {
  alert('Navigated to state "' + e.token + '"');
}

// The history token can also be set from code directly.
h.setToken('foo');
goog.Promise
Promises provide a result that may be resolved asynchronously. A Promise may be resolved by being fulfilled or rejected with a value, which will be known as the fulfillment value or the rejection reason. Whether fulfilled or rejected, the Promise result is immutable once it is set. Promises may represent results of any type, including undefined. Rejection reasons are typically Errors, but may also be of any type. Closure Promises allow for optional type annotations that enforce that fulfillment values are of the appropriate types at compile time. The result of a Promise is accessible by calling then and registering onFulfilled and onRejected callbacks. Once the Promise resolves, the relevant callbacks are invoked with the fulfillment value or rejection reason as argument. Callbacks are always invoked in the order they were registered, even when additional then calls are made from inside another callback. A callback is always run asynchronously sometime after the scope containing the registering then invocation has returned. If a Promise is resolved with another Promise, the first Promise will block until the second is resolved, and then assumes the same result as the second Promise. This allows Promises to depend on the results of other Promises, linking together multiple asynchronous operations. This implementation is compatible with the Promises/A+ specification and passes that specification's conformance test suite. A Closure Promise may be resolved with a Promise instance (or sufficiently compatible Promise-like object) created by other Promise implementations. From the specification, Promise-like objects are known as "Thenables".
goog.Thenable
Provides a more strict interface for Thenables in terms of http://promisesaplus.com for interop with .
goog.Throttle
A deprecated alias.
goog.Timer
Class for handling timing events.
goog.Uri
This class contains setters and getters for the parts of the URI. The getXyz/setXyz methods return the decoded part -- sogoog.Uri.parse('/foo%20bar').getPath() will return the decoded path, /foo bar. The constructor accepts an optional unparsed, raw URI string. The parser is relaxed, so special characters that aren't escaped but don't cause ambiguities will not cause parse failures. All setters return this and so may be chained, a la goog.Uri.parse('/foo').setFragment('part').toString().

Public Protected Private

Global Functions

goog.addDependency(relPathprovidesrequires)
Adds a dependency from a file to the files it requires.
Arguments:
relPath : string
The path to the js file.
provides : Array
An array of strings with the names of the objects this file provides.
requires : Array
An array of strings with the names of the objects this file requires.
code »
goog.addSingletonGetter(ctor)
Adds a getInstance static method that always returns the same instance object.
Arguments:
ctor : !Function
The constructor for the class to add the static method to.
code »
goog.base(meopt_methodNamevar_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.
Arguments:
me : !Object
Should always be "this".
opt_methodName : *=
The method name if calling a super method.
var_args : ...*
The rest of the arguments.
Returns: *  The return value of the superclass method.
code »
goog.bind(fnselfObjvar_args) !Function
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: #partial. Usage:
var barMethBound = bind(myFunction, myObj, 'arg1', 'arg2');
barMethBound('arg3', 'arg4');
Arguments:
fn : ?function(this:T, ...)
A function to partially apply.
selfObj : T
Specifies the object which this should point to when the function is run.
var_args : ...*
Additional arguments that are partially applied to the function.
Returns: !Function  A partially-applied form of the function bind() was invoked as a method of.
code »
goog.bindJs_(fnselfObjvar_args) !Function
A pure-JS implementation of goog.bind.
Arguments:
fn : Function
A function to partially apply.
selfObj : Object | undefined
Specifies the object which this should point to when the function is run.
var_args : ...*
Additional arguments that are partially applied to the function.
Returns: !Function  A partially-applied form of the function bind() was invoked as a method of.
code »
goog.bindNative_(fnselfObjvar_args) !Function
A native implementation of goog.bind.
Arguments:
fn : Function
A function to partially apply.
selfObj : Object | undefined
Specifies the object which this should point to when the function is run.
var_args : ...*
Additional arguments that are partially applied to the function.
Returns: !Function  A partially-applied form of the function bind() was invoked as a method of.
code »
goog.cloneObject(obj) *
goog.cloneObject is unsafe. Prefer the goog.object methods. Clones a value. The input may be an Object, Array, or basic type. Objects and arrays will be cloned recursively. WARNINGS: goog.cloneObject does not detect reference loops. Objects that refer to themselves will cause infinite recursion. goog.cloneObject is unaware of unique identifiers, and copies UIDs created by getUid into cloned results.
Arguments:
obj : *
The value to clone.
Returns: *  A clone of the input value.
code »
goog.define(namedefaultValue)
Defines a named value. In uncompiled mode, the value is retreived 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 compiler command-line options.
Arguments:
name : string
The distinguished name to provide.
defaultValue : string | number | boolean
No description.
code »
goog.dispose(obj)
Calls dispose on the argument if it supports it. If obj is not an object with a dispose() method, this is a no-op.
Arguments:
obj : *
The object to dispose of.
code »
goog.disposeAll(var_args)
Calls dispose on each member of the list that supports it. (If the member is an ArrayLike, then goog.disposeAll() will be called recursively on each of its members.) If the member is not an object with a dispose() method, then it is ignored.
Arguments:
var_args : ...*
The list.
code »
goog.exportPath_(nameopt_objectopt_objectToExportTo)
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.
Arguments:
name : string
name of the object that this file defines.
opt_object : *=
the object to expose at the end of the path.
opt_objectToExportTo : Object=
The object to add the path to; default is |goog.global|.
code »
goog.exportProperty(objectpublicNamesymbol)
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);
Arguments:
object : Object
Object whose static property is being exported.
publicName : string
Unobfuscated name to export.
symbol : *
Object the name should point to.
code »
goog.exportSymbol(publicPathobjectopt_objectToExportTo)
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();
Arguments:
publicPath : string
Unobfuscated name to export.
object : *
Object the name should point to.
opt_objectToExportTo : Object=
The object to add the path to; default is goog.global.
code »
goog.findBasePath_()
Tries to detect the base path of base.js script that bootstraps Closure.
code »
goog.forwardDeclare(name)
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.
Arguments:
name : string
The namespace to forward declare in the form of "goog.package.part".
code »
goog.getCssName(classNameopt_modifier) string
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.
Arguments:
className : string
The class name.
opt_modifier : string=
A modifier to be appended to the class name.
Returns: string  The class name or the concatenation of the class name and the modifier.
code »
goog.getHashCode(obj) number
Use goog.getUid instead. Adds a hash code field to an object. The hash code is unique for the given object.
Arguments:
obj : Object
The object to get the hash code for.
Returns: number  The hash code for the object.
code »
goog.getMsg(stropt_values) string
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: var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});
Arguments:
str : string
Translatable string, places holders in the form {$foo}.
opt_values : Object=
Map of place holder name to value.
Returns: string  message with placeholders filled.
code »
goog.getMsgWithFallback(ab) string
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: var x = goog.getMsgWithFallback(MSG_A, MSG_B); where MSG_A and MSG_B were initialized with goog.getMsg.
Arguments:
a : string
The preferred message.
b : string
The fallback message.
Returns: string  The best translated message.
code »
goog.getObjectByName(nameopt_obj) ?
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.
Arguments:
name : string
The fully qualified name.
opt_obj : Object=
The object within which to look; default is |goog.global|.
Returns: ?  The value (object or primitive) or, if not found, null.
code »
goog.getObjectByName()
No description.
code »
goog.getPathFromDeps_(rule) ?string
Looks at the dependency rules and tries to determine the script file that fulfills a particular rule.
Arguments:
rule : string
In the form goog.namespace.Class or project.script.
Returns: ?string  Url corresponding to the rule, or null.
code »
goog.getUid(obj) number
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 getUid. There is no guarantee that the ID is unique or consistent across sessions. It is unsafe to generate unique ID for function prototypes.
Arguments:
obj : Object
The object to get the unique ID for.
Returns: number  The unique ID for the object.
code »
goog.globalEval(script)
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.
Arguments:
script : string
JavaScript string.
code »
goog.globalEval()
No description.
code »
goog.globalize(objopt_global)
Properties may be explicitly exported to the global scope, but this should no longer be done in bulk. Globalizes a whole namespace, such as goog or goog.lang.
Arguments:
obj : Object
The namespace to globalize.
opt_global : Object=
The object to add the properties to.
code »
goog.hasUid(obj) boolean
Whether the given object is alreay assigned a unique ID. This does not modify the object.
Arguments:
obj : Object
The object to check.
Returns: boolean  Whether there an assigned unique id for the object.
code »
goog.identityFunction(opt_returnValuevar_args) ?
Use goog.functions.identity instead. The identity function. Returns its first argument.
Arguments:
opt_returnValue : *=
The single value that will be returned.
var_args : ...*
Optional trailing arguments. These are ignored.
Returns: ?  The first argument. We can't know the type -- just pass it along without type.
code »
goog.importScript_(src)
Imports a script if, and only if, that script hasn't already been imported. (Must be called at execution time)
Arguments:
src : string
Script source.
code »
goog.inHtmlDocument_() boolean
Tries to detect whether is in the context of an HTML document.
Returns: boolean  True if it looks like HTML document.
code »
goog.inherits(childCtorparentCtor)
Inherit the prototype methods from one constructor into another. Usage:
function ParentClass(a, b) { }
ParentClass.prototype.foo = function(a) { }

function ChildClass(a, b, c) {
  goog.base(this, a, b);
}
goog.inherits(ChildClass, ParentClass);

var child = new ChildClass('a', 'b', 'see');
child.foo(); // This works.
In addition, a superclass' implementation of a method can be invoked as follows:
ChildClass.prototype.foo = function(a) {
  ChildClass.superClass_.foo.call(this, a);
  // Other code here.
};
Arguments:
childCtor : Function
Child class.
parentCtor : Function
Parent class.
code »
goog.isArray(val) boolean
Returns true if the specified value is an array.
Arguments:
val : ?
Variable to test.
Returns: boolean  Whether variable is an array.
code »
goog.isArrayLike(val) boolean
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.
Arguments:
val : ?
Variable to test.
Returns: boolean  Whether variable is an array.
code »
goog.isBoolean(val) boolean
Returns true if the specified value is a boolean.
Arguments:
val : ?
Variable to test.
Returns: boolean  Whether variable is boolean.
code »
goog.isDateLike(val) boolean
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.
Arguments:
val : ?
Variable to test.
Returns: boolean  Whether variable is a like a Date.
code »
goog.isDef(val) boolean
Returns true if the specified value is not undefined. WARNING: Do not use this to test if an object has a property. Use the in operator instead.
Arguments:
val : ?
Variable to test.
Returns: boolean  Whether variable is defined.
code »
goog.isDefAndNotNull(val) boolean
Returns true if the specified value is defined and not null.
Arguments:
val : ?
Variable to test.
Returns: boolean  Whether variable is defined and not null.
code »
goog.isFunction(val) boolean
Returns true if the specified value is a function.
Arguments:
val : ?
Variable to test.
Returns: boolean  Whether variable is a function.
code »
goog.isNull(val) boolean
Returns true if the specified value is null.
Arguments:
val : ?
Variable to test.
Returns: boolean  Whether variable is null.
code »
goog.isNumber(val) boolean
Returns true if the specified value is a number.
Arguments:
val : ?
Variable to test.
Returns: boolean  Whether variable is a number.
code »
goog.isObject(val) boolean
Returns true if the specified value is an object. This includes arrays and functions.
Arguments:
val : ?
Variable to test.
Returns: boolean  Whether variable is an object.
code »
goog.isProvided_(name) boolean
Check if the given name has been goog.provided. This will return false for names that are available only as implicit namespaces.
Arguments:
name : string
name of the object to look for.
Returns: boolean  Whether the name has been provided.
code »
goog.isString(val) boolean
Returns true if the specified value is a string.
Arguments:
val : ?
Variable to test.
Returns: boolean  Whether variable is a string.
code »
goog.memoize(fopt_serializer) !Function
Decorator around functions that caches the inner function's return values. To cache parameterless functions, see goog.functions.cacheReturnValue.
Arguments:
f : Function
The function to wrap. Its return value may only depend on its arguments and 'this' context. There may be further restrictions on the arguments depending on the capabilities of the serializer used.
opt_serializer : function(number, Object): string=
A function to serialize f's arguments. It must have the same signature as goog.memoize.simpleSerializer. It defaults to that function.
Returns: !Function  The wrapped function.
code »
goog.mixin(targetsource)
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.
Arguments:
target : Object
Target.
source : Object
Source.
code »
goog.now() number
No description.
Returns: number  An integer value representing the number of milliseconds between midnight, January 1, 1970 and the current time.
code »
goog.now()
No description.
code »
testDateConstructor&goog.now()
No description.
code »
testDateTimeConstructor&goog.now()
No description.
code »
goog.nullFunction() void
Null function used for default values of callbacks, etc.
Returns: void  Nothing.
code »
goog.partial(fnvar_args) !Function
Like bind(), except that a 'this object' is not required. Useful when the target function is already bound. Usage: var g = partial(f, arg1, arg2); g(arg3, arg4);
Arguments:
fn : Function
A function to partially apply.
var_args : ...*
Additional arguments that are partially applied to fn.
Returns: !Function  A partially-applied form of the function bind() was invoked as a method of.
code »
goog.provide(name)
Creates object stubs for a namespace. The presence of one or more goog.provide() calls indicate that the file defines the given objects/namespaces. Provided objects must not be null or undefined. Build tools also scan for provide/require statements to discern dependencies, build dependency files (see deps.js), etc.
Arguments:
name : string
Namespace provided by this file in the form "goog.package.part".
code »
goog.removeHashCode(obj)
Use goog.removeUid instead. Removes the hash code field from an object.
Arguments:
obj : Object
The object to remove the field from.
code »
goog.removeUid(obj)
Removes the unique ID from an object. This is useful if the object was previously mutated using goog.getUid in which case the mutation is undone.
Arguments:
obj : Object
The object to remove the unique ID field from.
code »
goog.require(name)
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 JSCompiler when the --closure_pass option is used.
Arguments:
name : string
Namespace to include (as was given in goog.provide()) in the form "goog.package.part".
code »
goog.scope(fn)
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.
Arguments:
fn : function()
Function to call. This function can contain aliases to namespaces (e.g. "var dom = goog.dom") or classes (e.g. "var Timer = goog.Timer").
code »
goog.setCssNameMapping(mappingopt_style)
Sets the map to check when returning a value from goog.getCssName(). Example:
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')
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 --closure_pass flag is set.
Arguments:
mapping : !Object
A map of strings to strings where keys are possible arguments to goog.getCssName() and values are the corresponding values that should be returned.
opt_style : string=
The style of css name mapping. There are two valid options: 'BY_PART', and 'BY_WHOLE'.
code »
goog.setTestOnly(opt_message)
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).
Arguments:
opt_message : string=
Optional message to add to the error that's raised when used in production code.
code »
goog.typeOf(value) string
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'.
Arguments:
value : *
The value to get the type of.
Returns: string  The name of the type.
code »
goog.writeScriptTag_(src) boolean
The default implementation of the import function. Writes a script tag to import the script.
Arguments:
src : string
The script source.
Returns: boolean  True if the script was imported, false otherwise.
code »
goog.writeScripts_()
Resolves dependencies based on the dependencies added using addDependency and calls importScript_ in the correct order.
code »

Global Properties

goog.DEBUG :
No description.
Code »
goog.DEPENDENCIES_ENABLED :
True if goog.dependencies_ is available.
Code »
goog.DisposableTest :
No description.
Code »
goog.ENABLE_DEBUG_LOADER :
No description.
Code »
goog.HistoryTest :
No description.
Code »
goog.LOCALE :
No description.
Code »
goog.NATIVE_ARRAY_PROTOTYPES :
No description.
Code »
goog.PromiseTest :
No description.
Code »
goog.STRICT_MODE_COMPATIBLE :
No description.
Code »
goog.TRUSTED_SITE :
No description.
Code »
goog.TimerTest :
No description.
Code »
goog.UID_PROPERTY_ :
Name for unique ID property. Initialized in a way to help avoid collisions with other closure JavaScript on the same page.
Code »
goog.UriTest :
No description.
Code »
goog.a11y :
No description.
Code »
goog.abstractMethod :
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. Note: This does not take the name of the function to override as an argument because that would make it more difficult to obfuscate our JavaScript code.
Code »
goog.array :
No description.
Code »
goog.arrayTest :
No description.
Code »
goog.asserts :
No description.
Code »
goog.assertsTest :
No description.
Code »
goog.async :
No description.
Code »
goog.basePath :
Path for included scripts.
Code »
goog.color :
No description.
Code »
goog.colorTest :
No description.
Code »
goog.crypt :
No description.
Code »
goog.cryptTest :
No description.
Code »
goog.cssNameMappingStyle_ :
Optional obfuscation style for CSS class names. Should be set to either 'BY_WHOLE' or 'BY_PART' if defined.
Code »
goog.cssNameMapping_ :
Optional map of CSS class names to obfuscated names used with goog.getCssName().
Code »
goog.cssom :
No description.
Code »
goog.cssomTest :
No description.
Code »
goog.date :
No description.
Code »
goog.dateTest :
No description.
Code »
goog.db :
No description.
Code »
goog.dbTest :
No description.
Code »
goog.debug :
No description.
Code »
goog.debugEnhanceErrorTest :
No description.
Code »
goog.debugTest :
No description.
Code »
goog.defineClassTest :
No description.
Code »
goog.demos :
No description.
Code »
goog.dependencies_ :
This object is used to keep track of dependencies and other data that is used for loading scripts.
Code »
goog.disposable :
No description.
Code »
goog.dom :
No description.
Code »
goog.ds :
No description.
Code »
goog.editor :
No description.
Code »
goog.evalWorksForGlobals_ :
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
Code »
goog.events :
No description.
Code »
goog.eventsTest :
No description.
Code »
goog.format :
No description.
Code »
goog.formatTest :
No description.
Code »
goog.fs :
No description.
Code »
goog.fsTest :
No description.
Code »
goog.functions :
No description.
Code »
goog.functionsTest :
No description.
Code »
goog.fx :
No description.
Code »
goog.fxTest :
No description.
Code »
goog.graphics :
No description.
Code »
goog.history :
No description.
Code »
goog.html :
No description.
Code »
goog.i18n :
No description.
Code »
goog.implicitNamespaces_ :
Namespaces implicitly defined by goog.provide. For example, goog.provide('goog.events.Event') implicitly declares that 'goog' and 'goog.events' must be namespaces.
Code »
goog.included_ :
Object used to keep track of urls that have already been added. This record allows the prevention of circular dependencies.
Code »
goog.instantiatedSingletons_ :
All singleton classes that have been instantiated, for testing. Don't read it directly, use the goog.testing.singleton module. The compiler removes this variable if unused.
Code »
goog.iter :
No description.
Code »
goog.iterTest :
No description.
Code »
goog.json :
No description.
Code »
goog.jsonPerf :
No description.
Code »
goog.jsonTest :
No description.
Code »
goog.labs :
No description.
Code »
goog.locale :
No description.
Code »
goog.log :
No description.
Code »
goog.logTest :
No description.
Code »
goog.math :
No description.
Code »
goog.mathTest :
No description.
Code »
goog.memoizeTest :
No description.
Code »
goog.messaging :
No description.
Code »
goog.module :
No description.
Code »
goog.net :
No description.
Code »
goog.object :
No description.
Code »
goog.objectTest :
No description.
Code »
goog.oldDbTest :
No description.
Code »
goog.osapi :
No description.
Code »
goog.positioning :
No description.
Code »
goog.positioningTest :
No description.
Code »
goog.promise :
No description.
Code »
goog.proto :
No description.
Code »
goog.proto2 :
No description.
Code »
goog.protoTest :
No description.
Code »
goog.pubsub :
No description.
Code »
goog.reflect :
No description.
Code »
goog.result :
No description.
Code »
goog.soy :
No description.
Code »
goog.soyTest :
No description.
Code »
goog.spell :
No description.
Code »
goog.stats :
No description.
Code »
goog.storage :
No description.
Code »
goog.string :
No description.
Code »
goog.stringTest :
No description.
Code »
goog.structs :
No description.
Code »
goog.structsTest :
No description.
Code »
goog.style :
No description.
Code »
goog.styleScrollbarTester :
No description.
Code »
goog.style_test :
No description.
Code »
goog.testing :
No description.
Code »
goog.text :
No description.
Code »
goog.tweak :
No description.
Code »
goog.ui :
No description.
Code »
goog.uidCounter_ :
Counter for UID.
Code »
goog.uri :
No description.
Code »
goog.userAgent :
No description.
Code »
goog.userAgentQuirksTest :
No description.
Code »
goog.userAgentTest :
No description.
Code »
goog.userAgentTestUtil :
No description.
Code »
goog.vec :
No description.
Code »
goog.webgl :
No description.
Code »
goog.window :
No description.
Code »
goog.windowTest :
No description.
Code »

Package

Package Reference