var goog = goog || {};
  
  

A macro for defining composite types. By assigning goog.typedef to a name, this tells Google internal JSCompiler that this is not the name of a class, but rather it's the name of a composite type. For example,

@type {Array|NodeList} / goog.ArrayLike = goog.typedef; will tell JSCompiler to replace all appearances of goog.ArrayLike in type definitions with the union of Array and NodeList. Does nothing in uncompiled code.

goog.typedef = true;

Reference to the global context. In most cases this will be 'window'.

o3djs.global = this;

Flag used to force a function to run in the browser when it is called from V8. @type {undefined}

o3djs.BROWSER_ONLY = undefined;

Array of namespaces that have been provided. @private @type {!Array.<string>}

o3djs.provided_ = [];

Creates object stubs for a namespace. When present in a file, o3djs.provide also indicates that the file defines the indicated object.
parameter: {string} name name of the object that this file defines.

o3djs.provide = function(name) {
  // Ensure that the same namespace isn't provided twice.
  if (o3djs.getObjectByName(name) &&
      !o3djs.implicitNamespaces_[name]) {
    throw 'Namespace "' + name + '" already declared.';
  }

  var namespace = name;
  while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {
    o3djs.implicitNamespaces_[namespace] = true;
  }

  o3djs.exportPath_(name);
  o3djs.provided_.push(name);
};

Namespaces implicitly defined by o3djs.provide. For example, o3djs.provide('o3djs.events.Event') implicitly declares that 'o3djs' and 'o3djs.events' must be namespaces. @type {Object} @private

o3djs.implicitNamespaces_ = {};

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 o3djs.provide and o3djs.exportSymbol.
parameter: {string} name name of the object that this file defines.
parameter: {Object} opt_object the object to expose at the end of the path.
parameter: {Object} opt_objectToExportTo The object to add the path to; default is |o3djs.global|. @private

o3djs.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
  var parts = name.split('.');
  var cur = opt_objectToExportTo || o3djs.global;
  var part;

  // 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]);
  }

  // Parentheses added to eliminate strict JS warning in Firefox.
  while (parts.length && (part = parts.shift())) {
    if (!parts.length && o3djs.isDef(opt_object)) {
      // last part and we have an object; use it.
      cur[part] = opt_object;
    } else if (cur[part]) {
      cur = cur[part];
    } else {
      cur = cur[part] = {};
    }
  }
};

Returns an object based on its fully qualified external name. If you are using a compilation pass that renames property names beware that using this function will not find renamed properties.
parameter: {string} name The fully qualified name.
parameter: {Object} opt_obj The object within which to look; default is |o3djs.global|.
returns: {Object?} The object or, if not found, null.

o3djs.getObjectByName = function(name, opt_obj) {
  var parts = name.split('.');
  var cur = opt_obj || o3djs.global;
  for (var pp = 0; pp < parts.length; ++pp) {
    var part = parts[pp];
    if (cur[part]) {
      cur = cur[part];
    } else {
      return null;
    }
  }
  return cur;
};

Implements a system for the dynamic resolution of dependencies.
parameter: {string} rule Rule to include, in the form o3djs.package.part.

o3djs.require = function(rule) {
  // if the object already exists we do not need do do anything
  if (o3djs.getObjectByName(rule)) {
    return;
  }
  var path = o3djs.getPathFromRule_(rule);
  if (path) {
    o3djs.included_[path] = true;
    o3djs.writeScripts_();
  } else {
    throw new Error('o3djs.require could not find: ' + rule);
  }
};

Path for included scripts. @type {string}

o3djs.basePath = '';

Object used to keep track of urls that have already been added. This record allows the prevention of circular dependencies. @type {Object} @private

o3djs.included_ = {};

This object is used to keep track of dependencies and other data that is used for loading scripts. @private @type {Object}

o3djs.dependencies_ = {
  visited: {},  // used when resolving dependencies to prevent us from
                // visiting the file twice.
  written: {}  // used to keep track of script files we have written.
};

Tries to detect the base path of the o3djs-base.js script that bootstraps the o3djs libraries. @private

o3djs.findBasePath_ = function() {
  var doc = o3djs.global.document;
  if (typeof doc == 'undefined') {
    return;
  }
  if (o3djs.global.BASE_PATH) {
    o3djs.basePath = o3djs.global.BASE_PATH;
    return;
  } else {
    // HACKHACK to hide compiler warnings :(
    o3djs.global.BASE_PATH = null;
  }
  var scripts = doc.getElementsByTagName('script');
  for (var script, i = 0; script = scripts[i]; i++) {
    var src = script.src;
    var l = src.length;
    if (src.substr(l - 13) == 'o3djs/base.js') {
      o3djs.basePath = src.substr(0, l - 13);
      return;
    }
  }
};

Writes a script tag if, and only if, that script hasn't already been added to the document. (Must be called at execution time.)
parameter: {string} src Script source. @private

o3djs.writeScriptTag_ = function(src) {
  var doc = o3djs.global.document;
  if (typeof doc != 'undefined' &&
      !o3djs.dependencies_.written[src]) {
    o3djs.dependencies_.written[src] = true;
    doc.write('<script type="text/javascript" src="' +
              src + '"></' + 'script>');
  }
};

Resolves dependencies based on the dependencies added using addDependency and calls writeScriptTag_ in the correct order. @private

o3djs.writeScripts_ = function() {
  // the scripts we need to write this time.
  var scripts = [];
  var seenScript = {};
  var deps = o3djs.dependencies_;

  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) {
      if (!(path in seenScript)) {
        seenScript[path] = true;
        scripts.push(path);
      }
      return;
    }

    deps.visited[path] = true;

    if (!(path in seenScript)) {
      seenScript[path] = true;
      scripts.push(path);
    }
  }

  for (var path in o3djs.included_) {
    if (!deps.written[path]) {
      visitNode(path);
    }
  }

  for (var i = 0; i < scripts.length; i++) {
    if (scripts[i]) {
      o3djs.writeScriptTag_(o3djs.basePath + scripts[i]);
    } else {
      throw Error('Undefined script input');
    }
  }
};

Looks at the dependency rules and tries to determine the script file that fulfills a particular rule.
parameter: {string} rule In the form o3djs.namespace.Class or project.script.
returns: {string?} Url corresponding to the rule, or null. @private

o3djs.getPathFromRule_ = function(rule) {
  var parts = rule.split('.');
  return parts.join('/') + '.js';
};

o3djs.findBasePath_();

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.
parameter: {*} val Variable to test.
returns: {boolean} Whether variable is defined.

o3djs.isDef = function(val) {
  return typeof val != 'undefined';
};

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 o3djs.exportProperty. <p>Also handy for making public items that are defined in anonymous closures. ex. o3djs.exportSymbol('Foo', Foo); ex. o3djs.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction); public.path.Foo.staticFunction(); ex. o3djs.exportSymbol('public.path.Foo.prototype.myMethod', Foo.prototype.myMethod); new public.path.Foo().myMethod();
parameter: {string} publicPath Unobfuscated name to export.
parameter: {Object} object Object the name should point to.
parameter: {Object} opt_objectToExportTo The object to add the path to; default is |o3djs.global|.

o3djs.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
  o3djs.exportPath_(publicPath, object, opt_objectToExportTo);
};

This string contains JavaScript code to initialize a new V8 instance. @private @type {string}

o3djs.v8Initializer_ = '';

This array contains references to objects that v8 needs to bind to when it initializes. @private @type {!Array.<Object>}

o3djs.v8InitializerArgs_ = [];

Converts any JavaScript value to a string representation that when evaluated will result in an equal value.
parameter: {*} value Any value.
returns: {string} A string representation for the value. @private

o3djs.valueToString_ = function(value) {
  switch (typeof(value)) {
    case 'undefined':
      return 'undefined';
    case 'string':
      var escaped = escape(value);
      if (escaped === value) {
        return '"' + value + '"';
      } else {
        return 'unescape("' + escaped + '")';
      }
    case 'object':
      if (value === null) {
        return 'null';
      } else {
        // TODO: all the other builtin JavaScript objects like Date,
        // Number, Boolean, etc.
        if (value instanceof RegExp) {
          var result =
              'new RegExp(' + o3djs.valueToString_(value.source) + ', "';
          if (value.global) {
            result += 'g';
          }
          if (value.ignoreCase) {
            result += 'i';
          }
          if (value.multiline) {
            result += 'm';
          }
          result += '")';
          return result;
        } else if (o3djs.base.isArray(value)) {
          var result = '[';
          var separator = '';
          for (var i = 0; i < value.length; ++i) {
            result += separator + o3djs.valueToString_(value[i]);
            separator = ',';
          }
          result += ']\n';
          return result;
        } else {
          var result = '{\n';
          var separator = '';
          for (var propertyName in value) {
            result += separator + '"' + propertyName + '": ' +
              valueToString(value[propertyName]);
            separator = ',';
          }
          result += '}\n';
          return result;
        }
      }
    default:
      return value.toString()
  }
};

Given an object holding a namespace and the name of that namespace, generates a string that when evaluated will populate the namespace.
parameter: {!Object} namespaceObject An object holding a namespace.
parameter: {string} namespaceName The name of the namespace.
parameter: {!Array.