@dra2020/district-analytics 1.0.1

package/dist/district-analytics.js

@@ -0,0 +1,2937 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["district-analytics"] = factory();
+	else
+		root["district-analytics"] = factory();
+})(global, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = "./src/index.ts");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "./src/_api.ts":
+/*!*********************!*\
+  !*** ./src/_api.ts ***!
+  \*********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// THE NODE PACKAGE API
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const preprocess_1 = __webpack_require__(/*! ./preprocess */ "./src/preprocess.ts");
+const analyze_1 = __webpack_require__(/*! ./analyze */ "./src/analyze.ts");
+const report_1 = __webpack_require__(/*! ./report */ "./src/report.ts");
+const D = __webpack_require__(/*! ./_data */ "./src/_data.ts");
+const U = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+class AnalyticsSession {
+    constructor(SessionRequest) {
+        this.config = {};
+        this.bOneTimeProcessingDone = false;
+        this.bPlanAnalyzed = false;
+        this.bPostProcessingDone = false;
+        this.testScales = {};
+        this.tests = {};
+        this.scorecard = {};
+        this.title = SessionRequest['title'];
+        this.legislativeDistricts = SessionRequest['legislativeDistricts'];
+        this.config = this.processConfig(SessionRequest['config']);
+        this.state = new D.State(this, SessionRequest['stateXX'], SessionRequest['nDistricts']);
+        this.counties = new D.Counties(this, SessionRequest['counties']);
+        this.graph = new D.Graph(this, SessionRequest['graph']);
+        this.features = new D.Features(this, SessionRequest['data'], this.config['datasets']);
+        this.plan = new D.Plan(this, SessionRequest['plan']);
+        this.districts = new D.Districts(this, SessionRequest['districtShapes']);
+        // NOTE: I've pulled these out of the individual analytics to here. Eventually,
+        // we could want them to passed into an analytics session as data, along with
+        // everything else. For now, this keeps branching out of the main code.
+        report_1.doConfigureScales(this);
+    }
+    processConfig(config) {
+        // NOTE - Session settings are required:
+        // - Analytics suites can be defaulted to all with [], but
+        // - Dataset keys must be explicitly specified with 'dataset'
+        let defaultSuites = [0 /* Legal */, 1 /* Fair */, 2 /* Best */];
+        // If the config passed in has no suites = [], use the default suites
+        if (U.isArrayEmpty(config['suites'])) {
+            config['suites'] = defaultSuites;
+        }
+        // Default the Census & redistricting cycle to 2010
+        if (!(U.keyExists('cycle', config)))
+            config['cycle'] = 2010;
+        return config;
+    }
+    // Using the the data in the analytics session, calculate all the
+    // analytics & validations, saving/updating the individual test results.
+    analyzePlan(bLog = false) {
+        try {
+            preprocess_1.doPreprocessData(this);
+            analyze_1.doAnalyzeDistricts(this, bLog);
+            analyze_1.doAnalyzePlan(this, bLog);
+            report_1.doAnalyzePostProcessing(this);
+        }
+        catch (_a) {
+            return false;
+        }
+        return true;
+    }
+    // Get an individual test, so you can drive UI with the results.
+    getTest(testID) {
+        // Get the existing test entries
+        // T.Test is a numeric enum, so convert the string keys to numbers
+        let testValues = U.getNumericObjectKeys(this.tests);
+        // If there's no entry for this test, create & initialize one
+        if (!(testValues.includes(testID))) {
+            this.tests[testID] = {};
+            this.tests[testID]['score'] = undefined;
+            this.tests[testID]['details'] = {};
+        }
+        // Return a pointer to the the test entry for this test
+        return this.tests[testID];
+    }
+    // Prepare a scorecard for rendering
+    // NOTE - This assumes that analyzePlan() has been run!
+    prepareScorecard() {
+        return report_1.doPrepareScorecard(this);
+    }
+    // Prepare test results for rendering
+    // NOTE - This assumes that analyzePlan() has been run!
+    prepareTestLog() {
+        return report_1.doPrepareTestLog(this);
+    }
+    populationDeviationThreshold() {
+        return 1 - this.testScales[4 /* PopulationDeviation */]['testScale'][0];
+    }
+}
+exports.AnalyticsSession = AnalyticsSession;
+
+
+/***/ }),
+
+/***/ "./src/_data.ts":
+/*!**********************!*\
+  !*** ./src/_data.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// DATA ABSTRACTION LAYER
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const U = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const valid_1 = __webpack_require__(/*! ./valid */ "./src/valid.ts");
+const compact_1 = __webpack_require__(/*! ./compact */ "./src/compact.ts");
+const political_1 = __webpack_require__(/*! ./political */ "./src/political.ts");
+// DISTRICT STATISTICS
+// Indexes for statistics fields in Districts
+// NOTE - Not a const, so the number can be determined dynamically
+var DistrictField;
+(function (DistrictField) {
+    DistrictField[DistrictField["TotalPop"] = 0] = "TotalPop";
+    DistrictField[DistrictField["PopDevPct"] = 1] = "PopDevPct";
+    DistrictField[DistrictField["bEqualPop"] = 2] = "bEqualPop";
+    DistrictField[DistrictField["bNotEmpty"] = 3] = "bNotEmpty";
+    DistrictField[DistrictField["bContiguous"] = 4] = "bContiguous";
+    DistrictField[DistrictField["bNotEmbedded"] = 5] = "bNotEmbedded";
+    DistrictField[DistrictField["CountySplits"] = 6] = "CountySplits";
+    DistrictField[DistrictField["DemVotes"] = 7] = "DemVotes";
+    DistrictField[DistrictField["RepVotes"] = 8] = "RepVotes";
+    DistrictField[DistrictField["TwoPartyVote"] = 9] = "TwoPartyVote";
+    DistrictField[DistrictField["DemPct"] = 10] = "DemPct";
+    DistrictField[DistrictField["RepPct"] = 11] = "RepPct";
+    DistrictField[DistrictField["DemSeat"] = 12] = "DemSeat";
+    DistrictField[DistrictField["TotalVAP"] = 13] = "TotalVAP";
+    DistrictField[DistrictField["MinorityPop"] = 14] = "MinorityPop";
+    DistrictField[DistrictField["WhitePop"] = 15] = "WhitePop";
+    DistrictField[DistrictField["BlackPop"] = 16] = "BlackPop";
+    DistrictField[DistrictField["HispanicPop"] = 17] = "HispanicPop";
+    DistrictField[DistrictField["PacificPop"] = 18] = "PacificPop";
+    DistrictField[DistrictField["AsianPop"] = 19] = "AsianPop";
+    DistrictField[DistrictField["NativePop"] = 20] = "NativePop";
+    DistrictField[DistrictField["WhitePct"] = 21] = "WhitePct";
+    DistrictField[DistrictField["MinorityPct"] = 22] = "MinorityPct";
+    DistrictField[DistrictField["BlackPct"] = 23] = "BlackPct";
+    DistrictField[DistrictField["HispanicPct"] = 24] = "HispanicPct";
+    DistrictField[DistrictField["PacificPct"] = 25] = "PacificPct";
+    DistrictField[DistrictField["AsianPct"] = 26] = "AsianPct";
+    DistrictField[DistrictField["NativePct"] = 27] = "NativePct"; // Display
+    // 1 - MORE ...
+})(DistrictField = exports.DistrictField || (exports.DistrictField = {}));
+// The fields to display in a District Statistics pane
+exports.DisplayFields = [
+    DistrictField.TotalPop,
+    DistrictField.PopDevPct,
+    DistrictField.bEqualPop,
+    DistrictField.bNotEmpty,
+    DistrictField.bContiguous,
+    DistrictField.bNotEmbedded,
+    DistrictField.DemPct,
+    DistrictField.WhitePct,
+    DistrictField.MinorityPct,
+    DistrictField.BlackPct,
+    DistrictField.HispanicPct,
+    DistrictField.PacificPct,
+    DistrictField.AsianPct,
+    DistrictField.NativePct
+];
+class Districts {
+    constructor(s, ds) {
+        this._geoProperties = {};
+        this._session = s;
+        this._shapes = ds;
+        this.statistics = this.initStatistics();
+    }
+    getShape(i) { return this._shapes.features[i]; }
+    getGeoProperties(i) { return this._geoProperties[i]; }
+    setGeoProperties(i, p) { this._geoProperties[i] = p; }
+    numberOfColumns() { return U.countEnumValues(DistrictField); }
+    // +1 for dummy unassigned 0 "district" and +1 for N+1 summary "district" for
+    // state-level values. Real districts are 1–N.
+    numberOfRows() { return this._session.state.nDistricts + 2; }
+    numberOfWorkingDistricts() { return this._session.state.nDistricts + 1; }
+    // This is the core statistics 2D matrix:
+    // Fields on the outside, districts on the inside
+    initStatistics() {
+        let nRows = this.numberOfRows();
+        let nCols = this.numberOfColumns();
+        let outer = U.initArray(nCols, undefined);
+        for (let i = 0; i < nCols; i++) {
+            outer[i] = U.initArray(nRows, null);
+        }
+        return outer;
+    }
+    // This is the workhorse computational routine!
+    //
+    // TODO - Optimize for getting multiple properties from the same feature?
+    // TODO - Optimize by only re-calc'ing districts that have changed?
+    //        In this case, special attention to getting county-splits right.
+    // TODO - Optimize by asyn'ing this?
+    // TODO - Is there a way to do this programmatically off data? Does it matter?
+    recalcStatistics(bLog = false) {
+        // Compute these once per recalc cycle
+        let targetSize = this._session.state.totalPop / this._session.state.nDistricts;
+        let deviationThreshold = this._session.populationDeviationThreshold();
+        let planByDistrict = this._session.plan.byDistrictID();
+        let plan = this._session.plan;
+        let graph = this._session.graph;
+        // INITIALIZE STATE VALUES THAT WILL BE ACCUMULATED
+        let stateTPVote = 0;
+        let stateDemVote = 0;
+        let stateRepVote = 0;
+        let stateVAPPop = 0;
+        let stateWhitePop = 0;
+        let stateMinorityPop = 0;
+        let stateBlackPop = 0;
+        let stateHispanicPop = 0;
+        let statePacificPop = 0;
+        let stateAsianPop = 0;
+        let stateNativePop = 0;
+        // NOTE - These plan-level booleans are set in their respective analytics:
+        // - Equal population (bEqualPop)
+        // - Complete (bNotEmpty)
+        // - Contiguos (bContiguous)
+        // - Free of holes (bNotEmbedded)
+        // 2 - MORE ...
+        // Loop over the districts (including the dummy unassigned one)
+        for (let i = 0; i < this.numberOfWorkingDistricts(); i++) {
+            // INITIALIZE DISTRICT VALUES THAT WILL BE ACCUMULATED (VS. DERIVED)
+            let featurePop;
+            let totalPop = 0;
+            let countySplits = U.initArray(this._session.counties.nCounties, 0);
+            let demVotes = 0;
+            let repVotes = 0;
+            let totalVAP = 0;
+            let whitePop = 0;
+            let blackPop = 0;
+            let hispanicPop = 0;
+            let pacificPop = 0;
+            let asianPop = 0;
+            let nativePop = 0;
+            // 3 - MORE ...
+            // HACK - Because "this" gets ghosted inside the forEach loop below
+            let outerThis = this;
+            // Get the geoIDs assigned to it ...
+            let geoIDs = this._session.plan.geoIDsForDistrictID(i);
+            // ... loop over them creating district-by-district statistics 
+            geoIDs.forEach(function (geoID) {
+                // Map from geoID to feature index
+                let featureID = outerThis._session.features.featureID(geoID);
+                let f = outerThis._session.features.featureByIndex(featureID);
+                // ACCUMULATE VALUES
+                // Total population of each feature (used more than once)
+                featurePop = outerThis._session.features.fieldForFeature(f, "CENSUS" /* CENSUS */, "Tot" /* TotalPop */);
+                // Total district population
+                totalPop += featurePop;
+                // Total population by counties w/in a district
+                countySplits[outerThis.getCountyIndex(geoID)] += featurePop;
+                // Democratic and Republican vote totals
+                demVotes += outerThis._session.features.fieldForFeature(f, "ELECTION" /* ELECTION */, "D" /* DemVotes */);
+                repVotes += outerThis._session.features.fieldForFeature(f, "ELECTION" /* ELECTION */, "R" /* RepVotes */);
+                // Voting-age demographic breakdowns (or citizen voting-age)
+                totalVAP += outerThis._session.features.fieldForFeature(f, "VAP" /* VAP */, "Tot" /* TotalPop */);
+                whitePop += outerThis._session.features.fieldForFeature(f, "VAP" /* VAP */, "Wh" /* WhitePop */);
+                blackPop += outerThis._session.features.fieldForFeature(f, "VAP" /* VAP */, "BlC" /* BlackPop */);
+                hispanicPop += outerThis._session.features.fieldForFeature(f, "VAP" /* VAP */, "His" /* HispanicPop */);
+                pacificPop += outerThis._session.features.fieldForFeature(f, "VAP" /* VAP */, "PacC" /* PacificPop */);
+                asianPop += outerThis._session.features.fieldForFeature(f, "VAP" /* VAP */, "AsnC" /* AsianPop */);
+                nativePop += outerThis._session.features.fieldForFeature(f, "VAP" /* VAP */, "NatC" /* NativePop */);
+                // 4 - MORE ...
+            });
+            // COMPUTE DERIVED VALUES
+            // Population deviation % and equal population (boolean) by district.
+            // Leave the values null for the dummy unassigned district.
+            let popDevPct = null;
+            let bEqualPop = null;
+            if (i > 0) {
+                popDevPct = (totalPop - targetSize) / targetSize;
+                bEqualPop = (popDevPct <= deviationThreshold);
+            }
+            // Total two-party (not total total!) votes, Democratic and Republican vote
+            // shares, and Democratic first-past-the-post win (= 1) or loss (= 0).
+            let totVotes;
+            let demPct = null;
+            let repPct = null;
+            let DemSeat = null;
+            totVotes = demVotes + repVotes;
+            if (totVotes > 0) {
+                demPct = demVotes / totVotes;
+                repPct = repVotes / totVotes;
+                DemSeat = political_1.fptpWin(demPct);
+            }
+            // Total minority VAP
+            let minorityPop = totalVAP - whitePop;
+            // Voting-age demographic proportions (or citizen voting-age)
+            let whitePct = null;
+            let minorityPct = null;
+            let blackPct = null;
+            let hispanicPct = null;
+            let pacificPct = null;
+            let asianPct = null;
+            let nativePct = null;
+            if (totalVAP > 0) {
+                whitePct = whitePop / totalVAP;
+                minorityPct = minorityPop / totalVAP;
+                blackPct = blackPop / totalVAP;
+                hispanicPct = hispanicPop / totalVAP;
+                pacificPct = pacificPop / totalVAP;
+                asianPct = asianPop / totalVAP;
+                nativePct = nativePop / totalVAP;
+            }
+            // 5 - MORE ...
+            // COMPUTE DISTRICT-LEVEL VALUES
+            // Validations
+            let bNotEmpty = (!U.isSetEmpty(geoIDs));
+            let bContiguous = null;
+            let bNotEmbedded = null;
+            // Leave the values null for the dummy unassigned district,
+            // and districts that are empty.
+            if (i > 0) {
+                if (bNotEmpty) {
+                    bContiguous = valid_1.isConnected(geoIDs, graph);
+                    bNotEmbedded = (!valid_1.isEmbedded(i, planByDistrict[i], plan, graph));
+                }
+            }
+            // 6 - MORE ...
+            // UPDATE THE DISTRICT STATISTICS
+            this.statistics[DistrictField.bNotEmpty][i] = bNotEmpty;
+            this.statistics[DistrictField.bContiguous][i] = bContiguous;
+            this.statistics[DistrictField.bNotEmbedded][i] = bNotEmbedded;
+            this.statistics[DistrictField.TotalPop][i] = totalPop;
+            this.statistics[DistrictField.PopDevPct][i] = popDevPct;
+            this.statistics[DistrictField.bEqualPop][i] = bEqualPop;
+            this.statistics[DistrictField.CountySplits][i] = countySplits;
+            this.statistics[DistrictField.DemVotes][i] = demVotes;
+            this.statistics[DistrictField.RepVotes][i] = repVotes;
+            this.statistics[DistrictField.TwoPartyVote][i] = totVotes;
+            this.statistics[DistrictField.DemPct][i] = demPct;
+            this.statistics[DistrictField.RepPct][i] = repPct;
+            this.statistics[DistrictField.DemSeat][i] = DemSeat;
+            this.statistics[DistrictField.WhitePop][i] = whitePop;
+            this.statistics[DistrictField.MinorityPop][i] = minorityPop;
+            this.statistics[DistrictField.BlackPop][i] = blackPop;
+            this.statistics[DistrictField.HispanicPop][i] = hispanicPop;
+            this.statistics[DistrictField.PacificPop][i] = pacificPop;
+            this.statistics[DistrictField.AsianPop][i] = asianPop;
+            this.statistics[DistrictField.NativePop][i] = nativePop;
+            this.statistics[DistrictField.TotalVAP][i] = totalVAP;
+            this.statistics[DistrictField.WhitePct][i] = whitePct;
+            this.statistics[DistrictField.MinorityPct][i] = minorityPct;
+            this.statistics[DistrictField.BlackPct][i] = blackPct;
+            this.statistics[DistrictField.HispanicPct][i] = hispanicPct;
+            this.statistics[DistrictField.PacificPct][i] = pacificPct;
+            this.statistics[DistrictField.AsianPct][i] = asianPct;
+            this.statistics[DistrictField.NativePct][i] = nativePct;
+            // 7 - MORE ...
+            // ACCUMULATE STATE STATISTICS FROM DISTRICT TOTALS
+            stateTPVote += totVotes;
+            stateDemVote += demVotes;
+            stateRepVote += repVotes;
+            stateVAPPop += totalVAP;
+            stateWhitePop += whitePop;
+            stateMinorityPop += minorityPop;
+            stateBlackPop += blackPop;
+            stateHispanicPop += hispanicPop;
+            statePacificPop += pacificPop;
+            stateAsianPop += asianPop;
+            stateNativePop += nativePop;
+        }
+        // UPDATE STATE STATISTICS
+        let summaryRow = this.numberOfRows() - 1;
+        if (stateTPVote > 0) {
+            this.statistics[DistrictField.DemPct][summaryRow] = stateDemVote / stateTPVote;
+            this.statistics[DistrictField.RepPct][summaryRow] = stateRepVote / stateTPVote;
+        }
+        if (stateVAPPop > 0) {
+            this.statistics[DistrictField.WhitePct][summaryRow] = stateWhitePop / stateVAPPop;
+            this.statistics[DistrictField.MinorityPct][summaryRow] = stateMinorityPop / stateVAPPop;
+            this.statistics[DistrictField.BlackPct][summaryRow] = stateBlackPop / stateVAPPop;
+            this.statistics[DistrictField.HispanicPct][summaryRow] = stateHispanicPop / stateVAPPop;
+            this.statistics[DistrictField.PacificPct][summaryRow] = statePacificPop / stateVAPPop;
+            this.statistics[DistrictField.AsianPct][summaryRow] = stateAsianPop / stateVAPPop;
+            this.statistics[DistrictField.NativePct][summaryRow] = stateNativePop / stateVAPPop;
+        }
+    }
+    // NOTE - I did not roll these into district statistics, because creating the
+    //   district shapes themselves is the big district-by-district activity, these
+    //   calc's already work, and I'm not going to expose these values. Wrapping
+    //   the underlying function and exposing it here to illustrate the parallelism
+    //   with recalcStatistics(). These are called in tandem by doAnalyzeDistricts().
+    extractDistrictShapeProperties(bLog = false) {
+        compact_1.extractDistrictProperties(this._session, bLog);
+    }
+    getCountyIndex(geoID) {
+        let countyGeoID = U.parseGeoID(geoID)['county'];
+        let countyFIPS = U.getFIPSFromCountyGeoID(countyGeoID);
+        let countyIndex = this._session.counties.indexFromFIPS(countyFIPS);
+        return countyIndex;
+    }
+}
+exports.Districts = Districts;
+exports.DatasetDescriptions = {
+    D16F: "2016 ACS Total Population",
+    D16T: "2016 ACS Voting Age Population",
+    E16GPR: "2016 Presidential Election"
+    // TODO - What other potential datasets?
+};
+// Wrap data by feature, to abstract the specifics of the internal structure
+class Features {
+    constructor(s, data, keys) {
+        this._featureIDs = {};
+        this._session = s;
+        this._data = data;
+        this._keys = keys;
+    }
+    nFeatures() { return this._data.features.length; }
+    featureByIndex(i) { return this._data.features[i]; }
+    geoIDForFeature(f) { return f.properties['GEOID']; }
+    fieldForFeature(f, dt, fk) {
+        let dk = this._keys[dt];
+        return _getFeatures(f, dk, fk);
+    }
+    resetDataset(d, k) {
+        this._keys[d] = k;
+        // TODO - Does anything need to be recalc'd now when a dataset is changed?
+    }
+    mapGeoIDsToFeatureIDs() {
+        for (let i = 0; i < this._session.features.nFeatures(); i++) {
+            let f = this._session.features.featureByIndex(i);
+            let geoID = this._session.features.geoIDForFeature(f);
+            this._featureIDs[geoID] = i;
+        }
+    }
+    featureID(i) { return this._featureIDs[i]; }
+}
+exports.Features = Features;
+// NOTE - This accessor is cloned from fGetW() in dra-client/restrict.ts
+//  f is a direct GeoJSON feature
+//  p is a geoID
+function _getFeatures(f, datasetKey, p) {
+    // Shim to load sample data2.json from disk for command-line scaffolding
+    if (f.properties && f.properties['datasets']) {
+        return f.properties['datasets'][datasetKey][p];
+    }
+    // NOTE - The fGetW() code from dra-client below here ...
+    // Direct property?
+    if (f.properties && f.properties[p] !== undefined)
+        return f.properties[p];
+    // Joined property?
+    let a = _fGetJoined(f);
+    if (a) {
+        for (let i = 0; i < a.length; i++) {
+            let o = a[i];
+            if (!datasetKey) {
+                if (o[p] !== undefined)
+                    return o[p];
+            }
+            else {
+                if (o['datasets'] && o['datasets'][datasetKey])
+                    if (o['datasets'][datasetKey][p])
+                        return o['datasets'][datasetKey][p];
+            }
+        }
+    }
+    return undefined;
+}
+function _fGetJoined(f) {
+    return (f.properties && f.properties.joined) ? f.properties.joined : undefined;
+}
+// Wrap data by county, to abstract the specifics of the internal structure
+class Counties {
+    constructor(s, data) {
+        this.index = {};
+        this._session = s;
+        this._data = data;
+        this.nCounties = this._data.features.length;
+        this._countyNameLookup = {};
+    }
+    // nCounties(): number { return this._data.features.length; }
+    countyByIndex(i) { return this._data.features[i]; }
+    propertyForCounty(f, pk) { return f.properties[pk]; }
+    mapFIPSToName(fips, name) { this._countyNameLookup[fips] = name; }
+    nameFromFIPS(fips) { return this._countyNameLookup[fips]; }
+    indexFromFIPS(fips) { return this.index[fips]; }
+}
+exports.Counties = Counties;
+// CLASSES TO ORGANIZE AND/OR ABSTRACT OTHER DATA
+class State {
+    constructor(s, xx, n) {
+        this.totalPop = 0;
+        this.tooBigFIPS = [];
+        this.tooBigName = [];
+        this.expectedSplits = 0;
+        this.expectedAffected = 0;
+        this._session = s;
+        this.xx = xx;
+        this.nDistricts = n;
+    }
+}
+exports.State = State;
+class Plan {
+    constructor(s, p) {
+        this._session = s;
+        this._planByGeoID = p;
+        this._planByDistrictID = {};
+        this.districtIDs = []; // Set when the plan in inverted
+    }
+    invertPlan() {
+        this._planByDistrictID = U.invertPlan(this._planByGeoID);
+        this.districtIDs = U.getNumericObjectKeys(this._planByDistrictID);
+    }
+    initializeDistrict(i) { this._planByDistrictID[i] = new Set(); }
+    byGeoID() { return this._planByGeoID; }
+    byDistrictID() { return this._planByDistrictID; }
+    districtForGeoID(i) { return this._planByGeoID[i]; }
+    geoIDsForDistrictID(i) { return this._planByDistrictID[i]; }
+}
+exports.Plan = Plan;
+class Graph {
+    constructor(s, graph) {
+        this._session = s;
+        this._graph = graph;
+    }
+    // TODO - Rework this, when we support MIXED MAPS.
+    peerNeighbors(node) {
+        // Get the neighboring geoIDs connected to a geoID
+        // Ignore the lengths of the shared borders (the values), for now
+        return U.getObjectKeys(this._graph[node]);
+    }
+}
+exports.Graph = Graph;
+
+
+/***/ }),
+
+/***/ "./src/analyze.ts":
+/*!************************!*\
+  !*** ./src/analyze.ts ***!
+  \************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// ANALYZE A PLAN
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const valid_1 = __webpack_require__(/*! ./valid */ "./src/valid.ts");
+const equal_1 = __webpack_require__(/*! ./equal */ "./src/equal.ts");
+const compact_1 = __webpack_require__(/*! ./compact */ "./src/compact.ts");
+const cohesive_1 = __webpack_require__(/*! ./cohesive */ "./src/cohesive.ts");
+const political_1 = __webpack_require__(/*! ./political */ "./src/political.ts");
+const minority_1 = __webpack_require__(/*! ./minority */ "./src/minority.ts");
+// Compile district-level info for plan/map-level analytics
+function doAnalyzeDistricts(s, bLog = false) {
+    s.districts.recalcStatistics(bLog);
+    s.districts.extractDistrictShapeProperties(bLog);
+}
+exports.doAnalyzeDistricts = doAnalyzeDistricts;
+// TODO - I could make this table-driven, but I'm thinking that the explicit
+//   calls might make chunking for aync easier.
+// Calculate the analytics & validations and cache the results
+// NOTE - doAnalyzePlan() depends on doAnalyzeDistricts() having run first.
+function doAnalyzePlan(s, bLog = false) {
+    // Get the requested suites, and only execute those tests
+    let requestedSuites = s.config['suites'];
+    // Tests in the "Legal" suite, i.e., pass/ fail constraints
+    if (requestedSuites.includes(0 /* Legal */)) {
+        s.tests[0 /* Complete */] = valid_1.doIsComplete(s);
+        s.tests[1 /* Contiguous */] = valid_1.doIsContiguous(s);
+        s.tests[2 /* FreeOfHoles */] = valid_1.doIsFreeOfHoles(s);
+        s.tests[4 /* PopulationDeviation */] = equal_1.doPopulationDeviation(s);
+        // NOTE - I can't check whether a population deviation is legal or not, until
+        // the raw % is normalized. A zero (0) would mean "too much" / "not legal," for
+        // the given type of district (CD vs. LD). The EqualPopulation test is derived
+        // from PopulationDeviation, as part of scorecard or test log preparation.
+        // Create an empty test entry here though ...
+        s.tests[3 /* EqualPopulation */] = s.getTest(3 /* EqualPopulation */);
+    }
+    // Tests in the "Fair" suite
+    if (requestedSuites.includes(1 /* Fair */)) {
+        s.tests[9 /* SeatsBias */] = political_1.doSeatsBias(s);
+        s.tests[10 /* VotesBias */] = political_1.doVotesBias(s);
+        s.tests[11 /* Responsiveness */] = political_1.doResponsiveness(s);
+        s.tests[12 /* ResponsiveDistricts */] = political_1.doResponsiveDistricts(s);
+        s.tests[13 /* EfficiencyGap */] = political_1.doEfficiencyGap(s);
+        s.tests[14 /* MajorityMinorityDistricts */] = minority_1.doMajorityMinorityDistricts(s);
+    }
+    // Tests in the "Best" suite, i.e., criteria for better/worse
+    if (requestedSuites.includes(2 /* Best */)) {
+        s.tests[5 /* Reock */] = compact_1.doReock(s, bLog);
+        s.tests[6 /* PolsbyPopper */] = compact_1.doPolsbyPopper(s, bLog);
+        s.tests[7 /* CountySplits */] = cohesive_1.doCountySplits(s);
+        s.tests[8 /* Complexity */] = cohesive_1.doPlanComplexity(s);
+    }
+    // Enable a Test Log and Scorecard to be generated
+    s.bPlanAnalyzed = true;
+    s.bPostProcessingDone = false;
+}
+exports.doAnalyzePlan = doAnalyzePlan;
+// Derive secondary analytics that are based on primary tests.
+// This concept allows Population Deviation to be a primary numeric test and
+// Equal Population to be secondary pass/fail validation.
+//
+// NOTE - Should this be conditionalized on the test suites requested? 
+//   Those are encapsulated in reports.ts right now, so not doing that.
+function doDeriveSecondaryTests(s) {
+    s.tests[3 /* EqualPopulation */] = equal_1.doHasEqualPopulations(s);
+}
+exports.doDeriveSecondaryTests = doDeriveSecondaryTests;
+
+
+/***/ }),
+
+/***/ "./src/cohesive.ts":
+/*!*************************!*\
+  !*** ./src/cohesive.ts ***!
+  \*************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// "COHESIVE" - We're naming this category which is about county splitting.
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const U = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const D = __webpack_require__(/*! ./_data */ "./src/_data.ts");
+function doCountySplits(s) {
+    let test = s.getTest(7 /* CountySplits */);
+    // THE THREE VALUES TO DETERMINE FOR A PLAN
+    let unexpectedSplits = 0;
+    let unexpectedAffected = 0;
+    let countiesSplitUnexpectedly = [];
+    // FIRST, ANALYZE THE COUNTY SPLITING FOR THE PLAN
+    // Pivot census totals into county-district "splits"
+    let countiesByDistrict = s.districts.statistics[D.DistrictField.CountySplits];
+    // countiesByDistrict = countiesByDistrict.slice(1, -1);
+    // Find the single-county districts, i.e., districts NOT split across counties.
+    // Ignore the dummy unassigned 0 and N+1 summary "districts."
+    let singleCountyDistricts = [];
+    for (let d = 1; d <= s.state.nDistricts; d++) {
+        // See if there's only one county partition
+        let nCountiesInDistrict = 0;
+        for (let c = 0; c < s.counties.nCounties; c++) {
+            if (countiesByDistrict[d][c] > 0) {
+                nCountiesInDistrict += 1;
+                if (nCountiesInDistrict > 1) {
+                    break;
+                }
+            }
+        }
+        // If so, save the district
+        if (nCountiesInDistrict == 1) {
+            singleCountyDistricts.push(d);
+        }
+    }
+    // Process the splits/partitions in the plan:
+    // - Count the total # of partitions,
+    // - Find the counties split across districts, and
+    // - Accumulate the number people affected (except when single-county districts)
+    let nPartitionsOverall = 0;
+    let splitCounties = new Set(); // The counties that are split across districts
+    let totalAffected = 0; // The total population affected by those splits
+    for (let c = 0; c < s.counties.nCounties; c++) {
+        let nCountyParts = 0;
+        let subtotal = 0;
+        for (let d = 1; d <= s.state.nDistricts; d++) {
+            if (countiesByDistrict[d][c] > 0) {
+                nPartitionsOverall += 1;
+                nCountyParts += 1;
+                if (!(U.arrayContains(singleCountyDistricts, d))) {
+                    subtotal += countiesByDistrict[d][c];
+                }
+            }
+        }
+        if (nCountyParts > 1) {
+            splitCounties.add(c);
+            totalAffected += subtotal;
+        }
+    }
+    // Convert county ordinals to FIPS codes
+    let splitCountiesFIPS = U.getSelectObjectKeys(s.counties.index, [...splitCounties]);
+    // THEN TAKE ACCOUNT OF THE COUNTY SPLITTING THAT IS EXPECTED (REQUIRED)
+    // Compute the total number of splits this way, in case any counties are split
+    // more than once. I.e., it's not just len(all_counties_split).
+    let nSplits = nPartitionsOverall - s.counties.nCounties;
+    // Determine the number of *unexpected* splits. NOTE: Prevent negative numbers,
+    // in case you have a plan the *doesn't* split counties that would have to be
+    // split due to their size.
+    unexpectedSplits = Math.max(0, nSplits - s.state.expectedSplits);
+    // Subtract off the total population that *has* to be affected by splits,
+    // because their counties are too big. NOTE: Again, prevent negative numbers, 
+    // in case you have a plan the *doesn't* split counties that would have to be
+    // split due to their size.
+    unexpectedAffected = U.trim(Math.max(0, totalAffected - s.state.expectedAffected) / s.state.totalPop);
+    // Find the counties that are split *unexpectedly*. From all the counties that
+    // are split, remove those that *have* to be split, because they are bigger than
+    // a district.
+    let countiesSplitUnexpectedlyFIPS = [];
+    for (let fips of splitCountiesFIPS) {
+        if (!(U.arrayContains(s.state.tooBigFIPS, fips))) {
+            countiesSplitUnexpectedlyFIPS.push(fips);
+        }
+    }
+    //  ... and convert the FIPS codes to county names.
+    for (let fips of countiesSplitUnexpectedlyFIPS) {
+        countiesSplitUnexpectedly.push(s.counties.nameFromFIPS(fips));
+    }
+    countiesSplitUnexpectedly = countiesSplitUnexpectedly.sort();
+    // Cache the results in the test
+    test['score'] = unexpectedAffected; // TODO - Use Moon's complexity metric here
+    test['details'] = {
+        'unexpectedSplits': unexpectedSplits,
+        'unexpectedAffected': unexpectedAffected,
+        'countiesSplitUnexpectedly': countiesSplitUnexpectedly
+    };
+    return test;
+}
+exports.doCountySplits = doCountySplits;
+// 2 - THE COMPLEXITY ANALYTIC NEEDS THE FOLLOWING DATA:
+//
+// If a map is already in simplified (mixed) form, the complexity analytic needs
+// two pieces of data:
+// - The counts of features by summary level--i.e., the numbers of counties, tracts,
+//   block groups, and blocks in a state; and
+// - The map -- So it can count the features by summary level in the map,
+//   as well as the number of BG’s that are split.
+//
+// TODO - Where would the state counts come from? Preprocessed and passed in, or
+//   done in a one-time initialization call (which would require a full set of
+//   block geo_id's for the state).
+//
+// However, if a map is not yet (fully) simplified, then determining the
+//   complexity of a map also requires a preprocessed summary level hierarchy, so
+//   you can get the child features (e.g., tracts) of a parent feature (e.g.,
+//   a county).
+//
+// NOTE - I have script for producing this hierarchy which we could repurpose.
+//
+// TODO - For mixed map processing--specfically to find the neighbors of a feature
+//   that are actually in the map (as opposed to just neighbors at the same
+//   summary level in the static graph)--you need a special hierarchy that
+//   distinguishes between the 'interior' and 'edge children of a feature.
+//
+// NOTE - The script noted above does this.
+function doPlanComplexity(s) {
+    let test = s.getTest(8 /* Complexity */);
+    console.log("TODO - Calculating plan complexity ...");
+    return test;
+}
+exports.doPlanComplexity = doPlanComplexity;
+
+
+/***/ }),
+
+/***/ "./src/compact.ts":
+/*!************************!*\
+  !*** ./src/compact.ts ***!
+  \************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// COMPACT
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const geofeature_1 = __webpack_require__(/*! ./geofeature */ "./src/geofeature.ts");
+const U = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+// Measures of compactness compare district shapes to various ideally compact
+// benchmarks, such as circles. All else equal, more compact districts are better.
+// 
+// There are four popular measures of compactness. They either focus on how
+// dispersed or how indented a shapes are.
+//
+// These first two measures are the most important:
+// 
+// Reock is the primary measure of the dispersion of district shapes, calculated
+// as “the area of the district to the area of the minimum spanning circle that
+// can enclose the district.”
+//
+//    R = A / A(Minimum Bounding Circle)
+//    R = A / (π * (D / 2)^2)
+//
+//    R = 4A / πD^2
+//
+// where A is the area of the district and D is the diameter of the minimum
+// bounding circle.
+//
+// Polsby-Popper is the primary measure of the indendentation of district shapes,
+// calculated as the “the ratio of the area of the district to the area of a circle
+// whose circumference is equal to the perimeter of the district.”
+//
+//    PP = A / A(C)
+//
+// where C is that circle. In other words:
+//
+//    P = 2πRc and A(C) = π(P / 2π)^2
+//
+// where P is the perimeter of the district and Rc is the radius of the circle.
+//
+// Hence, the measure simplifies to:
+//
+//    PP = 4π * (A / P^2)
+// 
+// I propose that we use these two, normalize them, and weight equally to determine
+// our compactness value.
+// 
+// These second two measures may be used to complement the primary ones above:
+// 
+// Convex Hull is a secondary measure of the dispersion of district shapes, calculated
+// as “the ratio of the district area to the area of the minimum convex bounding
+// polygon (also known as a convex hull) enclosing the district.”
+//
+//    CH = A / A(Convex Hull)
+// 
+// where a convex hull is the minimum perimeter that encloses all points in a shape,
+// basically the shortest unstretched rubber band that fits around the shape.
+//
+// Schwartzberg is a secondary measure of the degree of indentation of district
+// shapes, calculated as “the ratio of the perimeter of the district to the circumference
+// of a circle whose area is equal to the area of the district.”
+//
+//    S = 1 / (P / C)
+//
+// where P is the perimeter of the district and C is the circumference of the circle.
+// The radius of the circle is:
+//
+//    Rc = SQRT(A / π)
+//
+// So, the circumference of the circle is:
+//
+//    C = 2πRc or C = 2π * SQRT(A / π)
+//
+// Hence:
+//
+//    S = 1 (P / 2π * SQRT(A / π))
+//
+//    S = (2π * SQRT(A / π)) / P
+//
+// All these measures produce values between 0 and 1, with 0 being the least compact
+// and 1 being the most compact. Sometimes these values are multiplied by 100 to
+// give values between 0 and 100.
+// 
+// For each measure, the compactness of a set of Congressional districts is the
+// average of that measure for all the districts.
+//
+// Calculate Reock compactness:
+// reock = (4 * a) / (math.pi * d**2)
+// NOTE - Depends on extractDistrictProperties running first
+function doReock(s, bLog = false) {
+    let test = s.getTest(5 /* Reock */);
+    // Calculate Reock scores by district
+    let scores = [];
+    for (let districtID = 1; districtID <= s.state.nDistricts; districtID++) {
+        let districtProps = s.districts.getGeoProperties(districtID);
+        let a = districtProps[0 /* Area */];
+        let d = districtProps[1 /* Diameter */];
+        let reock = (4 * a) / (Math.PI * Math.pow(d, 2));
+        // Save each district score
+        scores.push(reock);
+        // Echo the results by district
+        if (bLog)
+            console.log("Reock for district", districtID, "=", reock);
+    }
+    // Populate the test entry
+    let averageReock = U.avgArray(scores);
+    test['score'] = U.trim(averageReock);
+    test['details'] = {}; // TODO - Any details?
+    return test;
+}
+exports.doReock = doReock;
+// Calculate Polsby-Popper compactness measures:
+// polsby_popper = (4 * math.pi) * (a / p**2)
+// NOTE - Depends on extractDistrictProperties running first
+function doPolsbyPopper(s, bLog = false) {
+    let test = s.getTest(6 /* PolsbyPopper */);
+    // Calculate Polsby-Popper scores by district
+    let scores = [];
+    for (let districtID = 1; districtID <= s.state.nDistricts; districtID++) {
+        let districtProps = s.districts.getGeoProperties(districtID);
+        let a = districtProps[0 /* Area */];
+        let p = districtProps[2 /* Perimeter */];
+        let polsbyPopper = (4 * Math.PI) * (a / Math.pow(p, 2));
+        // Save each district score
+        scores.push(polsbyPopper);
+        // Echo the results by district
+        if (bLog)
+            console.log("Polsby-Popper for district", districtID, "=", polsbyPopper);
+    }
+    // Populate the test entry
+    let averagePolsbyPopper = U.avgArray(scores);
+    test['score'] = U.trim(averagePolsbyPopper);
+    test['details'] = {}; // TODO - Any details?
+    return test;
+}
+exports.doPolsbyPopper = doPolsbyPopper;
+// HELPER TO EXTRACT PROPERTIES OF DISTRICT SHAPES
+function extractDistrictProperties(s, bLog = false) {
+    for (let i = 1; i <= s.state.nDistricts; i++) {
+        let j = i - 1; // TODO - Terry: How do you get away w/o this?!?
+        let poly = s.districts.getShape(j);
+        // TODO - Bundle these calls?
+        let area = geofeature_1.gfArea(poly);
+        let perimeter = geofeature_1.gfPerimeter(poly);
+        let diameter = geofeature_1.gfDiameter(poly);
+        let props = [0, 0, 0]; // TODO - Terry?!?
+        props[0 /* Area */] = area;
+        props[1 /* Diameter */] = diameter;
+        props[2 /* Perimeter */] = perimeter;
+        s.districts.setGeoProperties(i, props);
+        if (bLog)
+            console.log("District", i, "A =", area, "P =", perimeter, "D =", diameter);
+    }
+}
+exports.extractDistrictProperties = extractDistrictProperties;
+// SAVE THESE NOTES, IN CASE WE NEED TO REWORK HOW WE PERFORM THESE CALCS.
+// THEY REFLECT HOW I DID THEM IN PYTHON.
+//
+// THE COMPACTNESS ANALYTICS NEED THE FOLLOWING DATA,
+// IN ADDITION TO THE MAP (IDEALLY, GEO_IDS INDEXED BY DISTRICT_ID)
+//
+// Shapes by geo_id
+//
+// If we need/want to speed compactness calculations up, we'll need
+//   to calculate the perimeters and diameters (and areas) of districts implicitly,
+//   which will require identifying district boundaries initially and updating
+//   them incrementally as districts are (re)assigned.
+//
+//   A district's boundary info is the set/list of features that constitute the
+//   district's border along with each boundary feature's neighbors. Hence, this
+//   requires a contiguity graph with the lengths of shared edges between features
+//   precomputed.
+//
+// NOTE - I can write up (if not implement) the logic for determining what shapes
+//   constitute a district's boundary. There are a few nuances.
+//
+//   If we have to optimize like this when we generalize to mixed maps, the
+//   determination of "neighbors in the map" and the length of shared borders
+//   (for determining a district perimeters) becomes more complicated and dynamic.
+//
+// NOTE - Again, I can write up (if not implement) the logic for both of these.
+//   They are a bit tricky and require special preprocessing of the summary level
+//   hierarchy (which I also have a script for that we can repurpose).
+
+
+/***/ }),
+
+/***/ "./src/equal.ts":
+/*!**********************!*\
+  !*** ./src/equal.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// EQUAL POPULATION
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const U = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const D = __webpack_require__(/*! ./_data */ "./src/_data.ts");
+function doPopulationDeviation(s) {
+    let test = s.getTest(4 /* PopulationDeviation */);
+    // Compute the min, max, and average district populations,
+    // excluding the dummy 'unassigned' 0 and N+1 summary "districts."
+    let totPopByDistrict = s.districts.statistics[D.DistrictField.TotalPop];
+    totPopByDistrict = totPopByDistrict.slice(1, -1);
+    let min = U.minArray(totPopByDistrict);
+    let max = U.maxArray(totPopByDistrict);
+    let total = U.sumArray(totPopByDistrict);
+    // Calculate the raw population deviation.
+    // The target size is the average population.
+    let avg = total / s.state.nDistricts;
+    let popDev = (max - min) / avg;
+    // Round the raw value to the desired level of precision
+    popDev = U.trim(popDev);
+    // Populate the test entry
+    test['score'] = popDev;
+    test['details'] = { 'maxDeviation': max - min };
+    // Populate the N+1 summary "district" in district.statistics
+    let totalPop = s.districts.statistics[D.DistrictField.TotalPop];
+    let popDevPct = s.districts.statistics[D.DistrictField.PopDevPct];
+    let summaryRow = s.districts.numberOfRows() - 1;
+    totalPop[summaryRow] = avg; // aka "target size"
+    popDevPct[summaryRow] = popDev;
+    return test;
+}
+exports.doPopulationDeviation = doPopulationDeviation;
+// NOTE - This validity check is *derived* and depends on population deviation %
+//   being computed (above) and normalized in test log & scorecard generation.
+function doHasEqualPopulations(s) {
+    let test = s.getTest(3 /* EqualPopulation */);
+    // Get the normalized population deviation %
+    let popDevTest = s.getTest(4 /* PopulationDeviation */);
+    let popDevPct = popDevTest['score'];
+    let popDevNormalized = popDevTest['normalizedScore'];
+    // Populate the test entry
+    if (popDevNormalized > 0) {
+        test['score'] = true;
+    }
+    else {
+        test['score'] = false;
+    }
+    test['details']['deviation'] = popDevPct;
+    test['details']['thresholds'] = popDevTest['details']['scale'];
+    // Populate the N+1 summary "district" in district.statistics
+    let bEqualPop = s.districts.statistics[D.DistrictField.bEqualPop];
+    let summaryRow = s.districts.numberOfRows() - 1;
+    bEqualPop[summaryRow] = test['score'];
+    return test;
+}
+exports.doHasEqualPopulations = doHasEqualPopulations;
+
+
+/***/ }),
+
+/***/ "./src/geofeature.ts":
+/*!***************************!*\
+  !*** ./src/geofeature.ts ***!
+  \***************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// GEO-FEATURES UTILITIES
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const Poly = __webpack_require__(/*! @dra2020/poly */ "@dra2020/poly");
+// CARTESIAN SHIMS OVER 'POLY' FUNCTIONS
+// TODO - Terry: Confirm Cartesian calculations
+function gfArea(poly) {
+    let area = _polygonArea(poly);
+    // let polyOptions = { noLatitudeCorrection: false }    DELETE
+    // let area: number = Poly.polyArea(poly, polyOptions);
+    return area;
+}
+exports.gfArea = gfArea;
+// Algorithm for the area of a simple/single planar polygon:
+// https://algorithmtutor.com/Computational-Geometry/Area-of-a-polygon-given-a-set-of-points/
+// https://mathopenref.com/coordpolygonarea2.html
+//
+// function polygonArea(X, Y, numPoints) 
+// { 
+//   area = 0;         // Accumulates area in the loop
+//   j = numPoints-1;  // The last vertex is the 'previous' one to the first
+//   for (i=0; i<numPoints; i++)
+//     { area = area +  (X[j]+X[i]) * (Y[j]-Y[i]); 
+//       j = i;  //j is previous vertex to i
+//     }
+//   return area/2;
+// }
+// Reimplemented to use polygons vs. X & Y vectors
+function _polygonSimpleArea(p) {
+    let area = 0; // Accumulates area in the loop
+    let n = p.length;
+    let j = n - 1; // The last vertex is the 'previous' one to the first
+    for (let i = 0; i < n; i++) {
+        area = area + (p[j][0] + p[i][0]) * (p[j][1] - p[i][1]);
+        // area = area + (X[j] + X[i]) * (Y[j] - Y[i]);
+        j = i; // j is previous vertex to i
+    }
+    return Math.abs(area / 2);
+}
+// Generalizes the above for MultiPolygons -- cloned from polyArea() in 'poly'
+function _polygonArea(poly) {
+    let polyOptions = { noLatitudeCorrection: true }; // NO-OP?
+    poly = Poly.polyNormalize(poly, polyOptions); // TODO - Discuss w/ Terry
+    let a = 0;
+    // A MultiPolygon is a set of polygons
+    for (let i = 0; poly && i < poly.length; i++) {
+        // A single polygon is an exterior ring with interior holes. Holes are subtracted.
+        let p = poly[i];
+        for (let j = 0; j < p.length; j++) {
+            let sp = p[j];
+            a += _polygonSimpleArea(sp) * (j == 0 ? 1 : -1);
+        }
+    }
+    return a;
+}
+// TODO - Terry: Confirm Cartesian calculations
+// The perimeter calculation already just computes cartesian distance if you
+// pass in the noLatitudeCorrection flag. You would need to divide by 
+// Poly.EARTH_RADIUS to go from the returned units of meters to Lat/Lon “units”.
+function gfPerimeter(poly) {
+    let perimeter = _polygonPerimeter(poly);
+    // let polyOptions = { noLatitudeCorrection: true }  // Cartesian distance
+    // let perimeter: number = Poly.polyPerimeter(poly, polyOptions);  DELETE
+    return perimeter;
+    // return perimeter / Poly.EARTH_RADIUS;  DELETE
+}
+exports.gfPerimeter = gfPerimeter;
+// TODO - Terry: Confirm Cartesian calculations
+// Cloned from polyPerimeter() in 'poly' and revised to use Cartesian distance
+// NOTE: No conversion of degrees to radians!
+function _polygonPerimeter(poly) {
+    let polyOptions = { noLatitudeCorrection: true }; // Cartesian distance
+    poly = Poly.polyNormalize(poly, polyOptions);
+    let perimeter = 0;
+    for (let i = 0; poly && i < poly.length; i++) {
+        // Ignore holes so only look at first polyline
+        let p = poly[i][0];
+        for (let j = 0; j < p.length - 1; j++)
+            perimeter += _distance(p[j][0], p[j][1], p[j + 1][0], p[j + 1][1]);
+        // perimeter += haversine(p[j][0], p[j][1], p[j + 1][0], p[j + 1][1], options);  DELETE
+        if (p.length > 2 && (p[0][0] != p[p.length - 1][0] || p[0][1] != p[p.length - 1][1]))
+            perimeter += _distance(p[0][0], p[0][1], p[p.length - 1][0], p[p.length - 1][1]);
+        // perimeter += haversine(p[0][0], p[0][1], p[p.length - 1][0], p[p.length - 1][1], options);  DELETE
+    }
+    return perimeter;
+}
+function _distance(x1, y1, x2, y2) {
+    let dLat = y2 - y1;
+    let dLon = x2 - x1;
+    let d;
+    d = Math.sqrt((dLat * dLat) + (dLon * dLon));
+    return d;
+}
+// TODO - Terry: Confirm Cartesian calculations
+// As I mentioned, the polyCircle code was already just treating the coordinate
+// system as Cartesian. I then did polyFromCircle to convert it to a polygon that
+// then could be passed to polyArea in order to take into account the projection.
+// If instead, you compute area directly from the circle as PI R squared, then
+// you should have your cartesian circular area.
+function gfDiameter(poly) {
+    let polyOptions = { noLatitudeCorrection: true }; // NO-OP
+    let circle = Poly.polyToCircle(poly, polyOptions);
+    // let circleArea: number = Poly.polyArea(Poly.polyFromCircle(circle, undefined, polyOptions), polyOptions);
+    // let circleRadius: number = Math.sqrt(circleArea / Math.PI);
+    // let diameter: number = circleRadius * 2;  DELETE
+    let diameter = circle.r * 2;
+    return diameter;
+}
+exports.gfDiameter = gfDiameter;
+
+
+/***/ }),
+
+/***/ "./src/index.ts":
+/*!**********************!*\
+  !*** ./src/index.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// THE DISTRICT-ANALYTICS NODE PACKAGE API
+//
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./_api */ "./src/_api.ts"));
+__export(__webpack_require__(/*! ./types */ "./src/types.ts"));
+
+
+/***/ }),
+
+/***/ "./src/minority.ts":
+/*!*************************!*\
+  !*** ./src/minority.ts ***!
+  \*************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// PROTECTS MINORITIES
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+// TODO - This definition is wrong. Need to fix it.
+//
+// MINORITY-PROTECTION ANALYTICS NEED THE FOLLOWING DATA:
+//
+// The TOTAL, WHITE, BLACK, and HISPANIC counts from the Census, aggregated by
+// district. We *might* also ultimately need TOTAL18, WHITE18, BLACK18, and
+// HISPANIC18 counts by feature for these analytics.
+//
+// The minority population of a feature will probably be calculated as everyone
+// exceot non-Hispanic Whites:
+//
+// MINORITY = TOTAL - (WHITE - HISPANIC)
+//
+// That could be calculated as part of preprocessing the Census data, or it
+// could be computed on the fly. Since it's derived data and the formula might
+// change, it's probably best to compute it on the fly.
+//
+// In addition to the Census extract, these analytics need:
+// - The # of districts in the map, for determining minority proportionality
+// - Minorities as a % of the total population; possibly the voting age share
+//
+// TODO - Is the # of districts passed as a parameter or inferred from the # in
+//   the map?
+// TODO - Is minority share preprocessed once and passed as a parameter or
+//   computed in a initialization routine?
+function doMajorityMinorityDistricts(s) {
+    let test = s.getTest(14 /* MajorityMinorityDistricts */);
+    console.log("TODO - Calculating # of majority-minority districts ...");
+    return test;
+}
+exports.doMajorityMinorityDistricts = doMajorityMinorityDistricts;
+// SAVE THESE NOTES, IN CASE WE NEED TO REWORK HOW WE DO PERFORM THESE CALCS.
+// THEY REFLECT HOW I/ALEC DID THESE IN PYTHON.
+//
+// MINORITY-PROTECTION ANALYTICS WILL NEED THE FOLLOWING DATA,
+// IN ADDITION TO THE MAP (IDEALLY, GEO_IDS INDEXED BY DISTRICT_ID)
+//
+// Census data by geo_id - { total population | white | black | hispanic }
+//
+// The minority population of a feature will probably be calculated as the # of
+// non-White Hispanics:
+//
+// MINORITY = TOTAL - (WHITE - HISPANIC)
+//
+// That could be calculated as part of preprocessing the Census data, or it
+// could be computed on the fly.
+//
+// And probably:
+// 'districts' - The # of districts for determining minority proportionality.
+// 'minority_share' - Minorities as a % of the total population
+//
+// TODO - Is the # of districts passed as a parameter or inferred from the # in
+//   the map?
+// TODO - Is minority share preprocessed once and passed as a parameter or
+//   computed in a initialization routine?
+
+
+/***/ }),
+
+/***/ "./src/political.ts":
+/*!**************************!*\
+  !*** ./src/political.ts ***!
+  \**************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// FAIR/PROPORTIONAL
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __webpack_require__(/*! assert */ "assert");
+const U = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const D = __webpack_require__(/*! ./_data */ "./src/_data.ts");
+// Partisan analytics need the following data:
+//
+// An "election model" by geo_id, where each item has 4 pieces of data:
+//
+//   { geo_id, Democratic votes, Republican votes, Total votes }
+//
+// NOTE: D + R <= Total, because there could be third-party or write-in votes.
+//
+// An election model can simply represent one election, e.g., President 2012,
+// or combine multiple elections in some fashion. An election model is used to
+// computer a single index of the likely partisan weight / lean / preference
+// for the districts in a plan. An election model and the associated index go
+// hand in hand. So much so that the index frequently stands in as the name for
+// both, e.g., Cook's PVI is one example, Nagle's 7s, Hofeller's Formula, NDRC's
+// DPI.
+//
+// I'm labelling this general concept a "Voter Preference Index (VPI)," a
+// conscious +1 letter play on Cook's "PVI" acronymn.
+// MEASURING BIAS & RESPONSIVENESS (NAGLE'S METHOD)
+function doSeatsBias(s) {
+    let test = s.getTest(9 /* SeatsBias */);
+    console.log("TODO - Calculating seats bias ...");
+    return test;
+}
+exports.doSeatsBias = doSeatsBias;
+function doVotesBias(s) {
+    let test = s.getTest(10 /* VotesBias */);
+    console.log("TODO - Calculating votes bias ...");
+    return test;
+}
+exports.doVotesBias = doVotesBias;
+function doResponsiveness(s) {
+    let test = s.getTest(11 /* Responsiveness */);
+    console.log("TODO - Calculating responsiveness ...");
+    return test;
+}
+exports.doResponsiveness = doResponsiveness;
+function doResponsiveDistricts(s) {
+    let test = s.getTest(12 /* ResponsiveDistricts */);
+    console.log("TODO - Calculating # of responsive districts ...");
+    return test;
+}
+exports.doResponsiveDistricts = doResponsiveDistricts;
+// OTHER MEASURES OF PARTISAN BIAS
+// TODO - This formula might need to be inverted for D vs. R +/-
+// TODO - Normalize the results.
+function doEfficiencyGap(s) {
+    console.log("TODO - Calculating the efficiency gap ...");
+    let test = s.getTest(13 /* EfficiencyGap */);
+    // Get partisan statistics by districts.
+    // Use Democratic votes, seats, and shares by convention.
+    let DVotes = s.districts.statistics[D.DistrictField.DemVotes];
+    let DSeats = s.districts.statistics[D.DistrictField.DemSeat];
+    let TPVotes = s.districts.statistics[D.DistrictField.TwoPartyVote];
+    // Exclude the dummy unassigned '0' and N+1 summary "districts"
+    DVotes = DVotes.slice(1, -1);
+    DSeats = DSeats.slice(1, -1);
+    TPVotes = TPVotes.slice(1, -1);
+    // Calculate D vote share & D seat share
+    let DVoteShare = U.sumArray(DVotes) / U.sumArray(TPVotes);
+    let DSeatShare = U.sumArray(DSeats) / s.state.nDistricts;
+    // Finally, calculate the Efficiency Gap
+    let efficiencyGap = (DSeatShare - 0.5) - (2.0 * (DVoteShare - 0.5));
+    // Round the raw value to the desired level of precision
+    efficiencyGap = U.trim(efficiencyGap);
+    // Populate the test entry
+    test['score'] = efficiencyGap;
+    // test['normalizedScore'] = 0;     /* TODO - Normalize the raw score */
+    test['details'] = {}; /* TODO - Add details, if any     */
+    return test;
+}
+exports.doEfficiencyGap = doEfficiencyGap;
+// HELPERS
+function fptpWin(demPct) {
+    // Vote shares should be fractions in the range [0.0 – 1.0]
+    assert_1.strict((demPct <= 1.0) && (demPct >= 0.));
+    return ((demPct > 0.5) ? 1 : 0);
+}
+exports.fptpWin = fptpWin;
+
+
+/***/ }),
+
+/***/ "./src/preprocess.ts":
+/*!***************************!*\
+  !*** ./src/preprocess.ts ***!
+  \***************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// PREPROCESS DATA
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const U = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+// NOTE - Do preprocessing separately, so the constructor returns quickly.
+function doPreprocessData(s) {
+    // If necessary, do one-time preprocessing
+    if (!s.bOneTimeProcessingDone) {
+        doPreprocessCountyFeatures(s);
+        doPreprocessCensus(s);
+        doPreprocessElection(s);
+        s.bOneTimeProcessingDone = true;
+    }
+    // Invert the plan by district ID
+    s.plan.invertPlan();
+    // Create a map of geoIDs to feature IDs
+    s.features.mapGeoIDsToFeatureIDs();
+}
+exports.doPreprocessData = doPreprocessData;
+// CREATE A FIPS CODE TO COUNTY NAME LOOKUP
+function doPreprocessCountyFeatures(s) {
+    for (let i = 0; i < s.counties.nCounties; i++) {
+        let county = s.counties.countyByIndex(i);
+        let fips = s.counties.propertyForCounty(county, 'COUNTYFP');
+        let name = s.counties.propertyForCounty(county, 'NAME');
+        s.counties.mapFIPSToName(fips, name);
+    }
+}
+// ANALYZE THE CENSUS BY COUNTY
+function doPreprocessCensus(s) {
+    // The county-splitting analytic needs the following info, using NC as an example:
+    // '_stateTotal' = The total state population, e.g., 9,535,483 for NC's 2010 Census
+    // 'totalByCounty' = The total population by county FIPS code
+    let totalByCounty = {};
+    // NOTE - This works w/o GEOIDs, because you're looping over all features.
+    for (let i = 0; i < s.features.nFeatures(); i++) {
+        let f = s.features.featureByIndex(i);
+        let geoID = s.features.geoIDForFeature(f);
+        let value = s.features.fieldForFeature(f, "CENSUS" /* CENSUS */, "Tot" /* TotalPop */);
+        // Sum total population across the state
+        s.state.totalPop += value;
+        // Get the county FIPS code for the feature
+        let county = U.parseGeoID(geoID)['county'];
+        let countyFIPS = U.getFIPSFromCountyGeoID(county);
+        // If a subtotal for the county doesn't exist, initialize one
+        if (!(U.keyExists(countyFIPS, totalByCounty))) {
+            totalByCounty[countyFIPS] = 0;
+        }
+        // Sum total population by county
+        totalByCounty[countyFIPS] += value;
+    }
+    // NOTE - The above could be replaced, if I got totals on county.geojson.
+    // 'target_size': 733499, # calc as total / districts
+    let targetSize = Math.round(s.state.totalPop / s.state.nDistricts);
+    // Find counties that are bigger than the target district size.
+    // 'too_big' = The counties that are bigger than a district, e.g., ['Mecklenburg', 'Wake']
+    // 'too_big_fips' = Their FIPS codes, e.g., ['119', '183']
+    // 'expected_splits' = The # of counties that are bigger than a single district, e.g., 2
+    // 'expected_affected' = The # of people whose district must be split, e.g., 353,623
+    let tooBigFIPS = [];
+    let tooBigName = [];
+    let expectedSplits = 0;
+    let expectedAffected = 0;
+    // Create a FIPS code-ordinal map
+    // Get the county FIPS codes
+    let fipsCodes = U.getObjectKeys(totalByCounty);
+    // Sort the results
+    fipsCodes = fipsCodes.sort();
+    // Create the ID-ordinal map
+    for (let i in fipsCodes) {
+        s.counties.index[fipsCodes[i]] = Number(i);
+    }
+    // Loop over the counties
+    for (let county in fipsCodes) {
+        let fipsCode = fipsCodes[county];
+        let countyAffected = 0;
+        // Find the number of required splits, assuming target district size.
+        let rawQuotient = totalByCounty[fipsCode] / (targetSize + 1);
+        let remainder = rawQuotient % 1;
+        let quotient = rawQuotient - remainder;
+        let countySplits = quotient;
+        if (countySplits > 0) {
+            countyAffected = totalByCounty[fipsCode] % targetSize;
+            tooBigFIPS.push(fipsCode);
+            tooBigName.push(s.counties.nameFromFIPS(fipsCode));
+        }
+        expectedSplits += countySplits;
+        expectedAffected += countyAffected;
+    }
+    s.state.tooBigFIPS = tooBigFIPS;
+    s.state.tooBigName = tooBigName;
+    s.state.expectedSplits = expectedSplits;
+    s.state.expectedAffected = expectedAffected;
+}
+// PREPROCESS ELECTION RESULTS
+function doPreprocessElection(s) {
+    console.log("TODO - Preprocessing election data ...");
+}
+
+
+/***/ }),
+
+/***/ "./src/report.ts":
+/*!***********************!*\
+  !*** ./src/report.ts ***!
+  \***********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// GENERATE REPORTS
+// - A test log: a simple enumeration of all analytics & validations w/ raw results
+// - A scorecard: a structured subset of analytics & validations w/ normalized
+//   results, cateories, and an overall score
+// 
+Object.defineProperty(exports, "__esModule", { value: true });
+const U = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const S = __webpack_require__(/*! ./settings */ "./src/settings.ts");
+const D = __webpack_require__(/*! ./_data */ "./src/_data.ts");
+const analyze_1 = __webpack_require__(/*! ./analyze */ "./src/analyze.ts");
+// TEST META-DATA
+var TestType;
+(function (TestType) {
+    TestType[TestType["PassFail"] = 0] = "PassFail";
+    TestType[TestType["Percentage"] = 1] = "Percentage";
+    TestType[TestType["Number"] = 2] = "Number";
+})(TestType || (TestType = {}));
+const completeDefn = {
+    ID: 0 /* Complete */,
+    name: "Complete",
+    normalize: false,
+    externalType: TestType.PassFail,
+    detailsFn: doPrepareCompleteDetails,
+    suites: [0 /* Legal */]
+};
+const contiguousDefn = {
+    ID: 1 /* Contiguous */,
+    name: "Contiguous",
+    normalize: false,
+    externalType: TestType.PassFail,
+    detailsFn: doPrepareContiguousDetails,
+    suites: [0 /* Legal */]
+};
+const freeOfHolesDefn = {
+    ID: 2 /* FreeOfHoles */,
+    name: "Free of Holes",
+    normalize: false,
+    externalType: TestType.PassFail,
+    detailsFn: doPrepareFreeOfHolesDetails,
+    suites: [0 /* Legal */]
+};
+const equalPopulationDefn = {
+    ID: 3 /* EqualPopulation */,
+    name: "Equal Population",
+    normalize: false,
+    externalType: TestType.PassFail,
+    detailsFn: doPrepareEqualPopulationDetails,
+    suites: [0 /* Legal */]
+};
+const populationDeviationDefn = {
+    ID: 4 /* PopulationDeviation */,
+    name: "Population Deviation",
+    normalize: true,
+    externalType: TestType.Percentage,
+    detailsFn: doPreparePopulationDeviationDetails,
+    suites: [0 /* Legal */, 2 /* Best */] // Both so EqualPopulation can be assessed
+};
+const reockDefn = {
+    ID: 5 /* Reock */,
+    name: "Reock",
+    normalize: true,
+    externalType: TestType.Number,
+    detailsFn: doPrepareReockDetails,
+    suites: [2 /* Best */]
+};
+const polsbyPopperDefn = {
+    ID: 6 /* PolsbyPopper */,
+    name: "Polsby-Popper",
+    normalize: true,
+    externalType: TestType.Number,
+    detailsFn: doPreparePolsbyPopperDetails,
+    suites: [2 /* Best */]
+};
+const countySplitsDefn = {
+    ID: 7 /* CountySplits */,
+    name: "County splits",
+    trailer: "of the population had their county split unexpectedly.",
+    normalize: true,
+    externalType: TestType.Percentage,
+    detailsFn: doPrepareCountySplitDetails,
+    suites: [2 /* Best */]
+};
+const efficiencyGapDefn = {
+    ID: 13 /* EfficiencyGap */,
+    name: "Efficiency Gap",
+    normalize: false,
+    externalType: TestType.Percentage,
+    detailsFn: doPrepareEfficiencyGapDetails,
+    suites: [1 /* Fair */]
+};
+// All the tests that have been defined (can be reported on)
+const testDefns = {
+    [0 /* Complete */]: completeDefn,
+    [1 /* Contiguous */]: contiguousDefn,
+    [2 /* FreeOfHoles */]: freeOfHolesDefn,
+    [3 /* EqualPopulation */]: equalPopulationDefn,
+    [4 /* PopulationDeviation */]: populationDeviationDefn,
+    [5 /* Reock */]: reockDefn,
+    [6 /* PolsbyPopper */]: polsbyPopperDefn,
+    [7 /* CountySplits */]: countySplitsDefn,
+    [13 /* EfficiencyGap */]: efficiencyGapDefn
+    /* TODO - More tests ... */
+};
+// Scorecard category definitions
+const validCategory = {
+    catName: "Valid",
+    catTests: [
+        { testID: 0 /* Complete */ },
+        { testID: 1 /* Contiguous */ },
+        { testID: 2 /* FreeOfHoles */ },
+        { testID: 3 /* EqualPopulation */ }
+    ],
+    catNumeric: false,
+    catWeight: undefined,
+    catPrepareFn: doPrepareValidSection
+};
+const fairCategory = {
+    catName: "Fair",
+    catTests: [
+        {
+            testID: 13 /* EfficiencyGap */,
+            testWeight: 100
+        }
+    ],
+    catNumeric: true,
+    catWeight: undefined,
+    catPrepareFn: doPrepareFairSection
+};
+// TODO - Decide on the relative weights of these tests!
+// NOTE: 'testWeights' are simply relative, i.e., each normalized score is
+//   multiplied by the associated 'testWeight', and the sum of those is divided
+//   by the total weight. Weights don't have to add to 100.
+const bestCategory = {
+    catName: "Best",
+    catTests: [
+        {
+            testID: 4 /* PopulationDeviation */,
+            testWeight: 10
+        },
+        {
+            testID: 5 /* Reock */,
+            testWeight: 25
+        },
+        {
+            testID: 6 /* PolsbyPopper */,
+            testWeight: 25
+        },
+        {
+            testID: 7 /* CountySplits */,
+            testWeight: 50
+        }
+    ],
+    catNumeric: true,
+    catWeight: undefined,
+    catPrepareFn: doPrepareBestSection
+};
+// The overall scorecard definition
+const scorecardDefn = {
+    [0 /* Legal */]: validCategory,
+    // TODO - NIY
+    // [T.Suite.Fair]: fairCategory,
+    [2 /* Best */]: bestCategory
+};
+// NORMALIZE RAW ANALYTICS
+//   Raw numeric analytics, such as population deviation, compactness, etc. are
+//   normalized as part of creating a scorecard, so the code to normalize results
+//   is encapsulated here.
+// Configure scale parameters for normalizing each raw test result
+//   This needs to be separate from the scorecard configuration info above,
+//   because some scales need access to the analytics session object.
+function doConfigureScales(s) {
+    // Scale defn for PopulationDeviation
+    const CDLimit = 0.75 / 100; // Deviation threshold for CD's
+    const LDLimit = 10.00 / 100; // Deviation threshold for LD's
+    const CDGoodEnough = 0.20 / 100;
+    const LDGoodEnough = (CDGoodEnough / CDLimit) * LDLimit;
+    const scale = (s.legislativeDistricts) ? [1.0 - LDLimit, 1.0 - LDGoodEnough] : [1.0 - CDLimit, 1.0 - CDGoodEnough];
+    // const scale = [1.0 - CDLimit, 1.0 - CDGoodEnough];
+    s.testScales[4 /* PopulationDeviation */] = { testScale: scale, testInvertp: true };
+    s.testScales[5 /* Reock */] = { testScale: [0.25, 0.50], testInvertp: false };
+    s.testScales[6 /* PolsbyPopper */] = { testScale: [0.10, 0.50], testInvertp: false };
+    const SPLITLimit = 0.1; // TODO - Just a placeholder default maximum (10%)
+    s.testScales[7 /* CountySplits */] = { testScale: [1.0 - SPLITLimit, 1.0], testInvertp: true };
+    // TODO - More analytics ...
+}
+exports.doConfigureScales = doConfigureScales;
+// Postprocess analytics - Normalize numeric results and derive secondary tests.
+// Do this after analytics have been run and before preparing a test log or scorecard. 
+function doAnalyzePostProcessing(s) {
+    // Normalize the raw scores for all the numerics tests
+    let testResults = U.getNumericObjectKeys(testDefns);
+    for (let testID of testResults) {
+        if (testDefns[testID]['normalize']) {
+            let testResult = s.getTest(testID);
+            let rawScore = testResult['score'];
+            let normalizedScore;
+            let { testScale, testInvertp } = s.testScales[testID];
+            normalizedScore = U.normalize(rawScore, testScale, testInvertp);
+            testResult['normalizedScore'] = normalizedScore;
+            // Add the scale used to normalize the raw score to the details
+            testResult['details']['scale'] = testScale;
+        }
+    }
+    // Derive secondary tests
+    analyze_1.doDeriveSecondaryTests(s);
+    // Toggle the semaphore, so postprocessing isn't for both the testlog & scorecard
+    s.bPostProcessingDone = true;
+}
+exports.doAnalyzePostProcessing = doAnalyzePostProcessing;
+// Prepare a structured but unformatted scorecard, from the test results
+function doGenerateScorecard(s) {
+    if (!(s.bPostProcessingDone)) {
+        doAnalyzePostProcessing(s);
+    }
+    // Create a new scorecard
+    let scorecard = {};
+    // Filter the defined scorecard categories by the requested test suites
+    let categories = U.getNumericObjectKeys(scorecardDefn);
+    let suitesRequested = s.config['suites'];
+    categories = categories.filter(x => suitesRequested.includes(x));
+    // ... and initialize each one in the new scorecard
+    for (let c of categories) {
+        scorecard[c] = {};
+        scorecard[c]['catName'] = scorecardDefn[c]['catName'];
+        scorecard[c]['catTests'] = {};
+        // scorecard[c]['catScore'] = undefined;
+    }
+    // For each scorecard category
+    for (let c of categories) {
+        // Grab the scorecard category definition
+        let { catName, catTests, catNumeric } = scorecardDefn[c];
+        let numericCategoryScore = 0;
+        let totalWeight = 0;
+        let booleanCategoryScore = true;
+        // Process the results for each test result in the category
+        for (let testDefn of catTests) {
+            // Get the config info for the test
+            let testID = testDefn['testID'];
+            // ... and the actual test result
+            let testResult = s.getTest(testID);
+            // Create a new test entry for the scorecard
+            let testReport = U.deepCopy(testResult);
+            // Add the name
+            testReport['name'] = testDefns[testID]['name'];
+            if (catNumeric) {
+                // Normalize raw numeric scores ... moved to FIRST PASS above
+                // Accumulate a category score
+                let normalizedScore = testReport['normalizedScore'];
+                numericCategoryScore += normalizedScore * testDefn['testWeight'];
+                totalWeight += testDefn['testWeight'];
+            }
+            else {
+                // AND together pass/fail tests into a category score
+                if (!testReport['score']) {
+                    booleanCategoryScore = false;
+                }
+            }
+            scorecard[c]['catTests'][testID] = testReport;
+        }
+        // Set the category score
+        if (catNumeric) {
+            scorecard[c]['catScore'] = Math.round(numericCategoryScore / totalWeight);
+        }
+        else {
+            scorecard[c]['catScore'] = booleanCategoryScore;
+        }
+    }
+    // TODO - Compute an overall score from the category weights
+    return scorecard;
+}
+// Prepare a formatted scorecard suitable for rendering
+function doPrepareScorecard(s) {
+    // Initialize the output format
+    let text = { data: [] };
+    let blocks = text.data;
+    // If the plan as already been analyzed, prepare a scorecard
+    if (s.bPlanAnalyzed) {
+        // Create and cache a new, unformatted scorecard
+        s.scorecard = doGenerateScorecard(s);
+        // Create a scorecard header
+        blocks.push({ variant: 'h4', text: `Analysis` });
+        // Report district statistics
+        blocks.push({ variant: 'h5', text: `Individual Districts` });
+        let districtStatisticsText = doPrepareDistrictStatistics(s);
+        blocks.push(...districtStatisticsText);
+        // Prepare each scorecard category
+        blocks.push({ variant: 'h5', text: `Overall Plan` });
+        let categories = U.getNumericObjectKeys(s.scorecard);
+        for (let c of categories) {
+            let sectionPrepareFn = scorecardDefn[c]['catPrepareFn'];
+            let sectionText = sectionPrepareFn(s, c);
+            blocks.push(...sectionText);
+        }
+        // Report what datasets were used
+        let c = s.config['datasets']["CENSUS" /* CENSUS */];
+        let v = s.config['datasets']["VAP" /* VAP */];
+        let e = s.config['datasets']["ELECTION" /* ELECTION */];
+        blocks.push({ variant: 'body1', text: `Using datasets:` });
+        blocks.push({ variant: 'body1', text: `* ${c}: ${D.DatasetDescriptions[c]}` });
+        blocks.push({ variant: 'body1', text: `* ${v}: ${D.DatasetDescriptions[v]}` });
+        blocks.push({ variant: 'body1', text: `* ${e}: ${D.DatasetDescriptions[e]}` });
+    }
+    // Otherwise, return a blank scorecard
+    // TODO - What dra-client returns from renderAnalyzeCore()
+    // return <STV.StaticTextView text={ text } />;
+    return text;
+}
+exports.doPrepareScorecard = doPrepareScorecard;
+function doPrepareDistrictStatistics(s) {
+    let text = { data: [] };
+    let blocks = text.data;
+    blocks.push({ variant: 'beginTable' });
+    blocks.push({ variant: 'row', cells: ['ID', 'Total', 'Δ%', 'OK?', '*', 'Dem', 'Rep', 'White', 'Minority', 'Black', 'Hispanic', 'Pacific', 'Asian', 'Native'] });
+    for (let d = 0; d < s.districts.numberOfRows(); d++) {
+        let tot = s.districts.statistics[D.DistrictField.TotalPop][d];
+        if (tot == 0)
+            blocks.push({ variant: 'row', cells: [String(d), '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-'] });
+        else {
+            tot = Math.round(tot);
+            let dev = fractionToPercentage(s.districts.statistics[D.DistrictField.PopDevPct][d]);
+            let bEq = true; // TODO - Set based on population threshold
+            let bC = s.districts.statistics[D.DistrictField.bContiguous][d]
+                && s.districts.statistics[D.DistrictField.bNotEmbedded][d];
+            let dPct = fractionToPercentage(s.districts.statistics[D.DistrictField.DemPct][d]);
+            let rPct = fractionToPercentage(s.districts.statistics[D.DistrictField.RepPct][d]);
+            let wPct = fractionToPercentage(s.districts.statistics[D.DistrictField.WhitePct][d]);
+            let mPct = fractionToPercentage(s.districts.statistics[D.DistrictField.MinorityPct][d]);
+            let bPct = fractionToPercentage(s.districts.statistics[D.DistrictField.BlackPct][d]);
+            let hPct = fractionToPercentage(s.districts.statistics[D.DistrictField.HispanicPct][d]);
+            let pPct = fractionToPercentage(s.districts.statistics[D.DistrictField.PacificPct][d]);
+            let aPct = fractionToPercentage(s.districts.statistics[D.DistrictField.AsianPct][d]);
+            let nPct = fractionToPercentage(s.districts.statistics[D.DistrictField.NativePct][d]);
+            let id;
+            if (d == 0)
+                id = "??";
+            else if (d == (s.districts.numberOfRows() - 1))
+                id = "  ";
+            else
+                id = String(d);
+            blocks.push({
+                variant: 'row',
+                cells: [
+                    `${id}`,
+                    `${formatInteger(tot)}`,
+                    `${formatPercentage(dev)}%`,
+                    `${pfBoolToString(bEq)}`,
+                    `${pfBoolToString(bC)}`,
+                    `${formatPercentage(dPct)}%`,
+                    `${formatPercentage(rPct)}%`,
+                    `${formatPercentage(wPct)}%`,
+                    `${formatPercentage(mPct)}%`,
+                    `${formatPercentage(bPct)}%`,
+                    `${formatPercentage(hPct)}%`,
+                    `${formatPercentage(pPct)}%`,
+                    `${formatPercentage(aPct)}%`,
+                    `${formatPercentage(nPct)}%`
+                ]
+            });
+        }
+    }
+    blocks.push({ variant: 'endTable' });
+    return blocks;
+}
+// TEST LOG
+// Prepare formatted test results for rendering
+function doPrepareTestLog(s) {
+    // Initialize the output format
+    let text = { data: [] };
+    let blocks = text.data;
+    // If the plan as already been analyzed, prepare a test log
+    if (s.bPlanAnalyzed) {
+        if (!(s.bPostProcessingDone)) {
+            doAnalyzePostProcessing(s);
+        }
+        // Create a test log header
+        blocks.push({ variant: 'h4', text: `Test Log` });
+        let testResults = U.getNumericObjectKeys(testDefns);
+        let suitesRequested = new Set(s.config['suites']);
+        for (let testID of testResults) {
+            // Filter the defined tests by the requested test suites
+            let inSuites = testDefns[testID]['suites'];
+            if (!(U.isArrayEmpty(inSuites.filter(x => suitesRequested.has(x))))) {
+                // Get the test result
+                let testResult = s.getTest(testID);
+                // Prepare the text for it, and append it to the output
+                let testText = prepareTestEntry(testID, testResult);
+                blocks.push(...testText);
+            }
+        }
+    }
+    // Otherwise, return a blank test log
+    // TODO - What dra-client returns from renderAnalyzeCore()
+    // return <STV.StaticTextView text={ text } />;
+    return text;
+}
+exports.doPrepareTestLog = doPrepareTestLog;
+function prepareTestEntry(testID, testResult) {
+    let text = { data: [] };
+    let blocks = text.data;
+    let testName = testDefns[testID]['name'];
+    let testNameTrailer = "";
+    if (U.keyExists('trailer', testDefns[testID])) {
+        testNameTrailer = testDefns[testID]['trailer'];
+    }
+    let testType = testDefns[testID]['externalType'];
+    let bNormalize = testDefns[testID]['normalize'];
+    let detailsFn = testDefns[testID]['detailsFn'];
+    let detailsText = detailsFn(testResult);
+    let score; // NOTE - Won't be undefined here
+    let normalizedScore;
+    let scoreText;
+    // Get the score ...
+    score = testResult['score'];
+    // ... and format it for rendering
+    switch (testType) {
+        case TestType.PassFail: {
+            scoreText = pfBoolToString(score);
+            blocks.push({ variant: 'body1', text: `${testName}: ${scoreText} ${testNameTrailer}` });
+            break;
+        }
+        case TestType.Percentage: {
+            score = fractionToPercentage(score);
+            if (bNormalize) {
+                normalizedScore = testResult['normalizedScore'];
+                blocks.push({ variant: 'body1', text: `${testName}: ${normalizedScore} / 100 : ${formatPercentage(score)}% ${testNameTrailer}` });
+            }
+            else {
+                blocks.push({ variant: 'body1', text: `${testName}: ${formatPercentage(score)}% ${testNameTrailer}` });
+            }
+            break;
+        }
+        case TestType.Number: {
+            if (bNormalize) {
+                normalizedScore = testResult['normalizedScore'];
+                blocks.push({ variant: 'body1', text: `${testName}: ${normalizedScore} / 100 : ${formatNumber(score)} ${testNameTrailer}` });
+            }
+            else {
+                blocks.push({ variant: 'body1', text: `${testName}: ${formatNumber(score)} ${testNameTrailer}` });
+            }
+            break;
+        }
+        default: {
+            // Unknown test type
+            throw new RangeError();
+        }
+    }
+    // Add the details text
+    blocks.push(...detailsText);
+    return blocks;
+}
+// FORMATTERS FOR TEST DETAILS
+function doPrepareCompleteDetails(testResult) {
+    let text = { data: [] };
+    let blocks = text.data;
+    if (!U.isObjectEmpty(testResult['details'])) {
+        let unassignedText = "";
+        let emptyText = "";
+        let missingText = "";
+        if (U.keyExists('unassignedFeatures', testResult['details'])) {
+            let unassignedFeatures = testResult['details']['unassignedFeatures'];
+            let unassignedList = prepareListItems(unassignedFeatures);
+            let unassignedTextTemplates = [
+                `GEOID ${unassignedList} is not assigned to a district.`,
+                `GEOIDs ${unassignedList} are not assigned to districts.`,
+                `Several GEOIDs are not assigned to districts, including ${unassignedList}.`
+            ];
+            unassignedText = prepareListText(unassignedFeatures, unassignedTextTemplates);
+        }
+        if (U.keyExists('emptyDistricts', testResult['details'])) {
+            let emptyDistricts = testResult['details']['emptyDistricts'];
+            let emptyList = prepareListItems(emptyDistricts);
+            let emptyTextTemplates = [
+                `District ${emptyList} is empty.`,
+                `Districts ${emptyList} are empty.`,
+                `Several districts are empty, including ${emptyList}.`
+            ];
+            emptyText = prepareListText(emptyDistricts, emptyTextTemplates);
+        }
+        if (U.keyExists('missingDistricts', testResult['details'])) {
+            missingText = `Not enough districts have been defined. `;
+        }
+        let detailsText = "  " + unassignedText + emptyText + missingText;
+        blocks.push({ variant: 'body1', text: detailsText });
+    }
+    return blocks;
+}
+function doPrepareContiguousDetails(testResult) {
+    let text = { data: [] };
+    let blocks = text.data;
+    if (!U.isObjectEmpty(testResult['details'])) {
+        let discontiguousDistricts = testResult['details']['discontiguousDistricts'];
+        let discontiguousList = prepareListItems(discontiguousDistricts);
+        let discontiguousTextTemplates = [
+            `District ${discontiguousList} is not contiguous.`,
+            `Districts ${discontiguousList} are not contiguous.`,
+            `Several districts are not contiguous, including ${discontiguousList}.`
+        ];
+        let detailsText = prepareListText(discontiguousDistricts, discontiguousTextTemplates);
+        blocks.push({ variant: 'body1', text: detailsText });
+    }
+    return blocks;
+}
+function doPrepareFreeOfHolesDetails(testResult) {
+    let text = { data: [] };
+    let blocks = text.data;
+    if (!U.isObjectEmpty(testResult['details'])) {
+        let embeddedDistricts = testResult['details']['embeddedDistricts'];
+        let embeddedList = prepareListItems(embeddedDistricts);
+        let embeddedTextTemplates = [
+            `District ${embeddedList} is fully embedded within another district.`,
+            `Both districts ${embeddedList} are fully embedded within other districts.`,
+            `Several districts are fully embedded within other districts, including ${embeddedList}.`
+        ];
+        let detailsText = prepareListText(embeddedDistricts, embeddedTextTemplates);
+        blocks.push({ variant: 'body1', text: detailsText });
+    }
+    return blocks;
+}
+function doPrepareEqualPopulationDetails(testResult) {
+    let text = { data: [] };
+    let blocks = text.data;
+    if (!U.isObjectEmpty(testResult['details'])) {
+        let popDevPct = fractionToPercentage(testResult['details']['deviation']);
+        let thresholdPct = fractionToPercentage(1.0 - testResult['details']['thresholds'][0]);
+        let detailsText = '';
+        if (!(testResult['score'])) {
+            detailsText = `The ${formatPercentage(popDevPct)}% population deviation is greater than the ${formatPercentage(thresholdPct)}% threshold tolerated by courts.`;
+        }
+        blocks.push({ variant: 'body1', text: detailsText });
+    }
+    return blocks;
+}
+function doPreparePopulationDeviationDetails(testResult) {
+    let text = { data: [] };
+    let blocks = text.data;
+    let n = Math.round(testResult['details']['maxDeviation']);
+    let term = "people";
+    if (n == 1) {
+        term = "person";
+    }
+    blocks.push({ variant: 'body1', text: `The maximum population deviation between districts is ${formatInteger(n)} ${term}.` });
+    return blocks;
+}
+function doPrepareReockDetails(testResult) {
+    let text = { data: [] };
+    let blocks = text.data;
+    // TODO - No details implemented yet
+    return blocks;
+}
+function doPreparePolsbyPopperDetails(testResult) {
+    let text = { data: [] };
+    let blocks = text.data;
+    // TODO - No details implemented yet
+    return blocks;
+}
+function doPrepareEfficiencyGapDetails(testResult) {
+    let text = { data: [] };
+    let blocks = text.data;
+    // TODO - Not yet implemented
+    return blocks;
+}
+function doPrepareCountySplitDetails(testResult) {
+    let text = { data: [] };
+    let blocks = text.data;
+    let unexpectedAffected = fractionToPercentage(testResult['details']['unexpectedAffected']);
+    let affectedText = `affecting ${formatPercentage(unexpectedAffected)}% of the total population.`;
+    let countiesSplitUnexpectedly = testResult['details']['countiesSplitUnexpectedly'];
+    let nCountiesSplitUnexpectedly = countiesSplitUnexpectedly.length;
+    let nUnexpectedSplits = testResult['details']['unexpectedSplits'];
+    let splitList = prepareListItems(countiesSplitUnexpectedly);
+    let splitTextTemplates = [
+        `${splitList} county is split unexpectedly, `,
+        `${splitList} counties are split unexpectedly, `,
+        // `These ${formatInteger(nCountiesSplitUnexpectedly)} counties are split unexpectedly--${splitList}--`
+        `${splitList} counties are split unexpectedly ${formatInteger(nUnexpectedSplits)} times, `
+    ];
+    let detailsText = prepareListText(countiesSplitUnexpectedly, splitTextTemplates) + affectedText;
+    blocks.push({ variant: 'body1', text: detailsText });
+    return blocks;
+}
+// FORMATTERS FOR CATEGORIES
+// This function parses & formats the 'Valid' section of a scorecard.
+function doPrepareValidSection(s, c) {
+    // Get the category meta data
+    let { catName, catScore, catTests } = s.scorecard[c];
+    let testReport;
+    // Initialize the section text
+    let text = { data: [] };
+    let blocks = text.data;
+    let testText;
+    // Section header
+    let stringScore = pfBoolToString(catScore);
+    blocks.push({ variant: 'h6', text: `${catName}: ${stringScore}` });
+    // Complete
+    testReport = catTests[0 /* Complete */];
+    testText = prepareTestEntry(0 /* Complete */, testReport);
+    blocks.push(...testText);
+    // Contiguous
+    testReport = catTests[1 /* Contiguous */];
+    testText = prepareTestEntry(1 /* Contiguous */, testReport);
+    blocks.push(...testText);
+    // Free of holes (no embedded districts)
+    testReport = catTests[2 /* FreeOfHoles */];
+    testText = prepareTestEntry(2 /* FreeOfHoles */, testReport);
+    blocks.push(...testText);
+    // Equal population (w/in the appropriate legal threshold)
+    testReport = catTests[3 /* EqualPopulation */];
+    testText = prepareTestEntry(3 /* EqualPopulation */, testReport);
+    blocks.push(...testText);
+    return blocks;
+}
+// TODO - NIY
+// This function parses & formats the 'Fair' section of a scorecard.
+function doPrepareFairSection(s, c) {
+    // Get the category meta data
+    let { catName, catScore, catTests } = s.scorecard[c];
+    let testReport;
+    // Initialize the section text
+    let text = { data: [] };
+    let blocks = text.data;
+    let testText;
+    // Section header
+    blocks.push({ variant: 'h6', text: `${catName}: ${catScore}` });
+    // TODO - Flesh this out
+    // There's only one test: Population Deviation.
+    // testReport = catTests[T.Test.PopulationDeviation];
+    // testText = prepareTestEntry(T.Test.PopulationDeviation, testReport);
+    // blocks.push(...testText);
+    return blocks;
+}
+// This function parses & formats the 'Best' section of a scorecard.
+function doPrepareBestSection(s, c) {
+    // Get the category meta data
+    let { catName, catScore, catTests } = s.scorecard[c];
+    let testReport;
+    // Initialize the section text
+    let text = { data: [] };
+    let blocks = text.data;
+    let testText;
+    // Section header
+    blocks.push({ variant: 'h6', text: `${catName}: ${catScore}` });
+    // Population deviation
+    testReport = catTests[4 /* PopulationDeviation */];
+    testText = prepareTestEntry(4 /* PopulationDeviation */, testReport);
+    blocks.push(...testText);
+    // Compactness
+    testReport = catTests[5 /* Reock */];
+    let normalizedReock = testReport['normalizedScore'];
+    let reockTestText = prepareTestEntry(5 /* Reock */, testReport);
+    testReport = catTests[6 /* PolsbyPopper */];
+    let normalizedPolsbyPopper = testReport['normalizedScore'];
+    let polsbyPopperTestText = prepareTestEntry(6 /* PolsbyPopper */, testReport);
+    let compactnessScore = (normalizedReock + normalizedPolsbyPopper) / 2;
+    blocks.push({ variant: 'body1', text: `Compactness: ${compactnessScore} / 100` });
+    blocks.push(...reockTestText);
+    blocks.push(...polsbyPopperTestText);
+    // County splits
+    testReport = catTests[7 /* CountySplits */];
+    testText = prepareTestEntry(7 /* CountySplits */, testReport);
+    blocks.push(...testText);
+    return blocks;
+}
+// FORMATTING HELPERS
+// Convert a boolean representing Pass/Fail to a string
+function pfBoolToString(score) {
+    if (score) {
+        return "Yes";
+    }
+    else {
+        return "No";
+    }
+}
+function fractionToPercentage(f) {
+    return f * 100;
+}
+function formatNumber(n) {
+    let p = S.PRECISION;
+    return n.toLocaleString('en-US', { minimumFractionDigits: p, maximumFractionDigits: p });
+}
+function formatPercentage(n) {
+    let p = (S.PRECISION / 2);
+    return n.toLocaleString('en-US', { minimumFractionDigits: p, maximumFractionDigits: p });
+}
+function formatInteger(i) {
+    return new Intl.NumberFormat().format(i);
+}
+// Prepare the items in a list for rendering
+function prepareListItems(list) {
+    let nItems = list.length;
+    let listStr;
+    switch (nItems) {
+        case 1: {
+            listStr = list[0];
+            break;
+        }
+        case 2: {
+            listStr = list[0] + " and " + list[1];
+            break;
+        }
+        default: {
+            let listWithCommas = list.join(', ');
+            let lastCommaIndex = listWithCommas.length - ((list[list.length - 1].length) + 1);
+            let beforeAnd = listWithCommas.substr(0, lastCommaIndex);
+            let afterAnd = listWithCommas.substr(lastCommaIndex + 1);
+            listStr = beforeAnd + " and " + afterAnd;
+            break;
+        }
+    }
+    return listStr;
+}
+// Pick the rendering text for the appropriate list length
+function prepareListText(list, listTemplates) {
+    let nItems = list.length;
+    switch (nItems) {
+        case 1: {
+            return listTemplates[0];
+            break;
+        }
+        case 2: {
+            return listTemplates[1];
+            break;
+        }
+        default: {
+            return listTemplates[2];
+            break;
+        }
+    }
+}
+/* COMMAND-LINE TESTS
+
+node main.js scorecard -v -x NC -n 13 -p ~/src/district-analytics/data/SAMPLE-BG-map.csv -d ~/src/district-analytics/data/SAMPLE-BG-data2.json -s ~/src/district-analytics/data/SAMPLE-BG-shapes.geojson -g ~/src/district-analytics/data/SAMPLE-BG-graph.json -c ~/src/district-analytics/data/SAMPLE-COUNTY.geojson
+node --inspect --inspect-brk main.js scorecard -v -x NC -n 13 -p ~/src/district-analytics/data/SAMPLE-BG-map.csv -d ~/src/district-analytics/data/SAMPLE-BG-data2.json -s ~/src/district-analytics/data/SAMPLE-BG-shapes.geojson -g ~/src/district-analytics/data/SAMPLE-BG-graph.json -c ~/src/district-analytics/data/SAMPLE-COUNTY.geojson
+
+-or-
+
+./main.js scorecard -v -x NC -n 13 -p ../data/SAMPLE-BG-map.csv -d ../data/SAMPLE-BG-data2.json -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -c ../data/SAMPLE-COUNTY.geojson
+./main.js --inspect --inspect-brk scorecard -v -x NC -n 13 -p ../data/SAMPLE-BG-map.csv -d ../data/SAMPLE-BG-data2.json -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -c ../data/SAMPLE-COUNTY.geojson
+
+These calls work at the project directory, using samples in the data/ directory:
+
+./main.js testlog -v -x NC -n 13 -p ../data/SAMPLE-BG-map.csv -d ../data/SAMPLE-BG-data2.json -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -c ../data/SAMPLE-COUNTY.geojson
+
+TODO - Fix this
+./main.js testlog -v -x NC -n 13 -p ../data/SAMPLE-BG-map-missing.csv -d ../data/SAMPLE-BG-data2.json -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -c ../data/SAMPLE-COUNTY.geojson
+./main.js scorecard -v -x NC-n 13 -p ../data/SAMPLE-BG-map-missing.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+
+./main.js testlog -v -x NC -n 13 -p ../data/SAMPLE-BG-map-unassigned.csv -d ../data/SAMPLE-BG-data2.json -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -c ../data/SAMPLE-COUNTY.geojson
+./main.js scorecard -v -x NC -n 13 -p ../data/SAMPLE-BG-map-unassigned.csv -d ../data/SAMPLE-BG-data2.json -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -c ../data/SAMPLE-COUNTY.geojson
+
+TODO - HERE
+
+./main.js -v -x NC testlog -p ../data/SAMPLE-BG-map.csv -d ../data/SAMPLE-BG-data2.json -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -c ../data/SAMPLE-COUNTY.geojson --empty
+./main.js -v -x NC scorecard -p ../data/SAMPLE-BG-map.csv -d ../data/SAMPLE-BG-data2.json -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -c ../data/SAMPLE-COUNTY.geojson --empty
+
+TODO
+
+./main.js testlog -n 13 -p ../data/SAMPLE-BG-map-discontiguous.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+./main.js scorecard -n 13 -p ../data/SAMPLE-BG-map-discontiguous.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+
+./main.js testlog -n 13 -p ../data/SAMPLE-BG-map-hole.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+./main.js scorecard -n 13 -p ../data/SAMPLE-BG-map-hole.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+
+
+node --inspect --inspect-brk main.js scorecard -v -n 13 -p ../data/SAMPLE-BG-map.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+node main.js scorecard -v -n 13 -p ../data/SAMPLE-BG-map.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+
+
+These calls test NC block-level data stored in my ~/data/redistricting-data/2010/compact/sample directory:
+
+node --inspect --inspect-brk main.js scorecard -v -n 13 -p ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-map.csv -c ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-census.csv -s ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-shapes.geojson -g ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-graph.json -e ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-election.csv -f ~/data/redistricting-data/2010/compact/sample/SAMPLE-FIPS-county-name-map.csv
+node --inspect --inspect-brk main.js scorecard -v -n 13 -p ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-map.csv -c ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-census.csv -s ~/data/redistricting-data/2010/compact/sample/tl_2018_37_tabblock10.json -g ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-graph.json -e ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-election.csv -f ~/data/redistricting-data/2010/compact/sample/SAMPLE-FIPS-county-name-map.csv
+
+node main.js scorecard -v -n 13 -p ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-map.csv -c ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-census.csv -s ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-shapes.geojson -g ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-graph.json -e ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-election.csv -f ~/data/redistricting-data/2010/compact/sample/SAMPLE-FIPS-county-name-map.csv
+node main.js scorecard -v -n 13 -p ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-map.csv -c ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-census.csv -s ~/data/redistricting-data/2010/compact/sample/tl_2018_37_tabblock10.json -g ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-graph.json -e ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-election.csv -f ~/data/redistricting-data/2010/compact/sample/SAMPLE-FIPS-county-name-map.csv
+
+
+
+*/
+/* TODO - DELETE
+
+These calls work at the project directory, using samples in the data/ directory:
+
+./main.js testlog -n 13 -p ../data/SAMPLE-BG-map.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+./main.js scorecard -n 13 -p ../data/SAMPLE-BG-map.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+
+./main.js testlog -n 13 -p ../data/SAMPLE-BG-map-missing.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+./main.js scorecard -n 13 -p ../data/SAMPLE-BG-map-missing.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+
+./main.js testlog -n 13 -p ../data/SAMPLE-BG-map-unassigned.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+./main.js scorecard -n 13 -p ../data/SAMPLE-BG-map-unassigned.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+
+./main.js testlog -n 13 -p ../data/SAMPLE-BG-map.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv --empty
+./main.js scorecard -n 13 -p ../data/SAMPLE-BG-map.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv --empty
+
+./main.js testlog -n 13 -p ../data/SAMPLE-BG-map-discontiguous.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+./main.js scorecard -n 13 -p ../data/SAMPLE-BG-map-discontiguous.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+
+./main.js testlog -n 13 -p ../data/SAMPLE-BG-map-hole.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+./main.js scorecard -n 13 -p ../data/SAMPLE-BG-map-hole.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+
+
+node --inspect --inspect-brk main.js scorecard -v -n 13 -p ../data/SAMPLE-BG-map.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+node main.js scorecard -v -n 13 -p ../data/SAMPLE-BG-map.csv -c ../data/SAMPLE-BG-census.csv -s ../data/SAMPLE-BG-shapes.geojson -g ../data/SAMPLE-BG-graph.json -e ../data/SAMPLE-BG-election.csv -f ../data/SAMPLE-FIPS-county-name-map.csv
+
+
+These calls test NC block-level data stored in my ~/data/redistricting-data/2010/compact/sample directory:
+
+node --inspect --inspect-brk main.js scorecard -v -n 13 -p ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-map.csv -c ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-census.csv -s ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-shapes.geojson -g ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-graph.json -e ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-election.csv -f ~/data/redistricting-data/2010/compact/sample/SAMPLE-FIPS-county-name-map.csv
+node --inspect --inspect-brk main.js scorecard -v -n 13 -p ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-map.csv -c ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-census.csv -s ~/data/redistricting-data/2010/compact/sample/tl_2018_37_tabblock10.json -g ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-graph.json -e ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-election.csv -f ~/data/redistricting-data/2010/compact/sample/SAMPLE-FIPS-county-name-map.csv
+
+node main.js scorecard -v -n 13 -p ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-map.csv -c ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-census.csv -s ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-shapes.geojson -g ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-graph.json -e ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-election.csv -f ~/data/redistricting-data/2010/compact/sample/SAMPLE-FIPS-county-name-map.csv
+node main.js scorecard -v -n 13 -p ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-map.csv -c ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-census.csv -s ~/data/redistricting-data/2010/compact/sample/tl_2018_37_tabblock10.json -g ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-graph.json -e ~/data/redistricting-data/2010/compact/sample/SAMPLE-BLOCK-election.csv -f ~/data/redistricting-data/2010/compact/sample/SAMPLE-FIPS-county-name-map.csv
+
+*/
+
+
+/***/ }),
+
+/***/ "./src/settings.ts":
+/*!*************************!*\
+  !*** ./src/settings.ts ***!
+  \*************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// GLOBAL CONSTANTS
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+// Keep four decimal places for fractions [0–1], i.e.,
+// keep two decimal places for %'s [0–100].
+exports.PRECISION = 4;
+// Normalized scores [0-100]
+exports.NORMALIZED_RANGE = 100;
+// The dummy district ID for features not assigned districts yet
+exports.NOT_ASSIGNED = 0;
+// TODO - Discuss w/ Dave & Terry
+// # of items to report as problematic (e.g., features, districts, etc.)
+exports.NUMBER_OF_ITEMS_TO_REPORT = 10;
+// The virtual geoID for "neighbors" in other states
+exports.OUT_OF_STATE = "OUT_OF_STATE";
+
+
+/***/ }),
+
+/***/ "./src/types.ts":
+/*!**********************!*\
+  !*** ./src/types.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// TYPE DEFINITIONS
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+// END
+
+
+/***/ }),
+
+/***/ "./src/utils.ts":
+/*!**********************!*\
+  !*** ./src/utils.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// UTILITIES
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const S = __webpack_require__(/*! ./settings */ "./src/settings.ts");
+// PLAN HELPERS
+// Is a "neighbor" in state?
+function isInState(geoID) {
+    return geoID != S.OUT_OF_STATE;
+}
+exports.isInState = isInState;
+// Is a "neighbor" out of state?
+function isOutOfState(geoID) {
+    return geoID == S.OUT_OF_STATE;
+}
+exports.isOutOfState = isOutOfState;
+// Get the districtID to which a geoID is assigned
+function getDistrict(plan, geoID) {
+    // All geoIDs in a state *should be* assigned to a district (including the
+    // dummy "unassigned" district), but "water-only" features are sometimes missing
+    // from a map. This is also a guard against a bug in which a geoID has no district.
+    if (keyExists(geoID, plan)) {
+        return plan[geoID];
+    }
+    else {
+        return undefined;
+    }
+}
+exports.getDistrict = getDistrict;
+// Invert a feature assignment structure to sets of ids by district
+// NOTE - This is here vs. _data.ts, so it can also be used in cli.ts
+function invertPlan(plan) {
+    let invertedPlan = {};
+    // Add a dummy 'unassigned' district
+    invertedPlan[S.NOT_ASSIGNED] = new Set();
+    for (let geoID in plan) {
+        let districtID = plan[geoID];
+        // Make sure the set for the districtID exists
+        if (!(objectContains(invertedPlan, districtID))) {
+            invertedPlan[districtID] = new Set();
+        }
+        // Add the geoID to the districtID's set
+        invertedPlan[districtID].add(geoID);
+    }
+    return invertedPlan;
+}
+exports.invertPlan = invertPlan;
+// WORKING WITH GEOIDS
+function parseGeoID(geoID) {
+    let parts = {};
+    parts['state'] = geoID.substring(0, 2);
+    parts['county'] = geoID.substring(0, 5);
+    let l = geoID.length;
+    if (l >= 11) {
+        parts['tract'] = geoID.substring(0, 11);
+    }
+    if (l >= 12) {
+        parts['bg'] = geoID.substring(0, 12);
+    }
+    if (l == 15) {
+        parts['block'] = geoID;
+    }
+    return parts;
+}
+exports.parseGeoID = parseGeoID;
+function getFIPSFromCountyGeoID(geoID) {
+    return geoID.substring(2, 5);
+}
+exports.getFIPSFromCountyGeoID = getFIPSFromCountyGeoID;
+// NORMALIZING RESULTS
+// Convert a raw score [0-1] into a normalized score [0-100]
+function normalize(rawScore, scale, invertp = false) {
+    // Invert the axis if necessary to make bigger = better
+    if (invertp) {
+        rawScore = 1.0 - rawScore;
+    }
+    // Coerce the value to be w/in the given range
+    let rangeMin = scale[0];
+    let rangeMax = scale[1];
+    let coercedValue = Math.min(Math.max(rawScore, rangeMin), rangeMax);
+    // Scale the bounded value w/in the range [0 - (rangeMax - rangeMin)]
+    let scaledValue = (coercedValue - rangeMin) / (rangeMax - rangeMin);
+    // Finally, make the range [0-100]
+    return Math.round(scaledValue * S.NORMALIZED_RANGE);
+}
+exports.normalize = normalize;
+// Round a fractional number [0-1] to the desired level of PRECISION.
+function trim(fullFraction) {
+    let shiftPlaces = Math.pow(10, S.PRECISION);
+    return Math.round(fullFraction * shiftPlaces) / shiftPlaces;
+}
+exports.trim = trim;
+// ARRAY HELPERS
+function sumArray(arr) {
+    return arr.reduce((a, b) => a + b, 0);
+}
+exports.sumArray = sumArray;
+function avgArray(arr) {
+    return (arr.reduce((a, b) => a + b, 0)) / arr.length;
+}
+exports.avgArray = avgArray;
+function minArray(arr) {
+    return Math.min(...arr);
+}
+exports.minArray = minArray;
+function maxArray(arr) {
+    return Math.max(...arr);
+}
+exports.maxArray = maxArray;
+function initArray(n, value) {
+    return Array.from(Array(n), () => value);
+}
+exports.initArray = initArray;
+function andArray(arr) {
+    return arr.reduce(function (a, b) { return a && b; }, true);
+}
+exports.andArray = andArray;
+// WORKING WITH OBJECT KEYS/PROPERTIES
+// TODO - Terry, is this copesetic?
+// Does an object have a key/property?
+function keyExists(k, o) {
+    return k in o;
+}
+exports.keyExists = keyExists;
+// TODO - Terry, can these three be combined into a generic isEmpty() check?
+// Does an object (dict) have any keys/properties?
+function isObjectEmpty(o) {
+    return Object.keys(o).length === 0;
+}
+exports.isObjectEmpty = isObjectEmpty;
+// Does a Set have any members?
+function isSetEmpty(s) {
+    return s.size === 0;
+}
+exports.isSetEmpty = isSetEmpty;
+// Does an array hold any items?
+function isArrayEmpty(a) {
+    if (a === undefined || a.length == 0) {
+        // array empty or does not exist
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+exports.isArrayEmpty = isArrayEmpty;
+// Get the keys for an object
+function getObjectKeys(o) {
+    return Object.keys(o);
+}
+exports.getObjectKeys = getObjectKeys;
+// TODO - Convert getNumericObjectKeys() idiom to for..of where possible
+function getNumericObjectKeys(o) {
+    return Object.keys(o).map(Number);
+}
+exports.getNumericObjectKeys = getNumericObjectKeys;
+function getSelectObjectKeys(o, v) {
+    let selectKeys = [];
+    Object.keys(o).forEach(key => {
+        if (arrayContains(v, o[key])) {
+            selectKeys.push(key);
+        }
+    });
+    return selectKeys;
+}
+exports.getSelectObjectKeys = getSelectObjectKeys;
+function arrayContains(a, item) {
+    return a.some(x => x === item);
+}
+exports.arrayContains = arrayContains;
+function objectContains(o, key) {
+    return (key in o);
+}
+exports.objectContains = objectContains;
+// ENUM HELPERS
+// Source: https://stackoverflow.com/questions/38034673/determine-the-number-of-enum-elements-typescript
+function countEnumValues(enumName) {
+    let count = 0;
+    for (let item in enumName) {
+        if (isNaN(Number(item)))
+            count++;
+    }
+    return count;
+}
+exports.countEnumValues = countEnumValues;
+// COPYING - Copied from dra-client/util.ts
+function shallowCopy(src) {
+    if (Array.isArray(src))
+        return src.slice();
+    else if (typeof src === 'object') {
+        let dst = {};
+        for (var p in src)
+            if (src.hasOwnProperty(p))
+                dst[p] = src[p];
+        return dst;
+    }
+    else
+        return src;
+}
+exports.shallowCopy = shallowCopy;
+function deepCopy(src) {
+    if (Array.isArray(src)) {
+        let dst = [];
+        for (let i = 0; i < src.length; i++)
+            dst.push(deepCopy(src[i]));
+        return dst;
+    }
+    else if (typeof src === 'object') {
+        let dst = {};
+        for (var p in src)
+            if (src.hasOwnProperty(p))
+                dst[p] = deepCopy(src[p]);
+        return dst;
+    }
+    else
+        return src;
+}
+exports.deepCopy = deepCopy;
+// TODO - Terry: What is this the simple explanation of what this thing is doing?
+var util_1 = __webpack_require__(/*! @dra2020/util */ "@dra2020/util");
+exports.depthof = util_1.depthof;
+
+
+/***/ }),
+
+/***/ "./src/valid.ts":
+/*!**********************!*\
+  !*** ./src/valid.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// MAP/PLAN VALIDATIONS
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const U = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const S = __webpack_require__(/*! ./settings */ "./src/settings.ts");
+const D = __webpack_require__(/*! ./_data */ "./src/_data.ts");
+//
+// COMPLETE - Are all geo's assigned to a district, and do all districts have
+//   at least one geo assigned to them?
+//
+function doIsComplete(s) {
+    let test = s.getTest(0 /* Complete */);
+    let bAllAssigned = true;
+    let bNoneEmpty = true;
+    let unassignedFeatures = [];
+    let emptyDistricts = [];
+    // Get the by district results, including the dummy unassigned district,
+    // but ignoring the N+1 summary district
+    let bNotEmptyByDistrict = s.districts.statistics[D.DistrictField.bNotEmpty];
+    bNotEmptyByDistrict = bNotEmptyByDistrict.slice(0, -1);
+    // Are all features assigned to districts?
+    // Check the dummy district that holds any unassigned features.
+    bAllAssigned = (!bNotEmptyByDistrict[S.NOT_ASSIGNED]);
+    if (!bAllAssigned) {
+        let unassignedDistrict = s.plan.geoIDsForDistrictID(S.NOT_ASSIGNED);
+        unassignedFeatures = Array.from(unassignedDistrict);
+        unassignedFeatures = unassignedFeatures.slice(0, S.NUMBER_OF_ITEMS_TO_REPORT);
+    }
+    // Do all real districts have at least one feature assigned to them?
+    bNoneEmpty = U.andArray(bNotEmptyByDistrict.slice(1));
+    // Case 1 - One or more districts are missing:
+    //   The # of enumerated districts minus the dummy NOT_ASSIGNED one should
+    //   equal the number apportioned districts. This guards against a district
+    //   not being included in a map that is imported.
+    //
+    // TODO - I'm no longer checking for this, but DRA should!
+    // Case 2 - Or a district is explicitly named but empty:
+    //   Note, this can happen if a district is created, and then all features
+    //   are removed from it (in DRA).
+    // Populate the test entry
+    test['score'] = bAllAssigned && bNoneEmpty;
+    if (!bAllAssigned) {
+        test['details']['unassignedFeatures'] = unassignedFeatures;
+    }
+    if (!bNoneEmpty) {
+        test['details']['emptyDistricts'] = emptyDistricts;
+    }
+    // Populate the N+1 summary "district" in district.statistics
+    let bNotEmpty = s.districts.statistics[D.DistrictField.bNotEmpty];
+    let summaryRow = s.districts.numberOfRows() - 1;
+    bNotEmpty[summaryRow] = test['score'];
+    return test;
+}
+exports.doIsComplete = doIsComplete;
+//
+// CONTIGUOUS - Is each district in a plan fully connected?
+//
+//   NOTE - To check "operational contiguity," we need to use a graph, i.e.,
+//   we can't rely on just the geometric contiguity of shapes in a shapefile.
+//
+//   To test this, load the NC 2010 map 'SAMPLE-BG-map-discontiguous.csv'.
+//
+function doIsContiguous(s) {
+    let test = s.getTest(1 /* Contiguous */);
+    // Get the contiguity of each district. Ignore dummy unassigned district
+    // and the N+1 summary district.
+    let bContiguousByDistrict = s.districts.statistics[D.DistrictField.bContiguous];
+    bContiguousByDistrict = bContiguousByDistrict.slice(1, -1);
+    // If any real districts aren't contiguous, mark the plan as not contiguous
+    let bMapContiguous = U.andArray(bContiguousByDistrict);
+    // If the map is not contiguous, log the offending districts.
+    let discontiguousDistricts = [];
+    let districtID = 1;
+    bContiguousByDistrict.forEach(function (bDistrictContiguous) {
+        if (!bDistrictContiguous)
+            discontiguousDistricts.push(districtID);
+        districtID += 1;
+    });
+    // Populate the test entry
+    test['score'] = bMapContiguous;
+    if (!bMapContiguous) {
+        test['details'] = { 'discontiguousDistricts': discontiguousDistricts };
+    }
+    // Populate the N+1 summary "district" in district.statistics
+    let bContiguous = s.districts.statistics[D.DistrictField.bContiguous];
+    let summaryRow = s.districts.numberOfRows() - 1;
+    bContiguous[summaryRow] = test['score'];
+    return test;
+}
+exports.doIsContiguous = doIsContiguous;
+// Are the features in a district fully connected?
+function isConnected(districtGeos, graph) {
+    // export function isConnected(districtGeos: Set<string>, graph: T.ContiguityGraph): boolean {
+    // TODO - Terry, why does this constructor need a <T> type specification?
+    let visited = new Set();
+    let toProcess = [];
+    // Start processing with the first geoID in the district
+    let iter = districtGeos.values();
+    toProcess.push(iter.next().value);
+    // While there are geoIDs in the district that haven't been processed
+    while (toProcess.length > 0) {
+        // Grab a geoID and process it
+        let node = toProcess.pop();
+        visited.add(node);
+        // Get its actual, in-state neighbors
+        let actualNeighbors = graph.peerNeighbors(node).filter(x => U.isInState(x));
+        // Add neighbors to visit, if they're in the same district Y haven't already been visited
+        let neighborsToVisit = actualNeighbors.filter(x => districtGeos.has(x) && (!visited.has(x)));
+        // TODO - Terry, is this the quickest/best way to do this?
+        toProcess.push(...neighborsToVisit);
+    }
+    // Stop when you've visited all the geoIDs in the district
+    return visited.size == districtGeos.size;
+}
+exports.isConnected = isConnected;
+//
+// FREE OF HOLES - Are any districts fully embedded w/in another district?
+//
+//   A district is NOT a "donut hole" district:
+//   - If any neighbor is 'OUT_OF_STATE'; or
+//   - If there are 2 or more neighboring districts.
+//
+//   To test this, load the NC 2010 map 'SAMPLE-BG-map-hole.csv'. District 1,
+//   Buncombe County (37021), is a donut hole w/in District 3.
+//
+// TODO - Optimize this to take advantage of district boundary info, if/when
+//   we cache one to optimize compactness.
+//
+function doIsFreeOfHoles(s) {
+    let test = s.getTest(2 /* FreeOfHoles */);
+    // Initialize values
+    let bFreeOfHoles = true;
+    let embeddedDistricts = [];
+    // Get the embeddedness of each district. Ignore dummy unassigned district
+    // and the N+1 summary district.
+    let bNotEmbeddedByDistrict = s.districts.statistics[D.DistrictField.bNotEmbedded];
+    bNotEmbeddedByDistrict = bNotEmbeddedByDistrict.slice(1, -1);
+    let districtID = 1;
+    bNotEmbeddedByDistrict.forEach(function (bDistrictNotEmbedded) {
+        if (!bDistrictNotEmbedded) {
+            embeddedDistricts.push(districtID);
+            bFreeOfHoles = false;
+        }
+        districtID += 1;
+    });
+    // Populate the test entry
+    test['score'] = bFreeOfHoles;
+    if (!bFreeOfHoles) {
+        test['details'] = { 'embeddedDistricts': embeddedDistricts };
+    }
+    // Populate the N+1 summary "district" in district.statistics
+    let bNotEmbedded = s.districts.statistics[D.DistrictField.bNotEmbedded];
+    let summaryRow = s.districts.numberOfRows() - 1;
+    bNotEmbedded[summaryRow] = test['score'];
+    return test;
+}
+exports.doIsFreeOfHoles = doIsFreeOfHoles;
+// Test whether one district is embedded w/in any other.
+function isEmbedded(districtID, geoIDs, plan, graph) {
+    // TODO - Make "features" = "geoIDs." These aren't "features" proper, just
+    //   identifier strings.
+    let features = geoIDs;
+    let planByGeo = plan.byGeoID();
+    // Assume the district is embedded
+    let bEmbedded = true;
+    // Keep track of the neighoring districts
+    let neighboringDistricts = new Set();
+    // TODO - Use just the boundary features, when available
+    // Get the features for the real district
+    let featuresToCheck = Array.from(features);
+    // If the district has features, check whether it is embedded
+    if (!(U.isArrayEmpty(featuresToCheck))) {
+        // For each feature that needs to be checked (see above)
+        for (let feature of featuresToCheck) {
+            // Get its neighbors (including the virtual "out of state" ones)
+            let neighbors = graph.peerNeighbors(feature);
+            for (let neighbor of neighbors) {
+                if (U.isOutOfState(neighbor)) {
+                    bEmbedded = false;
+                    // No need to check any more neighbors
+                    break;
+                }
+                else {
+                    let neighboringDistrict = U.getDistrict(planByGeo, neighbor);
+                    // Assume that a missing district assignment (= None) means that the
+                    // feature is "water-only" AND part of the state border (vs. internal)
+                    // and, therefore, not in the plan/map.
+                    if (neighboringDistrict == undefined) {
+                        bEmbedded = false;
+                        // No need to check any more neighbors
+                        break;
+                    }
+                    else {
+                        // TODO - Since we're checking *all* features in a district right
+                        //   now, not just boundary features and neighbors in other districts,
+                        //   prune out the current district. If/when we optimize compactness
+                        //   to cache district boundaries (as before in my Python implementation),
+                        //   we won't have to guard adding "neighboring" districts in this way.
+                        if (neighboringDistrict != districtID) {
+                            neighboringDistricts.add(neighboringDistrict);
+                        }
+                        if (neighboringDistricts.size > 1) {
+                            bEmbedded = false;
+                            // No need to check any more neighbors
+                            break;
+                        }
+                    }
+                }
+            }
+            // If a district is not embedded, there's no need to check anymore
+            // border geos.
+            if (!bEmbedded) {
+                break;
+            }
+        }
+    }
+    return bEmbedded;
+}
+exports.isEmbedded = isEmbedded;
+// TODO - MIXED MAPS
+// - When we generalize to mixed maps, the determination of "neighbors in
+//   the map" -- which is the core function in determining connectedness -- becomes
+//   *much* more complicated and dynamic.
+// - I can write up (if not implement) the logic for this. It is a bit tricky
+//   and requires special preprocessing of the summary level hierarchy (which I
+//   also have a script for that we can repurpose) to distinguish between 'interior'
+//   and 'edge' children.
+
+
+/***/ }),
+
+/***/ "@dra2020/poly":
+/*!********************************!*\
+  !*** external "@dra2020/poly" ***!
+  \********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("@dra2020/poly");
+
+/***/ }),
+
+/***/ "@dra2020/util":
+/*!********************************!*\
+  !*** external "@dra2020/util" ***!
+  \********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("@dra2020/util");
+
+/***/ }),
+
+/***/ "assert":
+/*!*************************!*\
+  !*** external "assert" ***!
+  \*************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("assert");
+
+/***/ })
+
+/******/ });
+});
+//# sourceMappingURL=district-analytics.js.map