yui.js revision 7f42f69d1fb2e4ea5f1635fc635d3a6c70860c50
/**
* The YUI module contains the components required for building the YUI seed
* file. This includes the script loading mechanism, a simple queue, and
* the core utilities for the library.
* @module yui
* @submodule yui-base
*/
if (typeof YUI != 'undefined') {
}
/**
* The YUI global namespace object. If YUI is already defined, the
* existing YUI object will not be overwritten so that defined
* namespaces are preserved. It is the constructor for the object
* the end user interacts with. As indicated below, each instance
* has full custom event support, but only if the event system
* is available. This is a self-instantiable factory function. You
* can invoke it directly like this:
*
* YUI().use('*', function(Y) {
* // ready
* });
*
* But it also works like this:
*
* var Y = YUI();
*
* @class YUI
* @constructor
* @global
* @uses EventTarget
* @param o* {object} 0..n optional configuration objects. these values
* are store in Y.config. See config for the list of supported
* properties.
*/
/*global YUI*/
/*global YUI_config*/
var YUI = function() {
var i = 0,
Y = this,
instanceOf = function(o, type) {
return (o && o.hasOwnProperty && (o instanceof type));
},
if (!(instanceOf(Y, YUI))) {
Y = new YUI();
} else {
// set up the core environment
Y._init();
// YUI.GlobalConfig is a master configuration that might span
// multiple contexts in a non-browser environment. It is applied
// first to all instances in all contexts.
if (YUI.GlobalConfig) {
}
// YUI_Config is a page-level config. It is applied to all
// instances created on the page. This is applied after
// YUI.GlobalConfig, and before the instance level configuration
// objects.
if (gconf) {
Y.applyConfig(gconf);
}
// bind the specified additional modules for this instance
if (!l) {
Y._setup();
}
}
if (l) {
// Each instance can accept one or more configuration objects.
// These are applied after YUI.GlobalConfig and YUI_Config,
// overriding values set in those config files if there is a '
// matching property.
for (; i < l; i++) {
Y.applyConfig(args[i]);
}
Y._setup();
}
Y.instanceOf = instanceOf;
return Y;
};
(function() {
VERSION = '@VERSION@',
PERIOD = '.',
DOC_LABEL = 'yui3-js-enabled',
NOOP = function() {},
'io.xdrResponse': 1, // can call. this should
'SWF.eventHandler': 1 }, // be done at build time
instances = {},
}
},
// this can throw an uncaught exception in FF
try {
} catch (ex) {}
}
},
handleLoad = function() {
if (hasWin) {
}
},
getLoader = function(Y, o) {
if (loader) {
loader.ignoreRegistered = false;
} else {
}
return loader;
},
clobber = function(r, s) {
for (var i in s) {
if (s.hasOwnProperty(i)) {
r[i] = s[i];
}
}
},
ALREADY_DONE = { success: true };
// Stamp the documentElement (HTML) with a class of "yui-loaded" to
// enable styles that need to key off of JS being enabled.
if (docClass) {
docClass += ' ';
}
}
}
proto = {
/**
* Applies a new configuration object to the YUI instance config.
* update the loader cache if necessary. Updating Y.config directly
* will not update the cache.
* @method applyConfig
* @param {object} the configuration object.
* @since 3.2.0
*/
applyConfig: function(o) {
o = o || NOOP;
var attr,
name,
// detail,
for (name in o) {
if (o.hasOwnProperty(name)) {
} else if (name == 'win') {
} else if (name == '_yuid') {
// preserve the guid
} else {
}
}
}
if (loader) {
}
},
_config: function(o) {
this.applyConfig(o);
},
/**
* Initialize this YUI instance
* @private
*/
_init: function() {
var filter,
Y = this,
prop;
/**
* The version number of the YUI instance.
* @property version
* @type string
*/
if (!Env) {
Y.Env = {
mods: {}, // flat module map
versions: {}, // version module map
// bootstrapped: false,
_idx: 0,
_used: {},
_attached: {},
_yidx: 0,
_uidx: 0,
_guidp: 'y',
_loaded: {},
// serviced: {},
function(srcPattern, comboPattern) {
// get from querystring
if (src) {
if (b) {
// this is to set up the path to the loader. The file
// filter for loader should match the yui include.
if (filter) {
if (match > -1) {
}
}
// extract correct path for mixed combo urls
}
break;
}
}
}
// use CDN default
}
};
}
}
}
}
Y.constructor = YUI;
// configuration defaults
debug: true,
useBrowserConsole: true,
throwFail: true,
bootstrap: true,
cacheUse: true,
fetchCSS: true
};
filter = '-min.';
}
},
/**
* Finishes the instance setup. Attaches whatever modules were defined
* when the yui modules was registered.
* @method _setup
* @private
*/
_setup: function(o) {
var i, Y = this,
core = [],
'rls',
'intl-base',
'loader',
'yui-log',
'yui-later',
'yui-throttle'];
}
}
Y._attach(['yui-base']);
// Y.log(Y.id + ' initialized', 'info', 'yui');
},
/**
* Executes a method on a YUI instance with
* the specified id if the specified method is whitelisted.
* @method applyTo
* @param id {string} the YUI instance id.
* @param method {string} the name of the method to exectute.
* Ex: 'Object.keys'.
* @param args {Array} the arguments to apply to the method.
* @return {object} the return value from the applied method or null.
*/
if (!(method in APPLY_TO_AUTH)) {
return null;
}
if (instance) {
m = instance;
m = m[nest[i]];
if (!m) {
}
}
}
return null;
},
/**
* Registers a module with the YUI global. The easiest way to create a
* first-class YUI module is to use the YUI component build tool.
*
*
* The build system will produce the YUI.add wrapper for you module, along
* with any configuration info required for the module.
* @method add
* @param name {string} module name.
* @param fn {Function} entry point into the module that
* is used to bind module to the YUI instance.
* @param version {string} version string.
* @param details {object} optional config data:
* requires: features that must be present before this module can be
* attached.
* optional: optional features that should be present if loadOptional
* is defined. Note: modules are not often loaded this way in YUI 3,
* but this field is still useful to inform the user that certain
* features in the component will require additional dependencies.
* use: features that are included within this module which need to
* be attached automatically when this module is attached. This
* supports the YUI 3 rollup system -- a module with submodules
* defined will need to have the submodules listed in the 'use'
* config. The YUI component build tool does this for you.
* @return {YUI} the YUI instance.
*
*/
mod = {
},
for (i in instances) {
if (instances.hasOwnProperty(i)) {
if (loader) {
}
}
}
}
return this;
},
/**
* Executes the function associated with each required
* module, binding the module to the YUI instance.
* @method _attach
* @private
*/
_attach: function(r, fromLoader) {
Y = this, j,
// Y.log('attaching: ' + r, 'info', 'yui');
for (i = 0; i < len; i++) {
if (!done[r[i]]) {
name = r[i];
if (!mod) {
// Y.log('no js def for: ' + name, 'info', 'yui');
}
} else {
if (req) {
return false;
}
break;
}
}
}
if (after) {
return false;
}
break;
}
}
}
try {
} catch (e) {
return false;
}
}
if (use) {
return false;
}
break;
}
}
}
}
}
}
return true;
},
/**
* Attaches one or more modules to the YUI instance. When this
* is executed, the requirements are analyzed, and one of
* several things can happen:
*
* - All requirements are available on the page -- The modules
* are attached to the instance. If supplied, the use callback
* is executed synchronously.
*
* - Modules are missing, the Get utility is not available OR
* the 'bootstrap' config is false -- A warning is issued about
* the missing modules and all available modules are attached.
*
* - Modules are missing, the Loader is not available but the Get
* utility is and boostrap is not false -- The loader is bootstrapped
* before doing the following....
*
* - Modules are missing and the Loader is available -- The loader
* expands the dependency tree and fetches missing modules. When
* the loader is finshed the callback supplied to use is executed
* asynchronously.
*
* @param modules* {string} 1-n modules to bind (uses arguments array).
* @param *callback {function} callback function executed when
* the instance has the required functionality. If included, it
* must be the last parameter.
* <code>
* // loads and attaches drag and drop and its dependencies
* YUI().use('dd', function(Y) {});
* // attaches all modules that are available on the page
* YUI().use('*', function(Y) {});
* // intrinsic YUI gallery support (since 3.1.0)
* YUI().use('gallery-yql', function(Y) {});
* // intrinsic YUI 2in3 support (since 3.1.0)
* YUI().use('yui2-datatable', function(Y) {});.
* </code>
*
* @return {YUI} the YUI instance.
*/
use: function() {
Y = this,
i = 0,
info,
name,
provisioned = true;
// The last argument supplied to use can be a load complete callback
} else {
callback = null;
}
provisioned = false;
break;
}
}
if (provisioned) {
return Y;
}
}
} else if (Y._loading) {
} else {
});
}
return Y;
},
} else if (callback) {
try {
} catch (e) {
}
}
},
if (!this.Array) {
this._attach(['yui-base']);
}
Y = this,
YArray = Y.Array,
missing = [],
r = [],
ret = true,
return;
}
// add this module to full list of things to attach
if (!skip) {
}
// only attach a module once
return;
}
if (m) {
} else {
// CSS files don't register themselves, see if it has
// been loaded
} else {
}
}
// make sure requirements are attached
}
// make sure we grab the submodule dependencies too
}
});
},
handleLoader = function(fromLoader) {
var response = fromLoader || {
success: true,
msg: 'not dynamic'
},
ret = true,
Y._loading = false;
if (data) {
missing = [];
r = [];
if (redo) {
redo = false;
}
}
}
Y._loading = false;
}
});
} else {
if (data) {
// Y.log('attaching from loader: ' + data, 'info', 'yui');
}
if (ret) {
}
}
}
};
// Y.log(Y.id + ': use called: ' + a + ' :: ' + callback, 'info', 'yui');
// YUI().use('*'); // bind everything available
if (firstArg === '*') {
if (ret) {
handleLoader();
}
return Y;
}
// Y.log('before loader requirements: ' + args, 'info', 'yui');
// use loader to expand dependencies and sort the
// requirements if it is available.
loader.ignoreRegistered = true;
}
// process each requirement and any additional requirements
// the module metadata specifies
if (len) {
}
// dynamic load
// Y.log('Using loader to fetch missing deps: ' + missing, 'info', 'yui');
Y._loading = true;
loader.ignoreRegistered = false;
// loader.partial(missing, (fetchCSS) ? null : 'js');
// server side loader service
onEnd: function(o) {
handleLoader(o);
},
});
Y._loading = true;
handleBoot = function() {
Y._loading = false;
Env.bootstrapped = true;
if (Y._attach(['loader'])) {
}
};
if (G_ENV._bootstrapping) {
} else {
G_ENV._bootstrapping = true;
});
}
} else {
if (ret) {
handleLoader();
}
}
return Y;
},
/**
* Returns the namespace specified and creates it if it doesn't exist
* <pre>
* YUI.namespace("property.package");
* YUI.namespace("YAHOO.property.package");
* </pre>
* Either of the above would create YUI.property, then
* YUI.property.package (YAHOO is scrubbed out, this is
* to remain compatible with YUI2)
*
* Be careful when naming packages. Reserved words may work in some browsers
* and not others. For instance, the following will fail in Safari:
* <pre>
* YUI.namespace("really.long.nested.namespace");
* </pre>
* This fails because "long" is a future reserved word in ECMAScript
*
* @method namespace
* @param {string*} arguments 1-n namespaces to create.
* @return {object} A reference to the last namespace object created.
*/
namespace: function() {
for (; i < a.length; i++) {
// d = ('' + a[i]).split('.');
arg = a[i];
o[d[j]] = o[d[j]] || {};
o = o[d[j]];
}
} else {
}
}
return o;
},
// this is replaced if the log module is included
/**
* Report an error. The reporting mechanism is controled by
* the 'throwFail' configuration attribute. If throwFail is
* not specified, the message is written to the Logger, otherwise
* a JS error is thrown
* @method error
* @param msg {string} the error message.
* @param e {Error|string} Optional JS error that was caught, or an error string.
* @param data Optional additional info
* and throwFail is specified, this error will be re-thrown.
* @return {YUI} this YUI instance.
*/
var Y = this, ret;
}
} else {
}
return Y;
},
/**
* Generate an id that is unique among all YUI instances
* @method guid
* @param pre {string} optional guid prefix.
* @return {string} the guid.
*/
},
/**
* Returns a guid associated with an object. If the object
* does not have one, a new one is created unless readOnly
* is specified.
* @method stamp
* @param o The object to stamp.
* @param readOnly {boolean} if true, a valid guid will only
* be returned if the object has one assigned to it.
* @return {string} The object's guid or null.
*/
var uid;
if (!o) {
return o;
}
// IE generates its own unique ID for dom nodes
// The uniqueID property of a document node returns a new ID
} else {
}
if (!uid) {
if (!readOnly) {
try {
} catch (e) {
uid = null;
}
}
}
return uid;
},
/**
* Destroys the YUI instance
* @method destroy
* @since 3.3.0
*/
destroy: function() {
var Y = this;
if (Y.Event) {
}
delete Y.Env;
delete Y.config;
}
/**
* instanceof check for objects that works around
* memory leak in IE when the item tested is
* @method instanceOf
* @since 3.3.0
*/
};
// inheritance utilities are not available yet
}
}
// set up the environment
if (hasWin) {
// add a window load event at load time so we can capture
// the case where it fires before dynamic loading is
// complete.
} else {
handleLoad();
}
/*global exports*/
// Support the CommonJS method for exporting our single global
if (typeof exports == 'object') {
}
}());
/**
* The config object contains all of the configuration options for
* the YUI instance. This object is supplied by the implementer
* when instantiating a YUI instance. Some properties have default
* values if they are not supplied by the implementer. This should
* not be updated directly because some values are cached. Use
* applyConfig() to update the config object on a YUI instance that
* has already been configured.
*
* @class config
* @static
*/
/**
* Allows the YUI seed file to fetch the loader component and library
* metadata to dynamically load additional dependencies.
*
* @property bootstrap
* @type boolean
* @default true
*/
/**
* Log to the browser console if debug is on and the browser has a
* supported console.
*
* @property useBrowserConsole
* @type boolean
* @default true
*/
/**
* A hash of log sources that should be logged. If specified, only
* log messages from these sources will be logged.
*
* @property logInclude
* @type object
*/
/**
* A hash of log sources that should be not be logged. If specified,
* all sources are logged if not on this list.
*
* @property logExclude
* @type object
*/
/**
* Set to true if the yui seed file was dynamically loaded in
* order to bootstrap components relying on the window load event
* and the 'domready' custom event.
*
* @property injected
* @type boolean
* @default false
*/
/**
* If throwFail is set, Y.error will generate or re-throw a JS Error.
* Otherwise the failure is logged.
*
* @property throwFail
* @type boolean
* @default true
*/
/**
*
* @property win
* @type Window
* @default the window hosting YUI
*/
/**
* The document associated with the 'win' configuration.
*
* @property doc
* @type Document
* @default the document hosting YUI
*/
/**
* A list of modules that defines the YUI core (overrides the default).
*
* @property core
* @type string[]
*/
/**
* A list of languages in order of preference. This list is matched against
* the list of available languages in modules that the YUI instance uses to
* determine the best possible localization of language sensitive modules.
* Languages are represented using BCP 47 language tags, such as "en-GB" for
* English as used in the United Kingdom, or "zh-Hans-CN" for simplified
* Chinese as used in China. The list can be provided as a comma-separated
* list or as an array.
*
* @property lang
* @type string|string[]
*/
/**
* The default date format
* @property dateFormat
* @type string
* @deprecated use configuration in DataType.Date.format() instead.
*/
/**
* The default locale
* @property locale
* @type string
* @deprecated use config.lang instead.
*/
/**
* The default interval when polling in milliseconds.
* @property pollInterval
* @type int
* @default 20
*/
/**
* The number of dynamic nodes to insert by default before
* automatically removing them. This applies to script nodes
* because remove the node will not make the evaluated script
* unavailable. Dynamic CSS is not auto purged, because removing
* a linked style sheet will also remove the style definitions.
* @property purgethreshold
* @type int
* @default 20
*/
/**
* The default interval when polling in milliseconds.
* @property windowResizeDelay
* @type int
* @default 40
*/
/**
* Base directory for dynamic loading
* @property base
* @type string
*/
/*
* The secure base dir (not implemented)
* For dynamic loading.
* @property secureBase
* @type string
*/
/**
* The YUI combo service base dir. Ex: http://yui.yahooapis.com/combo?
* For dynamic loading.
* @property comboBase
* @type string
*/
/**
* The root path to prepend to module path for the combo service.
* For dynamic loading.
* @property root
* @type string
*/
/**
* A filter to apply to result urls. This filter will modify the default
* path for all modules. The default path for the YUI library is the
* minified version of the files (e.g., event-min.js). The filter property
* can be a predefined filter or a custom filter. The valid predefined
* filters are:
* <dl>
* <dt>DEBUG</dt>
* <dd>Selects the debug versions of the library (e.g., event-debug.js).
* This option will automatically include the Logger widget</dd>
* <dt>RAW</dt>
* <dd>Selects the non-minified version of the library (e.g., event.js).</dd>
* </dl>
* You can also define a custom filter, which must be an object literal
* containing a search expression and a replace string:
* <pre>
* myFilter: {
* 'searchExp': "-min\\.js",
* 'replaceStr': "-debug.js"
* }
* </pre>
*
* For dynamic loading.
*
* @property filter
* @type string|object
*/
/**
* The 'skin' config let's you configure application level skin
* customizations. It contains the following attributes which
* can be specified to override the defaults:
*
* // The default skin, which is automatically applied if not
* // overriden by a component-specific skin definition.
* // Change this in to apply a different skin globally
* defaultSkin: 'sam',
*
* // This is combined with the loader base property to get
* // the default root directory for a skin.
*
* // Any component-specific overrides can be specified here,
* // making it possible to load different skins for different
* // components. It is possible to load more than one skin
* // for a given component as well.
* overrides: {
* slider: ['capsule', 'round']
* }
*
* For dynamic loading.
*
* @property skin
*/
/**
* Hash of per-component filter specification. If specified for a given
* component, this overrides the filter config.
*
* For dynamic loading.
*
* @property filters
*/
/**
* Use the YUI combo service to reduce the number of http connections
* required to load your dependencies. Turning this off will
* disable combo handling for YUI and all module groups configured
* with a combo service.
*
* For dynamic loading.
*
* @property combine
* @type boolean
* @default true if 'base' is not supplied, false if it is.
*/
/**
* A list of modules that should never be dynamically loaded
*
* @property ignore
* @type string[]
*/
/**
* A list of modules that should always be loaded when required, even if already
* present on the page.
*
* @property force
* @type string[]
*/
/**
* Node or id for a node that should be used as the insertion point for new
* nodes. For dynamic loading.
*
* @property insertBefore
* @type string
*/
/**
* Object literal containing attributes to add to dynamically loaded script
* nodes.
* @property jsAttributes
* @type string
*/
/**
* Object literal containing attributes to add to dynamically loaded link
* nodes.
* @property cssAttributes
* @type string
*/
/**
* Number of milliseconds before a timeout occurs when dynamically
* loading nodes. If not set, there is no timeout.
* @property timeout
* @type int
*/
/**
* Callback for the 'CSSComplete' event. When dynamically loading YUI
* components with CSS, this property fires when the CSS is finished
* loading but script loading is still ongoing. This provides an
* opportunity to enhance the presentation of a loading page a little
* bit before the entire loading process is done.
*
* @property onCSS
* @type function
*/
/**
* A hash of module definitions to add to the list of YUI components.
* These components can then be dynamically loaded side by side with
* YUI via the use() method. This is a hash, the key is the module
* name, and the value is an object literal specifying the metdata
* for the module. * See Loader.addModule for the supported module
* metadata fields. Also @see groups, which provides a way to
* configure the base and combo spec for a set of modules.
* <code>
* modules: {
* mymod1: {
* requires: ['node'],
* fullpath: 'http://myserver.mydomain.com/mymod1/mymod1.js'
* },
* mymod2: {
* requires: ['mymod1'],
* fullpath: 'http://myserver.mydomain.com/mymod2/mymod2.js'
* }
* }
* </code>
*
* @property modules
* @type object
*/
/**
* A hash of module group definitions. It for each group you
* can specify a list of modules and the base path and
* combo spec to use when dynamically loading the modules. @see
* @see modules for the details about the modules part of the
* group definition.
* <code>
* groups: {
* yui2: {
* // specify whether or not this group has a combo service
* combine: true,
*
* // the base path for non-combo paths
* base: 'http://yui.yahooapis.com/2.8.0r4/build/',
*
* // the path to the combo service
* comboBase: 'http://yui.yahooapis.com/combo?',
*
* // a fragment to prepend to the path attribute when
* // when building combo urls
*
* // the module definitions
* modules: {
* yui2_yde: {
* path: "yahoo-dom-event/yahoo-dom-event.js"
* },
* yui2_anim: {
* path: "animation/animation.js",
* requires: ['yui2_yde']
* }
* }
* }
* }
* </code>
* @property modules
* @type object
*/
/**
* The loader 'path' attribute to the loader itself. This is combined
* with the 'base' attribute to dynamically load the loader component
* when boostrapping with the get utility alone.
*
* @property loaderPath
* @type string
* @default loader/loader-min.js
*/
/**
* Specifies whether or not YUI().use(...) will attempt to load CSS
* resources at all. Any truthy value will cause CSS dependencies
* to load when fetching script. The special value 'force' will
* cause CSS dependencies to be loaded even if no script is needed.
*
* @property fetchCSS
* @type boolean|string
* @default true
*/
/**
* The default gallery version to build gallery module urls
* @property gallery
* @type string
* @since 3.1.0
*/
/**
* The default YUI 2 version to build yui2 module urls. This is for
* intrinsic YUI 2 support via the 2in3 project. Also @see the '2in3'
* config for pulling different revisions of the wrapped YUI 2
* modules.
* @since 3.1.0
* @property yui2
* @type string
* @default 2.8.1
*/
/**
* The 2in3 project is a deployment of the various versions of YUI 2
* deployed as first-class YUI 3 modules. Eventually, the wrapper
* for the modules will change (but the underlying YUI 2 code will
* be the same), and you can select a particular version of
* the wrapper modules via this config.
* @since 3.1.0
* @property 2in3
* @type string
* @default 1
*/
/**
* Alternative console log function for use in environments without
* a supported native console. The function is executed in the
* YUI instance context.
* @since 3.1.0
* @property logFn
* @type Function
*/
/**
* A callback to execute when Y.error is called. It receives the
* error message and an javascript error object if Y.error was
* executed because a javascript error was caught. The function
* is executed in the YUI instance context.
*
* @since 3.2.0
* @property errorFn
* @type Function
*/
/**
* A callback to execute when the loader fails to load one or
* more resource. This could be because of a script load
* failure. It can also fail if a javascript module fails
* to register itself, but only when the 'requireRegistration'
* is true. If this function is defined, the use() callback will
* only be called when the loader succeeds, otherwise it always
* executes unless there was a javascript error when attaching
* a module.
*
* @since 3.3.0
* @property loadErrorFn
* @type Function
*/
/**
* When set to true, the YUI loader will expect that all modules
* it is responsible for loading will be first-class YUI modules
* that register themselves with the YUI global. If this is
* set to true, loader will fail if the module registration fails
* to happen after the script is loaded.
*
* @since 3.3.0
* @property requireRegistration
* @type boolean
* @default false
*/
/**
* Cache serviced use() requests.
* @since 3.3.0
* @property cacheUse
* @type boolean
* @default true
* @deprecated no longer used
*/
/**
* The parameter defaults for the remote loader service.
* Requires the rls submodule. The properties that are
* supported:
* <pre>
* m: comma separated list of module requirements. This
* must be the param name even for custom implemetations.
* v: the version of YUI to load. Defaults to the version
* of YUI that is being used.
* gv: the version of the gallery to load (@see the gallery config)
* env: comma separated list of modules already on the page.
* this must be the param name even for custom implemetations.
* lang: the languages supported on the page (@see the lang config)
* '2in3v': the version of the 2in3 wrapper to use (@see the 2in3 config).
* '2v': the version of yui2 to use in the yui 2in3 wrappers
* (@see the yui2 config)
* filt: a filter def to apply to the urls (@see the filter config).
* filts: a list of custom filters to apply per module
* (@see the filters config).
* tests: this is a map of conditional module test function id keys
* with the values of 1 if the test passes, 0 if not. This must be
* the name of the querystring param in custom templates.
*</pre>
*
* @since 3.2.0
* @property rls
*/
/**
* The base path to the remote loader service
*
* @since 3.2.0
* @property rls_base
*/
/**
* The template to use for building the querystring portion
* of the remote loader service url. The default is determined
* by the rls config -- each property that has a value will be
* represented.
*
* ex: m={m}&v={v}&env={env}&lang={lang}&filt={filt}&tests={tests}
*
*
* @since 3.2.0
* @property rls_tmpl
*/
/**
* Configure the instance to use a remote loader service instead of
* the client loader.
*
* @since 3.2.0
* @property use_rls
*/