@hpcc-js/dgrid 2.34.1 → 2.34.2

package/dist/index.es6.js

@@ -2,8 +2,8 @@ import { publish, HTMLWidget, format, Palette, select, PropertyExt } from '@hpcc
 import { hashSum } from '@hpcc-js/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.
@@ -7228,1349 +7228,1839 @@ function requireDist () {
 
 		/***/ }),
 
-		/***/ 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__));
 
@@ -9356,7 +9846,7 @@ function requireDist () {
 		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";
 		
 
 		/***/ }),
@@ -26537,1000 +27027,510 @@ function requireDist () {
 						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);};
 
 		/***/ }),
 
@@ -29970,7 +29970,7 @@ function requireDist () {
 		/******/ 				"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;
@@ -30006,7 +30006,7 @@ function requireDist () {
 		/******/ 						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) {