=} opt_values Maps place holder name to value.
1788 | * @param {{html: (boolean|undefined),
1789 | * unescapeHtmlEntities: (boolean|undefined)}=} opt_options Options:
1790 | * html: Escape '<' in str to '<'. Used by Closure Templates where the
1791 | * generated code size and performance is critical which is why {@link
1792 | * goog.html.SafeHtmlFormatter} is not used. The value must be literal true
1793 | * or false.
1794 | * unescapeHtmlEntities: Unescape common html entities: >, <, ',
1795 | * " and &. Used for messages not in HTML context, such as with
1796 | * `textContent` property.
1797 | * @return {string} message with placeholders filled.
1798 | */
1799 | goog.getMsg = function(str, opt_values, opt_options) {
1800 | if (opt_options && opt_options.html) {
1801 | // Note that '&' is not replaced because the translation can contain HTML
1802 | // entities.
1803 | str = str.replace(/')
1809 | .replace(/'/g, '\'')
1810 | .replace(/"/g, '"')
1811 | .replace(/&/g, '&');
1812 | }
1813 | if (opt_values) {
1814 | str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
1815 | return (opt_values != null && key in opt_values) ? opt_values[key] :
1816 | match;
1817 | });
1818 | }
1819 | return str;
1820 | };
1821 |
1822 |
1823 | /**
1824 | * Gets a localized message. If the message does not have a translation, gives a
1825 | * fallback message.
1826 | *
1827 | * This is useful when introducing a new message that has not yet been
1828 | * translated into all languages.
1829 | *
1830 | * This function is a compiler primitive. Must be used in the form:
1831 | * var x = goog.getMsgWithFallback(MSG_A, MSG_B);
1832 | * where MSG_A and MSG_B were initialized with goog.getMsg.
1833 | *
1834 | * @param {string} a The preferred message.
1835 | * @param {string} b The fallback message.
1836 | * @return {string} The best translated message.
1837 | */
1838 | goog.getMsgWithFallback = function(a, b) {
1839 | return a;
1840 | };
1841 |
1842 |
1843 | /**
1844 | * Exposes an unobfuscated global namespace path for the given object.
1845 | * Note that fields of the exported object *will* be obfuscated, unless they are
1846 | * exported in turn via this function or goog.exportProperty.
1847 | *
1848 | * Also handy for making public items that are defined in anonymous closures.
1849 | *
1850 | * ex. goog.exportSymbol('public.path.Foo', Foo);
1851 | *
1852 | * ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);
1853 | * public.path.Foo.staticFunction();
1854 | *
1855 | * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',
1856 | * Foo.prototype.myMethod);
1857 | * new public.path.Foo().myMethod();
1858 | *
1859 | * @param {string} publicPath Unobfuscated name to export.
1860 | * @param {*} object Object the name should point to.
1861 | * @param {?Object=} objectToExportTo The object to add the path to; default
1862 | * is goog.global.
1863 | */
1864 | goog.exportSymbol = function(publicPath, object, objectToExportTo) {
1865 | goog.exportPath_(
1866 | publicPath, object, /* overwriteImplicit= */ true, objectToExportTo);
1867 | };
1868 |
1869 |
1870 | /**
1871 | * Exports a property unobfuscated into the object's namespace.
1872 | * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);
1873 | * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);
1874 | * @param {Object} object Object whose static property is being exported.
1875 | * @param {string} publicName Unobfuscated name to export.
1876 | * @param {*} symbol Object the name should point to.
1877 | */
1878 | goog.exportProperty = function(object, publicName, symbol) {
1879 | object[publicName] = symbol;
1880 | };
1881 |
1882 |
1883 | /**
1884 | * Inherit the prototype methods from one constructor into another.
1885 | *
1886 | * Usage:
1887 | *
1888 | * function ParentClass(a, b) { }
1889 | * ParentClass.prototype.foo = function(a) { };
1890 | *
1891 | * function ChildClass(a, b, c) {
1892 | * ChildClass.base(this, 'constructor', a, b);
1893 | * }
1894 | * goog.inherits(ChildClass, ParentClass);
1895 | *
1896 | * var child = new ChildClass('a', 'b', 'see');
1897 | * child.foo(); // This works.
1898 | *
1899 | *
1900 | * @param {!Function} childCtor Child class.
1901 | * @param {!Function} parentCtor Parent class.
1902 | * @suppress {strictMissingProperties} superClass_ and base is not defined on
1903 | * Function.
1904 | * @deprecated Use ECMAScript class syntax instead.
1905 | */
1906 | goog.inherits = function(childCtor, parentCtor) {
1907 | /** @constructor */
1908 | function tempCtor() {}
1909 | tempCtor.prototype = parentCtor.prototype;
1910 | childCtor.superClass_ = parentCtor.prototype;
1911 | childCtor.prototype = new tempCtor();
1912 | /** @override */
1913 | childCtor.prototype.constructor = childCtor;
1914 |
1915 | /**
1916 | * Calls superclass constructor/method.
1917 | *
1918 | * This function is only available if you use goog.inherits to
1919 | * express inheritance relationships between classes.
1920 | *
1921 | * NOTE: This is a replacement for goog.base and for superClass_
1922 | * property defined in childCtor.
1923 | *
1924 | * @param {!Object} me Should always be "this".
1925 | * @param {string} methodName The method name to call. Calling
1926 | * superclass constructor can be done with the special string
1927 | * 'constructor'.
1928 | * @param {...*} var_args The arguments to pass to superclass
1929 | * method/constructor.
1930 | * @return {*} The return value of the superclass method/constructor.
1931 | */
1932 | childCtor.base = function(me, methodName, var_args) {
1933 | // Copying using loop to avoid deop due to passing arguments object to
1934 | // function. This is faster in many JS engines as of late 2014.
1935 | var args = new Array(arguments.length - 2);
1936 | for (var i = 2; i < arguments.length; i++) {
1937 | args[i - 2] = arguments[i];
1938 | }
1939 | return parentCtor.prototype[methodName].apply(me, args);
1940 | };
1941 | };
1942 |
1943 |
1944 | /**
1945 | * Allow for aliasing within scope functions. This function exists for
1946 | * uncompiled code - in compiled code the calls will be inlined and the aliases
1947 | * applied. In uncompiled code the function is simply run since the aliases as
1948 | * written are valid JavaScript.
1949 | *
1950 | *
1951 | * @param {function()} fn Function to call. This function can contain aliases
1952 | * to namespaces (e.g. "var dom = goog.dom") or classes
1953 | * (e.g. "var Timer = goog.Timer").
1954 | * @deprecated Use goog.module instead.
1955 | */
1956 | goog.scope = function(fn) {
1957 | if (goog.isInModuleLoader_()) {
1958 | throw new Error('goog.scope is not supported within a module.');
1959 | }
1960 | fn.call(goog.global);
1961 | };
1962 |
1963 |
1964 | /*
1965 | * To support uncompiled, strict mode bundles that use eval to divide source
1966 | * like so:
1967 | * eval('someSource;//# sourceUrl sourcefile.js');
1968 | * We need to export the globally defined symbols "goog" and "COMPILED".
1969 | * Exporting "goog" breaks the compiler optimizations, so we required that
1970 | * be defined externally.
1971 | * NOTE: We don't use goog.exportSymbol here because we don't want to trigger
1972 | * extern generation when that compiler option is enabled.
1973 | */
1974 | if (!COMPILED) {
1975 | goog.global['COMPILED'] = COMPILED;
1976 | }
1977 |
1978 |
1979 | //==============================================================================
1980 | // goog.defineClass implementation
1981 | //==============================================================================
1982 |
1983 |
1984 | /**
1985 | * Creates a restricted form of a Closure "class":
1986 | * - from the compiler's perspective, the instance returned from the
1987 | * constructor is sealed (no new properties may be added). This enables
1988 | * better checks.
1989 | * - the compiler will rewrite this definition to a form that is optimal
1990 | * for type checking and optimization (initially this will be a more
1991 | * traditional form).
1992 | *
1993 | * @param {Function} superClass The superclass, Object or null.
1994 | * @param {goog.defineClass.ClassDescriptor} def
1995 | * An object literal describing
1996 | * the class. It may have the following properties:
1997 | * "constructor": the constructor function
1998 | * "statics": an object literal containing methods to add to the constructor
1999 | * as "static" methods or a function that will receive the constructor
2000 | * function as its only parameter to which static properties can
2001 | * be added.
2002 | * all other properties are added to the prototype.
2003 | * @return {!Function} The class constructor.
2004 | * @deprecated Use ECMAScript class syntax instead.
2005 | */
2006 | goog.defineClass = function(superClass, def) {
2007 | // TODO(johnlenz): consider making the superClass an optional parameter.
2008 | var constructor = def.constructor;
2009 | var statics = def.statics;
2010 | // Wrap the constructor prior to setting up the prototype and static methods.
2011 | if (!constructor || constructor == Object.prototype.constructor) {
2012 | constructor = function() {
2013 | throw new Error(
2014 | 'cannot instantiate an interface (no constructor defined).');
2015 | };
2016 | }
2017 |
2018 | var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
2019 | if (superClass) {
2020 | goog.inherits(cls, superClass);
2021 | }
2022 |
2023 | // Remove all the properties that should not be copied to the prototype.
2024 | delete def.constructor;
2025 | delete def.statics;
2026 |
2027 | goog.defineClass.applyProperties_(cls.prototype, def);
2028 | if (statics != null) {
2029 | if (statics instanceof Function) {
2030 | statics(cls);
2031 | } else {
2032 | goog.defineClass.applyProperties_(cls, statics);
2033 | }
2034 | }
2035 |
2036 | return cls;
2037 | };
2038 |
2039 |
2040 | /**
2041 | * @typedef {{
2042 | * constructor: (!Function|undefined),
2043 | * statics: (Object|undefined|function(Function):void)
2044 | * }}
2045 | */
2046 | goog.defineClass.ClassDescriptor;
2047 |
2048 |
2049 | /**
2050 | * @define {boolean} Whether the instances returned by goog.defineClass should
2051 | * be sealed when possible.
2052 | *
2053 | * When sealing is disabled the constructor function will not be wrapped by
2054 | * goog.defineClass, making it incompatible with ES6 class methods.
2055 | */
2056 | goog.defineClass.SEAL_CLASS_INSTANCES =
2057 | goog.define('goog.defineClass.SEAL_CLASS_INSTANCES', goog.DEBUG);
2058 |
2059 |
2060 | /**
2061 | * If goog.defineClass.SEAL_CLASS_INSTANCES is enabled and Object.seal is
2062 | * defined, this function will wrap the constructor in a function that seals the
2063 | * results of the provided constructor function.
2064 | *
2065 | * @param {!Function} ctr The constructor whose results maybe be sealed.
2066 | * @param {Function} superClass The superclass constructor.
2067 | * @return {!Function} The replacement constructor.
2068 | * @private
2069 | */
2070 | goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
2071 | if (!goog.defineClass.SEAL_CLASS_INSTANCES) {
2072 | // Do now wrap the constructor when sealing is disabled. Angular code
2073 | // depends on this for injection to work properly.
2074 | return ctr;
2075 | }
2076 |
2077 | // NOTE: The sealing behavior has been removed
2078 |
2079 | /**
2080 | * @this {Object}
2081 | * @return {?}
2082 | */
2083 | var wrappedCtr = function() {
2084 | // Don't seal an instance of a subclass when it calls the constructor of
2085 | // its super class as there is most likely still setup to do.
2086 | var instance = ctr.apply(this, arguments) || this;
2087 | instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];
2088 |
2089 | return instance;
2090 | };
2091 |
2092 | return wrappedCtr;
2093 | };
2094 |
2095 |
2096 |
2097 | // TODO(johnlenz): share these values with the goog.object
2098 | /**
2099 | * The names of the fields that are defined on Object.prototype.
2100 | * @type {!Array}
2101 | * @private
2102 | * @const
2103 | */
2104 | goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [
2105 | 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
2106 | 'toLocaleString', 'toString', 'valueOf'
2107 | ];
2108 |
2109 |
2110 | // TODO(johnlenz): share this function with the goog.object
2111 | /**
2112 | * @param {!Object} target The object to add properties to.
2113 | * @param {!Object} source The object to copy properties from.
2114 | * @private
2115 | */
2116 | goog.defineClass.applyProperties_ = function(target, source) {
2117 | // TODO(johnlenz): update this to support ES5 getters/setters
2118 |
2119 | var key;
2120 | for (key in source) {
2121 | if (Object.prototype.hasOwnProperty.call(source, key)) {
2122 | target[key] = source[key];
2123 | }
2124 | }
2125 |
2126 | // For IE the for-in-loop does not contain any properties that are not
2127 | // enumerable on the prototype object (for example isPrototypeOf from
2128 | // Object.prototype) and it will also not include 'replace' on objects that
2129 | // extend String and change 'replace' (not that it is common for anyone to
2130 | // extend anything except Object).
2131 | for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {
2132 | key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];
2133 | if (Object.prototype.hasOwnProperty.call(source, key)) {
2134 | target[key] = source[key];
2135 | }
2136 | }
2137 | };
2138 |
2139 | /**
2140 | * Returns the parameter.
2141 | * @param {string} s
2142 | * @return {string}
2143 | * @private
2144 | */
2145 | goog.identity_ = function(s) {
2146 | return s;
2147 | };
2148 |
2149 |
2150 | /**
2151 | * Creates Trusted Types policy if Trusted Types are supported by the browser.
2152 | * The policy just blesses any string as a Trusted Type. It is not visibility
2153 | * restricted because anyone can also call trustedTypes.createPolicy directly.
2154 | * However, the allowed names should be restricted by a HTTP header and the
2155 | * reference to the created policy should be visibility restricted.
2156 | * @param {string} name
2157 | * @return {?TrustedTypePolicy}
2158 | */
2159 | goog.createTrustedTypesPolicy = function(name) {
2160 | var policy = null;
2161 | var policyFactory = goog.global.trustedTypes;
2162 | if (!policyFactory || !policyFactory.createPolicy) {
2163 | return policy;
2164 | }
2165 | // trustedTypes.createPolicy throws if called with a name that is already
2166 | // registered, even in report-only mode. Until the API changes, catch the
2167 | // error not to break the applications functionally. In such case, the code
2168 | // will fall back to using regular Safe Types.
2169 | // TODO(koto): Remove catching once createPolicy API stops throwing.
2170 | try {
2171 | policy = policyFactory.createPolicy(name, {
2172 | createHTML: goog.identity_,
2173 | createScript: goog.identity_,
2174 | createScriptURL: goog.identity_
2175 | });
2176 | } catch (e) {
2177 | goog.logToConsole_(e.message);
2178 | }
2179 | return policy;
2180 | };
2181 |
2182 | // There's a bug in the compiler where without collapse properties the
2183 | // Closure namespace defines do not guard code correctly. To help reduce code
2184 | // size also check for !COMPILED even though it redundant until this is fixed.
2185 | if (!COMPILED && goog.DEPENDENCIES_ENABLED) {
2186 |
2187 |
2188 | /**
2189 | * Tries to detect whether the current browser is Edge, based on the user
2190 | * agent. This matches only pre-Chromium Edge.
2191 | * @see https://docs.microsoft.com/en-us/microsoft-edge/web-platform/user-agent-string
2192 | * @return {boolean} True if the current browser is Edge.
2193 | * @private
2194 | */
2195 | goog.isEdge_ = function() {
2196 | var userAgent = goog.global.navigator && goog.global.navigator.userAgent ?
2197 | goog.global.navigator.userAgent :
2198 | '';
2199 | var edgeRe = /Edge\/(\d+)(\.\d)*/i;
2200 | return !!userAgent.match(edgeRe);
2201 | };
2202 |
2203 |
2204 | /**
2205 | * Tries to detect whether is in the context of an HTML document.
2206 | * @return {boolean} True if it looks like HTML document.
2207 | * @private
2208 | */
2209 | goog.inHtmlDocument_ = function() {
2210 | /** @type {!Document} */
2211 | var doc = goog.global.document;
2212 | return doc != null && 'write' in doc; // XULDocument misses write.
2213 | };
2214 |
2215 |
2216 | /**
2217 | * We'd like to check for if the document readyState is 'loading'; however
2218 | * there are bugs on IE 10 and below where the readyState being anything other
2219 | * than 'complete' is not reliable.
2220 | * @return {boolean}
2221 | * @private
2222 | */
2223 | goog.isDocumentLoading_ = function() {
2224 | // attachEvent is available on IE 6 thru 10 only, and thus can be used to
2225 | // detect those browsers.
2226 | /** @type {!HTMLDocument} */
2227 | var doc = goog.global.document;
2228 | return doc.attachEvent ? doc.readyState != 'complete' :
2229 | doc.readyState == 'loading';
2230 | };
2231 |
2232 |
2233 | /**
2234 | * Tries to detect the base path of base.js script that bootstraps Closure.
2235 | * @private
2236 | */
2237 | goog.findBasePath_ = function() {
2238 | if (goog.global.CLOSURE_BASE_PATH != undefined &&
2239 | // Anti DOM-clobbering runtime check (b/37736576).
2240 | typeof goog.global.CLOSURE_BASE_PATH === 'string') {
2241 | goog.basePath = goog.global.CLOSURE_BASE_PATH;
2242 | return;
2243 | } else if (!goog.inHtmlDocument_()) {
2244 | return;
2245 | }
2246 | /** @type {!Document} */
2247 | var doc = goog.global.document;
2248 | // If we have a currentScript available, use it exclusively.
2249 | var currentScript = doc.currentScript;
2250 | if (currentScript) {
2251 | var scripts = [currentScript];
2252 | } else {
2253 | var scripts = doc.getElementsByTagName('SCRIPT');
2254 | }
2255 | // Search backwards since the current script is in almost all cases the one
2256 | // that has base.js.
2257 | for (var i = scripts.length - 1; i >= 0; --i) {
2258 | var script = /** @type {!HTMLScriptElement} */ (scripts[i]);
2259 | var src = script.src;
2260 | var qmark = src.lastIndexOf('?');
2261 | var l = qmark == -1 ? src.length : qmark;
2262 | if (src.substr(l - 7, 7) == 'base.js') {
2263 | goog.basePath = src.substr(0, l - 7);
2264 | return;
2265 | }
2266 | }
2267 | };
2268 |
2269 | goog.findBasePath_();
2270 |
2271 | /** @struct @constructor @final */
2272 | goog.Transpiler = function() {
2273 | /** @private {?Object} */
2274 | this.requiresTranspilation_ = null;
2275 | /** @private {string} */
2276 | this.transpilationTarget_ = goog.TRANSPILE_TO_LANGUAGE;
2277 | };
2278 | /**
2279 | * Returns a newly created map from language mode string to a boolean
2280 | * indicating whether transpilation should be done for that mode as well as
2281 | * the highest level language that this environment supports.
2282 | *
2283 | * Guaranteed invariant:
2284 | * For any two modes, l1 and l2 where l2 is a newer mode than l1,
2285 | * `map[l1] == true` implies that `map[l2] == true`.
2286 | *
2287 | * Note this method is extracted and used elsewhere, so it cannot rely on
2288 | * anything external (it should easily be able to be transformed into a
2289 | * standalone, top level function).
2290 | *
2291 | * @private
2292 | * @return {{
2293 | * target: string,
2294 | * map: !Object
2295 | * }}
2296 | */
2297 | goog.Transpiler.prototype.createRequiresTranspilation_ = function() {
2298 | var transpilationTarget = 'es3';
2299 | var /** !Object */ requiresTranspilation = {'es3': false};
2300 | var transpilationRequiredForAllLaterModes = false;
2301 |
2302 | /**
2303 | * Adds an entry to requiresTranspliation for the given language mode.
2304 | *
2305 | * IMPORTANT: Calls must be made in order from oldest to newest language
2306 | * mode.
2307 | * @param {string} modeName
2308 | * @param {function(): boolean} isSupported Returns true if the JS engine
2309 | * supports the given mode.
2310 | */
2311 | function addNewerLanguageTranspilationCheck(modeName, isSupported) {
2312 | if (transpilationRequiredForAllLaterModes) {
2313 | requiresTranspilation[modeName] = true;
2314 | } else if (isSupported()) {
2315 | transpilationTarget = modeName;
2316 | requiresTranspilation[modeName] = false;
2317 | } else {
2318 | requiresTranspilation[modeName] = true;
2319 | transpilationRequiredForAllLaterModes = true;
2320 | }
2321 | }
2322 |
2323 | /**
2324 | * Does the given code evaluate without syntax errors and return a truthy
2325 | * result?
2326 | */
2327 | function /** boolean */ evalCheck(/** string */ code) {
2328 | try {
2329 | return !!eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(code));
2330 | } catch (ignored) {
2331 | return false;
2332 | }
2333 | }
2334 |
2335 | // Identify ES3-only browsers by their incorrect treatment of commas.
2336 | addNewerLanguageTranspilationCheck('es5', function() {
2337 | return evalCheck('[1,].length==1');
2338 | });
2339 | addNewerLanguageTranspilationCheck('es6', function() {
2340 | // Edge has a non-deterministic (i.e., not reproducible) bug with ES6:
2341 | // https://github.com/Microsoft/ChakraCore/issues/1496.
2342 | if (goog.isEdge_()) {
2343 | // The Reflect.construct test below is flaky on Edge. It can sometimes
2344 | // pass or fail on 40 15.15063, so just exit early for Edge and treat
2345 | // it as ES5. Until we're on a more up to date version just always use
2346 | // ES5. See https://github.com/Microsoft/ChakraCore/issues/3217.
2347 | return false;
2348 | }
2349 | // Test es6: [FF50 (?), Edge 14 (?), Chrome 50]
2350 | // (a) default params (specifically shadowing locals),
2351 | // (b) destructuring, (c) block-scoped functions,
2352 | // (d) for-of (const), (e) new.target/Reflect.construct
2353 | var es6fullTest =
2354 | 'class X{constructor(){if(new.target!=String)throw 1;this.x=42}}' +
2355 | 'let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof ' +
2356 | 'String))throw 1;for(const a of[2,3]){if(a==2)continue;function ' +
2357 | 'f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()' +
2358 | '==3}';
2359 |
2360 | return evalCheck('(()=>{"use strict";' + es6fullTest + '})()');
2361 | });
2362 | // ** and **= are the only new features in 'es7'
2363 | addNewerLanguageTranspilationCheck('es7', function() {
2364 | return evalCheck('2**3==8');
2365 | });
2366 | // async functions are the only new features in 'es8'
2367 | addNewerLanguageTranspilationCheck('es8', function() {
2368 | return evalCheck('async()=>1,1');
2369 | });
2370 | addNewerLanguageTranspilationCheck('es9', function() {
2371 | return evalCheck('({...rest}={}),1');
2372 | });
2373 | // optional catch binding, unescaped unicode paragraph separator in strings
2374 | addNewerLanguageTranspilationCheck('es_2019', function() {
2375 | return evalCheck('let r;try{r="\u2029"}catch{};r');
2376 | });
2377 | // optional chaining, nullish coalescing
2378 | // untested/unsupported: bigint, import meta
2379 | addNewerLanguageTranspilationCheck('es_2020', function() {
2380 | return evalCheck('null?.x??1');
2381 | });
2382 | addNewerLanguageTranspilationCheck('es_next', function() {
2383 | return false; // assume it always need to transpile
2384 | });
2385 | return {target: transpilationTarget, map: requiresTranspilation};
2386 | };
2387 |
2388 |
2389 | /**
2390 | * Determines whether the given language needs to be transpiled.
2391 | * @param {string} lang
2392 | * @param {string|undefined} module
2393 | * @return {boolean}
2394 | */
2395 | goog.Transpiler.prototype.needsTranspile = function(lang, module) {
2396 | if (goog.TRANSPILE == 'always') {
2397 | return true;
2398 | } else if (goog.TRANSPILE == 'never') {
2399 | return false;
2400 | } else if (!this.requiresTranspilation_) {
2401 | var obj = this.createRequiresTranspilation_();
2402 | this.requiresTranspilation_ = obj.map;
2403 | this.transpilationTarget_ = this.transpilationTarget_ || obj.target;
2404 | }
2405 | if (lang in this.requiresTranspilation_) {
2406 | if (this.requiresTranspilation_[lang]) {
2407 | return true;
2408 | } else if (
2409 | goog.inHtmlDocument_() && module == 'es6' &&
2410 | !('noModule' in goog.global.document.createElement('script'))) {
2411 | return true;
2412 | } else {
2413 | return false;
2414 | }
2415 | } else {
2416 | throw new Error('Unknown language mode: ' + lang);
2417 | }
2418 | };
2419 |
2420 |
2421 | /**
2422 | * Lazily retrieves the transpiler and applies it to the source.
2423 | * @param {string} code JS code.
2424 | * @param {string} path Path to the code.
2425 | * @return {string} The transpiled code.
2426 | */
2427 | goog.Transpiler.prototype.transpile = function(code, path) {
2428 | // TODO(johnplaisted): We should delete goog.transpile_ and just have this
2429 | // function. But there's some compile error atm where goog.global is being
2430 | // stripped incorrectly without this.
2431 | return goog.transpile_(code, path, this.transpilationTarget_);
2432 | };
2433 |
2434 |
2435 | /** @private @final {!goog.Transpiler} */
2436 | goog.transpiler_ = new goog.Transpiler();
2437 |
2438 | /**
2439 | * Rewrites closing script tags in input to avoid ending an enclosing script
2440 | * tag.
2441 | *
2442 | * @param {string} str
2443 | * @return {string}
2444 | * @private
2445 | */
2446 | goog.protectScriptTag_ = function(str) {
2447 | return str.replace(/<\/(SCRIPT)/ig, '\\x3c/$1');
2448 | };
2449 |
2450 |
2451 | /**
2452 | * A debug loader is responsible for downloading and executing javascript
2453 | * files in an unbundled, uncompiled environment.
2454 | *
2455 | * This can be custimized via the setDependencyFactory method, or by
2456 | * CLOSURE_IMPORT_SCRIPT/CLOSURE_LOAD_FILE_SYNC.
2457 | *
2458 | * @struct @constructor @final @private
2459 | */
2460 | goog.DebugLoader_ = function() {
2461 | /** @private @const {!Object} */
2462 | this.dependencies_ = {};
2463 | /** @private @const {!Object} */
2464 | this.idToPath_ = {};
2465 | /** @private @const {!Object} */
2466 | this.written_ = {};
2467 | /** @private @const {!Array} */
2468 | this.loadingDeps_ = [];
2469 | /** @private {!Array} */
2470 | this.depsToLoad_ = [];
2471 | /** @private {boolean} */
2472 | this.paused_ = false;
2473 | /** @private {!goog.DependencyFactory} */
2474 | this.factory_ = new goog.DependencyFactory(goog.transpiler_);
2475 | /** @private @const {!Object} */
2476 | this.deferredCallbacks_ = {};
2477 | /** @private @const {!Array} */
2478 | this.deferredQueue_ = [];
2479 | };
2480 |
2481 | /**
2482 | * @param {!Array} namespaces
2483 | * @param {function(): undefined} callback Function to call once all the
2484 | * namespaces have loaded.
2485 | */
2486 | goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {
2487 | var cb = callback;
2488 | function resolve() {
2489 | if (cb) {
2490 | goog.global.setTimeout(cb, 0);
2491 | cb = null;
2492 | }
2493 | }
2494 |
2495 | if (!namespaces.length) {
2496 | resolve();
2497 | return;
2498 | }
2499 |
2500 | var deps = [];
2501 | for (var i = 0; i < namespaces.length; i++) {
2502 | var path = this.getPathFromDeps_(namespaces[i]);
2503 | if (!path) {
2504 | throw new Error('Unregonized namespace: ' + namespaces[i]);
2505 | }
2506 | deps.push(this.dependencies_[path]);
2507 | }
2508 |
2509 | var require = goog.require;
2510 | var loaded = 0;
2511 | for (var i = 0; i < namespaces.length; i++) {
2512 | require(namespaces[i]);
2513 | deps[i].onLoad(function() {
2514 | if (++loaded == namespaces.length) {
2515 | resolve();
2516 | }
2517 | });
2518 | }
2519 | };
2520 |
2521 |
2522 | /**
2523 | * Loads the Closure Dependency file.
2524 | *
2525 | * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base
2526 | * loaded, setDependencyFactory called, and then this called. i.e. allows
2527 | * custom loading of the deps file.
2528 | */
2529 | goog.DebugLoader_.prototype.loadClosureDeps = function() {
2530 | // Circumvent addDependency, which would try to transpile deps.js if
2531 | // transpile is set to always.
2532 | var relPath = 'deps.js';
2533 | this.depsToLoad_.push(this.factory_.createDependency(
2534 | goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {},
2535 | false));
2536 | this.loadDeps_();
2537 | };
2538 |
2539 |
2540 | /**
2541 | * Notifies the debug loader when a dependency has been requested.
2542 | *
2543 | * @param {string} absPathOrId Path of the dependency or goog id.
2544 | * @param {boolean=} opt_force
2545 | */
2546 | goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {
2547 | var path = this.getPathFromDeps_(absPathOrId);
2548 | if (path &&
2549 | (opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {
2550 | var callback = this.deferredCallbacks_[path];
2551 | if (callback) {
2552 | delete this.deferredCallbacks_[path];
2553 | callback();
2554 | }
2555 | }
2556 | };
2557 |
2558 |
2559 | /**
2560 | * Sets the dependency factory, which can be used to create custom
2561 | * goog.Dependency implementations to control how dependencies are loaded.
2562 | *
2563 | * @param {!goog.DependencyFactory} factory
2564 | */
2565 | goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {
2566 | this.factory_ = factory;
2567 | };
2568 |
2569 |
2570 | /**
2571 | * Travserses the dependency graph and queues the given dependency, and all of
2572 | * its transitive dependencies, for loading and then starts loading if not
2573 | * paused.
2574 | *
2575 | * @param {string} namespace
2576 | * @private
2577 | */
2578 | goog.DebugLoader_.prototype.load_ = function(namespace) {
2579 | if (!this.getPathFromDeps_(namespace)) {
2580 | var errorMessage = 'goog.require could not find: ' + namespace;
2581 | goog.logToConsole_(errorMessage);
2582 | } else {
2583 | var loader = this;
2584 |
2585 | var deps = [];
2586 |
2587 | /** @param {string} namespace */
2588 | var visit = function(namespace) {
2589 | var path = loader.getPathFromDeps_(namespace);
2590 |
2591 | if (!path) {
2592 | throw new Error('Bad dependency path or symbol: ' + namespace);
2593 | }
2594 |
2595 | if (loader.written_[path]) {
2596 | return;
2597 | }
2598 |
2599 | loader.written_[path] = true;
2600 |
2601 | var dep = loader.dependencies_[path];
2602 | for (var i = 0; i < dep.requires.length; i++) {
2603 | if (!goog.isProvided_(dep.requires[i])) {
2604 | visit(dep.requires[i]);
2605 | }
2606 | }
2607 |
2608 | deps.push(dep);
2609 | };
2610 |
2611 | visit(namespace);
2612 |
2613 | var wasLoading = !!this.depsToLoad_.length;
2614 | this.depsToLoad_ = this.depsToLoad_.concat(deps);
2615 |
2616 | if (!this.paused_ && !wasLoading) {
2617 | this.loadDeps_();
2618 | }
2619 | }
2620 | };
2621 |
2622 |
2623 | /**
2624 | * Loads any queued dependencies until they are all loaded or paused.
2625 | *
2626 | * @private
2627 | */
2628 | goog.DebugLoader_.prototype.loadDeps_ = function() {
2629 | var loader = this;
2630 | var paused = this.paused_;
2631 |
2632 | while (this.depsToLoad_.length && !paused) {
2633 | (function() {
2634 | var loadCallDone = false;
2635 | var dep = loader.depsToLoad_.shift();
2636 |
2637 | var loaded = false;
2638 | loader.loading_(dep);
2639 |
2640 | var controller = {
2641 | pause: function() {
2642 | if (loadCallDone) {
2643 | throw new Error('Cannot call pause after the call to load.');
2644 | } else {
2645 | paused = true;
2646 | }
2647 | },
2648 | resume: function() {
2649 | if (loadCallDone) {
2650 | loader.resume_();
2651 | } else {
2652 | // Some dep called pause and then resume in the same load call.
2653 | // Just keep running this same loop.
2654 | paused = false;
2655 | }
2656 | },
2657 | loaded: function() {
2658 | if (loaded) {
2659 | throw new Error('Double call to loaded.');
2660 | }
2661 |
2662 | loaded = true;
2663 | loader.loaded_(dep);
2664 | },
2665 | pending: function() {
2666 | // Defensive copy.
2667 | var pending = [];
2668 | for (var i = 0; i < loader.loadingDeps_.length; i++) {
2669 | pending.push(loader.loadingDeps_[i]);
2670 | }
2671 | return pending;
2672 | },
2673 | /**
2674 | * @param {goog.ModuleType} type
2675 | */
2676 | setModuleState: function(type) {
2677 | goog.moduleLoaderState_ = {
2678 | type: type,
2679 | moduleName: '',
2680 | declareLegacyNamespace: false
2681 | };
2682 | },
2683 | /** @type {function(string, string, string=)} */
2684 | registerEs6ModuleExports: function(
2685 | path, exports, opt_closureNamespace) {
2686 | if (opt_closureNamespace) {
2687 | goog.loadedModules_[opt_closureNamespace] = {
2688 | exports: exports,
2689 | type: goog.ModuleType.ES6,
2690 | moduleId: opt_closureNamespace || ''
2691 | };
2692 | }
2693 | },
2694 | /** @type {function(string, ?)} */
2695 | registerGoogModuleExports: function(moduleId, exports) {
2696 | goog.loadedModules_[moduleId] = {
2697 | exports: exports,
2698 | type: goog.ModuleType.GOOG,
2699 | moduleId: moduleId
2700 | };
2701 | },
2702 | clearModuleState: function() {
2703 | goog.moduleLoaderState_ = null;
2704 | },
2705 | defer: function(callback) {
2706 | if (loadCallDone) {
2707 | throw new Error(
2708 | 'Cannot register with defer after the call to load.');
2709 | }
2710 | loader.defer_(dep, callback);
2711 | },
2712 | areDepsLoaded: function() {
2713 | return loader.areDepsLoaded_(dep.requires);
2714 | }
2715 | };
2716 |
2717 | try {
2718 | dep.load(controller);
2719 | } finally {
2720 | loadCallDone = true;
2721 | }
2722 | })();
2723 | }
2724 |
2725 | if (paused) {
2726 | this.pause_();
2727 | }
2728 | };
2729 |
2730 |
2731 | /** @private */
2732 | goog.DebugLoader_.prototype.pause_ = function() {
2733 | this.paused_ = true;
2734 | };
2735 |
2736 |
2737 | /** @private */
2738 | goog.DebugLoader_.prototype.resume_ = function() {
2739 | if (this.paused_) {
2740 | this.paused_ = false;
2741 | this.loadDeps_();
2742 | }
2743 | };
2744 |
2745 |
2746 | /**
2747 | * Marks the given dependency as loading (load has been called but it has not
2748 | * yet marked itself as finished). Useful for dependencies that want to know
2749 | * what else is loading. Example: goog.modules cannot eval if there are
2750 | * loading dependencies.
2751 | *
2752 | * @param {!goog.Dependency} dep
2753 | * @private
2754 | */
2755 | goog.DebugLoader_.prototype.loading_ = function(dep) {
2756 | this.loadingDeps_.push(dep);
2757 | };
2758 |
2759 |
2760 | /**
2761 | * Marks the given dependency as having finished loading and being available
2762 | * for require.
2763 | *
2764 | * @param {!goog.Dependency} dep
2765 | * @private
2766 | */
2767 | goog.DebugLoader_.prototype.loaded_ = function(dep) {
2768 | for (var i = 0; i < this.loadingDeps_.length; i++) {
2769 | if (this.loadingDeps_[i] == dep) {
2770 | this.loadingDeps_.splice(i, 1);
2771 | break;
2772 | }
2773 | }
2774 |
2775 | for (var i = 0; i < this.deferredQueue_.length; i++) {
2776 | if (this.deferredQueue_[i] == dep.path) {
2777 | this.deferredQueue_.splice(i, 1);
2778 | break;
2779 | }
2780 | }
2781 |
2782 | if (this.loadingDeps_.length == this.deferredQueue_.length &&
2783 | !this.depsToLoad_.length) {
2784 | // Something has asked to load these, but they may not be directly
2785 | // required again later, so load them now that we know we're done loading
2786 | // everything else. e.g. a goog module entry point.
2787 | while (this.deferredQueue_.length) {
2788 | this.requested(this.deferredQueue_.shift(), true);
2789 | }
2790 | }
2791 |
2792 | dep.loaded();
2793 | };
2794 |
2795 |
2796 | /**
2797 | * @param {!Array} pathsOrIds
2798 | * @return {boolean}
2799 | * @private
2800 | */
2801 | goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {
2802 | for (var i = 0; i < pathsOrIds.length; i++) {
2803 | var path = this.getPathFromDeps_(pathsOrIds[i]);
2804 | if (!path ||
2805 | (!(path in this.deferredCallbacks_) &&
2806 | !goog.isProvided_(pathsOrIds[i]))) {
2807 | return false;
2808 | }
2809 | }
2810 |
2811 | return true;
2812 | };
2813 |
2814 |
2815 | /**
2816 | * @param {string} absPathOrId
2817 | * @return {?string}
2818 | * @private
2819 | */
2820 | goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {
2821 | if (absPathOrId in this.idToPath_) {
2822 | return this.idToPath_[absPathOrId];
2823 | } else if (absPathOrId in this.dependencies_) {
2824 | return absPathOrId;
2825 | } else {
2826 | return null;
2827 | }
2828 | };
2829 |
2830 |
2831 | /**
2832 | * @param {!goog.Dependency} dependency
2833 | * @param {!Function} callback
2834 | * @private
2835 | */
2836 | goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {
2837 | this.deferredCallbacks_[dependency.path] = callback;
2838 | this.deferredQueue_.push(dependency.path);
2839 | };
2840 |
2841 |
2842 | /**
2843 | * Interface for goog.Dependency implementations to have some control over
2844 | * loading of dependencies.
2845 | *
2846 | * @record
2847 | */
2848 | goog.LoadController = function() {};
2849 |
2850 |
2851 | /**
2852 | * Tells the controller to halt loading of more dependencies.
2853 | */
2854 | goog.LoadController.prototype.pause = function() {};
2855 |
2856 |
2857 | /**
2858 | * Tells the controller to resume loading of more dependencies if paused.
2859 | */
2860 | goog.LoadController.prototype.resume = function() {};
2861 |
2862 |
2863 | /**
2864 | * Tells the controller that this dependency has finished loading.
2865 | *
2866 | * This causes this to be removed from pending() and any load callbacks to
2867 | * fire.
2868 | */
2869 | goog.LoadController.prototype.loaded = function() {};
2870 |
2871 |
2872 | /**
2873 | * List of dependencies on which load has been called but which have not
2874 | * called loaded on their controller. This includes the current dependency.
2875 | *
2876 | * @return {!Array}
2877 | */
2878 | goog.LoadController.prototype.pending = function() {};
2879 |
2880 |
2881 | /**
2882 | * Registers an object as an ES6 module's exports so that goog.modules may
2883 | * require it by path.
2884 | *
2885 | * @param {string} path Full path of the module.
2886 | * @param {?} exports
2887 | * @param {string=} opt_closureNamespace Closure namespace to associate with
2888 | * this module.
2889 | */
2890 | goog.LoadController.prototype.registerEs6ModuleExports = function(
2891 | path, exports, opt_closureNamespace) {};
2892 |
2893 |
2894 | /**
2895 | * Sets the current module state.
2896 | *
2897 | * @param {goog.ModuleType} type Type of module.
2898 | */
2899 | goog.LoadController.prototype.setModuleState = function(type) {};
2900 |
2901 |
2902 | /**
2903 | * Clears the current module state.
2904 | */
2905 | goog.LoadController.prototype.clearModuleState = function() {};
2906 |
2907 |
2908 | /**
2909 | * Registers a callback to call once the dependency is actually requested
2910 | * via goog.require + all of the immediate dependencies have been loaded or
2911 | * all other files have been loaded. Allows for lazy loading until
2912 | * require'd without pausing dependency loading, which is needed on old IE.
2913 | *
2914 | * @param {!Function} callback
2915 | */
2916 | goog.LoadController.prototype.defer = function(callback) {};
2917 |
2918 |
2919 | /**
2920 | * @return {boolean}
2921 | */
2922 | goog.LoadController.prototype.areDepsLoaded = function() {};
2923 |
2924 |
2925 | /**
2926 | * Basic super class for all dependencies Closure Library can load.
2927 | *
2928 | * This default implementation is designed to load untranspiled, non-module
2929 | * scripts in a web broswer.
2930 | *
2931 | * For transpiled non-goog.module files {@see goog.TranspiledDependency}.
2932 | * For goog.modules see {@see goog.GoogModuleDependency}.
2933 | * For untranspiled ES6 modules {@see goog.Es6ModuleDependency}.
2934 | *
2935 | * @param {string} path Absolute path of this script.
2936 | * @param {string} relativePath Path of this script relative to goog.basePath.
2937 | * @param {!Array} provides goog.provided or goog.module symbols
2938 | * in this file.
2939 | * @param {!Array} requires goog symbols or relative paths to Closure
2940 | * this depends on.
2941 | * @param {!Object} loadFlags
2942 | * @struct @constructor
2943 | */
2944 | goog.Dependency = function(
2945 | path, relativePath, provides, requires, loadFlags) {
2946 | /** @const */
2947 | this.path = path;
2948 | /** @const */
2949 | this.relativePath = relativePath;
2950 | /** @const */
2951 | this.provides = provides;
2952 | /** @const */
2953 | this.requires = requires;
2954 | /** @const */
2955 | this.loadFlags = loadFlags;
2956 | /** @private {boolean} */
2957 | this.loaded_ = false;
2958 | /** @private {!Array} */
2959 | this.loadCallbacks_ = [];
2960 | };
2961 |
2962 |
2963 | /**
2964 | * @return {string} The pathname part of this dependency's path if it is a
2965 | * URI.
2966 | */
2967 | goog.Dependency.prototype.getPathName = function() {
2968 | var pathName = this.path;
2969 | var protocolIndex = pathName.indexOf('://');
2970 | if (protocolIndex >= 0) {
2971 | pathName = pathName.substring(protocolIndex + 3);
2972 | var slashIndex = pathName.indexOf('/');
2973 | if (slashIndex >= 0) {
2974 | pathName = pathName.substring(slashIndex + 1);
2975 | }
2976 | }
2977 | return pathName;
2978 | };
2979 |
2980 |
2981 | /**
2982 | * @param {function()} callback Callback to fire as soon as this has loaded.
2983 | * @final
2984 | */
2985 | goog.Dependency.prototype.onLoad = function(callback) {
2986 | if (this.loaded_) {
2987 | callback();
2988 | } else {
2989 | this.loadCallbacks_.push(callback);
2990 | }
2991 | };
2992 |
2993 |
2994 | /**
2995 | * Marks this dependency as loaded and fires any callbacks registered with
2996 | * onLoad.
2997 | * @final
2998 | */
2999 | goog.Dependency.prototype.loaded = function() {
3000 | this.loaded_ = true;
3001 | var callbacks = this.loadCallbacks_;
3002 | this.loadCallbacks_ = [];
3003 | for (var i = 0; i < callbacks.length; i++) {
3004 | callbacks[i]();
3005 | }
3006 | };
3007 |
3008 |
3009 | /**
3010 | * Whether or not document.written / appended script tags should be deferred.
3011 | *
3012 | * @private {boolean}
3013 | */
3014 | goog.Dependency.defer_ = false;
3015 |
3016 |
3017 | /**
3018 | * Map of script ready / state change callbacks. Old IE cannot handle putting
3019 | * these properties on goog.global.
3020 | *
3021 | * @private @const {!Object}
3022 | */
3023 | goog.Dependency.callbackMap_ = {};
3024 |
3025 |
3026 | /**
3027 | * @param {function(...?):?} callback
3028 | * @return {string}
3029 | * @private
3030 | */
3031 | goog.Dependency.registerCallback_ = function(callback) {
3032 | var key = Math.random().toString(32);
3033 | goog.Dependency.callbackMap_[key] = callback;
3034 | return key;
3035 | };
3036 |
3037 |
3038 | /**
3039 | * @param {string} key
3040 | * @private
3041 | */
3042 | goog.Dependency.unregisterCallback_ = function(key) {
3043 | delete goog.Dependency.callbackMap_[key];
3044 | };
3045 |
3046 |
3047 | /**
3048 | * @param {string} key
3049 | * @param {...?} var_args
3050 | * @private
3051 | * @suppress {unusedPrivateMembers}
3052 | */
3053 | goog.Dependency.callback_ = function(key, var_args) {
3054 | if (key in goog.Dependency.callbackMap_) {
3055 | var callback = goog.Dependency.callbackMap_[key];
3056 | var args = [];
3057 | for (var i = 1; i < arguments.length; i++) {
3058 | args.push(arguments[i]);
3059 | }
3060 | callback.apply(undefined, args);
3061 | } else {
3062 | var errorMessage = 'Callback key ' + key +
3063 | ' does not exist (was base.js loaded more than once?).';
3064 | throw Error(errorMessage);
3065 | }
3066 | };
3067 |
3068 |
3069 | /**
3070 | * Starts loading this dependency. This dependency can pause loading if it
3071 | * needs to and resume it later via the controller interface.
3072 | *
3073 | * When this is loaded it should call controller.loaded(). Note that this will
3074 | * end up calling the loaded method of this dependency; there is no need to
3075 | * call it explicitly.
3076 | *
3077 | * @param {!goog.LoadController} controller
3078 | */
3079 | goog.Dependency.prototype.load = function(controller) {
3080 | if (goog.global.CLOSURE_IMPORT_SCRIPT) {
3081 | if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
3082 | controller.loaded();
3083 | } else {
3084 | controller.pause();
3085 | }
3086 | return;
3087 | }
3088 |
3089 | if (!goog.inHtmlDocument_()) {
3090 | goog.logToConsole_(
3091 | 'Cannot use default debug loader outside of HTML documents.');
3092 | if (this.relativePath == 'deps.js') {
3093 | // Some old code is relying on base.js auto loading deps.js failing with
3094 | // no error before later setting CLOSURE_IMPORT_SCRIPT.
3095 | // CLOSURE_IMPORT_SCRIPT should be set *before* base.js is loaded, or
3096 | // CLOSURE_NO_DEPS set to true.
3097 | goog.logToConsole_(
3098 | 'Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, ' +
3099 | 'or setting CLOSURE_NO_DEPS to true.');
3100 | controller.loaded();
3101 | } else {
3102 | controller.pause();
3103 | }
3104 | return;
3105 | }
3106 |
3107 | /** @type {!HTMLDocument} */
3108 | var doc = goog.global.document;
3109 |
3110 | // If the user tries to require a new symbol after document load,
3111 | // something has gone terribly wrong. Doing a document.write would
3112 | // wipe out the page. This does not apply to the CSP-compliant method
3113 | // of writing script tags.
3114 | if (doc.readyState == 'complete' &&
3115 | !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {
3116 | // Certain test frameworks load base.js multiple times, which tries
3117 | // to write deps.js each time. If that happens, just fail silently.
3118 | // These frameworks wipe the page between each load of base.js, so this
3119 | // is OK.
3120 | var isDeps = /\bdeps.js$/.test(this.path);
3121 | if (isDeps) {
3122 | controller.loaded();
3123 | return;
3124 | } else {
3125 | throw Error('Cannot write "' + this.path + '" after document load');
3126 | }
3127 | }
3128 |
3129 | var nonce = goog.getScriptNonce_();
3130 | if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
3131 | goog.isDocumentLoading_()) {
3132 | var key;
3133 | var callback = function(script) {
3134 | if (script.readyState && script.readyState != 'complete') {
3135 | script.onload = callback;
3136 | return;
3137 | }
3138 | goog.Dependency.unregisterCallback_(key);
3139 | controller.loaded();
3140 | };
3141 | key = goog.Dependency.registerCallback_(callback);
3142 |
3143 | var defer = goog.Dependency.defer_ ? ' defer' : '';
3144 | var nonceAttr = nonce ? ' nonce="' + nonce + '"' : '';
3145 | var script = '
6 |
7 |
11 |
--------------------------------------------------------------------------------
/testfiles/protopollution_test.html:
--------------------------------------------------------------------------------
1 |
6 |
7 |
11 |
--------------------------------------------------------------------------------
/testfiles/testfile:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/url.txt:
--------------------------------------------------------------------------------
1 | example.com
--------------------------------------------------------------------------------