@hpcc-js/dgrid 2.34.1 → 2.34.2

package/dist/index.js

@@ -4,8 +4,8 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@hpcc-js/dgrid"] = {}, global["@hpcc-js/common"], global["@hpcc-js/util"]));
 })(this, (function (exports, common, util) {
   var PKG_NAME = "@hpcc-js/dgrid";
-  var PKG_VERSION = "2.34.1";
-  var BUILD_VERSION = "2.108.2";
+  var PKG_VERSION = "2.34.2";
+  var BUILD_VERSION = "2.108.4";
 
   /******************************************************************************
   Copyright (c) Microsoft Corporation.
@@ -7230,1349 +7230,1839 @@
 
   		/***/ }),
 
-  		/***/ 2219:
-  		/*!*****************************************************!*\
-  		  !*** ../../node_modules/dojo-dstore/QueryMethod.js ***!
-  		  \*****************************************************/
-  		/***/ ((module, exports, __webpack_require__) => {
+  		/***/ 2093:
+  		/*!******************************************************************!*\
+  		  !*** ../../../../../../../tmp/tmp-5915xSdKDAV2AL3m/dojo/dojo.js ***!
+  		  \******************************************************************/
+  		/***/ ((module) => {
 
-  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
-  			/*=====
-  			var __QueryMethodArgs = {
-  				// type: String
-  				//		The type of the query. This identifies the query's type in the query log
-  				//		and the name of the corresponding query engine method.
-  				// normalizeArguments: Function?
-  				//		A function that normalizes arguments for consumption by a query engine
-  				// applyQuery: Function?
-  				//		A function that takes the query's new subcollection and the query's log entry
-  				//		and applies it to the new subcollection. This is useful for collections that need
-  				//		to both declare and implement new query methods.
-  				// querierFactory: Function?
-  				//		A factory function that provides a default querier implementation to use when
-  				//		a collection does not define its own querier factory method for this query type.
-  			};
-  			=====*/
-  			return function QueryMethod(/*__QueryMethodArgs*/ kwArgs) {
-  				// summary:
-  				//		The constructor for a dstore collection query method
-  				// description:
-  				//		This is the constructor for a collection query method. It encapsulates the following:
-  				//		* Creating a new subcollection for the query results
-  				//		* Logging the query in the collection's `queryLog`
-  				//		* Normalizing query arguments
-  				//		* Applying the query engine
-  				// kwArgs:
-  				//		The properties that define the query method
-  				// returns: Function
-  				//		Returns a function that takes query arguments and returns a new collection with
-  				//		the query associated with it.
+  		module.exports = function(userConfig, defaultConfig, global, window) { this.loaderVersion = "1.17.3"; (function(
+  			userConfig,
+  			defaultConfig
+  		){
+  			// summary:
+  			//		This is the "source loader" and is the entry point for Dojo during development. You may also load Dojo with
+  			//		any AMD-compliant loader via the package main module dojo/main.
+  			// description:
+  			//		This is the "source loader" for Dojo. It provides an AMD-compliant loader that can be configured
+  			//		to operate in either synchronous or asynchronous modes. After the loader is defined, dojo is loaded
+  			//		IAW the package main module dojo/main. In the event you wish to use a foreign loader, you may load dojo as a package
+  			//		via the package main module dojo/main and this loader is not required; see dojo/package.json for details.
+  			//
+  			//		In order to keep compatibility with the v1.x line, this loader includes additional machinery that enables
+  			//		the dojo.provide, dojo.require et al API. This machinery is loaded by default, but may be dynamically removed
+  			//		via the has.js API and statically removed via the build system.
+  			//
+  			//		This loader includes sniffing machinery to determine the environment; the following environments are supported:
+  			//
+  			//		- browser
+  			//		- node.js
+  			//		- rhino
+  			//
+  			//		This is the so-called "source loader". As such, it includes many optional features that may be discarded by
+  			//		building a customized version with the build system.
 
-  				var type = kwArgs.type,
-  					normalizeArguments = kwArgs.normalizeArguments,
-  					applyQuery = kwArgs.applyQuery,
-  					defaultQuerierFactory = kwArgs.querierFactory;
+  			// Design and Implementation Notes
+  			//
+  			// This is a dojo-specific adaption of bdLoad, donated to the dojo foundation by Altoviso LLC.
+  			//
+  			// This function defines an AMD-compliant (http://wiki.commonjs.org/wiki/Modules/AsynchronousDefinition)
+  			// loader that can be configured to operate in either synchronous or asynchronous modes.
+  			//
+  			// Since this machinery implements a loader, it does not have the luxury of using a load system and/or
+  			// leveraging a utility library. This results in an unpleasantly long file; here is a road map of the contents:
+  			//
+  			//	 1. Small library for use implementing the loader.
+  			//	 2. Define the has.js API; this is used throughout the loader to bracket features.
+  			//	 3. Define the node.js and rhino sniffs and sniff.
+  			//	 4. Define the loader's data.
+  			//	 5. Define the configuration machinery.
+  			//	 6. Define the script element sniffing machinery and sniff for configuration data.
+  			//	 7. Configure the loader IAW the provided user, default, and sniffing data.
+  			//	 8. Define the global require function.
+  			//	 9. Define the module resolution machinery.
+  			//	10. Define the module and plugin module definition machinery
+  			//	11. Define the script injection machinery.
+  			//	12. Define the window load detection.
+  			//	13. Define the logging API.
+  			//	14. Define the tracing API.
+  			//	16. Define the AMD define function.
+  			//	17. Define the dojo v1.x provide/require machinery--so called "legacy" modes.
+  			//	18. Publish global variables.
+  			//
+  			// Language and Acronyms and Idioms
+  			//
+  			// moduleId: a CJS module identifier, (used for public APIs)
+  			// mid: moduleId (used internally)
+  			// packageId: a package identifier (used for public APIs)
+  			// pid: packageId (used internally); the implied system or default package has pid===""
+  			// pack: package is used internally to reference a package object (since javascript has reserved words including "package")
+  			// prid: plugin resource identifier
+  			// The integer constant 1 is used in place of true and 0 in place of false.
+  			//
+  			// The "foreign-loader" has condition is defined if another loader is being used (e.g. webpack) and this code is only
+  			// needed for resolving module identifiers based on the config.  In this case, only the functions require.toUrl and 
+  			// require.toAbsMid are supported.  The require and define functions are not supported.
 
-  				return function () {
-  					// summary:
-  					//		A query method whose arguments are determined by the query type
-  					// returns: dstore/Collection
-  					//		A collection representing the query results
+  			// define global
+  			var globalObject = (function(){
+  				if (typeof global !== 'undefined' && typeof global !== 'function') {
+  					// global spec defines a reference to the global object called 'global'
+  					// https://github.com/tc39/proposal-global
+  					// `global` is also defined in NodeJS
+  					return global;
+  				}
+  				else if (typeof window !== 'undefined') {
+  					// window is defined in browsers
+  					return window;
+  				}
+  				else if (typeof self !== 'undefined') {
+  					// self is defined in WebWorkers
+  					return self;
+  				}
+  				return this;
+  			})();
 
-  					var originalArguments = Array.prototype.slice.call(arguments),
-  						normalizedArguments = normalizeArguments
-  							? normalizeArguments.apply(this, originalArguments)
-  							: originalArguments,
-  						logEntry = {
-  							type: type,
-  							arguments: originalArguments,
-  							normalizedArguments: normalizedArguments
-  						},
-  						querierFactory = this._getQuerierFactory(type) || defaultQuerierFactory;
+  			// define a minimal library to help build the loader
+  			var noop = function(){
+  				},
 
-  					if (querierFactory) {
-  						// Call the query factory in store context to support things like
-  						// mapping a filter query's string argument to a custom filter method on the collection
-  						logEntry.querier = querierFactory.apply(this, normalizedArguments);
+  				toString = {}.toString,
+
+  				isFunction = function(it){
+  					return toString.call(it) == "[object Function]";
+  				},
+
+  				isArray = function(it){
+  					return toString.call(it) == "[object Array]";
+  				},
+
+  				forEach = function(vector, callback){
+  					if(vector){
+  						for(var i = 0; i < vector.length;){
+  							callback(vector[i++]);
+  						}
   					}
+  				},
 
-  					var newCollection = this._createSubCollection({
-  						queryLog: this.queryLog.concat(logEntry)
-  					});
+  				mix = function(dest, src){
+  					for(var p in src){
+  						dest[p] = src[p];
+  					}
+  					return dest;
+  				},
 
-  					return applyQuery ? applyQuery.call(this, newCollection, logEntry) : newCollection;
-  				};
-  			};
-  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
-  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+  				makeError = function(error, info){
+  					return mix(new Error(error), {src:"dojoLoader", info:info});
+  				},
 
+  				uidSeed = 1,
 
-  		/***/ }),
+  				uid = function(){
+  					// Returns a unique identifier (within the lifetime of the document) of the form /_d+/.
+  					return "_" + uidSeed++;
+  				},
 
-  		/***/ 2236:
-  		/*!**********************************************************!*\
-  		  !*** ../../node_modules/dojo/promise/instrumentation.js ***!
-  		  \**********************************************************/
-  		/***/ ((module, exports, __webpack_require__) => {
+  				// FIXME: how to doc window.require() api
 
-  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
-  			__webpack_require__(/*! ./tracer */ 3185),
-  			__webpack_require__(/*! ../has */ 6356),
-  			__webpack_require__(/*! ../_base/lang */ 6323),
-  			__webpack_require__(/*! ../_base/array */ 6974)
-  		], __WEBPACK_AMD_DEFINE_RESULT__ = (function(tracer, has, lang, arrayUtil){
-  			has.add("config-useDeferredInstrumentation", "report-unhandled-rejections");
+  				// this will be the global require function; define it immediately so we can start hanging things off of it
+  				req = function(
+  					config,		  //(object, optional) hash of configuration properties
+  					dependencies, //(array of commonjs.moduleId, optional) list of modules to be loaded before applying callback
+  					callback	  //(function, optional) lambda expression to apply to module values implied by dependencies
+  				){
+  					return contextRequire(config, dependencies, callback, 0, req);
+  				},
 
-  			function logError(error, rejection, deferred){
-  				if(error && error.log === false){
-  					return;
-  				}
-  				var stack = "";
-  				if(error && error.stack){
-  					stack += error.stack;
-  				}
-  				if(rejection && rejection.stack){
-  					stack += "\n    ----------------------------------------\n    rejected" + rejection.stack.split("\n").slice(1).join("\n").replace(/^\s+/, " ");
-  				}
-  				if(deferred && deferred.stack){
-  					stack += "\n    ----------------------------------------\n" + deferred.stack;
-  				}
-  				console.error(error, stack);
+  				// the loader uses the has.js API to control feature inclusion/exclusion; define then use throughout
+  				global = globalObject,
+
+  				doc = global.document,
+
+  				element = doc && doc.createElement("DiV"),
+
+  				has = req.has = function(name){
+  					return isFunction(hasCache[name]) ? (hasCache[name] = hasCache[name](global, doc, element)) : hasCache[name];
+  				},
+
+  				hasCache = has.cache = defaultConfig.hasCache;
+
+  			if (isFunction(userConfig)) {
+  				userConfig = userConfig(globalObject);
   			}
 
-  			function reportRejections(error, handled, rejection, deferred){
-  				if(!handled){
-  					logError(error, rejection, deferred);
-  				}
+  			has.add = function(name, test, now, force){
+  				(hasCache[name]===undefined || force) && (hasCache[name] = test);
+  				return now && has(name);
+  			};
+
+  			// userConfig has tests override defaultConfig has tests; do this after the environment detection because
+  			// the environment detection usually sets some has feature values in the hasCache.
+  			for(var p in userConfig.has){
+  				has.add(p, userConfig.has[p], 0, 1);
+  			}
+  			{
+  				req.async = 1;
   			}
 
-  			var errors = [];
-  			var activeTimeout = false;
-  			var unhandledWait = 1000;
-  			function trackUnhandledRejections(error, handled, rejection, deferred){
-  				// try to find the existing tracking object
-  				if(!arrayUtil.some(errors, function(obj){
-  					if(obj.error === error){
-  						// found the tracking object for this error
-  						if(handled){
-  							// if handled, update the state
-  							obj.handled = true;
-  						}
-  						return true;
-  					}
-  				})){
-  					// no tracking object has been setup, create one
-  					errors.push({
-  						error: error,
-  						rejection: rejection,
-  						handled: handled,
-  						deferred: deferred,
-  						timestamp: new Date().getTime()
-  					});
-  				}
+  			//
+  			// loader eval
+  			//
+  			var eval_ =    // noop eval if there are csp restrictions
+  				function(){} ;
 
-  				if(!activeTimeout){
-  					activeTimeout = setTimeout(logRejected, unhandledWait);
-  				}
-  			}
+  			req.eval =
+  				function(text, hint){
+  					return eval_();
+  				};
 
-  			function logRejected(){
-  				var now = new Date().getTime();
-  				var reportBefore = now - unhandledWait;
-  				errors = arrayUtil.filter(errors, function(obj){
-  					// only report the error if we have waited long enough and
-  					// it hasn't been handled
-  					if(obj.timestamp < reportBefore){
-  						if(!obj.handled){
-  							logError(obj.error, obj.rejection, obj.deferred);
+  			//
+  			// loader micro events API
+  			//
+  			var listenerQueues = {},
+  				error = "error";
+  				req.signal = function(type, args){
+  					var queue = listenerQueues[type];
+  					// notice we run a copy of the queue; this allows listeners to add/remove
+  					// other listeners without affecting this particular signal
+  					forEach(queue && queue.slice(0), function(listener){
+  						listener.apply(null, isArray(args) ? args : [args]);
+  					});
+  				};
+  				var on = req.on = function(type, listener){
+  					// notice a queue is not created until a client actually connects
+  					var queue = listenerQueues[type] || (listenerQueues[type] = []);
+  					queue.push(listener);
+  					return {
+  						remove:function(){
+  							for(var i = 0; i<queue.length; i++){
+  								if(queue[i]===listener){
+  									queue.splice(i, 1);
+  									return;
+  								}
+  							}
   						}
-  						return false;
-  					}
-  					return true;
-  				});
+  					};
+  				};
 
-  				if(errors.length){
-  					activeTimeout = setTimeout(logRejected, errors[0].timestamp + unhandledWait - now);
-  				}else {
-  					activeTimeout = false;
-  				}
-  			}
+  			// configuration machinery; with an optimized/built defaultConfig, all configuration machinery can be discarded
+  			// lexical variables hold key loader data structures to help with minification; these may be completely,
+  			// one-time initialized by defaultConfig for optimized/built versions
+  			var aliases
+  					// a vector of pairs of [regexs or string, replacement] => (alias, actual)
+  					= [],
 
-  			return function(Deferred){
-  				// summary:
-  				//		Initialize instrumentation for the Deferred class.
-  				// description:
-  				//		Initialize instrumentation for the Deferred class.
-  				//		Done automatically by `dojo/Deferred` if the
-  				//		`deferredInstrumentation` and `useDeferredInstrumentation`
-  				//		config options are set.
-  				//
-  				//		Sets up `dojo/promise/tracer` to log to the console.
-  				//
-  				//		Sets up instrumentation of rejected deferreds so unhandled
-  				//		errors are logged to the console.
+  				pathsMapProg
+  					// list of (from-path, to-path, regex, length) derived from paths;
+  					// a "program" to apply paths; see computeMapProg
+  					= [],
 
-  				var usage = has("config-useDeferredInstrumentation");
-  				if(usage){
-  					tracer.on("resolved", lang.hitch(console, "log", "resolved"));
-  					tracer.on("rejected", lang.hitch(console, "log", "rejected"));
-  					tracer.on("progress", lang.hitch(console, "log", "progress"));
+  				packs
+  					// a map from packageId to package configuration object; see fixupPackageInfo
+  					= {};
 
-  					var args = [];
-  					if(typeof usage === "string"){
-  						args = usage.split(",");
-  						usage = args.shift();
-  					}
-  					if(usage === "report-rejections"){
-  						Deferred.instrumentRejected = reportRejections;
-  					}else if(usage === "report-unhandled-rejections" || usage === true || usage === 1){
-  						Deferred.instrumentRejected = trackUnhandledRejections;
-  						unhandledWait = parseInt(args[0], 10) || unhandledWait;
-  					}else {
-  						throw new Error("Unsupported instrumentation usage <" + usage + ">");
-  					}
-  				}
-  			};
-  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
-  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+  				req.map
+  					// AMD map config variable; dojo/_base/kernel needs req.map to figure out the scope map
+  					= {};
 
+  				var mapProgs
+  					// vector of quads as described by computeMapProg; map-key is AMD map key, map-value is AMD map value
+  					= [],
 
-  		/***/ }),
+  				modules
+  					// A hash:(mid) --> (module-object) the module namespace
+  					//
+  					// pid: the package identifier to which the module belongs (e.g., "dojo"); "" indicates the system or default package
+  					// mid: the fully-resolved (i.e., mappings have been applied) module identifier without the package identifier (e.g., "dojo/io/script")
+  					// url: the URL from which the module was retrieved
+  					// pack: the package object of the package to which the module belongs
+  					// executed: 0 => not executed; executing => in the process of traversing deps and running factory; executed => factory has been executed
+  					// deps: the dependency vector for this module (vector of modules objects)
+  					// def: the factory for this module
+  					// result: the result of the running the factory for this module
+  					// injected: (0 | requested | arrived) the status of the module; nonmodule means the resource did not call define
+  					// load: plugin load function; applicable only for plugins
+  					//
+  					// Modules go through several phases in creation:
+  					//
+  					// 1. Requested: some other module's definition or a require application contained the requested module in
+  					//	  its dependency vector or executing code explicitly demands a module via req.require.
+  					//
+  					// 2. Injected: a script element has been appended to the insert-point element demanding the resource implied by the URL
+  					//
+  					// 3. Loaded: the resource injected in [2] has been evaluated.
+  					//
+  					// 4. Defined: the resource contained a define statement that advised the loader about the module. Notice that some
+  					//	  resources may just contain a bundle of code and never formally define a module via define
+  					//
+  					// 5. Evaluated: the module was defined via define and the loader has evaluated the factory and computed a result.
+  					= {},
 
-  		/***/ 2284:
-  		/*!**************************************!*\
-  		  !*** ../../node_modules/dojo/dom.js ***!
-  		  \**************************************/
-  		/***/ ((module, exports, __webpack_require__) => {
+  				cacheBust
+  					// query string to append to module URLs to bust browser cache
+  					= "",
 
-  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(/*! ./sniff */ 2616), __webpack_require__(/*! ./_base/window */ 5075), __webpack_require__(/*! ./_base/kernel */ 1054)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(has, win, kernel){
-  			// module:
-  			//		dojo/dom
+  				cache
+  					// hash:(mid | url)-->(function | string)
+  					//
+  					// A cache of resources. The resources arrive via a config.cache object, which is a hash from either mid --> function or
+  					// url --> string. The url key is distinguished from the mid key by always containing the prefix "url:". url keys as provided
+  					// by config.cache always have a string value that represents the contents of the resource at the given url. mid keys as provided
+  					// by configl.cache always have a function value that causes the same code to execute as if the module was script injected.
+  					//
+  					// Both kinds of key-value pairs are entered into cache via the function consumePendingCache, which may relocate keys as given
+  					// by any mappings *iff* the config.cache was received as part of a module resource request.
+  					//
+  					// Further, for mid keys, the implied url is computed and the value is entered into that key as well. This allows mapped modules
+  					// to retrieve cached items that may have arrived consequent to another namespace.
+  					//
+  					 = {};
 
-  			// FIXME: need to add unit tests for all the semi-public methods
+  			var match; {
+  				// no config API, assume defaultConfig has everything the loader needs...for the entire lifetime of the application
+  				defaultConfig.paths;
+  				pathsMapProg = defaultConfig.pathsMapProg;
+  				packs = defaultConfig.packs;
+  				aliases = defaultConfig.aliases;
+  				mapProgs = defaultConfig.mapProgs;
+  				modules = defaultConfig.modules;
+  				cache = defaultConfig.cache;
+  				cacheBust = defaultConfig.cacheBust;
 
-  			if(has("ie") <= 7){
-  				try{
-  					document.execCommand("BackgroundImageCache", false, true);
-  				}catch(e){
-  					// sane browsers don't have cache "issues"
-  				}
+  				// remember the default config for other processes (e.g., dojo/config)
+  				req.rawConfig = defaultConfig;
   			}
 
-  			// =============================
-  			// DOM Functions
-  			// =============================
 
-  			// the result object
-  			var dom = {
-  				// summary:
-  				//		This module defines the core dojo DOM API.
-  			};
+  			var contextRequire; 
 
-  			if(has("ie")){
-  				dom.byId = function(id, doc){
-  					if(typeof id != "string"){
-  						return id || null;
-  					}
-  					var _d = doc || win.doc, te = id && _d.getElementById(id);
-  					// attributes.id.value is better than just id in case the
-  					// user has a name=id inside a form
-  					if(te && (te.attributes.id.value == id || te.id == id)){
-  						return te;
-  					}else {
-  						var eles = _d.all[id];
-  						if(!eles || eles.nodeName){
-  							eles = [eles];
-  						}
-  						// if more than 1, choose first with the correct id
-  						var i = 0;
-  						while((te = eles[i++])){
-  							if((te.attributes && te.attributes.id && te.attributes.id.value == id) || te.id == id){
-  								return te;
-  							}
+  			var runMapProg = function(targetMid, map){
+  					// search for targetMid in map; return the map item if found; falsy otherwise
+  					if(map){
+  					for(var i = 0; i < map.length; i++){
+  						if(map[i][2].test(targetMid)){
+  							return map[i];
   						}
   					}
-  					return null;
-  				};
-  			}else {
-  				dom.byId = function(id, doc){
-  					// inline'd type check.
-  					// be sure to return null per documentation, to match IE branch.
-  					return ((typeof id == "string") ? (doc || win.doc).getElementById(id) : id) || null; // DOMNode
-  				};
-  			}
-  			/*=====
-  			 dom.byId = function(id, doc){
-  				// summary:
-  				//		Returns DOM node with matching `id` attribute or falsy value (ex: null or undefined)
-  				//		if not found.  If `id` is a DomNode, this function is a no-op.
-  				//
-  				// id: String|DOMNode
-  				//		A string to match an HTML id attribute or a reference to a DOM Node
-  				//
-  				// doc: Document?
-  				//		Document to work in. Defaults to the current value of
-  				//		dojo/_base/window.doc.  Can be used to retrieve
-  				//		node references from other documents.
-  				//
-  				// example:
-  				//		Look up a node by ID:
-  				//	|	require(["dojo/dom"], function(dom){
-  				//	|		var n = dom.byId("foo");
-  				//	|	});
-  				//
-  				// example:
-  				//		Check if a node exists, and use it.
-  				//	|	require(["dojo/dom"], function(dom){
-  				//	|		var n = dom.byId("bar");
-  				//	|		if(n){ doStuff() ... }
-  				//	|	});
-  				//
-  				// example:
-  				//		Allow string or DomNode references to be passed to a custom function:
-  				//	|	require(["dojo/dom"], function(dom){
-  				//	|		var foo = function(nodeOrId){
-  				//	|			nodeOrId = dom.byId(nodeOrId);
-  				//	|			// ... more stuff
-  				//	|		}
-  				//	|	});
-  			 };
-  			 =====*/
-
-  			// Test for DOMNode.contains() method, available everywhere except FF8-
-  			// and IE8-, where it's available in general, but not on document itself,
-  			// and also problems when either ancestor or node are text nodes.
-
-  			var doc = kernel.global["document"] || null;
-  			has.add("dom-contains", !!(doc && doc.contains));
-  			dom.isDescendant = has("dom-contains") ?
-  				// FF9+, IE9+, webkit, opera, iOS, Android, Edge, etc.
-  				function(/*DOMNode|String*/ node, /*DOMNode|String*/ ancestor){
-  					return !!( (ancestor = dom.byId(ancestor)) && ancestor.contains(dom.byId(node)) );
-  				} :
-  				function(/*DOMNode|String*/ node, /*DOMNode|String*/ ancestor){
-  					// summary:
-  					//		Returns true if node is a descendant of ancestor
-  					// node: DOMNode|String
-  					//		string id or node reference to test
-  					// ancestor: DOMNode|String
-  					//		string id or node reference of potential parent to test against
-  					//
-  					// example:
-  					//		Test is node id="bar" is a descendant of node id="foo"
-  					//	|	require(["dojo/dom"], function(dom){
-  					//	|		if(dom.isDescendant("bar", "foo")){ ... }
-  					//	|	});
+  					}
+  					return 0;
+  				},
 
-  					try{
-  						node = dom.byId(node);
-  						ancestor = dom.byId(ancestor);
-  						while(node){
-  							if(node == ancestor){
-  								return true; // Boolean
-  							}
-  							node = node.parentNode;
-  						}
-  					}catch(e){ /* squelch, return false */ }
-  					return false; // Boolean
-  				};
+  				compactPath = function(path){
+  					var result = [],
+  						segment, lastSegment;
+  					path = path.replace(/\\/g, '/').split('/');
+  					while(path.length){
+  						segment = path.shift();
+  						if(segment==".." && result.length && lastSegment!=".."){
+  							result.pop();
+  							lastSegment = result[result.length - 1];
+  						}else if(segment!="."){
+  							result.push(lastSegment= segment);
+  						} // else ignore "."
+  					}
+  					return result.join("/");
+  				},
 
-  			// TODO: do we need setSelectable in the base?
+  				makeModuleInfo = function(pid, mid, pack, url){
+  					{
+  						return {pid:pid, mid:mid, pack:pack, url:url, executed:0, def:0};
+  					}
+  				},
 
-  			// Add feature test for user-select CSS property
-  			// (currently known to work in all but IE < 10 and Opera)
-  			// TODO: The user-select CSS property as of May 2014 is no longer part of
-  			// any CSS specification. In IE, -ms-user-select does not do the same thing
-  			// as the unselectable attribute on elements; namely, dijit Editor buttons
-  			// do not properly prevent the content of the editable content frame from
-  			// unblurring. As a result, the -ms- prefixed version is omitted here.
-  			has.add("css-user-select", function(global, doc, element){
-  				// Avoid exception when dom.js is loaded in non-browser environments
-  				if(!element){ return false; }
+  				getModuleInfo_ = function(mid, referenceModule, packs, modules, baseUrl, mapProgs, pathsMapProg, aliases, alwaysCreate, fromPendingCache){
+  					// arguments are passed instead of using lexical variables so that this function my be used independent of the loader (e.g., the builder)
+  					// alwaysCreate is useful in this case so that getModuleInfo never returns references to real modules owned by the loader
+  					var pid, pack, midInPackage, mapItem, url, result, isRelative;
+  					isRelative = /^\./.test(mid);
+  					if(/(^\/)|(\:)|(\.js$)/.test(mid) || (isRelative && !referenceModule)){
+  						// absolute path or protocol of .js filetype, or relative path but no reference module and therefore relative to page
+  						// whatever it is, it's not a module but just a URL of some sort
+  						// note: pid===0 indicates the routine is returning an unmodified mid
 
-  				var style = element.style;
-  				var prefixes = ["Khtml", "O", "Moz", "Webkit"],
-  					i = prefixes.length,
-  					name = "userSelect";
+  						return makeModuleInfo(0, mid, 0, mid);
+  					}else {
+  						// relative module ids are relative to the referenceModule; get rid of any dots
+  						mid = compactPath(isRelative ? (referenceModule.mid + "/../" + mid) : mid);
+  						if(/^\./.test(mid)){
+  							throw makeError("irrationalPath", mid);
+  						}
+  						// at this point, mid is an absolute mid
 
-  				// Iterate prefixes from most to least likely
-  				do{
-  					if(typeof style[name] !== "undefined"){
-  						// Supported; return property name
-  						return name;
-  					}
-  				}while(i-- && (name = prefixes[i] + "UserSelect"));
+  						// map the mid
+  						if(!isRelative && mapProgs.star){
+  							mapItem = runMapProg(mid, mapProgs.star[1]);
+  						}
+  						if(!mapItem && referenceModule){
+  							mapItem = runMapProg(referenceModule.mid, mapProgs);
+  							mapItem = mapItem && runMapProg(mid, mapItem[1]);
+  						}
 
-  				// Not supported if we didn't return before now
-  				return false;
-  			});
+  						if(mapItem){
+  							mid = mapItem[1] + mid.substring(mapItem[3]);
+  							}
 
-  			/*=====
-  			dom.setSelectable = function(node, selectable){
-  				// summary:
-  				//		Enable or disable selection on a node
-  				// node: DOMNode|String
-  				//		id or reference to node
-  				// selectable: Boolean
-  				//		state to put the node in. false indicates unselectable, true
-  				//		allows selection.
-  				// example:
-  				//		Make the node id="bar" unselectable
-  				//	|	require(["dojo/dom"], function(dom){
-  				//	|		dom.setSelectable("bar");
-  				//	|	});
-  				// example:
-  				//		Make the node id="bar" selectable
-  				//	|	require(["dojo/dom"], function(dom){
-  				//	|		dom.setSelectable("bar", true);
-  				//	|	});
-  			};
-  			=====*/
+  						match = mid.match(/^([^\/]+)(\/(.+))?$/);
+  						pid = match ? match[1] : "";
+  						if((pack = packs[pid])){
+  							mid = pid + "/" + (midInPackage = (match[3] || pack.main));
+  						}else {
+  							pid = "";
+  						}
 
-  			var cssUserSelect = has("css-user-select");
-  			dom.setSelectable = cssUserSelect ? function(node, selectable){
-  				// css-user-select returns a (possibly vendor-prefixed) CSS property name
-  				dom.byId(node).style[cssUserSelect] = selectable ? "" : "none";
-  			} : function(node, selectable){
-  				node = dom.byId(node);
+  						// search aliases
+  						var candidateLength = 0,
+  							candidate = 0;
+  						forEach(aliases, function(pair){
+  							var match = mid.match(pair[0]);
+  							if(match && match.length>candidateLength){
+  								candidate = isFunction(pair[1]) ? mid.replace(pair[0], pair[1]) : pair[1];
+  							}
+  						});
+  						if(candidate){
+  							return getModuleInfo_(candidate, 0, packs, modules, baseUrl, mapProgs, pathsMapProg, aliases, alwaysCreate);
+  						}
 
-  				// (IE < 10 / Opera) Fall back to setting/removing the
-  				// unselectable attribute on the element and all its children
-  				var nodes = node.getElementsByTagName("*"),
-  					i = nodes.length;
+  						result = modules[mid];
+  						if(result){
+  							return alwaysCreate ? makeModuleInfo(result.pid, result.mid, result.pack, result.url) : modules[mid];
+  						}
+  					}
+  					// get here iff the sought-after module does not yet exist; therefore, we need to compute the URL given the
+  					// fully resolved (i.e., all relative indicators and package mapping resolved) module id
 
-  				if(selectable){
-  					node.removeAttribute("unselectable");
-  					while(i--){
-  						nodes[i].removeAttribute("unselectable");
+  					// note: pid!==0 indicates the routine is returning a url that has .js appended unmodified mid
+  					mapItem = runMapProg(mid, pathsMapProg);
+  					if(mapItem){
+  						url = mapItem[1] + mid.substring(mapItem[3]);
+  					}else if(pid){
+  						url = (pack.location.slice(-1) === '/' ? pack.location.slice(0, -1) : pack.location) + "/" + midInPackage;
+  					}else {
+  						url = mid;
   					}
-  				}else {
-  					node.setAttribute("unselectable", "on");
-  					while(i--){
-  						nodes[i].setAttribute("unselectable", "on");
+  					// if result is not absolute, add baseUrl
+  					if(!(/(^\/)|(\:)/.test(url))){
+  						url = baseUrl + url;
   					}
-  				}
-  			};
-
-  			return dom;
-  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
-  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+  					url += ".js";
+  					return makeModuleInfo(pid, mid, pack, compactPath(url));
+  				},
 
+  				getModuleInfo = function(mid, referenceModule, fromPendingCache){
+  					return getModuleInfo_(mid, referenceModule, packs, modules, req.baseUrl, mapProgs, pathsMapProg, aliases, undefined);
+  				};
 
-  		/***/ }),
+  			req.toAbsMid = function(mid, referenceModule){
+  					return getModuleInfo(mid, referenceModule).mid;
+  				};
 
-  		/***/ 2348:
-  		/*!*********************************************!*\
-  		  !*** ../../node_modules/dgrid/Selection.js ***!
-  		  \*********************************************/
-  		/***/ ((module, exports, __webpack_require__) => {
+  				req.toUrl = function(name, referenceModule){
+  					var moduleInfo = getModuleInfo(name+"/x", referenceModule),
+  						url= moduleInfo.url;
+  					return fixupUrl(moduleInfo.pid===0 ?
+  						// if pid===0, then name had a protocol or absolute path; either way, toUrl is the identify function in such cases
+  						name :
+  						// "/x.js" since getModuleInfo automatically appends ".js" and we appended "/x" to make name look like a module id
+  						url.substring(0, url.length-5)
+  					);
+  				};
 
-  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
-  			__webpack_require__(/*! dojo/_base/declare */ 6345),
-  			__webpack_require__(/*! dojo/aspect */ 6566),
-  			__webpack_require__(/*! dojo/dom-class */ 8945),
-  			__webpack_require__(/*! dojo/mouse */ 8471),
-  			__webpack_require__(/*! dojo/on */ 2075),
-  			__webpack_require__(/*! dojo/sniff */ 2616),
-  			__webpack_require__.dj.h(/*! dojo/has!touch?./util/touch */"touch?5892"),
-  			__webpack_require__(/*! dojo/query */ 1172), // for on.selector
-  			__webpack_require__(/*! dojo/dom */ 2284) // for has('css-user-select') in 1.8.2+
-  		], __WEBPACK_AMD_DEFINE_RESULT__ = (function (declare, aspect, domClass, mouse, on, has, touchUtil) {
-
-  			has.add('dom-comparedocumentposition', function (global, doc, element) {
-  				return !!element.compareDocumentPosition;
-  			});
-
-  			// Add a feature test for the onselectstart event, which offers a more
-  			// graceful fallback solution than node.unselectable.
-  			has.add('dom-selectstart', typeof document.onselectstart !== 'undefined');
-
-  			var ctrlEquiv = has('mac') ? 'metaKey' : 'ctrlKey',
-  				hasUserSelect = has('css-user-select'),
-  				hasPointer = has('pointer'),
-  				hasMSPointer = hasPointer && hasPointer.slice(0, 2) === 'MS',
-  				downType = hasPointer ? hasPointer + (hasMSPointer ? 'Down' : 'down') : 'mousedown',
-  				upType = hasPointer ? hasPointer + (hasMSPointer ? 'Up' : 'up') : 'mouseup';
+  			var fixupUrl= typeof userConfig.fixupUrl == "function" ? userConfig.fixupUrl : function(url){
+  					url += ""; // make sure url is a Javascript string (some paths may be a Java string)
+  					return url + (cacheBust ? ((/\?/.test(url) ? "&" : "?") + cacheBust) : "");
+  				};
 
-  			if (hasUserSelect === 'WebkitUserSelect' && typeof document.documentElement.style.msUserSelect !== 'undefined') {
-  				// Edge defines both webkit and ms prefixes, rendering feature detects as brittle as UA sniffs...
-  				hasUserSelect = false;
+  			{
+  				req.log = noop;
   			}
 
-  			function makeUnselectable(node, unselectable) {
-  				// Utility function used in fallback path for recursively setting unselectable
-  				var value = node.unselectable = unselectable ? 'on' : '',
-  					elements = node.getElementsByTagName('*'),
-  					i = elements.length;
+  			{
+  				req.trace = noop;
+  			}
+  			var def; {
+  				var def = noop;
+  			}
+  			// allow config to override default implementation of named functions; this is useful for
+  			// non-browser environments, e.g., overriding injectUrl, getText, log, etc. in node.js, Rhino, etc.
+  			// also useful for testing and monkey patching loader
+  			mix(mix(req, defaultConfig.loaderPatch), userConfig.loaderPatch);
 
-  				while (--i) {
-  					if (elements[i].tagName === 'INPUT' || elements[i].tagName === 'TEXTAREA') {
-  						continue; // Don't prevent text selection in text input fields.
+  			// now that req is fully initialized and won't change, we can hook it up to the error signal
+  			on(error, function(arg){
+  				try{
+  					console.error(arg);
+  					if(arg instanceof Error){
+  						for(var p in arg){
+  							console.log(p + ":", arg[p]);
+  						}
+  						console.log(".");
   					}
-  					elements[i].unselectable = value;
-  				}
-  			}
+  				}catch(e){}
+  			});
 
-  			function setSelectable(grid, selectable) {
-  				// Alternative version of dojo/dom.setSelectable based on feature detection.
+  			// always publish these
+  			mix(req, {
+  				uid:uid,
+  				cache:cache,
+  				packs:packs
+  			});
 
-  				// For FF < 21, use -moz-none, which will respect -moz-user-select: text on
-  				// child elements (e.g. form inputs).  In FF 21, none behaves the same.
-  				// See https://developer.mozilla.org/en-US/docs/CSS/user-select
-  				var node = grid.bodyNode,
-  					value = selectable ? 'text' : has('ff') < 21 ? '-moz-none' : 'none';
+  			// the loader can be defined exactly once; look for global define which is the symbol AMD loaders are
+  			// *required* to define (as opposed to require, which is optional)
+  			if(global.define){
+  				return;
+  			}else {
+  				global.define = def;
+  				global.require = req;
+  			}
+  		})
+  		.call(this, userConfig, defaultConfig);};
 
-  				// In IE10+, -ms-user-select: none will block selection from starting within the
-  				// element, but will not block an existing selection from entering the element.
-  				// When using a modifier key, IE will select text inside of the element as well
-  				// as outside of the element, because it thinks the selection started outside.
-  				// Therefore, fall back to other means of blocking selection for IE10+.
-  				// Newer versions of Dojo do not even report msUserSelect (see https://github.com/dojo/dojo/commit/7ae2a43).
-  				if (hasUserSelect && hasUserSelect !== 'msUserSelect') {
-  					node.style[hasUserSelect] = value;
-  				}
-  				else if (has('dom-selectstart')) {
-  					// For browsers that don't support user-select but support selectstart (IE<10),
-  					// we can hook up an event handler as necessary.  Since selectstart bubbles,
-  					// it will handle any child elements as well.
-  					// Note, however, that both this and the unselectable fallback below are
-  					// incapable of preventing text selection from outside the targeted node.
-  					if (!selectable && !grid._selectstartHandle) {
-  						grid._selectstartHandle = on(node, 'selectstart', function (evt) {
-  							var tag = evt.target && evt.target.tagName;
+  		/***/ }),
 
-  							// Prevent selection except where a text input field is involved.
-  							if (tag !== 'INPUT' && tag !== 'TEXTAREA') {
-  								evt.preventDefault();
-  							}
-  						});
-  					}
-  					else if (selectable && grid._selectstartHandle) {
-  						grid._selectstartHandle.remove();
-  						delete grid._selectstartHandle;
-  					}
-  				}
-  				else {
-  					// For browsers that don't support either user-select or selectstart (Opera),
-  					// we need to resort to setting the unselectable attribute on all nodes
-  					// involved.  Since this doesn't automatically apply to child nodes, we also
-  					// need to re-apply it whenever rows are rendered.
-  					makeUnselectable(node, !selectable);
-  					if (!selectable && !grid._unselectableHandle) {
-  						grid._unselectableHandle = aspect.after(grid, 'renderRow', function (row) {
-  							makeUnselectable(row, true);
-  							return row;
-  						});
-  					}
-  					else if (selectable && grid._unselectableHandle) {
-  						grid._unselectableHandle.remove();
-  						delete grid._unselectableHandle;
-  					}
-  				}
-  			}
+  		/***/ 2219:
+  		/*!*****************************************************!*\
+  		  !*** ../../node_modules/dojo-dstore/QueryMethod.js ***!
+  		  \*****************************************************/
+  		/***/ ((module, exports, __webpack_require__) => {
 
-  			return declare(null, {
+  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
+  			/*=====
+  			var __QueryMethodArgs = {
+  				// type: String
+  				//		The type of the query. This identifies the query's type in the query log
+  				//		and the name of the corresponding query engine method.
+  				// normalizeArguments: Function?
+  				//		A function that normalizes arguments for consumption by a query engine
+  				// applyQuery: Function?
+  				//		A function that takes the query's new subcollection and the query's log entry
+  				//		and applies it to the new subcollection. This is useful for collections that need
+  				//		to both declare and implement new query methods.
+  				// querierFactory: Function?
+  				//		A factory function that provides a default querier implementation to use when
+  				//		a collection does not define its own querier factory method for this query type.
+  			};
+  			=====*/
+  			return function QueryMethod(/*__QueryMethodArgs*/ kwArgs) {
   				// summary:
-  				//		Add selection capabilities to a grid. The grid will have a selection property and
-  				//		fire "dgrid-select" and "dgrid-deselect" events.
-
-  				// selectionDelegate: String
-  				//		Selector to delegate to as target of selection events.
-  				selectionDelegate: '.dgrid-row',
+  				//		The constructor for a dstore collection query method
+  				// description:
+  				//		This is the constructor for a collection query method. It encapsulates the following:
+  				//		* Creating a new subcollection for the query results
+  				//		* Logging the query in the collection's `queryLog`
+  				//		* Normalizing query arguments
+  				//		* Applying the query engine
+  				// kwArgs:
+  				//		The properties that define the query method
+  				// returns: Function
+  				//		Returns a function that takes query arguments and returns a new collection with
+  				//		the query associated with it.
 
-  				// selectionEvents: String|Function
-  				//		Event (or comma-delimited events, or extension event) to listen on
-  				//		to trigger select logic.
-  				selectionEvents: downType + ',' + upType + ',dgrid-cellfocusin',
+  				var type = kwArgs.type,
+  					normalizeArguments = kwArgs.normalizeArguments,
+  					applyQuery = kwArgs.applyQuery,
+  					defaultQuerierFactory = kwArgs.querierFactory;
 
-  				// selectionTouchEvents: String|Function
-  				//		Event (or comma-delimited events, or extension event) to listen on
-  				//		in addition to selectionEvents for touch devices.
-  				selectionTouchEvents:  null,
+  				return function () {
+  					// summary:
+  					//		A query method whose arguments are determined by the query type
+  					// returns: dstore/Collection
+  					//		A collection representing the query results
 
-  				// deselectOnRefresh: Boolean
-  				//		If true, the selection object will be cleared when refresh is called.
-  				deselectOnRefresh: true,
+  					var originalArguments = Array.prototype.slice.call(arguments),
+  						normalizedArguments = normalizeArguments
+  							? normalizeArguments.apply(this, originalArguments)
+  							: originalArguments,
+  						logEntry = {
+  							type: type,
+  							arguments: originalArguments,
+  							normalizedArguments: normalizedArguments
+  						},
+  						querierFactory = this._getQuerierFactory(type) || defaultQuerierFactory;
 
-  				// allowSelectAll: Boolean
-  				//		If true, allow ctrl/cmd+A to select all rows.
-  				//		Also consulted by the selector plugin for showing select-all checkbox.
-  				allowSelectAll: false,
+  					if (querierFactory) {
+  						// Call the query factory in store context to support things like
+  						// mapping a filter query's string argument to a custom filter method on the collection
+  						logEntry.querier = querierFactory.apply(this, normalizedArguments);
+  					}
 
-  				// selection:
-  				//		An object where the property names correspond to
-  				//		object ids and values are true or false depending on whether an item is selected
-  				selection: {},
+  					var newCollection = this._createSubCollection({
+  						queryLog: this.queryLog.concat(logEntry)
+  					});
 
-  				// selectionMode: String
-  				//		The selection mode to use, can be "none", "multiple", "single", or "extended".
-  				selectionMode: 'extended',
+  					return applyQuery ? applyQuery.call(this, newCollection, logEntry) : newCollection;
+  				};
+  			};
+  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
+  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
 
-  				// allowTextSelection: Boolean
-  				//		Whether to still allow text within cells to be selected.  The default
-  				//		behavior is to allow text selection only when selectionMode is none;
-  				//		setting this property to either true or false will explicitly set the
-  				//		behavior regardless of selectionMode.
-  				allowTextSelection: undefined,
 
-  				// _selectionTargetType: String
-  				//		Indicates the property added to emitted events for selected targets;
-  				//		overridden in CellSelection
-  				_selectionTargetType: 'rows',
+  		/***/ }),
 
-  				create: function () {
-  					this.selection = {};
-  					return this.inherited(arguments);
-  				},
-  				postCreate: function () {
-  					this.inherited(arguments);
+  		/***/ 2236:
+  		/*!**********************************************************!*\
+  		  !*** ../../node_modules/dojo/promise/instrumentation.js ***!
+  		  \**********************************************************/
+  		/***/ ((module, exports, __webpack_require__) => {
 
-  					this._initSelectionEvents();
+  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
+  			__webpack_require__(/*! ./tracer */ 3185),
+  			__webpack_require__(/*! ../has */ 6356),
+  			__webpack_require__(/*! ../_base/lang */ 6323),
+  			__webpack_require__(/*! ../_base/array */ 6974)
+  		], __WEBPACK_AMD_DEFINE_RESULT__ = (function(tracer, has, lang, arrayUtil){
+  			has.add("config-useDeferredInstrumentation", "report-unhandled-rejections");
 
-  					// Force selectionMode setter to run
-  					var selectionMode = this.selectionMode;
-  					this.selectionMode = '';
-  					this._setSelectionMode(selectionMode);
-  				},
+  			function logError(error, rejection, deferred){
+  				if(error && error.log === false){
+  					return;
+  				}
+  				var stack = "";
+  				if(error && error.stack){
+  					stack += error.stack;
+  				}
+  				if(rejection && rejection.stack){
+  					stack += "\n    ----------------------------------------\n    rejected" + rejection.stack.split("\n").slice(1).join("\n").replace(/^\s+/, " ");
+  				}
+  				if(deferred && deferred.stack){
+  					stack += "\n    ----------------------------------------\n" + deferred.stack;
+  				}
+  				console.error(error, stack);
+  			}
 
-  				destroy: function () {
-  					this.inherited(arguments);
+  			function reportRejections(error, handled, rejection, deferred){
+  				if(!handled){
+  					logError(error, rejection, deferred);
+  				}
+  			}
 
-  					// Remove any extra handles added by Selection.
-  					if (this._selectstartHandle) {
-  						this._selectstartHandle.remove();
-  					}
-  					if (this._unselectableHandle) {
-  						this._unselectableHandle.remove();
-  					}
-  					if (this._removeDeselectSignals) {
-  						this._removeDeselectSignals();
+  			var errors = [];
+  			var activeTimeout = false;
+  			var unhandledWait = 1000;
+  			function trackUnhandledRejections(error, handled, rejection, deferred){
+  				// try to find the existing tracking object
+  				if(!arrayUtil.some(errors, function(obj){
+  					if(obj.error === error){
+  						// found the tracking object for this error
+  						if(handled){
+  							// if handled, update the state
+  							obj.handled = true;
+  						}
+  						return true;
   					}
-  				},
+  				})){
+  					// no tracking object has been setup, create one
+  					errors.push({
+  						error: error,
+  						rejection: rejection,
+  						handled: handled,
+  						deferred: deferred,
+  						timestamp: new Date().getTime()
+  					});
+  				}
 
-  				_setSelectionMode: function (mode) {
-  					// summary:
-  					//		Updates selectionMode, resetting necessary variables.
+  				if(!activeTimeout){
+  					activeTimeout = setTimeout(logRejected, unhandledWait);
+  				}
+  			}
 
-  					if (mode === this.selectionMode) {
-  						return;
+  			function logRejected(){
+  				var now = new Date().getTime();
+  				var reportBefore = now - unhandledWait;
+  				errors = arrayUtil.filter(errors, function(obj){
+  					// only report the error if we have waited long enough and
+  					// it hasn't been handled
+  					if(obj.timestamp < reportBefore){
+  						if(!obj.handled){
+  							logError(obj.error, obj.rejection, obj.deferred);
+  						}
+  						return false;
   					}
+  					return true;
+  				});
 
-  					// Start selection fresh when switching mode.
-  					this.clearSelection();
-
-  					this.selectionMode = mode;
-
-  					// Compute name of selection handler for this mode once
-  					// (in the form of _fooSelectionHandler)
-  					this._selectionHandlerName = '_' + mode + 'SelectionHandler';
-
-  					// Also re-run allowTextSelection setter in case it is in automatic mode.
-  					this._setAllowTextSelection(this.allowTextSelection);
-  				},
+  				if(errors.length){
+  					activeTimeout = setTimeout(logRejected, errors[0].timestamp + unhandledWait - now);
+  				}else {
+  					activeTimeout = false;
+  				}
+  			}
 
-  				_setAllowTextSelection: function (allow) {
-  					if (typeof allow !== 'undefined') {
-  						setSelectable(this, allow);
-  					}
-  					else {
-  						setSelectable(this, this.selectionMode === 'none');
-  					}
-  					this.allowTextSelection = allow;
-  				},
+  			return function(Deferred){
+  				// summary:
+  				//		Initialize instrumentation for the Deferred class.
+  				// description:
+  				//		Initialize instrumentation for the Deferred class.
+  				//		Done automatically by `dojo/Deferred` if the
+  				//		`deferredInstrumentation` and `useDeferredInstrumentation`
+  				//		config options are set.
+  				//
+  				//		Sets up `dojo/promise/tracer` to log to the console.
+  				//
+  				//		Sets up instrumentation of rejected deferreds so unhandled
+  				//		errors are logged to the console.
 
-  				_handleSelect: function (event, target) {
-  					if (mouse.isRight(event)) {
-  						return;
-  					}
+  				var usage = has("config-useDeferredInstrumentation");
+  				if(usage){
+  					tracer.on("resolved", lang.hitch(console, "log", "resolved"));
+  					tracer.on("rejected", lang.hitch(console, "log", "rejected"));
+  					tracer.on("progress", lang.hitch(console, "log", "progress"));
 
-  					// Don't run if selection mode doesn't have a handler (incl. "none"), target can't be selected,
-  					// or if coming from a dgrid-cellfocusin from a mousedown
-  					if (!this[this._selectionHandlerName] || !this.allowSelect(this.row(target)) ||
-  							(event.type === 'dgrid-cellfocusin' && event.parentType === 'mousedown') ||
-  							(event.type === upType && target !== this._waitForMouseUp)) {
-  						return;
+  					var args = [];
+  					if(typeof usage === "string"){
+  						args = usage.split(",");
+  						usage = args.shift();
   					}
-  					this._waitForMouseUp = null;
-  					this._selectionTriggerEvent = event;
-
-  					// Don't call select handler for ctrl+navigation
-  					if (!event.keyCode || !event.ctrlKey || event.keyCode === 32) {
-  						// If clicking a selected item, wait for mouseup so that drag n' drop
-  						// is possible without losing our selection
-  						if (!event.shiftKey && event.type === downType && this.isSelected(target)) {
-  							this._waitForMouseUp = target;
-  						}
-  						else {
-  							this[this._selectionHandlerName](event, target);
-  						}
+  					if(usage === "report-rejections"){
+  						Deferred.instrumentRejected = reportRejections;
+  					}else if(usage === "report-unhandled-rejections" || usage === true || usage === 1){
+  						Deferred.instrumentRejected = trackUnhandledRejections;
+  						unhandledWait = parseInt(args[0], 10) || unhandledWait;
+  					}else {
+  						throw new Error("Unsupported instrumentation usage <" + usage + ">");
   					}
-  					this._selectionTriggerEvent = null;
-  				},
+  				}
+  			};
+  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
+  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
 
-  				_singleSelectionHandler: function (event, target) {
-  					// summary:
-  					//		Selection handler for "single" mode, where only one target may be
-  					//		selected at a time.
 
-  					var ctrlKey = event.keyCode ? event.ctrlKey : event[ctrlEquiv];
-  					if (this._lastSelected === target) {
-  						// Allow ctrl to toggle selection, even within single select mode.
-  						this.select(target, null, !ctrlKey || !this.isSelected(target));
-  					}
-  					else {
-  						this.clearSelection();
-  						this.select(target);
-  						this._lastSelected = target;
-  					}
-  				},
+  		/***/ }),
 
-  				_multipleSelectionHandler: function (event, target) {
-  					// summary:
-  					//		Selection handler for "multiple" mode, where shift can be held to
-  					//		select ranges, ctrl/cmd can be held to toggle, and clicks/keystrokes
-  					//		without modifier keys will add to the current selection.
+  		/***/ 2284:
+  		/*!**************************************!*\
+  		  !*** ../../node_modules/dojo/dom.js ***!
+  		  \**************************************/
+  		/***/ ((module, exports, __webpack_require__) => {
 
-  					var lastRow = this._lastSelected,
-  						ctrlKey = event.keyCode ? event.ctrlKey : event[ctrlEquiv],
-  						value;
+  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(/*! ./sniff */ 2616), __webpack_require__(/*! ./_base/window */ 5075), __webpack_require__(/*! ./_base/kernel */ 1054)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(has, win, kernel){
+  			// module:
+  			//		dojo/dom
 
-  					if (!event.shiftKey) {
-  						// Toggle if ctrl is held; otherwise select
-  						value = ctrlKey ? null : true;
-  						lastRow = null;
-  					}
-  					this.select(target, lastRow, value);
+  			// FIXME: need to add unit tests for all the semi-public methods
 
-  					if (!lastRow) {
-  						// Update reference for potential subsequent shift+select
-  						// (current row was already selected above)
-  						this._lastSelected = target;
-  					}
-  				},
+  			if(has("ie") <= 7){
+  				try{
+  					document.execCommand("BackgroundImageCache", false, true);
+  				}catch(e){
+  					// sane browsers don't have cache "issues"
+  				}
+  			}
 
-  				_extendedSelectionHandler: function (event, target) {
-  					// summary:
-  					//		Selection handler for "extended" mode, which is like multiple mode
-  					//		except that clicks/keystrokes without modifier keys will clear
-  					//		the previous selection.
+  			// =============================
+  			// DOM Functions
+  			// =============================
 
-  					// If the target is already selected, and is the sole selection, ignore a user action
-  					// that would simply select the target (causing unnecessary deselect/select).
-  					if (!event[ctrlEquiv] && this.isSelected(target) && this.getSelectedCount() === 1) {
-  						return;
-  					}
+  			// the result object
+  			var dom = {
+  				// summary:
+  				//		This module defines the core dojo DOM API.
+  			};
 
-  					// Clear selection first for right-clicks outside selection and non-ctrl-clicks;
-  					// otherwise, extended mode logic is identical to multiple mode
-  					if (event.button === 2 ? !this.isSelected(target) :
-  							!(event.keyCode ? event.ctrlKey : event[ctrlEquiv])) {
-  						this.clearSelection(null, true);
+  			if(has("ie")){
+  				dom.byId = function(id, doc){
+  					if(typeof id != "string"){
+  						return id || null;
   					}
-  					this._multipleSelectionHandler(event, target);
-  				},
+  					var _d = doc || win.doc, te = id && _d.getElementById(id);
+  					// attributes.id.value is better than just id in case the
+  					// user has a name=id inside a form
+  					if(te && (te.attributes.id.value == id || te.id == id)){
+  						return te;
+  					}else {
+  						var eles = _d.all[id];
+  						if(!eles || eles.nodeName){
+  							eles = [eles];
+  						}
+  						// if more than 1, choose first with the correct id
+  						var i = 0;
+  						while((te = eles[i++])){
+  							if((te.attributes && te.attributes.id && te.attributes.id.value == id) || te.id == id){
+  								return te;
+  							}
+  						}
+  					}
+  					return null;
+  				};
+  			}else {
+  				dom.byId = function(id, doc){
+  					// inline'd type check.
+  					// be sure to return null per documentation, to match IE branch.
+  					return ((typeof id == "string") ? (doc || win.doc).getElementById(id) : id) || null; // DOMNode
+  				};
+  			}
+  			/*=====
+  			 dom.byId = function(id, doc){
+  				// summary:
+  				//		Returns DOM node with matching `id` attribute or falsy value (ex: null or undefined)
+  				//		if not found.  If `id` is a DomNode, this function is a no-op.
+  				//
+  				// id: String|DOMNode
+  				//		A string to match an HTML id attribute or a reference to a DOM Node
+  				//
+  				// doc: Document?
+  				//		Document to work in. Defaults to the current value of
+  				//		dojo/_base/window.doc.  Can be used to retrieve
+  				//		node references from other documents.
+  				//
+  				// example:
+  				//		Look up a node by ID:
+  				//	|	require(["dojo/dom"], function(dom){
+  				//	|		var n = dom.byId("foo");
+  				//	|	});
+  				//
+  				// example:
+  				//		Check if a node exists, and use it.
+  				//	|	require(["dojo/dom"], function(dom){
+  				//	|		var n = dom.byId("bar");
+  				//	|		if(n){ doStuff() ... }
+  				//	|	});
+  				//
+  				// example:
+  				//		Allow string or DomNode references to be passed to a custom function:
+  				//	|	require(["dojo/dom"], function(dom){
+  				//	|		var foo = function(nodeOrId){
+  				//	|			nodeOrId = dom.byId(nodeOrId);
+  				//	|			// ... more stuff
+  				//	|		}
+  				//	|	});
+  			 };
+  			 =====*/
 
-  				_toggleSelectionHandler: function (event, target) {
+  			// Test for DOMNode.contains() method, available everywhere except FF8-
+  			// and IE8-, where it's available in general, but not on document itself,
+  			// and also problems when either ancestor or node are text nodes.
+
+  			var doc = kernel.global["document"] || null;
+  			has.add("dom-contains", !!(doc && doc.contains));
+  			dom.isDescendant = has("dom-contains") ?
+  				// FF9+, IE9+, webkit, opera, iOS, Android, Edge, etc.
+  				function(/*DOMNode|String*/ node, /*DOMNode|String*/ ancestor){
+  					return !!( (ancestor = dom.byId(ancestor)) && ancestor.contains(dom.byId(node)) );
+  				} :
+  				function(/*DOMNode|String*/ node, /*DOMNode|String*/ ancestor){
   					// summary:
-  					//		Selection handler for "toggle" mode which simply toggles the selection
-  					//		of the given target.  Primarily useful for touch input.
+  					//		Returns true if node is a descendant of ancestor
+  					// node: DOMNode|String
+  					//		string id or node reference to test
+  					// ancestor: DOMNode|String
+  					//		string id or node reference of potential parent to test against
+  					//
+  					// example:
+  					//		Test is node id="bar" is a descendant of node id="foo"
+  					//	|	require(["dojo/dom"], function(dom){
+  					//	|		if(dom.isDescendant("bar", "foo")){ ... }
+  					//	|	});
 
-  					this.select(target, null, null);
-  				},
+  					try{
+  						node = dom.byId(node);
+  						ancestor = dom.byId(ancestor);
+  						while(node){
+  							if(node == ancestor){
+  								return true; // Boolean
+  							}
+  							node = node.parentNode;
+  						}
+  					}catch(e){ /* squelch, return false */ }
+  					return false; // Boolean
+  				};
 
-  				_initSelectionEvents: function () {
-  					// summary:
-  					//		Performs first-time hookup of event handlers containing logic
-  					//		required for selection to operate.
+  			// TODO: do we need setSelectable in the base?
 
-  					var grid = this,
-  						contentNode = this.contentNode,
-  						selector = this.selectionDelegate;
+  			// Add feature test for user-select CSS property
+  			// (currently known to work in all but IE < 10 and Opera)
+  			// TODO: The user-select CSS property as of May 2014 is no longer part of
+  			// any CSS specification. In IE, -ms-user-select does not do the same thing
+  			// as the unselectable attribute on elements; namely, dijit Editor buttons
+  			// do not properly prevent the content of the editable content frame from
+  			// unblurring. As a result, the -ms- prefixed version is omitted here.
+  			has.add("css-user-select", function(global, doc, element){
+  				// Avoid exception when dom.js is loaded in non-browser environments
+  				if(!element){ return false; }
 
-  					this._selectionEventQueues = {
-  						deselect: [],
-  						select: []
-  					};
+  				var style = element.style;
+  				var prefixes = ["Khtml", "O", "Moz", "Webkit"],
+  					i = prefixes.length,
+  					name = "userSelect";
 
-  					{
-  						// Listen for mouse/keyboard actions that should cause selections
-  						on(contentNode, on.selector(selector, this.selectionEvents), function (event) {
-  							grid._handleSelect(event, this);
-  						});
+  				// Iterate prefixes from most to least likely
+  				do{
+  					if(typeof style[name] !== "undefined"){
+  						// Supported; return property name
+  						return name;
   					}
+  				}while(i-- && (name = prefixes[i] + "UserSelect"));
 
-  					// Also hook up spacebar (for ctrl+space)
-  					if (this.addKeyHandler) {
-  						this.addKeyHandler(32, function (event) {
-  							grid._handleSelect(event, event.target);
-  						});
-  					}
+  				// Not supported if we didn't return before now
+  				return false;
+  			});
 
-  					// If allowSelectAll is true, bind ctrl/cmd+A to (de)select all rows,
-  					// unless the event was received from an editor component.
-  					// (Handler further checks against _allowSelectAll, which may be updated
-  					// if selectionMode is changed post-init.)
-  					if (this.allowSelectAll) {
-  						this.on('keydown', function (event) {
-  							if (event[ctrlEquiv] && event.keyCode === 65 &&
-  									!/\bdgrid-input\b/.test(event.target.className)) {
-  								event.preventDefault();
-  								grid[grid.allSelected ? 'clearSelection' : 'selectAll']();
-  							}
-  						});
-  					}
+  			/*=====
+  			dom.setSelectable = function(node, selectable){
+  				// summary:
+  				//		Enable or disable selection on a node
+  				// node: DOMNode|String
+  				//		id or reference to node
+  				// selectable: Boolean
+  				//		state to put the node in. false indicates unselectable, true
+  				//		allows selection.
+  				// example:
+  				//		Make the node id="bar" unselectable
+  				//	|	require(["dojo/dom"], function(dom){
+  				//	|		dom.setSelectable("bar");
+  				//	|	});
+  				// example:
+  				//		Make the node id="bar" selectable
+  				//	|	require(["dojo/dom"], function(dom){
+  				//	|		dom.setSelectable("bar", true);
+  				//	|	});
+  			};
+  			=====*/
 
-  					// Update aspects if there is a collection change
-  					if (this._setCollection) {
-  						this._listeners.push(
-  							aspect.before(this, '_setCollection', function (collection) {
-  								grid._updateDeselectionAspect(collection);
-  							})
-  						);
+  			var cssUserSelect = has("css-user-select");
+  			dom.setSelectable = cssUserSelect ? function(node, selectable){
+  				// css-user-select returns a (possibly vendor-prefixed) CSS property name
+  				dom.byId(node).style[cssUserSelect] = selectable ? "" : "none";
+  			} : function(node, selectable){
+  				node = dom.byId(node);
+
+  				// (IE < 10 / Opera) Fall back to setting/removing the
+  				// unselectable attribute on the element and all its children
+  				var nodes = node.getElementsByTagName("*"),
+  					i = nodes.length;
+
+  				if(selectable){
+  					node.removeAttribute("unselectable");
+  					while(i--){
+  						nodes[i].removeAttribute("unselectable");
   					}
-  					this._updateDeselectionAspect();
-  				},
+  				}else {
+  					node.setAttribute("unselectable", "on");
+  					while(i--){
+  						nodes[i].setAttribute("unselectable", "on");
+  					}
+  				}
+  			};
 
-  				_updateDeselectionAspect: function (collection) {
-  					// summary:
-  					//		Hooks up logic to handle deselection of removed items.
-  					//		Aspects to a trackable collection's notify method if applicable,
-  					//		or to the list/grid's removeRow method otherwise.
+  			return dom;
+  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
+  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
 
-  					var self = this,
-  						signals;
 
-  					function ifSelected(rowArg, methodName) {
-  						// Calls a method if the row corresponding to the object is selected.
-  						var row = self.row(rowArg),
-  							selection = row && self.selection[row.id];
-  						// Is the row currently in the selection list.
-  						if (selection) {
-  							self[methodName](row);
-  						}
-  					}
+  		/***/ }),
 
-  					// Remove anything previously configured
-  					if (this._removeDeselectSignals) {
-  						this._removeDeselectSignals();
-  					}
+  		/***/ 2348:
+  		/*!*********************************************!*\
+  		  !*** ../../node_modules/dgrid/Selection.js ***!
+  		  \*********************************************/
+  		/***/ ((module, exports, __webpack_require__) => {
 
-  					if (collection && collection.track && this._observeCollection) {
-  						signals = [
-  							aspect.before(this, '_observeCollection', function (collection) {
-  								signals.push(
-  									collection.on('delete', function (event) {
-  										if (typeof event.index === 'undefined') {
-  											// Call deselect on the row if the object is being removed.  This allows the
-  											// deselect event to reference the row element while it still exists in the DOM.
-  											ifSelected(event.id, 'deselect');
-  										}
-  									})
-  								);
-  							}),
-  							aspect.after(this, '_observeCollection', function (collection) {
-  								signals.push(
-  									collection.on('update', function (event) {
-  										if (typeof event.index !== 'undefined') {
-  											// When List updates an item, the row element is removed and a new one inserted.
-  											// If at this point the object is still in grid.selection,
-  											// then call select on the row so the element's CSS is updated.
-  											ifSelected(collection.getIdentity(event.target), 'select');
-  										}
-  									})
-  								);
-  							}, true)
-  						];
-  					}
-  					else {
-  						signals = [
-  							aspect.before(this, 'removeRow', function (rowElement, preserveDom) {
-  								var row;
-  								if (!preserveDom) {
-  									row = this.row(rowElement);
-  									// if it is a real row removal for a selected item, deselect it
-  									if (row && (row.id in this.selection)) {
-  										this.deselect(row);
-  									}
-  								}
-  							})
-  						];
-  					}
+  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
+  			__webpack_require__(/*! dojo/_base/declare */ 6345),
+  			__webpack_require__(/*! dojo/aspect */ 6566),
+  			__webpack_require__(/*! dojo/dom-class */ 8945),
+  			__webpack_require__(/*! dojo/mouse */ 8471),
+  			__webpack_require__(/*! dojo/on */ 2075),
+  			__webpack_require__(/*! dojo/sniff */ 2616),
+  			__webpack_require__.dj.h(/*! dojo/has!touch?./util/touch */"touch?5892"),
+  			__webpack_require__(/*! dojo/query */ 1172), // for on.selector
+  			__webpack_require__(/*! dojo/dom */ 2284) // for has('css-user-select') in 1.8.2+
+  		], __WEBPACK_AMD_DEFINE_RESULT__ = (function (declare, aspect, domClass, mouse, on, has, touchUtil) {
 
-  					this._removeDeselectSignals = function () {
-  						for (var i = signals.length; i--;) {
-  							signals[i].remove();
-  						}
-  						signals = [];
-  					};
-  				},
+  			has.add('dom-comparedocumentposition', function (global, doc, element) {
+  				return !!element.compareDocumentPosition;
+  			});
 
-  				allowSelect: function () {
-  					// summary:
-  					//		A method that can be overriden to determine whether or not a row (or
-  					//		cell) can be selected. By default, all rows (or cells) are selectable.
-  					// target: Object
-  					//		Row object (for Selection) or Cell object (for CellSelection) for the
-  					//		row/cell in question
-  					return true;
-  				},
+  			// Add a feature test for the onselectstart event, which offers a more
+  			// graceful fallback solution than node.unselectable.
+  			has.add('dom-selectstart', typeof document.onselectstart !== 'undefined');
 
-  				_fireSelectionEvent: function (type) {
-  					// summary:
-  					//		Fires an event for the accumulated rows once a selection
-  					//		operation is finished (whether singular or for a range)
+  			var ctrlEquiv = has('mac') ? 'metaKey' : 'ctrlKey',
+  				hasUserSelect = has('css-user-select'),
+  				hasPointer = has('pointer'),
+  				hasMSPointer = hasPointer && hasPointer.slice(0, 2) === 'MS',
+  				downType = hasPointer ? hasPointer + (hasMSPointer ? 'Down' : 'down') : 'mousedown',
+  				upType = hasPointer ? hasPointer + (hasMSPointer ? 'Up' : 'up') : 'mouseup';
 
-  					var queue = this._selectionEventQueues[type],
-  						triggerEvent = this._selectionTriggerEvent,
-  						eventObject;
+  			if (hasUserSelect === 'WebkitUserSelect' && typeof document.documentElement.style.msUserSelect !== 'undefined') {
+  				// Edge defines both webkit and ms prefixes, rendering feature detects as brittle as UA sniffs...
+  				hasUserSelect = false;
+  			}
 
-  					eventObject = {
-  						bubbles: true,
-  						grid: this
-  					};
-  					if (triggerEvent) {
-  						eventObject.parentType = triggerEvent.type;
+  			function makeUnselectable(node, unselectable) {
+  				// Utility function used in fallback path for recursively setting unselectable
+  				var value = node.unselectable = unselectable ? 'on' : '',
+  					elements = node.getElementsByTagName('*'),
+  					i = elements.length;
+
+  				while (--i) {
+  					if (elements[i].tagName === 'INPUT' || elements[i].tagName === 'TEXTAREA') {
+  						continue; // Don't prevent text selection in text input fields.
   					}
-  					eventObject[this._selectionTargetType] = queue;
+  					elements[i].unselectable = value;
+  				}
+  			}
 
-  					// Clear the queue so that the next round of (de)selections starts anew
-  					this._selectionEventQueues[type] = [];
+  			function setSelectable(grid, selectable) {
+  				// Alternative version of dojo/dom.setSelectable based on feature detection.
 
-  					on.emit(this.contentNode, 'dgrid-' + type, eventObject);
-  				},
+  				// For FF < 21, use -moz-none, which will respect -moz-user-select: text on
+  				// child elements (e.g. form inputs).  In FF 21, none behaves the same.
+  				// See https://developer.mozilla.org/en-US/docs/CSS/user-select
+  				var node = grid.bodyNode,
+  					value = selectable ? 'text' : has('ff') < 21 ? '-moz-none' : 'none';
 
-  				_fireSelectionEvents: function () {
-  					var queues = this._selectionEventQueues,
-  						type;
+  				// In IE10+, -ms-user-select: none will block selection from starting within the
+  				// element, but will not block an existing selection from entering the element.
+  				// When using a modifier key, IE will select text inside of the element as well
+  				// as outside of the element, because it thinks the selection started outside.
+  				// Therefore, fall back to other means of blocking selection for IE10+.
+  				// Newer versions of Dojo do not even report msUserSelect (see https://github.com/dojo/dojo/commit/7ae2a43).
+  				if (hasUserSelect && hasUserSelect !== 'msUserSelect') {
+  					node.style[hasUserSelect] = value;
+  				}
+  				else if (has('dom-selectstart')) {
+  					// For browsers that don't support user-select but support selectstart (IE<10),
+  					// we can hook up an event handler as necessary.  Since selectstart bubbles,
+  					// it will handle any child elements as well.
+  					// Note, however, that both this and the unselectable fallback below are
+  					// incapable of preventing text selection from outside the targeted node.
+  					if (!selectable && !grid._selectstartHandle) {
+  						grid._selectstartHandle = on(node, 'selectstart', function (evt) {
+  							var tag = evt.target && evt.target.tagName;
 
-  					for (type in queues) {
-  						if (queues[type].length) {
-  							this._fireSelectionEvent(type);
-  						}
+  							// Prevent selection except where a text input field is involved.
+  							if (tag !== 'INPUT' && tag !== 'TEXTAREA') {
+  								evt.preventDefault();
+  							}
+  						});
   					}
-  				},
-
-  				_select: function (row, toRow, value) {
-  					// summary:
-  					//		Contains logic for determining whether to select targets, but
-  					//		does not emit events.  Called from select, deselect, selectAll,
-  					//		and clearSelection.
-
-  					var selection,
-  						previousValue,
-  						element,
-  						toElement,
-  						direction;
-
-  					if (typeof value === 'undefined') {
-  						// default to true
-  						value = true;
+  					else if (selectable && grid._selectstartHandle) {
+  						grid._selectstartHandle.remove();
+  						delete grid._selectstartHandle;
   					}
-  					if (!row.element) {
-  						row = this.row(row);
+  				}
+  				else {
+  					// For browsers that don't support either user-select or selectstart (Opera),
+  					// we need to resort to setting the unselectable attribute on all nodes
+  					// involved.  Since this doesn't automatically apply to child nodes, we also
+  					// need to re-apply it whenever rows are rendered.
+  					makeUnselectable(node, !selectable);
+  					if (!selectable && !grid._unselectableHandle) {
+  						grid._unselectableHandle = aspect.after(grid, 'renderRow', function (row) {
+  							makeUnselectable(row, true);
+  							return row;
+  						});
+  					}
+  					else if (selectable && grid._unselectableHandle) {
+  						grid._unselectableHandle.remove();
+  						delete grid._unselectableHandle;
   					}
+  				}
+  			}
 
-  					// Check whether we're allowed to select the given row before proceeding.
-  					// If a deselect operation is being performed, this check is skipped,
-  					// to avoid errors when changing column definitions, and since disabled
-  					// rows shouldn't ever be selected anyway.
-  					if (value === false || this.allowSelect(row)) {
-  						selection = this.selection;
-  						previousValue = !!selection[row.id];
-  						if (value === null) {
-  							// indicates a toggle
-  							value = !previousValue;
-  						}
-  						element = row.element;
-  						if (!value && !this.allSelected) {
-  							delete this.selection[row.id];
-  						}
-  						else {
-  							selection[row.id] = value;
-  						}
-  						if (element) {
-  							// add or remove classes as appropriate
-  							if (value) {
-  								domClass.add(element, 'dgrid-selected' +
-  									(this.addUiClasses ? ' ui-state-active' : ''));
-  							}
-  							else {
-  								domClass.remove(element, 'dgrid-selected ui-state-active');
-  							}
-  						}
-  						if (value !== previousValue && element) {
-  							// add to the queue of row events
-  							this._selectionEventQueues[(value ? '' : 'de') + 'select'].push(row);
-  						}
+  			return declare(null, {
+  				// summary:
+  				//		Add selection capabilities to a grid. The grid will have a selection property and
+  				//		fire "dgrid-select" and "dgrid-deselect" events.
 
-  						if (toRow) {
-  							if (!toRow.element) {
-  								toRow = this.row(toRow);
-  							}
+  				// selectionDelegate: String
+  				//		Selector to delegate to as target of selection events.
+  				selectionDelegate: '.dgrid-row',
 
-  							if (!toRow) {
-  								this._lastSelected = element;
-  								console.warn('The selection range has been reset because the ' +
-  									'beginning of the selection is no longer in the DOM. ' +
-  									'If you are using OnDemandList, you may wish to increase ' +
-  									'farOffRemoval to avoid this, but note that keeping more nodes ' +
-  									'in the DOM may impact performance.');
-  								return;
-  							}
+  				// selectionEvents: String|Function
+  				//		Event (or comma-delimited events, or extension event) to listen on
+  				//		to trigger select logic.
+  				selectionEvents: downType + ',' + upType + ',dgrid-cellfocusin',
 
-  							toElement = toRow.element;
-  							if (toElement) {
-  								direction = this._determineSelectionDirection(element, toElement);
-  								if (!direction) {
-  									// The original element was actually replaced
-  									toElement = document.getElementById(toElement.id);
-  									direction = this._determineSelectionDirection(element, toElement);
-  								}
-  								while (row.element !== toElement && (row = this[direction](row))) {
-  									this._select(row, null, value);
-  								}
-  							}
-  						}
-  					}
-  				},
+  				// selectionTouchEvents: String|Function
+  				//		Event (or comma-delimited events, or extension event) to listen on
+  				//		in addition to selectionEvents for touch devices.
+  				selectionTouchEvents:  null,
 
-  				// Implement _determineSelectionDirection differently based on whether the
-  				// browser supports element.compareDocumentPosition; use sourceIndex for IE<9
-  				_determineSelectionDirection: has('dom-comparedocumentposition') ? function (from, to) {
-  					var result = to.compareDocumentPosition(from);
-  					if (result & 1) {
-  						return false; // Out of document
-  					}
-  					return result === 2 ? 'down' : 'up';
-  				} : function (from, to) {
-  					if (to.sourceIndex < 1) {
-  						return false; // Out of document
-  					}
-  					return to.sourceIndex > from.sourceIndex ? 'down' : 'up';
-  				},
+  				// deselectOnRefresh: Boolean
+  				//		If true, the selection object will be cleared when refresh is called.
+  				deselectOnRefresh: true,
 
-  				select: function (row, toRow, value) {
-  					// summary:
-  					//		Selects or deselects the given row or range of rows.
-  					// row: Mixed
-  					//		Row object (or something that can resolve to one) to (de)select
-  					// toRow: Mixed
-  					//		If specified, the inclusive range between row and toRow will
-  					//		be (de)selected
-  					// value: Boolean|Null
-  					//		Whether to select (true/default), deselect (false), or toggle
-  					//		(null) the row
+  				// allowSelectAll: Boolean
+  				//		If true, allow ctrl/cmd+A to select all rows.
+  				//		Also consulted by the selector plugin for showing select-all checkbox.
+  				allowSelectAll: false,
 
-  					this._select(row, toRow, value);
-  					this._fireSelectionEvents();
+  				// selection:
+  				//		An object where the property names correspond to
+  				//		object ids and values are true or false depending on whether an item is selected
+  				selection: {},
+
+  				// selectionMode: String
+  				//		The selection mode to use, can be "none", "multiple", "single", or "extended".
+  				selectionMode: 'extended',
+
+  				// allowTextSelection: Boolean
+  				//		Whether to still allow text within cells to be selected.  The default
+  				//		behavior is to allow text selection only when selectionMode is none;
+  				//		setting this property to either true or false will explicitly set the
+  				//		behavior regardless of selectionMode.
+  				allowTextSelection: undefined,
+
+  				// _selectionTargetType: String
+  				//		Indicates the property added to emitted events for selected targets;
+  				//		overridden in CellSelection
+  				_selectionTargetType: 'rows',
+
+  				create: function () {
+  					this.selection = {};
+  					return this.inherited(arguments);
   				},
-  				deselect: function (row, toRow) {
-  					// summary:
-  					//		Deselects the given row or range of rows.
-  					// row: Mixed
-  					//		Row object (or something that can resolve to one) to deselect
-  					// toRow: Mixed
-  					//		If specified, the inclusive range between row and toRow will
-  					//		be deselected
+  				postCreate: function () {
+  					this.inherited(arguments);
 
-  					this.select(row, toRow, false);
+  					this._initSelectionEvents();
+
+  					// Force selectionMode setter to run
+  					var selectionMode = this.selectionMode;
+  					this.selectionMode = '';
+  					this._setSelectionMode(selectionMode);
   				},
 
-  				clearSelection: function (exceptId, dontResetLastSelected) {
-  					// summary:
-  					//		Deselects any currently-selected items.
-  					// exceptId: Mixed?
-  					//		If specified, the given id will not be deselected.
+  				destroy: function () {
+  					this.inherited(arguments);
 
-  					this.allSelected = false;
-  					for (var id in this.selection) {
-  						if (exceptId !== id) {
-  							this._select(id, null, false);
-  						}
+  					// Remove any extra handles added by Selection.
+  					if (this._selectstartHandle) {
+  						this._selectstartHandle.remove();
   					}
-  					if (!dontResetLastSelected) {
-  						this._lastSelected = null;
+  					if (this._unselectableHandle) {
+  						this._unselectableHandle.remove();
   					}
-  					this._fireSelectionEvents();
-  				},
-  				selectAll: function () {
-  					this.allSelected = true;
-  					this.selection = {}; // we do this to clear out pages from previous sorts
-  					for (var i in this._rowIdToObject) {
-  						var row = this.row(this._rowIdToObject[i]);
-  						this._select(row.id, null, true);
+  					if (this._removeDeselectSignals) {
+  						this._removeDeselectSignals();
   					}
-  					this._fireSelectionEvents();
   				},
 
-  				getSelectedCount: function () {
-  					var count = 0;
+  				_setSelectionMode: function (mode) {
+  					// summary:
+  					//		Updates selectionMode, resetting necessary variables.
 
-  					for (var id in this.selection) {
-  						if (id) {
-  							count += 1;
-  						}
+  					if (mode === this.selectionMode) {
+  						return;
   					}
 
-  					return count;
+  					// Start selection fresh when switching mode.
+  					this.clearSelection();
+
+  					this.selectionMode = mode;
+
+  					// Compute name of selection handler for this mode once
+  					// (in the form of _fooSelectionHandler)
+  					this._selectionHandlerName = '_' + mode + 'SelectionHandler';
+
+  					// Also re-run allowTextSelection setter in case it is in automatic mode.
+  					this._setAllowTextSelection(this.allowTextSelection);
   				},
 
-  				isSelected: function (object) {
-  					// summary:
-  					//		Returns true if the indicated row is selected.
+  				_setAllowTextSelection: function (allow) {
+  					if (typeof allow !== 'undefined') {
+  						setSelectable(this, allow);
+  					}
+  					else {
+  						setSelectable(this, this.selectionMode === 'none');
+  					}
+  					this.allowTextSelection = allow;
+  				},
 
-  					if (typeof object === 'undefined' || object === null) {
-  						return false;
+  				_handleSelect: function (event, target) {
+  					if (mouse.isRight(event)) {
+  						return;
   					}
-  					if (!object.element) {
-  						object = this.row(object);
+
+  					// Don't run if selection mode doesn't have a handler (incl. "none"), target can't be selected,
+  					// or if coming from a dgrid-cellfocusin from a mousedown
+  					if (!this[this._selectionHandlerName] || !this.allowSelect(this.row(target)) ||
+  							(event.type === 'dgrid-cellfocusin' && event.parentType === 'mousedown') ||
+  							(event.type === upType && target !== this._waitForMouseUp)) {
+  						return;
   					}
+  					this._waitForMouseUp = null;
+  					this._selectionTriggerEvent = event;
 
-  					// First check whether the given row is indicated in the selection hash;
-  					// failing that, check if allSelected is true (testing against the
-  					// allowSelect method if possible)
-  					return (object.id in this.selection) ? !!this.selection[object.id] :
-  						this.allSelected && (!object.data || this.allowSelect(object));
+  					// Don't call select handler for ctrl+navigation
+  					if (!event.keyCode || !event.ctrlKey || event.keyCode === 32) {
+  						// If clicking a selected item, wait for mouseup so that drag n' drop
+  						// is possible without losing our selection
+  						if (!event.shiftKey && event.type === downType && this.isSelected(target)) {
+  							this._waitForMouseUp = target;
+  						}
+  						else {
+  							this[this._selectionHandlerName](event, target);
+  						}
+  					}
+  					this._selectionTriggerEvent = null;
   				},
 
-  				refresh: function () {
-  					if (this.deselectOnRefresh) {
+  				_singleSelectionHandler: function (event, target) {
+  					// summary:
+  					//		Selection handler for "single" mode, where only one target may be
+  					//		selected at a time.
+
+  					var ctrlKey = event.keyCode ? event.ctrlKey : event[ctrlEquiv];
+  					if (this._lastSelected === target) {
+  						// Allow ctrl to toggle selection, even within single select mode.
+  						this.select(target, null, !ctrlKey || !this.isSelected(target));
+  					}
+  					else {
   						this.clearSelection();
+  						this.select(target);
+  						this._lastSelected = target;
   					}
-  					this._lastSelected = null;
-  					return this.inherited(arguments);
   				},
 
-  				renderArray: function () {
-  					var rows = this.inherited(arguments),
-  						selection = this.selection,
-  						i,
-  						row,
-  						selected;
+  				_multipleSelectionHandler: function (event, target) {
+  					// summary:
+  					//		Selection handler for "multiple" mode, where shift can be held to
+  					//		select ranges, ctrl/cmd can be held to toggle, and clicks/keystrokes
+  					//		without modifier keys will add to the current selection.
 
-  					for (i = 0; i < rows.length; i++) {
-  						row = this.row(rows[i]);
-  						selected = row.id in selection ? selection[row.id] : this.allSelected;
-  						if (selected) {
-  							this.select(row, null, selected);
-  						}
-  					}
-  					this._fireSelectionEvents();
-  					return rows;
-  				}
-  			});
-  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
-  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+  					var lastRow = this._lastSelected,
+  						ctrlKey = event.keyCode ? event.ctrlKey : event[ctrlEquiv],
+  						value;
 
+  					if (!event.shiftKey) {
+  						// Toggle if ctrl is held; otherwise select
+  						value = ctrlKey ? null : true;
+  						lastRow = null;
+  					}
+  					this.select(target, lastRow, value);
 
-  		/***/ }),
+  					if (!lastRow) {
+  						// Update reference for potential subsequent shift+select
+  						// (current row was already selected above)
+  						this._lastSelected = target;
+  					}
+  				},
 
-  		/***/ 2573:
-  		/*!***************************************************!*\
-  		  !*** ../../node_modules/dojo/request/handlers.js ***!
-  		  \***************************************************/
-  		/***/ ((module, exports, __webpack_require__) => {
+  				_extendedSelectionHandler: function (event, target) {
+  					// summary:
+  					//		Selection handler for "extended" mode, which is like multiple mode
+  					//		except that clicks/keystrokes without modifier keys will clear
+  					//		the previous selection.
 
-  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
-  			__webpack_require__(/*! ../json */ 8212),
-  			__webpack_require__(/*! ../_base/kernel */ 1054),
-  			__webpack_require__(/*! ../_base/array */ 6974),
-  			__webpack_require__(/*! ../has */ 6356),
-  			__webpack_require__(/*! ../../node_modules/dojo-webpack-plugin/lib/NoModule.js */ 8819) // only included for has() qsa tests
-  		], __WEBPACK_AMD_DEFINE_RESULT__ = (function(JSON, kernel, array, has){
-  			has.add('activex', typeof ActiveXObject !== 'undefined');
-  			has.add('dom-parser', function(global){
-  				return 'DOMParser' in global;
-  			});
+  					// If the target is already selected, and is the sole selection, ignore a user action
+  					// that would simply select the target (causing unnecessary deselect/select).
+  					if (!event[ctrlEquiv] && this.isSelected(target) && this.getSelectedCount() === 1) {
+  						return;
+  					}
 
-  			var handleXML;
-  			if(has('activex')){
-  				// GUIDs obtained from http://msdn.microsoft.com/en-us/library/ms757837(VS.85).aspx
-  				var dp = [
-  					'Msxml2.DOMDocument.6.0',
-  					'Msxml2.DOMDocument.4.0',
-  					'MSXML2.DOMDocument.3.0',
-  					'MSXML.DOMDocument' // 2.0
-  				];
-  				var lastParser;
+  					// Clear selection first for right-clicks outside selection and non-ctrl-clicks;
+  					// otherwise, extended mode logic is identical to multiple mode
+  					if (event.button === 2 ? !this.isSelected(target) :
+  							!(event.keyCode ? event.ctrlKey : event[ctrlEquiv])) {
+  						this.clearSelection(null, true);
+  					}
+  					this._multipleSelectionHandler(event, target);
+  				},
 
-  				handleXML = function(response){
-  					var result = response.data;
-  					var text = response.text;
+  				_toggleSelectionHandler: function (event, target) {
+  					// summary:
+  					//		Selection handler for "toggle" mode which simply toggles the selection
+  					//		of the given target.  Primarily useful for touch input.
 
-  					if(result && has('dom-qsa2.1') && !result.querySelectorAll && has('dom-parser')){
-  						// http://bugs.dojotoolkit.org/ticket/15631
-  						// IE9 supports a CSS3 querySelectorAll implementation, but the DOM implementation
-  						// returned by IE9 xhr.responseXML does not. Manually create the XML DOM to gain
-  						// the fuller-featured implementation and avoid bugs caused by the inconsistency
-  						result = new DOMParser().parseFromString(text, 'application/xml');
+  					this.select(target, null, null);
+  				},
+
+  				_initSelectionEvents: function () {
+  					// summary:
+  					//		Performs first-time hookup of event handlers containing logic
+  					//		required for selection to operate.
+
+  					var grid = this,
+  						contentNode = this.contentNode,
+  						selector = this.selectionDelegate;
+
+  					this._selectionEventQueues = {
+  						deselect: [],
+  						select: []
+  					};
+
+  					{
+  						// Listen for mouse/keyboard actions that should cause selections
+  						on(contentNode, on.selector(selector, this.selectionEvents), function (event) {
+  							grid._handleSelect(event, this);
+  						});
   					}
 
-  					function createDocument(p) {
-  							try{
-  								var dom = new ActiveXObject(p);
-  								dom.async = false;
-  								dom.loadXML(text);
-  								result = dom;
-  								lastParser = p;
-  							}catch(e){ return false; }
-  							return true;
+  					// Also hook up spacebar (for ctrl+space)
+  					if (this.addKeyHandler) {
+  						this.addKeyHandler(32, function (event) {
+  							grid._handleSelect(event, event.target);
+  						});
   					}
 
-  					if(!result || !result.documentElement){
-  						// The creation of an ActiveX object is expensive, so we cache the
-  						// parser type to avoid trying all parser types each time we handle a
-  						// document. There is some concern that some parser types might fail
-  						// depending on the document being parsed. If parsing using the cached
-  						// parser type fails, we do the more expensive operation of finding one
-  						// that works for the given document.
-  						// https://bugs.dojotoolkit.org/ticket/15246
-  						if(!lastParser || !createDocument(lastParser)) {
-  							array.some(dp, createDocument);
-  						}
+  					// If allowSelectAll is true, bind ctrl/cmd+A to (de)select all rows,
+  					// unless the event was received from an editor component.
+  					// (Handler further checks against _allowSelectAll, which may be updated
+  					// if selectionMode is changed post-init.)
+  					if (this.allowSelectAll) {
+  						this.on('keydown', function (event) {
+  							if (event[ctrlEquiv] && event.keyCode === 65 &&
+  									!/\bdgrid-input\b/.test(event.target.className)) {
+  								event.preventDefault();
+  								grid[grid.allSelected ? 'clearSelection' : 'selectAll']();
+  							}
+  						});
   					}
 
-  					return result;
-  				};
-  			}
+  					// Update aspects if there is a collection change
+  					if (this._setCollection) {
+  						this._listeners.push(
+  							aspect.before(this, '_setCollection', function (collection) {
+  								grid._updateDeselectionAspect(collection);
+  							})
+  						);
+  					}
+  					this._updateDeselectionAspect();
+  				},
 
-  			var handleNativeResponse = function(response) {
-  				if(!has('native-xhr2-blob') && response.options.handleAs === 'blob' && typeof Blob !== 'undefined'){
-  					return new Blob([ response.xhr.response ], { type: response.xhr.getResponseHeader('Content-Type') });
-  				}
+  				_updateDeselectionAspect: function (collection) {
+  					// summary:
+  					//		Hooks up logic to handle deselection of removed items.
+  					//		Aspects to a trackable collection's notify method if applicable,
+  					//		or to the list/grid's removeRow method otherwise.
 
-  				return response.xhr.response;
-  			};
+  					var self = this,
+  						signals;
 
-  			var handlers = {
-  				'javascript': function(response){
-  					return kernel.eval(response.text || '');
+  					function ifSelected(rowArg, methodName) {
+  						// Calls a method if the row corresponding to the object is selected.
+  						var row = self.row(rowArg),
+  							selection = row && self.selection[row.id];
+  						// Is the row currently in the selection list.
+  						if (selection) {
+  							self[methodName](row);
+  						}
+  					}
+
+  					// Remove anything previously configured
+  					if (this._removeDeselectSignals) {
+  						this._removeDeselectSignals();
+  					}
+
+  					if (collection && collection.track && this._observeCollection) {
+  						signals = [
+  							aspect.before(this, '_observeCollection', function (collection) {
+  								signals.push(
+  									collection.on('delete', function (event) {
+  										if (typeof event.index === 'undefined') {
+  											// Call deselect on the row if the object is being removed.  This allows the
+  											// deselect event to reference the row element while it still exists in the DOM.
+  											ifSelected(event.id, 'deselect');
+  										}
+  									})
+  								);
+  							}),
+  							aspect.after(this, '_observeCollection', function (collection) {
+  								signals.push(
+  									collection.on('update', function (event) {
+  										if (typeof event.index !== 'undefined') {
+  											// When List updates an item, the row element is removed and a new one inserted.
+  											// If at this point the object is still in grid.selection,
+  											// then call select on the row so the element's CSS is updated.
+  											ifSelected(collection.getIdentity(event.target), 'select');
+  										}
+  									})
+  								);
+  							}, true)
+  						];
+  					}
+  					else {
+  						signals = [
+  							aspect.before(this, 'removeRow', function (rowElement, preserveDom) {
+  								var row;
+  								if (!preserveDom) {
+  									row = this.row(rowElement);
+  									// if it is a real row removal for a selected item, deselect it
+  									if (row && (row.id in this.selection)) {
+  										this.deselect(row);
+  									}
+  								}
+  							})
+  						];
+  					}
+
+  					this._removeDeselectSignals = function () {
+  						for (var i = signals.length; i--;) {
+  							signals[i].remove();
+  						}
+  						signals = [];
+  					};
   				},
-  				'json': function(response){
-  					return JSON.parse(response.text || null);
+
+  				allowSelect: function () {
+  					// summary:
+  					//		A method that can be overriden to determine whether or not a row (or
+  					//		cell) can be selected. By default, all rows (or cells) are selectable.
+  					// target: Object
+  					//		Row object (for Selection) or Cell object (for CellSelection) for the
+  					//		row/cell in question
+  					return true;
   				},
-  				'xml': handleXML,
-  				'blob': handleNativeResponse,
-  				'arraybuffer': handleNativeResponse,
-  				'document': handleNativeResponse
-  			};
 
-  			function handle(response){
-  				var handler = handlers[response.options.handleAs];
+  				_fireSelectionEvent: function (type) {
+  					// summary:
+  					//		Fires an event for the accumulated rows once a selection
+  					//		operation is finished (whether singular or for a range)
 
-  				response.data = handler ? handler(response) : (response.data || response.text);
+  					var queue = this._selectionEventQueues[type],
+  						triggerEvent = this._selectionTriggerEvent,
+  						eventObject;
 
-  				return response;
-  			}
+  					eventObject = {
+  						bubbles: true,
+  						grid: this
+  					};
+  					if (triggerEvent) {
+  						eventObject.parentType = triggerEvent.type;
+  					}
+  					eventObject[this._selectionTargetType] = queue;
 
-  			handle.register = function(name, handler){
-  				handlers[name] = handler;
-  			};
+  					// Clear the queue so that the next round of (de)selections starts anew
+  					this._selectionEventQueues[type] = [];
 
-  			return handle;
-  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
-  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+  					on.emit(this.contentNode, 'dgrid-' + type, eventObject);
+  				},
 
+  				_fireSelectionEvents: function () {
+  					var queues = this._selectionEventQueues,
+  						type;
 
-  		/***/ }),
+  					for (type in queues) {
+  						if (queues[type].length) {
+  							this._fireSelectionEvent(type);
+  						}
+  					}
+  				},
 
-  		/***/ 2616:
-  		/*!****************************************!*\
-  		  !*** ../../node_modules/dojo/sniff.js ***!
-  		  \****************************************/
-  		/***/ ((module, exports, __webpack_require__) => {
+  				_select: function (row, toRow, value) {
+  					// summary:
+  					//		Contains logic for determining whether to select targets, but
+  					//		does not emit events.  Called from select, deselect, selectAll,
+  					//		and clearSelection.
 
-  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(/*! ./has */ 6356)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(has){
-  			// module:
-  			//		dojo/sniff
+  					var selection,
+  						previousValue,
+  						element,
+  						toElement,
+  						direction;
 
-  			/*=====
-  			return function(){
-  				// summary:
-  				//		This module sets has() flags based on the current browser.
-  				//		It returns the has() function.
-  			};
-  			=====*/
+  					if (typeof value === 'undefined') {
+  						// default to true
+  						value = true;
+  					}
+  					if (!row.element) {
+  						row = this.row(row);
+  					}
 
-  			if(has("host-browser")){
-  				var n = navigator,
-  					dua = n.userAgent,
-  					dav = n.appVersion,
-  					tv = parseFloat(dav);
-  				has.add("air", dua.indexOf("AdobeAIR") >= 0);
-  				has.add("wp", parseFloat(dua.split("Windows Phone")[1]) || undefined);
-  				has.add("msapp", parseFloat(dua.split("MSAppHost/")[1]) || undefined);
-  				has.add("khtml", dav.indexOf("Konqueror") >= 0 ? tv : undefined);
-  				has.add("edge", parseFloat(dua.split("Edge/")[1]) || undefined);
-  				has.add("opr", parseFloat(dua.split("OPR/")[1]) || undefined);
-  				// NOTE: https://dev.opera.com/blog/opera-user-agent-strings-opera-15-and-beyond/
-  				has.add("webkit", !has("wp") // NOTE: necessary since Windows Phone 8.1 Update 1, see #18540
-  					&& !has("edge") && parseFloat(dua.split("WebKit/")[1]) || undefined);
-  				has.add("chrome", !has("edge") && !has("opr")
-  						&& parseFloat(dua.split("Chrome/")[1]) || undefined);
-  				has.add("android", !has("wp") // NOTE: necessary since Windows Phone 8.1 Update 1, see #18528
-  						&& parseFloat(dua.split("Android ")[1]) || undefined);
-  				has.add("safari", dav.indexOf("Safari") >= 0
-  						&& !has("wp") // NOTE: necessary since Windows Phone 8.1 Update 1, see #18540
-  						&& !has("chrome") && !has("android") && !has("edge") && !has("opr") ?
-  					parseFloat(dav.split("Version/")[1]) : undefined);
-  				has.add("mac", dav.indexOf("Macintosh") >= 0);
-  				has.add("quirks", document.compatMode == "BackCompat");
-  				if(!has("wp") // NOTE: necessary since Windows Phone 8.1 Update 1, see #18528
-  						&& dua.match(/(iPhone|iPod|iPad)/)){
-  					var p = RegExp.$1.replace(/P/, "p");
-  					var v = dua.match(/OS ([\d_]+)/) ? RegExp.$1 : "1";
-  					var os = parseFloat(v.replace(/_/, ".").replace(/_/g, ""));
-  					has.add(p, os);		// "iphone", "ipad" or "ipod"
-  					has.add("ios", os);
-  				}
-  				has.add("bb", (dua.indexOf("BlackBerry") >= 0 || dua.indexOf("BB10") >= 0) && parseFloat(dua.split("Version/")[1]) || undefined);
-  				has.add("trident", parseFloat(dav.split("Trident/")[1]) || undefined);
+  					// Check whether we're allowed to select the given row before proceeding.
+  					// If a deselect operation is being performed, this check is skipped,
+  					// to avoid errors when changing column definitions, and since disabled
+  					// rows shouldn't ever be selected anyway.
+  					if (value === false || this.allowSelect(row)) {
+  						selection = this.selection;
+  						previousValue = !!selection[row.id];
+  						if (value === null) {
+  							// indicates a toggle
+  							value = !previousValue;
+  						}
+  						element = row.element;
+  						if (!value && !this.allSelected) {
+  							delete this.selection[row.id];
+  						}
+  						else {
+  							selection[row.id] = value;
+  						}
+  						if (element) {
+  							// add or remove classes as appropriate
+  							if (value) {
+  								domClass.add(element, 'dgrid-selected' +
+  									(this.addUiClasses ? ' ui-state-active' : ''));
+  							}
+  							else {
+  								domClass.remove(element, 'dgrid-selected ui-state-active');
+  							}
+  						}
+  						if (value !== previousValue && element) {
+  							// add to the queue of row events
+  							this._selectionEventQueues[(value ? '' : 'de') + 'select'].push(row);
+  						}
 
-  				has.add("svg", typeof SVGAngle !== "undefined");
+  						if (toRow) {
+  							if (!toRow.element) {
+  								toRow = this.row(toRow);
+  							}
 
-  				if(!has("webkit")){
-  					// Opera
-  					if(dua.indexOf("Opera") >= 0){
-  						// see http://dev.opera.com/articles/view/opera-ua-string-changes and http://www.useragentstring.com/pages/Opera/
-  						// 9.8 has both styles; <9.8, 9.9 only old style
-  						has.add("opera", tv >= 9.8 ? parseFloat(dua.split("Version/")[1]) || tv : tv);
+  							if (!toRow) {
+  								this._lastSelected = element;
+  								console.warn('The selection range has been reset because the ' +
+  									'beginning of the selection is no longer in the DOM. ' +
+  									'If you are using OnDemandList, you may wish to increase ' +
+  									'farOffRemoval to avoid this, but note that keeping more nodes ' +
+  									'in the DOM may impact performance.');
+  								return;
+  							}
+
+  							toElement = toRow.element;
+  							if (toElement) {
+  								direction = this._determineSelectionDirection(element, toElement);
+  								if (!direction) {
+  									// The original element was actually replaced
+  									toElement = document.getElementById(toElement.id);
+  									direction = this._determineSelectionDirection(element, toElement);
+  								}
+  								while (row.element !== toElement && (row = this[direction](row))) {
+  									this._select(row, null, value);
+  								}
+  							}
+  						}
   					}
+  				},
 
-  					// Mozilla and firefox
-  					if(dua.indexOf("Gecko") >= 0 && !has("wp") // NOTE: necessary since Windows Phone 8.1 Update 1
-  							&& !has("khtml") && !has("trident") && !has("edge")){
-  						has.add("mozilla", tv);
+  				// Implement _determineSelectionDirection differently based on whether the
+  				// browser supports element.compareDocumentPosition; use sourceIndex for IE<9
+  				_determineSelectionDirection: has('dom-comparedocumentposition') ? function (from, to) {
+  					var result = to.compareDocumentPosition(from);
+  					if (result & 1) {
+  						return false; // Out of document
   					}
-  					if(has("mozilla")){
-  						//We really need to get away from this. Consider a sane isGecko approach for the future.
-  						has.add("ff", parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined);
+  					return result === 2 ? 'down' : 'up';
+  				} : function (from, to) {
+  					if (to.sourceIndex < 1) {
+  						return false; // Out of document
   					}
+  					return to.sourceIndex > from.sourceIndex ? 'down' : 'up';
+  				},
 
-  					// IE
-  					if(document.all && !has("opera")){
-  						var isIE = parseFloat(dav.split("MSIE ")[1]) || undefined;
+  				select: function (row, toRow, value) {
+  					// summary:
+  					//		Selects or deselects the given row or range of rows.
+  					// row: Mixed
+  					//		Row object (or something that can resolve to one) to (de)select
+  					// toRow: Mixed
+  					//		If specified, the inclusive range between row and toRow will
+  					//		be (de)selected
+  					// value: Boolean|Null
+  					//		Whether to select (true/default), deselect (false), or toggle
+  					//		(null) the row
 
-  						//In cases where the page has an HTTP header or META tag with
-  						//X-UA-Compatible, then it is in emulation mode.
-  						//Make sure isIE reflects the desired version.
-  						//document.documentMode of 5 means quirks mode.
-  						//Only switch the value if documentMode's major version
-  						//is different from isIE's major version.
-  						var mode = document.documentMode;
-  						if(mode && mode != 5 && Math.floor(isIE) != mode){
-  							isIE = mode;
+  					this._select(row, toRow, value);
+  					this._fireSelectionEvents();
+  				},
+  				deselect: function (row, toRow) {
+  					// summary:
+  					//		Deselects the given row or range of rows.
+  					// row: Mixed
+  					//		Row object (or something that can resolve to one) to deselect
+  					// toRow: Mixed
+  					//		If specified, the inclusive range between row and toRow will
+  					//		be deselected
+
+  					this.select(row, toRow, false);
+  				},
+
+  				clearSelection: function (exceptId, dontResetLastSelected) {
+  					// summary:
+  					//		Deselects any currently-selected items.
+  					// exceptId: Mixed?
+  					//		If specified, the given id will not be deselected.
+
+  					this.allSelected = false;
+  					for (var id in this.selection) {
+  						if (exceptId !== id) {
+  							this._select(id, null, false);
+  						}
+  					}
+  					if (!dontResetLastSelected) {
+  						this._lastSelected = null;
+  					}
+  					this._fireSelectionEvents();
+  				},
+  				selectAll: function () {
+  					this.allSelected = true;
+  					this.selection = {}; // we do this to clear out pages from previous sorts
+  					for (var i in this._rowIdToObject) {
+  						var row = this.row(this._rowIdToObject[i]);
+  						this._select(row.id, null, true);
+  					}
+  					this._fireSelectionEvents();
+  				},
+
+  				getSelectedCount: function () {
+  					var count = 0;
+
+  					for (var id in this.selection) {
+  						if (id) {
+  							count += 1;
   						}
+  					}
 
-  						has.add("ie", isIE);
+  					return count;
+  				},
+
+  				isSelected: function (object) {
+  					// summary:
+  					//		Returns true if the indicated row is selected.
+
+  					if (typeof object === 'undefined' || object === null) {
+  						return false;
+  					}
+  					if (!object.element) {
+  						object = this.row(object);
   					}
 
-  					// Wii
-  					has.add("wii", typeof opera != "undefined" && opera.wiiremote);
-  				}
-  			}
+  					// First check whether the given row is indicated in the selection hash;
+  					// failing that, check if allSelected is true (testing against the
+  					// allowSelect method if possible)
+  					return (object.id in this.selection) ? !!this.selection[object.id] :
+  						this.allSelected && (!object.data || this.allowSelect(object));
+  				},
 
-  			return has;
+  				refresh: function () {
+  					if (this.deselectOnRefresh) {
+  						this.clearSelection();
+  					}
+  					this._lastSelected = null;
+  					return this.inherited(arguments);
+  				},
+
+  				renderArray: function () {
+  					var rows = this.inherited(arguments),
+  						selection = this.selection,
+  						i,
+  						row,
+  						selected;
+
+  					for (i = 0; i < rows.length; i++) {
+  						row = this.row(rows[i]);
+  						selected = row.id in selection ? selection[row.id] : this.allSelected;
+  						if (selected) {
+  							this.select(row, null, selected);
+  						}
+  					}
+  					this._fireSelectionEvents();
+  					return rows;
+  				}
+  			});
+  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
+  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+
+
+  		/***/ }),
+
+  		/***/ 2573:
+  		/*!***************************************************!*\
+  		  !*** ../../node_modules/dojo/request/handlers.js ***!
+  		  \***************************************************/
+  		/***/ ((module, exports, __webpack_require__) => {
+
+  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
+  			__webpack_require__(/*! ../json */ 8212),
+  			__webpack_require__(/*! ../_base/kernel */ 1054),
+  			__webpack_require__(/*! ../_base/array */ 6974),
+  			__webpack_require__(/*! ../has */ 6356),
+  			__webpack_require__(/*! ../../node_modules/dojo-webpack-plugin/lib/NoModule.js */ 8819) // only included for has() qsa tests
+  		], __WEBPACK_AMD_DEFINE_RESULT__ = (function(JSON, kernel, array, has){
+  			has.add('activex', typeof ActiveXObject !== 'undefined');
+  			has.add('dom-parser', function(global){
+  				return 'DOMParser' in global;
+  			});
+
+  			var handleXML;
+  			if(has('activex')){
+  				// GUIDs obtained from http://msdn.microsoft.com/en-us/library/ms757837(VS.85).aspx
+  				var dp = [
+  					'Msxml2.DOMDocument.6.0',
+  					'Msxml2.DOMDocument.4.0',
+  					'MSXML2.DOMDocument.3.0',
+  					'MSXML.DOMDocument' // 2.0
+  				];
+  				var lastParser;
+
+  				handleXML = function(response){
+  					var result = response.data;
+  					var text = response.text;
+
+  					if(result && has('dom-qsa2.1') && !result.querySelectorAll && has('dom-parser')){
+  						// http://bugs.dojotoolkit.org/ticket/15631
+  						// IE9 supports a CSS3 querySelectorAll implementation, but the DOM implementation
+  						// returned by IE9 xhr.responseXML does not. Manually create the XML DOM to gain
+  						// the fuller-featured implementation and avoid bugs caused by the inconsistency
+  						result = new DOMParser().parseFromString(text, 'application/xml');
+  					}
+
+  					function createDocument(p) {
+  							try{
+  								var dom = new ActiveXObject(p);
+  								dom.async = false;
+  								dom.loadXML(text);
+  								result = dom;
+  								lastParser = p;
+  							}catch(e){ return false; }
+  							return true;
+  					}
+
+  					if(!result || !result.documentElement){
+  						// The creation of an ActiveX object is expensive, so we cache the
+  						// parser type to avoid trying all parser types each time we handle a
+  						// document. There is some concern that some parser types might fail
+  						// depending on the document being parsed. If parsing using the cached
+  						// parser type fails, we do the more expensive operation of finding one
+  						// that works for the given document.
+  						// https://bugs.dojotoolkit.org/ticket/15246
+  						if(!lastParser || !createDocument(lastParser)) {
+  							array.some(dp, createDocument);
+  						}
+  					}
+
+  					return result;
+  				};
+  			}
+
+  			var handleNativeResponse = function(response) {
+  				if(!has('native-xhr2-blob') && response.options.handleAs === 'blob' && typeof Blob !== 'undefined'){
+  					return new Blob([ response.xhr.response ], { type: response.xhr.getResponseHeader('Content-Type') });
+  				}
+
+  				return response.xhr.response;
+  			};
+
+  			var handlers = {
+  				'javascript': function(response){
+  					return kernel.eval(response.text || '');
+  				},
+  				'json': function(response){
+  					return JSON.parse(response.text || null);
+  				},
+  				'xml': handleXML,
+  				'blob': handleNativeResponse,
+  				'arraybuffer': handleNativeResponse,
+  				'document': handleNativeResponse
+  			};
+
+  			function handle(response){
+  				var handler = handlers[response.options.handleAs];
+
+  				response.data = handler ? handler(response) : (response.data || response.text);
+
+  				return response;
+  			}
+
+  			handle.register = function(name, handler){
+  				handlers[name] = handler;
+  			};
+
+  			return handle;
+  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
+  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+
+
+  		/***/ }),
+
+  		/***/ 2616:
+  		/*!****************************************!*\
+  		  !*** ../../node_modules/dojo/sniff.js ***!
+  		  \****************************************/
+  		/***/ ((module, exports, __webpack_require__) => {
+
+  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(/*! ./has */ 6356)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(has){
+  			// module:
+  			//		dojo/sniff
+
+  			/*=====
+  			return function(){
+  				// summary:
+  				//		This module sets has() flags based on the current browser.
+  				//		It returns the has() function.
+  			};
+  			=====*/
+
+  			if(has("host-browser")){
+  				var n = navigator,
+  					dua = n.userAgent,
+  					dav = n.appVersion,
+  					tv = parseFloat(dav);
+  				has.add("air", dua.indexOf("AdobeAIR") >= 0);
+  				has.add("wp", parseFloat(dua.split("Windows Phone")[1]) || undefined);
+  				has.add("msapp", parseFloat(dua.split("MSAppHost/")[1]) || undefined);
+  				has.add("khtml", dav.indexOf("Konqueror") >= 0 ? tv : undefined);
+  				has.add("edge", parseFloat(dua.split("Edge/")[1]) || undefined);
+  				has.add("opr", parseFloat(dua.split("OPR/")[1]) || undefined);
+  				// NOTE: https://dev.opera.com/blog/opera-user-agent-strings-opera-15-and-beyond/
+  				has.add("webkit", !has("wp") // NOTE: necessary since Windows Phone 8.1 Update 1, see #18540
+  					&& !has("edge") && parseFloat(dua.split("WebKit/")[1]) || undefined);
+  				has.add("chrome", !has("edge") && !has("opr")
+  						&& parseFloat(dua.split("Chrome/")[1]) || undefined);
+  				has.add("android", !has("wp") // NOTE: necessary since Windows Phone 8.1 Update 1, see #18528
+  						&& parseFloat(dua.split("Android ")[1]) || undefined);
+  				has.add("safari", dav.indexOf("Safari") >= 0
+  						&& !has("wp") // NOTE: necessary since Windows Phone 8.1 Update 1, see #18540
+  						&& !has("chrome") && !has("android") && !has("edge") && !has("opr") ?
+  					parseFloat(dav.split("Version/")[1]) : undefined);
+  				has.add("mac", dav.indexOf("Macintosh") >= 0);
+  				has.add("quirks", document.compatMode == "BackCompat");
+  				if(!has("wp") // NOTE: necessary since Windows Phone 8.1 Update 1, see #18528
+  						&& dua.match(/(iPhone|iPod|iPad)/)){
+  					var p = RegExp.$1.replace(/P/, "p");
+  					var v = dua.match(/OS ([\d_]+)/) ? RegExp.$1 : "1";
+  					var os = parseFloat(v.replace(/_/, ".").replace(/_/g, ""));
+  					has.add(p, os);		// "iphone", "ipad" or "ipod"
+  					has.add("ios", os);
+  				}
+  				has.add("bb", (dua.indexOf("BlackBerry") >= 0 || dua.indexOf("BB10") >= 0) && parseFloat(dua.split("Version/")[1]) || undefined);
+  				has.add("trident", parseFloat(dav.split("Trident/")[1]) || undefined);
+
+  				has.add("svg", typeof SVGAngle !== "undefined");
+
+  				if(!has("webkit")){
+  					// Opera
+  					if(dua.indexOf("Opera") >= 0){
+  						// see http://dev.opera.com/articles/view/opera-ua-string-changes and http://www.useragentstring.com/pages/Opera/
+  						// 9.8 has both styles; <9.8, 9.9 only old style
+  						has.add("opera", tv >= 9.8 ? parseFloat(dua.split("Version/")[1]) || tv : tv);
+  					}
+
+  					// Mozilla and firefox
+  					if(dua.indexOf("Gecko") >= 0 && !has("wp") // NOTE: necessary since Windows Phone 8.1 Update 1
+  							&& !has("khtml") && !has("trident") && !has("edge")){
+  						has.add("mozilla", tv);
+  					}
+  					if(has("mozilla")){
+  						//We really need to get away from this. Consider a sane isGecko approach for the future.
+  						has.add("ff", parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined);
+  					}
+
+  					// IE
+  					if(document.all && !has("opera")){
+  						var isIE = parseFloat(dav.split("MSIE ")[1]) || undefined;
+
+  						//In cases where the page has an HTTP header or META tag with
+  						//X-UA-Compatible, then it is in emulation mode.
+  						//Make sure isIE reflects the desired version.
+  						//document.documentMode of 5 means quirks mode.
+  						//Only switch the value if documentMode's major version
+  						//is different from isIE's major version.
+  						var mode = document.documentMode;
+  						if(mode && mode != 5 && Math.floor(isIE) != mode){
+  							isIE = mode;
+  						}
+
+  						has.add("ie", isIE);
+  					}
+
+  					// Wii
+  					has.add("wii", typeof opera != "undefined" && opera.wiiremote);
+  				}
+  			}
+
+  			return has;
   		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
   				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
 
@@ -9358,7 +9848,7 @@
   		exports.BUILD_VERSION = exports.PKG_VERSION = exports.PKG_NAME = void 0;
   		exports.PKG_NAME = "@hpcc-js/dgrid-shim";
   		exports.PKG_VERSION = "2.26.0";
-  		exports.BUILD_VERSION = "2.108.2";
+  		exports.BUILD_VERSION = "2.108.4";
   		
 
   		/***/ }),
@@ -26539,1000 +27029,510 @@
   						promise = dfd.promise;
   					}
 
-  					promise.otherwise(function (err) {
-  						emitError.call(self, err);
-  					});
-  					return promise;
-  				},
-
-  				removeRow: function (rowElement, preserveDom, options) {
-  					var row = {element: rowElement};
-  					// Check to see if we are now empty...
-  					if (!preserveDom && (this.up(row).element === rowElement) && (this.down(row).element === rowElement)) {
-  						// ...we are empty, so show the no data message.
-  						this._insertNoDataNode();
-  					}
-
-  					var rows = (options && options.rows) || this._rows;
-  					if (rows) {
-  						delete rows[rowElement.rowIndex];
-  					}
-
-  					return this.inherited(arguments);
-  				},
-
-  				renderQueryResults: function (results, beforeNode, options) {
-  					// summary:
-  					//		Renders objects from QueryResults as rows, before the given node.
-
-  					options = lang.mixin({ rows: this._rows }, options);
-  					var self = this;
-
-  					if (!has('dojo-built')) {
-  						// Check for null/undefined totalResults to help diagnose faulty services/stores
-  						results.totalLength.then(function (total) {
-  							if (total == null) {
-  								console.warn('Store reported null or undefined totalLength. ' +
-  									'Make sure your store (and service, if applicable) are reporting total correctly!');
-  							}
-  						});
-  					}
-
-  					return results.then(function (resolvedResults) {
-  						var resolvedRows = self.renderArray(resolvedResults, beforeNode, options);
-  						delete self._lastCollection; // used only for non-store List/Grid
-  						return resolvedRows;
-  					});
-  				},
-
-  				_observeCollection: function (collection, container, options) {
-  					var self = this,
-  						rows = options.rows,
-  						row;
-
-  					var handles = [
-  						collection.on('delete, update', function (event) {
-  							var from = event.previousIndex;
-  							var to = event.index;
-
-  							if (from !== undefined && rows[from]) {
-  								if ('max' in rows && (to === undefined || to < rows.min || to > rows.max)) {
-  									rows.max--;
-  								}
-
-  								// max should never be less than zero; if it is the logic in the 'add, update' handler
-  								// below will prevent insertion of rows (https://github.com/SitePen/dgrid/issues/1305)
-  								if (rows.max < 0) {
-  									rows.max = 0;
-  								}
-
-  								row = rows[from];
-
-  								// check to make the sure the node is still there before we try to remove it
-  								// (in case it was moved to a different place in the DOM)
-  								if (row.parentNode === container) {
-  									self.removeRow(row, false, options);
-  								}
-
-  								// remove the old slot
-  								rows.splice(from, 1);
-
-  								if (event.type === 'delete' ||
-  										(event.type === 'update' && (from < to || to === undefined))) {
-  									// adjust the rowIndex so adjustRowIndices has the right starting point
-  									rows[from] && rows[from].rowIndex--;
-  								}
-  							}
-  							if (event.type === 'delete') {
-  								// Reset row in case this is later followed by an add;
-  								// only update events should retain the row variable below
-  								row = null;
-  							}
-  						}),
-
-  						collection.on('add, update', function (event) {
-  							var from = event.previousIndex;
-  							var to = event.index;
-  							var nextNode;
-
-  							function advanceNext() {
-  								nextNode = (nextNode.connected || nextNode).nextSibling;
-  							}
-
-  							// When possible, restrict observations to the actually rendered range
-  							if (to !== undefined && (!('max' in rows) || (to >= rows.min && to <= rows.max))) {
-  								if ('max' in rows && (from === undefined || from < rows.min || from > rows.max)) {
-  									rows.max++;
-  								}
-  								// Add to new slot (either before an existing row, or at the end)
-  								// First determine the DOM node that this should be placed before.
-  								if (rows.length) {
-  									nextNode = rows[to];
-  									if (!nextNode) {
-  										nextNode = rows[to - 1];
-  										if (nextNode) {
-  											// Make sure to skip connected nodes, so we don't accidentally
-  											// insert a row in between a parent and its children.
-  											advanceNext();
-  										}
-  									}
-  								}
-  								else {
-  									// There are no rows.  Allow for subclasses to insert new rows somewhere other than
-  									// at the end of the parent node.
-  									nextNode = self._getFirstRowSibling && self._getFirstRowSibling(container);
-  								}
-  								// Make sure we don't trip over a stale reference to a
-  								// node that was removed, or try to place a node before
-  								// itself (due to overlapped queries)
-  								if (row && nextNode && row.id === nextNode.id) {
-  									advanceNext();
-  								}
-  								if (nextNode && !nextNode.parentNode) {
-  									nextNode = document.getElementById(nextNode.id);
-  								}
-  								rows.splice(to, 0, undefined);
-  								row = self.insertRow(event.target, container, nextNode, to, options);
-  								self.highlightRow(row);
-  							}
-  							// Reset row so it doesn't get reused on the next event
-  							row = null;
-  						}),
-
-  						collection.on('add, delete, update', function (event) {
-  							var from = (typeof event.previousIndex !== 'undefined') ? event.previousIndex : Infinity,
-  								to = (typeof event.index !== 'undefined') ? event.index : Infinity,
-  								adjustAtIndex = Math.min(from, to);
-  							from !== to && rows[adjustAtIndex] && self.adjustRowIndices(rows[adjustAtIndex]);
-
-  							// the removal of rows could cause us to need to page in more items
-  							if (from !== Infinity && self._processScroll && (rows[from] || rows[from - 1])) {
-  								self._processScroll();
-  							}
-
-  							// Fire _onNotification, even for out-of-viewport notifications,
-  							// since some things may still need to update (e.g. Pagination's status/navigation)
-  							self._onNotification(rows, event, collection);
-
-  							// Update _total after _onNotification so that it can potentially
-  							// decide whether to perform actions based on whether the total changed
-  							if (collection === self._renderedCollection && 'totalLength' in event) {
-  								self._total = event.totalLength;
-  							}
-  						})
-  					];
-
-  					return {
-  						remove: function () {
-  							while (handles.length > 0) {
-  								handles.pop().remove();
-  							}
-  						}
-  					};
-  				},
-
-  				_onNotification: function () {
-  					// summary:
-  					//		Protected method called whenever a store notification is observed.
-  					//		Intended to be extended as necessary by mixins/extensions.
-  					// rows: Array
-  					//		A sparse array of row nodes corresponding to data objects in the collection.
-  					// event: Object
-  					//		The notification event
-  					// collection: Object
-  					//		The collection that the notification is relevant to.
-  					//		Useful for distinguishing child-level from top-level notifications.
-  				}
-  			});
-  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
-  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-
-
-  		/***/ }),
-
-  		/***/ 8471:
-  		/*!****************************************!*\
-  		  !*** ../../node_modules/dojo/mouse.js ***!
-  		  \****************************************/
-  		/***/ ((module, exports, __webpack_require__) => {
-
-  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(/*! ./_base/kernel */ 1054), __webpack_require__(/*! ./on */ 2075), __webpack_require__(/*! ./has */ 6356), __webpack_require__(/*! ./dom */ 2284), __webpack_require__(/*! ./_base/window */ 5075)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(dojo, on, has, dom, win){
-
-  			// module:
-  			//		dojo/mouse
-
-  		    has.add("dom-quirks", win.doc && win.doc.compatMode == "BackCompat");
-  			has.add("events-mouseenter", win.doc && "onmouseenter" in win.doc.createElement("div"));
-  			has.add("events-mousewheel", win.doc && 'onmousewheel' in win.doc);
-
-  			var mouseButtons;
-  			if((has("dom-quirks") && has("ie")) || !has("dom-addeventlistener")){
-  				mouseButtons = {
-  					LEFT:   1,
-  					MIDDLE: 4,
-  					RIGHT:  2,
-  					// helper functions
-  					isButton: function(e, button){ return e.button & button; },
-  					isLeft:   function(e){ return e.button & 1; },
-  					isMiddle: function(e){ return e.button & 4; },
-  					isRight:  function(e){ return e.button & 2; }
-  				};
-  			}else {
-  				mouseButtons = {
-  					LEFT:   0,
-  					MIDDLE: 1,
-  					RIGHT:  2,
-  					// helper functions
-  					isButton: function(e, button){ return e.button == button; },
-  					isLeft:   function(e){ return e.button == 0; },
-  					isMiddle: function(e){ return e.button == 1; },
-  					isRight:  function(e){ return e.button == 2; }
-  				};
-  			}
-  			dojo.mouseButtons = mouseButtons;
-
-  		/*=====
-  			dojo.mouseButtons = {
-  				// LEFT: Number
-  				//		Numeric value of the left mouse button for the platform.
-  				LEFT:   0,
-  				// MIDDLE: Number
-  				//		Numeric value of the middle mouse button for the platform.
-  				MIDDLE: 1,
-  				// RIGHT: Number
-  				//		Numeric value of the right mouse button for the platform.
-  				RIGHT:  2,
-
-  				isButton: function(e, button){
-  					// summary:
-  					//		Checks an event object for a pressed button
-  					// e: Event
-  					//		Event object to examine
-  					// button: Number
-  					//		The button value (example: dojo.mouseButton.LEFT)
-  					return e.button == button; // Boolean
-  				},
-  				isLeft: function(e){
-  					// summary:
-  					//		Checks an event object for the pressed left button
-  					// e: Event
-  					//		Event object to examine
-  					return e.button == 0; // Boolean
-  				},
-  				isMiddle: function(e){
-  					// summary:
-  					//		Checks an event object for the pressed middle button
-  					// e: Event
-  					//		Event object to examine
-  					return e.button == 1; // Boolean
-  				},
-  				isRight: function(e){
-  					// summary:
-  					//		Checks an event object for the pressed right button
-  					// e: Event
-  					//		Event object to examine
-  					return e.button == 2; // Boolean
-  				}
-  			};
-  		=====*/
-
-  			function eventHandler(type, selectHandler){
-  				// emulation of mouseenter/leave with mouseover/out using descendant checking
-  				var handler = function(node, listener){
-  					return on(node, type, function(evt){
-  						if(selectHandler){
-  							return selectHandler(evt, listener);
-  						}
-  						if(!dom.isDescendant(evt.relatedTarget, node)){
-  							return listener.call(this, evt);
-  						}
-  					});
-  				};
-  				handler.bubble = function(select){
-  					return eventHandler(type, function(evt, listener){
-  						// using a selector, use the select function to determine if the mouse moved inside the selector and was previously outside the selector
-  						var target = select(evt.target);
-  						var relatedTarget = evt.relatedTarget;
-  						if(target && (target != (relatedTarget && relatedTarget.nodeType == 1 && select(relatedTarget)))){
-  							return listener.call(target, evt);
-  						} 
-  					});
-  				};
-  				return handler;
-  			}
-  			var wheel;
-  			if(has("events-mousewheel")){
-  				wheel = 'mousewheel';
-  			}else { //firefox
-  				wheel = function(node, listener){
-  					return on(node, 'DOMMouseScroll', function(evt){
-  						evt.wheelDelta = -evt.detail;
-  						listener.call(this, evt);
-  					});
-  				};
-  			}
-  			return {
-  				// summary:
-  				//		This module provide mouse event handling utility functions and exports
-  				//		mouseenter and mouseleave event emulation.
-  				// example:
-  				//		To use these events, you register a mouseenter like this:
-  				//		|	define(["dojo/on", "dojo/mouse"], function(on, mouse){
-  				//		|		on(targetNode, mouse.enter, function(event){
-  				//		|			dojo.addClass(targetNode, "highlighted");
-  				//		|		});
-  				//		|		on(targetNode, mouse.leave, function(event){
-  				//		|			dojo.removeClass(targetNode, "highlighted");
-  				//		|		});
-
-  				_eventHandler: eventHandler,		// for dojo/touch
-
-  				// enter: Synthetic Event
-  				//		This is an extension event for the mouseenter that IE provides, emulating the
-  				//		behavior on other browsers.
-  				enter: eventHandler("mouseover"),
-
-  				// leave: Synthetic Event
-  				//		This is an extension event for the mouseleave that IE provides, emulating the
-  				//		behavior on other browsers.
-  				leave: eventHandler("mouseout"),
-
-  				// wheel: Normalized Mouse Wheel Event
-  				//		This is an extension event for the mousewheel that non-Mozilla browsers provide,
-  				//		emulating the behavior on Mozilla based browsers.
-  				wheel: wheel,
-
-  				isLeft: mouseButtons.isLeft,
-  				/*=====
-  				isLeft: function(){
-  					// summary:
-  					//		Test an event object (from a mousedown event) to see if the left button was pressed.
-  				},
-  				=====*/
-
-  				isMiddle: mouseButtons.isMiddle,
-  				/*=====
-  				 isMiddle: function(){
-  					 // summary:
-  					 //		Test an event object (from a mousedown event) to see if the middle button was pressed.
-  				 },
-  				 =====*/
-
-  				isRight: mouseButtons.isRight
-  				/*=====
-  				 , isRight: function(){
-  					 // summary:
-  					 //		Test an event object (from a mousedown event) to see if the right button was pressed.
-  				 }
-  				 =====*/
-  			};
-  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
-  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-
-
-  		/***/ }),
-
-  		/***/ 8709:
-  		/*!******************************************************!*\
-  		  !*** ../../node_modules/dijit/_OnDijitClickMixin.js ***!
-  		  \******************************************************/
-  		/***/ ((module, exports, __webpack_require__) => {
-
-  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
-  			__webpack_require__(/*! dojo/on */ 2075),
-  			__webpack_require__(/*! dojo/_base/array */ 6974), // array.forEach
-  			__webpack_require__(/*! dojo/keys */ 4266), // keys.ENTER keys.SPACE
-  			__webpack_require__(/*! dojo/_base/declare */ 6345), // declare
-  			__webpack_require__(/*! dojo/has */ 6356), // has("dom-addeventlistener")
-  			__webpack_require__(/*! ./a11yclick */ 8240)
-  		], __WEBPACK_AMD_DEFINE_RESULT__ = (function(on, array, keys, declare, has, a11yclick){
-
-  			// module:
-  			//		dijit/_OnDijitClickMixin
-
-  			var ret = declare("dijit._OnDijitClickMixin", null, {
-  				// summary:
-  				//		Deprecated.   New code should access the dijit/a11yclick event directly, ex:
-  				//		|	this.own(on(node, a11yclick, function(){ ... }));
-  				//
-  				//		Mixing in this class will make _WidgetBase.connect(node, "ondijitclick", ...) work.
-  				//		It also used to be necessary to make templates with ondijitclick work, but now you can just require
-  				//		dijit/a11yclick.
-
-  				connect: function(obj, event, method){
-  					// override _WidgetBase.connect() to make this.connect(node, "ondijitclick", ...) work
-  					return this.inherited(arguments, [obj, event == "ondijitclick" ? a11yclick : event, method]);
-  				}
-  			});
-
-  			ret.a11yclick = a11yclick;	// back compat
-
-  			return ret;
-  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
-  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-
-
-  		/***/ }),
-
-  		/***/ 8769:
-  		/*!******************************************!*\
-  		  !*** ../../node_modules/dojo/request.js ***!
-  		  \******************************************/
-  		/***/ ((module, exports, __webpack_require__) => {
-
-  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
-  			__webpack_require__(/*! ./request/default! */ 9648)/*=====,
-  			'./_base/declare',
-  			'./promise/Promise' =====*/
-  		], __WEBPACK_AMD_DEFINE_RESULT__ = (function(request/*=====, declare, Promise =====*/){
-  			/*=====
-  			request = function(url, options){
-  				// summary:
-  				//		Send a request using the default transport for the current platform.
-  				// url: String
-  				//		The URL to request.
-  				// options: dojo/request.__Options?
-  				//		Options for the request.
-  				// returns: dojo/request.__Promise
-  			};
-  			request.__Promise = declare(Promise, {
-  				// response: dojo/promise/Promise
-  				//		A promise resolving to an object representing
-  				//		the response from the server.
-  			});
-  			request.__BaseOptions = declare(null, {
-  				// query: String|Object?
-  				//		Query parameters to append to the URL.
-  				// data: String|Object?
-  				//		Data to transfer.  This is ignored for GET and DELETE
-  				//		requests.
-  				// preventCache: Boolean?
-  				//		Whether to append a cache-busting parameter to the URL.
-  				// timeout: Integer?
-  				//		Milliseconds to wait for the response.  If this time
-  				//		passes, the then the promise is rejected.
-  				// handleAs: String?
-  				//		How to handle the response from the server.  Default is
-  				//		'text'.  Other values are 'json', 'javascript', and 'xml'.
-  			});
-  			request.__MethodOptions = declare(null, {
-  				// method: String?
-  				//		The HTTP method to use to make the request.  Must be
-  				//		uppercase.
-  			});
-  			request.__Options = declare([request.__BaseOptions, request.__MethodOptions]);
-
-  			request.get = function(url, options){
-  				// summary:
-  				//		Send an HTTP GET request using the default transport for the current platform.
-  				// url: String
-  				//		URL to request
-  				// options: dojo/request.__BaseOptions?
-  				//		Options for the request.
-  				// returns: dojo/request.__Promise
-  			};
-  			request.post = function(url, options){
-  				// summary:
-  				//		Send an HTTP POST request using the default transport for the current platform.
-  				// url: String
-  				//		URL to request
-  				// options: dojo/request.__BaseOptions?
-  				//		Options for the request.
-  				// returns: dojo/request.__Promise
-  			};
-  			request.put = function(url, options){
-  				// summary:
-  				//		Send an HTTP POST request using the default transport for the current platform.
-  				// url: String
-  				//		URL to request
-  				// options: dojo/request.__BaseOptions?
-  				//		Options for the request.
-  				// returns: dojo/request.__Promise
-  			};
-  			request.del = function(url, options){
-  				// summary:
-  				//		Send an HTTP DELETE request using the default transport for the current platform.
-  				// url: String
-  				//		URL to request
-  				// options: dojo/request.__BaseOptions?
-  				//		Options for the request.
-  				// returns: dojo/request.__Promise
-  			};
-  			=====*/
-  			return request;
-  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
-  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-
-
-  		/***/ }),
-
-  		/***/ 8810:
-  		/*!******************************************************************!*\
-  		  !*** ../../../../../../../tmp/tmp-5913NTIcDVnVQIZ1/dojo/dojo.js ***!
-  		  \******************************************************************/
-  		/***/ ((module) => {
-
-  		module.exports = function(userConfig, defaultConfig, global, window) { this.loaderVersion = "1.17.3"; (function(
-  			userConfig,
-  			defaultConfig
-  		){
-  			// summary:
-  			//		This is the "source loader" and is the entry point for Dojo during development. You may also load Dojo with
-  			//		any AMD-compliant loader via the package main module dojo/main.
-  			// description:
-  			//		This is the "source loader" for Dojo. It provides an AMD-compliant loader that can be configured
-  			//		to operate in either synchronous or asynchronous modes. After the loader is defined, dojo is loaded
-  			//		IAW the package main module dojo/main. In the event you wish to use a foreign loader, you may load dojo as a package
-  			//		via the package main module dojo/main and this loader is not required; see dojo/package.json for details.
-  			//
-  			//		In order to keep compatibility with the v1.x line, this loader includes additional machinery that enables
-  			//		the dojo.provide, dojo.require et al API. This machinery is loaded by default, but may be dynamically removed
-  			//		via the has.js API and statically removed via the build system.
-  			//
-  			//		This loader includes sniffing machinery to determine the environment; the following environments are supported:
-  			//
-  			//		- browser
-  			//		- node.js
-  			//		- rhino
-  			//
-  			//		This is the so-called "source loader". As such, it includes many optional features that may be discarded by
-  			//		building a customized version with the build system.
-
-  			// Design and Implementation Notes
-  			//
-  			// This is a dojo-specific adaption of bdLoad, donated to the dojo foundation by Altoviso LLC.
-  			//
-  			// This function defines an AMD-compliant (http://wiki.commonjs.org/wiki/Modules/AsynchronousDefinition)
-  			// loader that can be configured to operate in either synchronous or asynchronous modes.
-  			//
-  			// Since this machinery implements a loader, it does not have the luxury of using a load system and/or
-  			// leveraging a utility library. This results in an unpleasantly long file; here is a road map of the contents:
-  			//
-  			//	 1. Small library for use implementing the loader.
-  			//	 2. Define the has.js API; this is used throughout the loader to bracket features.
-  			//	 3. Define the node.js and rhino sniffs and sniff.
-  			//	 4. Define the loader's data.
-  			//	 5. Define the configuration machinery.
-  			//	 6. Define the script element sniffing machinery and sniff for configuration data.
-  			//	 7. Configure the loader IAW the provided user, default, and sniffing data.
-  			//	 8. Define the global require function.
-  			//	 9. Define the module resolution machinery.
-  			//	10. Define the module and plugin module definition machinery
-  			//	11. Define the script injection machinery.
-  			//	12. Define the window load detection.
-  			//	13. Define the logging API.
-  			//	14. Define the tracing API.
-  			//	16. Define the AMD define function.
-  			//	17. Define the dojo v1.x provide/require machinery--so called "legacy" modes.
-  			//	18. Publish global variables.
-  			//
-  			// Language and Acronyms and Idioms
-  			//
-  			// moduleId: a CJS module identifier, (used for public APIs)
-  			// mid: moduleId (used internally)
-  			// packageId: a package identifier (used for public APIs)
-  			// pid: packageId (used internally); the implied system or default package has pid===""
-  			// pack: package is used internally to reference a package object (since javascript has reserved words including "package")
-  			// prid: plugin resource identifier
-  			// The integer constant 1 is used in place of true and 0 in place of false.
-  			//
-  			// The "foreign-loader" has condition is defined if another loader is being used (e.g. webpack) and this code is only
-  			// needed for resolving module identifiers based on the config.  In this case, only the functions require.toUrl and 
-  			// require.toAbsMid are supported.  The require and define functions are not supported.
-
-  			// define global
-  			var globalObject = (function(){
-  				if (typeof global !== 'undefined' && typeof global !== 'function') {
-  					// global spec defines a reference to the global object called 'global'
-  					// https://github.com/tc39/proposal-global
-  					// `global` is also defined in NodeJS
-  					return global;
-  				}
-  				else if (typeof window !== 'undefined') {
-  					// window is defined in browsers
-  					return window;
-  				}
-  				else if (typeof self !== 'undefined') {
-  					// self is defined in WebWorkers
-  					return self;
-  				}
-  				return this;
-  			})();
-
-  			// define a minimal library to help build the loader
-  			var noop = function(){
-  				},
-
-  				toString = {}.toString,
-
-  				isFunction = function(it){
-  					return toString.call(it) == "[object Function]";
+  					promise.otherwise(function (err) {
+  						emitError.call(self, err);
+  					});
+  					return promise;
   				},
 
-  				isArray = function(it){
-  					return toString.call(it) == "[object Array]";
-  				},
+  				removeRow: function (rowElement, preserveDom, options) {
+  					var row = {element: rowElement};
+  					// Check to see if we are now empty...
+  					if (!preserveDom && (this.up(row).element === rowElement) && (this.down(row).element === rowElement)) {
+  						// ...we are empty, so show the no data message.
+  						this._insertNoDataNode();
+  					}
 
-  				forEach = function(vector, callback){
-  					if(vector){
-  						for(var i = 0; i < vector.length;){
-  							callback(vector[i++]);
-  						}
+  					var rows = (options && options.rows) || this._rows;
+  					if (rows) {
+  						delete rows[rowElement.rowIndex];
   					}
+
+  					return this.inherited(arguments);
   				},
 
-  				mix = function(dest, src){
-  					for(var p in src){
-  						dest[p] = src[p];
+  				renderQueryResults: function (results, beforeNode, options) {
+  					// summary:
+  					//		Renders objects from QueryResults as rows, before the given node.
+
+  					options = lang.mixin({ rows: this._rows }, options);
+  					var self = this;
+
+  					if (!has('dojo-built')) {
+  						// Check for null/undefined totalResults to help diagnose faulty services/stores
+  						results.totalLength.then(function (total) {
+  							if (total == null) {
+  								console.warn('Store reported null or undefined totalLength. ' +
+  									'Make sure your store (and service, if applicable) are reporting total correctly!');
+  							}
+  						});
   					}
-  					return dest;
-  				},
 
-  				makeError = function(error, info){
-  					return mix(new Error(error), {src:"dojoLoader", info:info});
+  					return results.then(function (resolvedResults) {
+  						var resolvedRows = self.renderArray(resolvedResults, beforeNode, options);
+  						delete self._lastCollection; // used only for non-store List/Grid
+  						return resolvedRows;
+  					});
   				},
 
-  				uidSeed = 1,
+  				_observeCollection: function (collection, container, options) {
+  					var self = this,
+  						rows = options.rows,
+  						row;
 
-  				uid = function(){
-  					// Returns a unique identifier (within the lifetime of the document) of the form /_d+/.
-  					return "_" + uidSeed++;
-  				},
+  					var handles = [
+  						collection.on('delete, update', function (event) {
+  							var from = event.previousIndex;
+  							var to = event.index;
 
-  				// FIXME: how to doc window.require() api
+  							if (from !== undefined && rows[from]) {
+  								if ('max' in rows && (to === undefined || to < rows.min || to > rows.max)) {
+  									rows.max--;
+  								}
 
-  				// this will be the global require function; define it immediately so we can start hanging things off of it
-  				req = function(
-  					config,		  //(object, optional) hash of configuration properties
-  					dependencies, //(array of commonjs.moduleId, optional) list of modules to be loaded before applying callback
-  					callback	  //(function, optional) lambda expression to apply to module values implied by dependencies
-  				){
-  					return contextRequire(config, dependencies, callback, 0, req);
-  				},
+  								// max should never be less than zero; if it is the logic in the 'add, update' handler
+  								// below will prevent insertion of rows (https://github.com/SitePen/dgrid/issues/1305)
+  								if (rows.max < 0) {
+  									rows.max = 0;
+  								}
 
-  				// the loader uses the has.js API to control feature inclusion/exclusion; define then use throughout
-  				global = globalObject,
+  								row = rows[from];
 
-  				doc = global.document,
+  								// check to make the sure the node is still there before we try to remove it
+  								// (in case it was moved to a different place in the DOM)
+  								if (row.parentNode === container) {
+  									self.removeRow(row, false, options);
+  								}
 
-  				element = doc && doc.createElement("DiV"),
+  								// remove the old slot
+  								rows.splice(from, 1);
 
-  				has = req.has = function(name){
-  					return isFunction(hasCache[name]) ? (hasCache[name] = hasCache[name](global, doc, element)) : hasCache[name];
-  				},
+  								if (event.type === 'delete' ||
+  										(event.type === 'update' && (from < to || to === undefined))) {
+  									// adjust the rowIndex so adjustRowIndices has the right starting point
+  									rows[from] && rows[from].rowIndex--;
+  								}
+  							}
+  							if (event.type === 'delete') {
+  								// Reset row in case this is later followed by an add;
+  								// only update events should retain the row variable below
+  								row = null;
+  							}
+  						}),
 
-  				hasCache = has.cache = defaultConfig.hasCache;
+  						collection.on('add, update', function (event) {
+  							var from = event.previousIndex;
+  							var to = event.index;
+  							var nextNode;
 
-  			if (isFunction(userConfig)) {
-  				userConfig = userConfig(globalObject);
-  			}
+  							function advanceNext() {
+  								nextNode = (nextNode.connected || nextNode).nextSibling;
+  							}
 
-  			has.add = function(name, test, now, force){
-  				(hasCache[name]===undefined || force) && (hasCache[name] = test);
-  				return now && has(name);
-  			};
+  							// When possible, restrict observations to the actually rendered range
+  							if (to !== undefined && (!('max' in rows) || (to >= rows.min && to <= rows.max))) {
+  								if ('max' in rows && (from === undefined || from < rows.min || from > rows.max)) {
+  									rows.max++;
+  								}
+  								// Add to new slot (either before an existing row, or at the end)
+  								// First determine the DOM node that this should be placed before.
+  								if (rows.length) {
+  									nextNode = rows[to];
+  									if (!nextNode) {
+  										nextNode = rows[to - 1];
+  										if (nextNode) {
+  											// Make sure to skip connected nodes, so we don't accidentally
+  											// insert a row in between a parent and its children.
+  											advanceNext();
+  										}
+  									}
+  								}
+  								else {
+  									// There are no rows.  Allow for subclasses to insert new rows somewhere other than
+  									// at the end of the parent node.
+  									nextNode = self._getFirstRowSibling && self._getFirstRowSibling(container);
+  								}
+  								// Make sure we don't trip over a stale reference to a
+  								// node that was removed, or try to place a node before
+  								// itself (due to overlapped queries)
+  								if (row && nextNode && row.id === nextNode.id) {
+  									advanceNext();
+  								}
+  								if (nextNode && !nextNode.parentNode) {
+  									nextNode = document.getElementById(nextNode.id);
+  								}
+  								rows.splice(to, 0, undefined);
+  								row = self.insertRow(event.target, container, nextNode, to, options);
+  								self.highlightRow(row);
+  							}
+  							// Reset row so it doesn't get reused on the next event
+  							row = null;
+  						}),
 
-  			// userConfig has tests override defaultConfig has tests; do this after the environment detection because
-  			// the environment detection usually sets some has feature values in the hasCache.
-  			for(var p in userConfig.has){
-  				has.add(p, userConfig.has[p], 0, 1);
-  			}
-  			{
-  				req.async = 1;
-  			}
+  						collection.on('add, delete, update', function (event) {
+  							var from = (typeof event.previousIndex !== 'undefined') ? event.previousIndex : Infinity,
+  								to = (typeof event.index !== 'undefined') ? event.index : Infinity,
+  								adjustAtIndex = Math.min(from, to);
+  							from !== to && rows[adjustAtIndex] && self.adjustRowIndices(rows[adjustAtIndex]);
 
-  			//
-  			// loader eval
-  			//
-  			var eval_ =    // noop eval if there are csp restrictions
-  				function(){} ;
+  							// the removal of rows could cause us to need to page in more items
+  							if (from !== Infinity && self._processScroll && (rows[from] || rows[from - 1])) {
+  								self._processScroll();
+  							}
 
-  			req.eval =
-  				function(text, hint){
-  					return eval_();
-  				};
+  							// Fire _onNotification, even for out-of-viewport notifications,
+  							// since some things may still need to update (e.g. Pagination's status/navigation)
+  							self._onNotification(rows, event, collection);
+
+  							// Update _total after _onNotification so that it can potentially
+  							// decide whether to perform actions based on whether the total changed
+  							if (collection === self._renderedCollection && 'totalLength' in event) {
+  								self._total = event.totalLength;
+  							}
+  						})
+  					];
 
-  			//
-  			// loader micro events API
-  			//
-  			var listenerQueues = {},
-  				error = "error";
-  				req.signal = function(type, args){
-  					var queue = listenerQueues[type];
-  					// notice we run a copy of the queue; this allows listeners to add/remove
-  					// other listeners without affecting this particular signal
-  					forEach(queue && queue.slice(0), function(listener){
-  						listener.apply(null, isArray(args) ? args : [args]);
-  					});
-  				};
-  				var on = req.on = function(type, listener){
-  					// notice a queue is not created until a client actually connects
-  					var queue = listenerQueues[type] || (listenerQueues[type] = []);
-  					queue.push(listener);
   					return {
-  						remove:function(){
-  							for(var i = 0; i<queue.length; i++){
-  								if(queue[i]===listener){
-  									queue.splice(i, 1);
-  									return;
-  								}
+  						remove: function () {
+  							while (handles.length > 0) {
+  								handles.pop().remove();
   							}
   						}
   					};
-  				};
-
-  			// configuration machinery; with an optimized/built defaultConfig, all configuration machinery can be discarded
-  			// lexical variables hold key loader data structures to help with minification; these may be completely,
-  			// one-time initialized by defaultConfig for optimized/built versions
-  			var aliases
-  					// a vector of pairs of [regexs or string, replacement] => (alias, actual)
-  					= [],
-
-  				pathsMapProg
-  					// list of (from-path, to-path, regex, length) derived from paths;
-  					// a "program" to apply paths; see computeMapProg
-  					= [],
+  				},
 
-  				packs
-  					// a map from packageId to package configuration object; see fixupPackageInfo
-  					= {};
+  				_onNotification: function () {
+  					// summary:
+  					//		Protected method called whenever a store notification is observed.
+  					//		Intended to be extended as necessary by mixins/extensions.
+  					// rows: Array
+  					//		A sparse array of row nodes corresponding to data objects in the collection.
+  					// event: Object
+  					//		The notification event
+  					// collection: Object
+  					//		The collection that the notification is relevant to.
+  					//		Useful for distinguishing child-level from top-level notifications.
+  				}
+  			});
+  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
+  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
 
-  				req.map
-  					// AMD map config variable; dojo/_base/kernel needs req.map to figure out the scope map
-  					= {};
 
-  				var mapProgs
-  					// vector of quads as described by computeMapProg; map-key is AMD map key, map-value is AMD map value
-  					= [],
+  		/***/ }),
 
-  				modules
-  					// A hash:(mid) --> (module-object) the module namespace
-  					//
-  					// pid: the package identifier to which the module belongs (e.g., "dojo"); "" indicates the system or default package
-  					// mid: the fully-resolved (i.e., mappings have been applied) module identifier without the package identifier (e.g., "dojo/io/script")
-  					// url: the URL from which the module was retrieved
-  					// pack: the package object of the package to which the module belongs
-  					// executed: 0 => not executed; executing => in the process of traversing deps and running factory; executed => factory has been executed
-  					// deps: the dependency vector for this module (vector of modules objects)
-  					// def: the factory for this module
-  					// result: the result of the running the factory for this module
-  					// injected: (0 | requested | arrived) the status of the module; nonmodule means the resource did not call define
-  					// load: plugin load function; applicable only for plugins
-  					//
-  					// Modules go through several phases in creation:
-  					//
-  					// 1. Requested: some other module's definition or a require application contained the requested module in
-  					//	  its dependency vector or executing code explicitly demands a module via req.require.
-  					//
-  					// 2. Injected: a script element has been appended to the insert-point element demanding the resource implied by the URL
-  					//
-  					// 3. Loaded: the resource injected in [2] has been evaluated.
-  					//
-  					// 4. Defined: the resource contained a define statement that advised the loader about the module. Notice that some
-  					//	  resources may just contain a bundle of code and never formally define a module via define
-  					//
-  					// 5. Evaluated: the module was defined via define and the loader has evaluated the factory and computed a result.
-  					= {},
+  		/***/ 8471:
+  		/*!****************************************!*\
+  		  !*** ../../node_modules/dojo/mouse.js ***!
+  		  \****************************************/
+  		/***/ ((module, exports, __webpack_require__) => {
 
-  				cacheBust
-  					// query string to append to module URLs to bust browser cache
-  					= "",
+  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(/*! ./_base/kernel */ 1054), __webpack_require__(/*! ./on */ 2075), __webpack_require__(/*! ./has */ 6356), __webpack_require__(/*! ./dom */ 2284), __webpack_require__(/*! ./_base/window */ 5075)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(dojo, on, has, dom, win){
 
-  				cache
-  					// hash:(mid | url)-->(function | string)
-  					//
-  					// A cache of resources. The resources arrive via a config.cache object, which is a hash from either mid --> function or
-  					// url --> string. The url key is distinguished from the mid key by always containing the prefix "url:". url keys as provided
-  					// by config.cache always have a string value that represents the contents of the resource at the given url. mid keys as provided
-  					// by configl.cache always have a function value that causes the same code to execute as if the module was script injected.
-  					//
-  					// Both kinds of key-value pairs are entered into cache via the function consumePendingCache, which may relocate keys as given
-  					// by any mappings *iff* the config.cache was received as part of a module resource request.
-  					//
-  					// Further, for mid keys, the implied url is computed and the value is entered into that key as well. This allows mapped modules
-  					// to retrieve cached items that may have arrived consequent to another namespace.
-  					//
-  					 = {};
+  			// module:
+  			//		dojo/mouse
 
-  			var match; {
-  				// no config API, assume defaultConfig has everything the loader needs...for the entire lifetime of the application
-  				defaultConfig.paths;
-  				pathsMapProg = defaultConfig.pathsMapProg;
-  				packs = defaultConfig.packs;
-  				aliases = defaultConfig.aliases;
-  				mapProgs = defaultConfig.mapProgs;
-  				modules = defaultConfig.modules;
-  				cache = defaultConfig.cache;
-  				cacheBust = defaultConfig.cacheBust;
+  		    has.add("dom-quirks", win.doc && win.doc.compatMode == "BackCompat");
+  			has.add("events-mouseenter", win.doc && "onmouseenter" in win.doc.createElement("div"));
+  			has.add("events-mousewheel", win.doc && 'onmousewheel' in win.doc);
 
-  				// remember the default config for other processes (e.g., dojo/config)
-  				req.rawConfig = defaultConfig;
+  			var mouseButtons;
+  			if((has("dom-quirks") && has("ie")) || !has("dom-addeventlistener")){
+  				mouseButtons = {
+  					LEFT:   1,
+  					MIDDLE: 4,
+  					RIGHT:  2,
+  					// helper functions
+  					isButton: function(e, button){ return e.button & button; },
+  					isLeft:   function(e){ return e.button & 1; },
+  					isMiddle: function(e){ return e.button & 4; },
+  					isRight:  function(e){ return e.button & 2; }
+  				};
+  			}else {
+  				mouseButtons = {
+  					LEFT:   0,
+  					MIDDLE: 1,
+  					RIGHT:  2,
+  					// helper functions
+  					isButton: function(e, button){ return e.button == button; },
+  					isLeft:   function(e){ return e.button == 0; },
+  					isMiddle: function(e){ return e.button == 1; },
+  					isRight:  function(e){ return e.button == 2; }
+  				};
   			}
+  			dojo.mouseButtons = mouseButtons;
 
+  		/*=====
+  			dojo.mouseButtons = {
+  				// LEFT: Number
+  				//		Numeric value of the left mouse button for the platform.
+  				LEFT:   0,
+  				// MIDDLE: Number
+  				//		Numeric value of the middle mouse button for the platform.
+  				MIDDLE: 1,
+  				// RIGHT: Number
+  				//		Numeric value of the right mouse button for the platform.
+  				RIGHT:  2,
 
-  			var contextRequire; 
+  				isButton: function(e, button){
+  					// summary:
+  					//		Checks an event object for a pressed button
+  					// e: Event
+  					//		Event object to examine
+  					// button: Number
+  					//		The button value (example: dojo.mouseButton.LEFT)
+  					return e.button == button; // Boolean
+  				},
+  				isLeft: function(e){
+  					// summary:
+  					//		Checks an event object for the pressed left button
+  					// e: Event
+  					//		Event object to examine
+  					return e.button == 0; // Boolean
+  				},
+  				isMiddle: function(e){
+  					// summary:
+  					//		Checks an event object for the pressed middle button
+  					// e: Event
+  					//		Event object to examine
+  					return e.button == 1; // Boolean
+  				},
+  				isRight: function(e){
+  					// summary:
+  					//		Checks an event object for the pressed right button
+  					// e: Event
+  					//		Event object to examine
+  					return e.button == 2; // Boolean
+  				}
+  			};
+  		=====*/
 
-  			var runMapProg = function(targetMid, map){
-  					// search for targetMid in map; return the map item if found; falsy otherwise
-  					if(map){
-  					for(var i = 0; i < map.length; i++){
-  						if(map[i][2].test(targetMid)){
-  							return map[i];
+  			function eventHandler(type, selectHandler){
+  				// emulation of mouseenter/leave with mouseover/out using descendant checking
+  				var handler = function(node, listener){
+  					return on(node, type, function(evt){
+  						if(selectHandler){
+  							return selectHandler(evt, listener);
   						}
-  					}
-  					}
-  					return 0;
-  				},
+  						if(!dom.isDescendant(evt.relatedTarget, node)){
+  							return listener.call(this, evt);
+  						}
+  					});
+  				};
+  				handler.bubble = function(select){
+  					return eventHandler(type, function(evt, listener){
+  						// using a selector, use the select function to determine if the mouse moved inside the selector and was previously outside the selector
+  						var target = select(evt.target);
+  						var relatedTarget = evt.relatedTarget;
+  						if(target && (target != (relatedTarget && relatedTarget.nodeType == 1 && select(relatedTarget)))){
+  							return listener.call(target, evt);
+  						} 
+  					});
+  				};
+  				return handler;
+  			}
+  			var wheel;
+  			if(has("events-mousewheel")){
+  				wheel = 'mousewheel';
+  			}else { //firefox
+  				wheel = function(node, listener){
+  					return on(node, 'DOMMouseScroll', function(evt){
+  						evt.wheelDelta = -evt.detail;
+  						listener.call(this, evt);
+  					});
+  				};
+  			}
+  			return {
+  				// summary:
+  				//		This module provide mouse event handling utility functions and exports
+  				//		mouseenter and mouseleave event emulation.
+  				// example:
+  				//		To use these events, you register a mouseenter like this:
+  				//		|	define(["dojo/on", "dojo/mouse"], function(on, mouse){
+  				//		|		on(targetNode, mouse.enter, function(event){
+  				//		|			dojo.addClass(targetNode, "highlighted");
+  				//		|		});
+  				//		|		on(targetNode, mouse.leave, function(event){
+  				//		|			dojo.removeClass(targetNode, "highlighted");
+  				//		|		});
 
-  				compactPath = function(path){
-  					var result = [],
-  						segment, lastSegment;
-  					path = path.replace(/\\/g, '/').split('/');
-  					while(path.length){
-  						segment = path.shift();
-  						if(segment==".." && result.length && lastSegment!=".."){
-  							result.pop();
-  							lastSegment = result[result.length - 1];
-  						}else if(segment!="."){
-  							result.push(lastSegment= segment);
-  						} // else ignore "."
-  					}
-  					return result.join("/");
-  				},
+  				_eventHandler: eventHandler,		// for dojo/touch
 
-  				makeModuleInfo = function(pid, mid, pack, url){
-  					{
-  						return {pid:pid, mid:mid, pack:pack, url:url, executed:0, def:0};
-  					}
+  				// enter: Synthetic Event
+  				//		This is an extension event for the mouseenter that IE provides, emulating the
+  				//		behavior on other browsers.
+  				enter: eventHandler("mouseover"),
+
+  				// leave: Synthetic Event
+  				//		This is an extension event for the mouseleave that IE provides, emulating the
+  				//		behavior on other browsers.
+  				leave: eventHandler("mouseout"),
+
+  				// wheel: Normalized Mouse Wheel Event
+  				//		This is an extension event for the mousewheel that non-Mozilla browsers provide,
+  				//		emulating the behavior on Mozilla based browsers.
+  				wheel: wheel,
+
+  				isLeft: mouseButtons.isLeft,
+  				/*=====
+  				isLeft: function(){
+  					// summary:
+  					//		Test an event object (from a mousedown event) to see if the left button was pressed.
   				},
+  				=====*/
 
-  				getModuleInfo_ = function(mid, referenceModule, packs, modules, baseUrl, mapProgs, pathsMapProg, aliases, alwaysCreate, fromPendingCache){
-  					// arguments are passed instead of using lexical variables so that this function my be used independent of the loader (e.g., the builder)
-  					// alwaysCreate is useful in this case so that getModuleInfo never returns references to real modules owned by the loader
-  					var pid, pack, midInPackage, mapItem, url, result, isRelative;
-  					isRelative = /^\./.test(mid);
-  					if(/(^\/)|(\:)|(\.js$)/.test(mid) || (isRelative && !referenceModule)){
-  						// absolute path or protocol of .js filetype, or relative path but no reference module and therefore relative to page
-  						// whatever it is, it's not a module but just a URL of some sort
-  						// note: pid===0 indicates the routine is returning an unmodified mid
+  				isMiddle: mouseButtons.isMiddle,
+  				/*=====
+  				 isMiddle: function(){
+  					 // summary:
+  					 //		Test an event object (from a mousedown event) to see if the middle button was pressed.
+  				 },
+  				 =====*/
 
-  						return makeModuleInfo(0, mid, 0, mid);
-  					}else {
-  						// relative module ids are relative to the referenceModule; get rid of any dots
-  						mid = compactPath(isRelative ? (referenceModule.mid + "/../" + mid) : mid);
-  						if(/^\./.test(mid)){
-  							throw makeError("irrationalPath", mid);
-  						}
-  						// at this point, mid is an absolute mid
+  				isRight: mouseButtons.isRight
+  				/*=====
+  				 , isRight: function(){
+  					 // summary:
+  					 //		Test an event object (from a mousedown event) to see if the right button was pressed.
+  				 }
+  				 =====*/
+  			};
+  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
+  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
 
-  						// map the mid
-  						if(!isRelative && mapProgs.star){
-  							mapItem = runMapProg(mid, mapProgs.star[1]);
-  						}
-  						if(!mapItem && referenceModule){
-  							mapItem = runMapProg(referenceModule.mid, mapProgs);
-  							mapItem = mapItem && runMapProg(mid, mapItem[1]);
-  						}
 
-  						if(mapItem){
-  							mid = mapItem[1] + mid.substring(mapItem[3]);
-  							}
+  		/***/ }),
 
-  						match = mid.match(/^([^\/]+)(\/(.+))?$/);
-  						pid = match ? match[1] : "";
-  						if((pack = packs[pid])){
-  							mid = pid + "/" + (midInPackage = (match[3] || pack.main));
-  						}else {
-  							pid = "";
-  						}
+  		/***/ 8709:
+  		/*!******************************************************!*\
+  		  !*** ../../node_modules/dijit/_OnDijitClickMixin.js ***!
+  		  \******************************************************/
+  		/***/ ((module, exports, __webpack_require__) => {
 
-  						// search aliases
-  						var candidateLength = 0,
-  							candidate = 0;
-  						forEach(aliases, function(pair){
-  							var match = mid.match(pair[0]);
-  							if(match && match.length>candidateLength){
-  								candidate = isFunction(pair[1]) ? mid.replace(pair[0], pair[1]) : pair[1];
-  							}
-  						});
-  						if(candidate){
-  							return getModuleInfo_(candidate, 0, packs, modules, baseUrl, mapProgs, pathsMapProg, aliases, alwaysCreate);
-  						}
+  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
+  			__webpack_require__(/*! dojo/on */ 2075),
+  			__webpack_require__(/*! dojo/_base/array */ 6974), // array.forEach
+  			__webpack_require__(/*! dojo/keys */ 4266), // keys.ENTER keys.SPACE
+  			__webpack_require__(/*! dojo/_base/declare */ 6345), // declare
+  			__webpack_require__(/*! dojo/has */ 6356), // has("dom-addeventlistener")
+  			__webpack_require__(/*! ./a11yclick */ 8240)
+  		], __WEBPACK_AMD_DEFINE_RESULT__ = (function(on, array, keys, declare, has, a11yclick){
 
-  						result = modules[mid];
-  						if(result){
-  							return alwaysCreate ? makeModuleInfo(result.pid, result.mid, result.pack, result.url) : modules[mid];
-  						}
-  					}
-  					// get here iff the sought-after module does not yet exist; therefore, we need to compute the URL given the
-  					// fully resolved (i.e., all relative indicators and package mapping resolved) module id
+  			// module:
+  			//		dijit/_OnDijitClickMixin
 
-  					// note: pid!==0 indicates the routine is returning a url that has .js appended unmodified mid
-  					mapItem = runMapProg(mid, pathsMapProg);
-  					if(mapItem){
-  						url = mapItem[1] + mid.substring(mapItem[3]);
-  					}else if(pid){
-  						url = (pack.location.slice(-1) === '/' ? pack.location.slice(0, -1) : pack.location) + "/" + midInPackage;
-  					}else {
-  						url = mid;
-  					}
-  					// if result is not absolute, add baseUrl
-  					if(!(/(^\/)|(\:)/.test(url))){
-  						url = baseUrl + url;
-  					}
-  					url += ".js";
-  					return makeModuleInfo(pid, mid, pack, compactPath(url));
-  				},
+  			var ret = declare("dijit._OnDijitClickMixin", null, {
+  				// summary:
+  				//		Deprecated.   New code should access the dijit/a11yclick event directly, ex:
+  				//		|	this.own(on(node, a11yclick, function(){ ... }));
+  				//
+  				//		Mixing in this class will make _WidgetBase.connect(node, "ondijitclick", ...) work.
+  				//		It also used to be necessary to make templates with ondijitclick work, but now you can just require
+  				//		dijit/a11yclick.
 
-  				getModuleInfo = function(mid, referenceModule, fromPendingCache){
-  					return getModuleInfo_(mid, referenceModule, packs, modules, req.baseUrl, mapProgs, pathsMapProg, aliases, undefined);
-  				};
+  				connect: function(obj, event, method){
+  					// override _WidgetBase.connect() to make this.connect(node, "ondijitclick", ...) work
+  					return this.inherited(arguments, [obj, event == "ondijitclick" ? a11yclick : event, method]);
+  				}
+  			});
 
-  			req.toAbsMid = function(mid, referenceModule){
-  					return getModuleInfo(mid, referenceModule).mid;
-  				};
+  			ret.a11yclick = a11yclick;	// back compat
 
-  				req.toUrl = function(name, referenceModule){
-  					var moduleInfo = getModuleInfo(name+"/x", referenceModule),
-  						url= moduleInfo.url;
-  					return fixupUrl(moduleInfo.pid===0 ?
-  						// if pid===0, then name had a protocol or absolute path; either way, toUrl is the identify function in such cases
-  						name :
-  						// "/x.js" since getModuleInfo automatically appends ".js" and we appended "/x" to make name look like a module id
-  						url.substring(0, url.length-5)
-  					);
-  				};
+  			return ret;
+  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
+  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
 
-  			var fixupUrl= typeof userConfig.fixupUrl == "function" ? userConfig.fixupUrl : function(url){
-  					url += ""; // make sure url is a Javascript string (some paths may be a Java string)
-  					return url + (cacheBust ? ((/\?/.test(url) ? "&" : "?") + cacheBust) : "");
-  				};
 
-  			{
-  				req.log = noop;
-  			}
+  		/***/ }),
 
-  			{
-  				req.trace = noop;
-  			}
-  			var def; {
-  				var def = noop;
-  			}
-  			// allow config to override default implementation of named functions; this is useful for
-  			// non-browser environments, e.g., overriding injectUrl, getText, log, etc. in node.js, Rhino, etc.
-  			// also useful for testing and monkey patching loader
-  			mix(mix(req, defaultConfig.loaderPatch), userConfig.loaderPatch);
+  		/***/ 8769:
+  		/*!******************************************!*\
+  		  !*** ../../node_modules/dojo/request.js ***!
+  		  \******************************************/
+  		/***/ ((module, exports, __webpack_require__) => {
 
-  			// now that req is fully initialized and won't change, we can hook it up to the error signal
-  			on(error, function(arg){
-  				try{
-  					console.error(arg);
-  					if(arg instanceof Error){
-  						for(var p in arg){
-  							console.log(p + ":", arg[p]);
-  						}
-  						console.log(".");
-  					}
-  				}catch(e){}
+  		__webpack_require__.dj.r;var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [
+  			__webpack_require__(/*! ./request/default! */ 9648)/*=====,
+  			'./_base/declare',
+  			'./promise/Promise' =====*/
+  		], __WEBPACK_AMD_DEFINE_RESULT__ = (function(request/*=====, declare, Promise =====*/){
+  			/*=====
+  			request = function(url, options){
+  				// summary:
+  				//		Send a request using the default transport for the current platform.
+  				// url: String
+  				//		The URL to request.
+  				// options: dojo/request.__Options?
+  				//		Options for the request.
+  				// returns: dojo/request.__Promise
+  			};
+  			request.__Promise = declare(Promise, {
+  				// response: dojo/promise/Promise
+  				//		A promise resolving to an object representing
+  				//		the response from the server.
   			});
-
-  			// always publish these
-  			mix(req, {
-  				uid:uid,
-  				cache:cache,
-  				packs:packs
+  			request.__BaseOptions = declare(null, {
+  				// query: String|Object?
+  				//		Query parameters to append to the URL.
+  				// data: String|Object?
+  				//		Data to transfer.  This is ignored for GET and DELETE
+  				//		requests.
+  				// preventCache: Boolean?
+  				//		Whether to append a cache-busting parameter to the URL.
+  				// timeout: Integer?
+  				//		Milliseconds to wait for the response.  If this time
+  				//		passes, the then the promise is rejected.
+  				// handleAs: String?
+  				//		How to handle the response from the server.  Default is
+  				//		'text'.  Other values are 'json', 'javascript', and 'xml'.
+  			});
+  			request.__MethodOptions = declare(null, {
+  				// method: String?
+  				//		The HTTP method to use to make the request.  Must be
+  				//		uppercase.
   			});
+  			request.__Options = declare([request.__BaseOptions, request.__MethodOptions]);
+
+  			request.get = function(url, options){
+  				// summary:
+  				//		Send an HTTP GET request using the default transport for the current platform.
+  				// url: String
+  				//		URL to request
+  				// options: dojo/request.__BaseOptions?
+  				//		Options for the request.
+  				// returns: dojo/request.__Promise
+  			};
+  			request.post = function(url, options){
+  				// summary:
+  				//		Send an HTTP POST request using the default transport for the current platform.
+  				// url: String
+  				//		URL to request
+  				// options: dojo/request.__BaseOptions?
+  				//		Options for the request.
+  				// returns: dojo/request.__Promise
+  			};
+  			request.put = function(url, options){
+  				// summary:
+  				//		Send an HTTP POST request using the default transport for the current platform.
+  				// url: String
+  				//		URL to request
+  				// options: dojo/request.__BaseOptions?
+  				//		Options for the request.
+  				// returns: dojo/request.__Promise
+  			};
+  			request.del = function(url, options){
+  				// summary:
+  				//		Send an HTTP DELETE request using the default transport for the current platform.
+  				// url: String
+  				//		URL to request
+  				// options: dojo/request.__BaseOptions?
+  				//		Options for the request.
+  				// returns: dojo/request.__Promise
+  			};
+  			=====*/
+  			return request;
+  		}).apply(null, __WEBPACK_AMD_DEFINE_ARRAY__),
+  				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
 
-  			// the loader can be defined exactly once; look for global define which is the symbol AMD loaders are
-  			// *required* to define (as opposed to require, which is optional)
-  			if(global.define){
-  				return;
-  			}else {
-  				global.define = def;
-  				global.require = req;
-  			}
-  		})
-  		.call(this, userConfig, defaultConfig);};
 
   		/***/ }),
 
@@ -29972,7 +29972,7 @@
   		/******/ 				"dojo/_base/query":4203,
   		/******/ 				"dojo/_base/NodeList":6659,
   		/******/ 				"dojo/NodeList-dom":8288
-  		/******/ 				// "/tmp/tmp-5913NTIcDVnVQIZ1/dojo/dojo.js" = 8810
+  		/******/ 				// "/tmp/tmp-5915xSdKDAV2AL3m/dojo/dojo.js" = 2093
   		/******/ 			});
   		/******/ 		
   		/******/ 			globalObj.require = req;
@@ -30008,7 +30008,7 @@
   		/******/ 						return url;
   		/******/ 					})}));
   		/******/ 			var defaultConfig = ({'hasCache':({'webpack':1,'host-browser':1,'dom':1,'dojo-loader':1,'dojo-has-api':1,'dojo-dom-ready-api':1,'dojo-sniff':1,'dojo-test-sniff':1,'config-deferredInstrumentation':1,'config-tlmSiblingOfDojo':1}),'paths':({'js':'js','theme':'theme','css':'//chuckdumont.github.io/dojo-css-plugin/1.0.0/css'}),'pathsMapProg':[['theme','theme',/^theme(\/|$)/,5],['css','//chuckdumont.github.io/dojo-css-plugin/1.0.0/css',/^css(\/|$)/,3],['js','js',/^js(\/|$)/,2]],'packs':({'dojo':({'main':'main','name':'dojo','location':'./dist/dojo','lib':'.'}),'dijit':({'main':'main','name':'dijit','location':'./dist/dijit','lib':'.'}),'dojox':({'main':'main','name':'dojox','location':'./dist/dojox','lib':'.'}),'dijit-themes':({'main':'main','name':'dijit-themes','location':'./dist/dijit-themes','lib':'.'}),'dgrid':({'main':'main','name':'dgrid','location':'./dist/dgrid','lib':'.'}),'dstore':({'main':'main','name':'dstore','location':'./dist/dojo-dstore','lib':'.'})}),'aliases':[],'mapProgs':[],'cacheBust':undefined,'modules':({}),'cache':({})});
-  		/******/ 			var dojoLoader = __webpack_require__(8810);
+  		/******/ 			var dojoLoader = __webpack_require__(2093);
   		/******/ 			dojoLoader.call(loaderScope, userConfig, defaultConfig, loaderScope, loaderScope);
   		/******/ 			loaderScope.require.baseUrl = "./";
   		/******/ 			Object.keys(loaderScope.require.packs).forEach(function(key) {