@dra2020/district-analytics 3.2.0 → 4.1.0

package/dist/cli.js

@@ -89264,7 +89264,15 @@ module.exports = g;
 //
 // THE NODE PACKAGE API
 //
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const C = __importStar(__webpack_require__(/*! ./config */ "./src/config.ts"));
 const score_1 = __webpack_require__(/*! ./score */ "./src/score.ts");
 class Scorer {
     constructor() {
@@ -89272,6 +89280,9 @@ class Scorer {
     score(profile, overridesJSON) {
         return score_1.scorePlan(profile, overridesJSON);
     }
+    populationDeviationThreshold(bLegislative) {
+        return C.popdevThreshold(bLegislative);
+    }
 }
 exports.Scorer = Scorer;
 
@@ -89300,27 +89311,33 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
 const S = __importStar(__webpack_require__(/*! ./settings */ "./src/settings.ts"));
+const C = __importStar(__webpack_require__(/*! ./config */ "./src/config.ts"));
 const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts");
 function scoreCountySplitting(rawValue, nCounties, nDistricts) {
     const _normalizer = new normalize_1.Normalizer(rawValue);
-    const stateCountySplitThreshold = countySplitThreshold(nCounties, nDistricts);
-    _normalizer.clip(S.COUNTY_BEST, stateCountySplitThreshold);
-    _normalizer.unitize(S.COUNTY_BEST, stateCountySplitThreshold);
+    const best = C.countySplittingRange()[C.BEG];
+    const worst = countySplitThreshold(nCounties, nDistricts);
+    _normalizer.clip(best, worst);
+    _normalizer.unitize(best, worst);
     _normalizer.invert();
     _normalizer.rescale();
     return _normalizer.normalizedNum;
 }
 exports.scoreCountySplitting = scoreCountySplitting;
 function countySplitThreshold(nCounties, nDistricts) {
-    const nAllowableSplits = Math.min(S.ALLOWABLE_SPLITS_MULTIPLIER * (nDistricts - 1));
-    const threshold = ((nAllowableSplits * S.COUNTY_WORST) + ((nCounties - nAllowableSplits) * 1.0)) / nCounties;
+    const m = C.allowableSplitsMultiplier();
+    const worst = C.countySplittingRange()[1];
+    const nAllowableSplits = Math.min(m * (nDistricts - 1));
+    const threshold = ((nAllowableSplits * worst) + ((nCounties - nAllowableSplits) * 1.0)) / nCounties;
     return threshold;
 }
 exports.countySplitThreshold = countySplitThreshold;
 function scoreDistrictSplitting(rawValue) {
     const _normalizer = new normalize_1.Normalizer(rawValue);
-    _normalizer.clip(S.DISTRICT_BEST, S.DISTRICT_WORST);
-    _normalizer.unitize(S.DISTRICT_BEST, S.DISTRICT_WORST);
+    const best = C.districtSplittingRange()[C.BEG];
+    const worst = C.districtSplittingRange()[C.END];
+    _normalizer.clip(best, worst);
+    _normalizer.unitize(best, worst);
     _normalizer.invert();
     _normalizer.rescale();
     return _normalizer.normalizedNum;
@@ -89415,7 +89432,7 @@ function reduceCSplits(CxD, districtTotals) {
         for (let i = 1; i < nD; i++) {
             let split_total = CxDreducedC[i][j];
             if (split_total > 0) {
-                if (areRoughlyEqual(split_total, districtTotals[i - 1])) {
+                if (U.areRoughlyEqual(split_total, districtTotals[i - 1], S.EQUAL_TOLERANCE)) {
                     CxDreducedC[0][j] += split_total;
                     CxDreducedC[i][j] = 0;
                 }
@@ -89438,7 +89455,7 @@ function reduceDSplits(CxD, countyTotals) {
         for (let j = 1; j < nC; j++) {
             let split_total = CxDreducedD[i][j];
             if (split_total > 0) {
-                if (areRoughlyEqual(split_total, countyTotals[j - 1])) {
+                if (U.areRoughlyEqual(split_total, countyTotals[j - 1], S.EQUAL_TOLERANCE)) {
                     CxDreducedD[i][0] += split_total;
                     CxDreducedD[i][j] = 0;
                 }
@@ -89502,13 +89519,6 @@ function calcDistrictFractions(CxD, districtTotals) {
     return g;
 }
 exports.calcDistrictFractions = calcDistrictFractions;
-// Deal with decimal census "counts" due to disagg/re-agg
-function areRoughlyEqual(x, y) {
-    let delta = Math.abs(x - y);
-    let result = (delta < S.EQUAL_TOLERANCE) ? true : false;
-    return result;
-}
-exports.areRoughlyEqual = areRoughlyEqual;
 function splitScore(splits) {
     let e;
     if (splits.length > 0) {
@@ -89593,7 +89603,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
-const S = __importStar(__webpack_require__(/*! ./settings */ "./src/settings.ts"));
+const C = __importStar(__webpack_require__(/*! ./config */ "./src/config.ts"));
 const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts");
 // Migrated from district-analytics:
 // Measures of compactness compare district shapes to various ideally compact
@@ -89715,8 +89725,10 @@ function calcReock(area, diameter) {
 exports.calcReock = calcReock;
 function scoreReock(rawValue) {
     const _normalizer = new normalize_1.Normalizer(rawValue);
-    _normalizer.clip(S.REOCK_WORST, S.REOCK_BEST);
-    _normalizer.unitize(S.REOCK_WORST, S.REOCK_BEST);
+    const worst = C.reockRange()[C.BEG];
+    const best = C.reockRange()[C.END];
+    _normalizer.clip(worst, best);
+    _normalizer.unitize(worst, best);
     _normalizer.rescale();
     return _normalizer.normalizedNum;
 }
@@ -89734,12 +89746,12 @@ function doPolsbyPopper(g, bLog = false) {
         if (districtProps) {
             let a = districtProps[0 /* Area */];
             let p = districtProps[1 /* Perimeter */];
-            let polsbyPopper = calcPolsbyPopper(a, p);
+            let polsby = calcPolsbyPopper(a, p);
             // Save each district score
-            scores.push(polsbyPopper);
+            scores.push(polsby);
             // Echo the results by district
             if (bLog)
-                console.log("Polsby-Popper for district", districtID, "=", polsbyPopper);
+                console.log("Polsby-Popper for district", districtID, "=", polsby);
         }
         else {
             console.log("No shape or no geopropertes in Polsby-Popper ...");
@@ -89762,14 +89774,233 @@ function calcPolsbyPopper(area, perimeter) {
 exports.calcPolsbyPopper = calcPolsbyPopper;
 function scorePolsbyPopper(rawValue) {
     const _normalizer = new normalize_1.Normalizer(rawValue);
-    _normalizer.clip(S.POLSBY_WORST, S.POLSBY_BEST);
-    _normalizer.unitize(S.POLSBY_WORST, S.POLSBY_BEST);
+    const worst = C.polsbyRange()[C.BEG];
+    const best = C.polsbyRange()[C.END];
+    _normalizer.clip(worst, best);
+    _normalizer.unitize(worst, best);
     _normalizer.rescale();
     return _normalizer.normalizedNum;
 }
 exports.scorePolsbyPopper = scorePolsbyPopper;
 
 
+/***/ }),
+
+/***/ "./src/config.json":
+/*!*************************!*\
+  !*** ./src/config.json ***!
+  \*************************/
+/*! exports provided: partisan, minority, traditionalPrinciples, default */
+/***/ (function(module) {
+
+module.exports = JSON.parse("{\"partisan\":{\"bias\":{\"range\":[0,0.2],\"weight\":[50,80]},\"impact\":{\"weight\":[50,0],\"threshold\":4},\"competitiveness\":{\"overall\":{\"range\":[0,0.67],\"weight\":25},\"marginal\":{\"range\":[0,0.85],\"weight\":75},\"range\":[0.45,0.55],\"distribution\":[0.25,0.75],\"weight\":[0,20]},\"bonus\":2,\"weight\":[100,80]},\"minority\":{\"range\":[0.37,0.5],\"distribution\":[0.25,0.75],\"shift\":0.12,\"bonus\":20},\"traditionalPrinciples\":{\"compactness\":{\"reock\":{\"range\":[0.25,0.5],\"weight\":50},\"polsby\":{\"range\":[0.1,0.5],\"weight\":50},\"weight\":[0,50]},\"splitting\":{\"county\":{\"range\":[1,1.71],\"allowableSplitsMultiplier\":1.5,\"weight\":50},\"district\":{\"range\":[1,1.5],\"weight\":50},\"weight\":[0,50]},\"popdev\":{\"range\":[[0.0075,0.002],[0.1,-1]],\"weight\":[0,0]},\"weight\":[0,20]}}");
+
+/***/ }),
+
+/***/ "./src/config.ts":
+/*!***********************!*\
+  !*** ./src/config.ts ***!
+  \***********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// THRESHOLDS, SCALES, AND WEIGHTS FOR SCORING MODEL
+//
+// * A layer of functions over config.json, so that they can be overridden dynamically (TODO)
+//
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Defaults
+const config_json_1 = __importDefault(__webpack_require__(/*! ./config.json */ "./src/config.json"));
+exports.BEG = 0;
+exports.END = 1;
+// PARTISAN
+function biasWeight(context, overridesJSON) {
+    const bW = config_json_1.default.partisan.bias.weight[context];
+    return bW;
+}
+exports.biasWeight = biasWeight;
+function biasRange(overridesJSON) {
+    const range = config_json_1.default.partisan.bias.range;
+    return range;
+}
+exports.biasRange = biasRange;
+function impactWeight(context, overridesJSON) {
+    const iW = config_json_1.default.partisan.impact.weight[context];
+    return iW;
+}
+exports.impactWeight = impactWeight;
+function winnerBonus(overridesJSON) {
+    const bonus = config_json_1.default.partisan.bonus;
+    return bonus;
+}
+exports.winnerBonus = winnerBonus;
+// The maximum # of unearned seats that scores positively
+function unearnedThreshold(overridesJSON) {
+    const threshold = config_json_1.default.partisan.impact.threshold;
+    return threshold;
+}
+exports.unearnedThreshold = unearnedThreshold;
+function competitivenessWeight(context, overridesJSON) {
+    const cW = config_json_1.default.partisan.competitiveness.weight[context];
+    return cW;
+}
+exports.competitivenessWeight = competitivenessWeight;
+function competitiveRange(overridesJSON) {
+    const range = config_json_1.default.partisan.competitiveness.range;
+    return range;
+}
+exports.competitiveRange = competitiveRange;
+function competitiveDistribution(overridesJSON) {
+    const dist = config_json_1.default.partisan.competitiveness.distribution;
+    return dist;
+}
+exports.competitiveDistribution = competitiveDistribution;
+function overallCompetitivenessRange(overridesJSON) {
+    const range = config_json_1.default.partisan.competitiveness.overall.range;
+    return range;
+}
+exports.overallCompetitivenessRange = overallCompetitivenessRange;
+function marginalCompetitivenessRange(overridesJSON) {
+    const range = config_json_1.default.partisan.competitiveness.marginal.range;
+    return range;
+}
+exports.marginalCompetitivenessRange = marginalCompetitivenessRange;
+function marginalCompetitivenessWeight(overridesJSON) {
+    const mcW = config_json_1.default.partisan.competitiveness.marginal.weight;
+    return mcW;
+}
+exports.marginalCompetitivenessWeight = marginalCompetitivenessWeight;
+function overallCompetitivenessWeight(overridesJSON) {
+    const ocW = config_json_1.default.partisan.competitiveness.overall.weight;
+    return ocW;
+}
+exports.overallCompetitivenessWeight = overallCompetitivenessWeight;
+// MINORITY
+function minorityOpportunityRange(overridesJSON) {
+    const range = config_json_1.default.minority.range;
+    return range;
+}
+exports.minorityOpportunityRange = minorityOpportunityRange;
+function minorityOpportunityDistribution(overridesJSON) {
+    const dist = config_json_1.default.minority.distribution;
+    return dist;
+}
+exports.minorityOpportunityDistribution = minorityOpportunityDistribution;
+function minorityShift(overridesJSON) {
+    const shift = config_json_1.default.minority.shift;
+    return shift;
+}
+exports.minorityShift = minorityShift;
+function opportunityDistrictBonus(overridesJSON) {
+    const bonus = config_json_1.default.minority.bonus;
+    return bonus;
+}
+exports.opportunityDistrictBonus = opportunityDistrictBonus;
+function minorityBonus(overridesJSON) {
+    const bonus = config_json_1.default.minority.bonus;
+    return bonus;
+}
+exports.minorityBonus = minorityBonus;
+// TRADITIONAL DISTRICTING PRINCIPLES
+function compactnessWeight(context, overridesJSON) {
+    const cW = config_json_1.default.traditionalPrinciples.compactness.weight[context];
+    return cW;
+}
+exports.compactnessWeight = compactnessWeight;
+function reockWeight(overridesJSON) {
+    const rW = config_json_1.default.traditionalPrinciples.compactness.reock.weight;
+    return rW;
+}
+exports.reockWeight = reockWeight;
+function reockRange(overridesJSON) {
+    const range = config_json_1.default.traditionalPrinciples.compactness.reock.range;
+    return range;
+}
+exports.reockRange = reockRange;
+function polsbyWeight(overridesJSON) {
+    const ppW = config_json_1.default.traditionalPrinciples.compactness.polsby.weight;
+    return ppW;
+}
+exports.polsbyWeight = polsbyWeight;
+function polsbyRange(overridesJSON) {
+    const range = config_json_1.default.traditionalPrinciples.compactness.polsby.range;
+    return range;
+}
+exports.polsbyRange = polsbyRange;
+function splittingWeight(context, overridesJSON) {
+    const sW = config_json_1.default.traditionalPrinciples.splitting.weight[context];
+    return sW;
+}
+exports.splittingWeight = splittingWeight;
+function countySplittingWeight(overridesJSON) {
+    const csW = config_json_1.default.traditionalPrinciples.splitting.county.weight;
+    return csW;
+}
+exports.countySplittingWeight = countySplittingWeight;
+function countySplittingRange(overridesJSON) {
+    const range = config_json_1.default.traditionalPrinciples.splitting.county.range;
+    return range;
+}
+exports.countySplittingRange = countySplittingRange;
+function allowableSplitsMultiplier(overridesJSON) {
+    const m = config_json_1.default.traditionalPrinciples.splitting.county.allowableSplitsMultiplier;
+    return m;
+}
+exports.allowableSplitsMultiplier = allowableSplitsMultiplier;
+function districtSplittingWeight(overridesJSON) {
+    const dsW = config_json_1.default.traditionalPrinciples.splitting.district.weight;
+    return dsW;
+}
+exports.districtSplittingWeight = districtSplittingWeight;
+function districtSplittingRange(overridesJSON) {
+    const range = config_json_1.default.traditionalPrinciples.splitting.district.range;
+    return range;
+}
+exports.districtSplittingRange = districtSplittingRange;
+function popdevWeight(context, overridesJSON) {
+    const pdW = config_json_1.default.traditionalPrinciples.popdev.weight[context];
+    return pdW;
+}
+exports.popdevWeight = popdevWeight;
+// NOTE - Raw ranges, not inverted (i.e., smaller is better)
+// NOTE - This could be optimized to not calc LD values for CD's (or do it once)
+function popdevRange(bLegislative, overridesJSON) {
+    const cdRange = config_json_1.default.traditionalPrinciples.popdev.range[0 /* Congressional */];
+    const worstCD = cdRange[exports.BEG];
+    const bestCD = cdRange[exports.END];
+    const ldRange = config_json_1.default.traditionalPrinciples.popdev.range[1 /* StateLegislative */];
+    const iRange = bLegislative ? ldRange : cdRange;
+    const worst = iRange[exports.BEG];
+    const best = bLegislative ? (bestCD / worstCD) * iRange[exports.BEG] : iRange[exports.END];
+    // Invert the range, so bigger is better.
+    return [worst, best];
+}
+exports.popdevRange = popdevRange;
+// NOTE - Raw threshold, not inverted (i.e., smaller is better)
+function popdevThreshold(bLegislative, overridesJSON) {
+    const threshold = popdevRange(bLegislative)[exports.BEG];
+    return threshold;
+}
+exports.popdevThreshold = popdevThreshold;
+// OVERALL SCORE 
+function partisanWeight(context, overridesJSON) {
+    const pW = config_json_1.default.partisan.weight[context];
+    return pW;
+}
+exports.partisanWeight = partisanWeight;
+function traditionalPrinciplesWeight(context, overridesJSON) {
+    const tpW = config_json_1.default.traditionalPrinciples.weight[context];
+    return tpW;
+}
+exports.traditionalPrinciplesWeight = traditionalPrinciplesWeight;
+
+
 /***/ }),
 
 /***/ "./src/equal.ts":
@@ -89793,7 +90024,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
-const S = __importStar(__webpack_require__(/*! ./settings */ "./src/settings.ts"));
+const C = __importStar(__webpack_require__(/*! ./config */ "./src/config.ts"));
 const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts");
 // Migrated from district-analytics
 // Expect a full dict of district IDs & values (which might be zero = empty)
@@ -89814,7 +90045,7 @@ function doPopulationDeviation(e, targetSize, bLegislative, bLog = false) {
     // Round the raw value to the desired level of precision
     const popDev = U.trim((max - min) / targetSize);
     const score = scorePopulationDeviation(popDev, bLegislative);
-    const threshold = bLegislative ? S.POPDEV_WORST_LD : S.POPDEV_WORST;
+    const threshold = C.popdevThreshold(bLegislative);
     const notes = {
         'maxDeviation': max - min,
         'threshold': threshold
@@ -89830,11 +90061,11 @@ function doPopulationDeviation(e, targetSize, bLegislative, bLog = false) {
 exports.doPopulationDeviation = doPopulationDeviation;
 function scorePopulationDeviation(rawValue, bLegislative) {
     const _normalizer = new normalize_1.Normalizer(rawValue);
-    const rangeMin = bLegislative ? S.POPEQ_MIN_LD : S.POPEQ_MIN;
-    const rangeMax = bLegislative ? S.POPEQ_MAX_LD : S.POPEQ_MAX;
+    // Raw range in not inverted (i.e., smaller is better)
+    const range = C.popdevRange(bLegislative);
     _normalizer.invert();
-    _normalizer.clip(rangeMin, rangeMax);
-    _normalizer.unitize(rangeMin, rangeMax);
+    _normalizer.clip(1.0 - range[C.BEG], 1.0 - range[C.END]);
+    _normalizer.unitize(1.0 - range[C.BEG], 1.0 - range[C.END]);
     _normalizer.rescale();
     return _normalizer.normalizedNum;
 }
@@ -89843,10 +90074,263 @@ exports.scorePopulationDeviation = scorePopulationDeviation;
 
 /***/ }),
 
-/***/ "./src/fair.ts":
-/*!*********************!*\
-  !*** ./src/fair.ts ***!
-  \*********************/
+/***/ "./src/index.ts":
+/*!**********************!*\
+  !*** ./src/index.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// SCORE 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"));
+var types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
+exports.sampleScorecard = types_1.sampleScorecard;
+exports.sampleProfile = types_1.sampleProfile;
+
+
+/***/ }),
+
+/***/ "./src/minority.ts":
+/*!*************************!*\
+  !*** ./src/minority.ts ***!
+  \*************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// SCORING FOR MINORITY OPPORTUNITY
+//
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
+const C = __importStar(__webpack_require__(/*! ./config */ "./src/config.ts"));
+const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts");
+const partisan_1 = __webpack_require__(/*! ./partisan */ "./src/partisan.ts");
+function evalMinorityOpportunity(p, bLog = false) {
+    // Calculate average Democratic win share
+    const VfArray = p.partisanProfile.vfArray;
+    const DWins = VfArray.filter(x => x > 0.5);
+    const averageDVf = (DWins.length > 0) ? U.avgArray(DWins) : undefined;
+    // Determine proportional minority districts by demographic (ignore 'White')
+    const districtsByDemo = calcDistrictsByDemo(p.demographicProfile.stateMfArray.slice(1), p.nDistricts);
+    // Initialize arrays for results
+    let offset = 1; // Don't process 'White'
+    let nDemos = 6 /* Native */ + 1 - offset; // Ditto
+    let nBuckets = 2; // 37–50% and > 50%
+    const demosByDistrict = p.demographicProfile.mfArrayByDistrict;
+    let bucketsByDemo = new Array(nDemos);
+    for (let j = 0; j < nDemos; j++) {
+        bucketsByDemo[j] = [0, 0];
+    }
+    let opptyByDemo = U.initArray(nDemos, 0.0);
+    // For each district
+    for (let i = 0; i < p.nDistricts; i++) {
+        // Find the opportunities for minority representation
+        for (let j = 0; j < nDemos; j++) {
+            const proportion = U.deepCopy(demosByDistrict[i][j + offset]);
+            if (exceedsMinimumThreshold(proportion)) {
+                // Bucket opportunity districts
+                const bucket = (exceedsMaximumThreshold(proportion)) ? 1 : 0;
+                bucketsByDemo[j][bucket] += 1;
+                // Accumulate seat probabilities
+                opptyByDemo[j] += estMinorityOpportunity(proportion);
+            }
+        }
+    }
+    // Sum the # of level 1 (37–50%) and level 2 (> 50%) opportunity districts - ignore total minority
+    // let l1: number = 0;
+    // let l2: number = 0;
+    // bucketsByDemo.slice(1).forEach(function (buckets: number[]): void
+    // {
+    //   l1 += buckets[T.OpportunityBucket.Level1];
+    //   l2 += buckets[T.OpportunityBucket.Level2]
+    // });
+    // Sum the # of opportunity districts - ignore total minority
+    const oD = U.sumArray(opptyByDemo.slice(1));
+    // Sum the # of proportion districts - ignore total minority
+    const pD = U.sumArray(districtsByDemo.slice(1));
+    // Score opportunity
+    const score = scoreMinority(oD, pD);
+    let mS = {
+        report: {
+            averageDVf: averageDVf,
+            bucketsByDemographic: bucketsByDemo
+        },
+        // nOpportunity1: l1,
+        // nOpportunity2: l2,
+        nProportional: pD,
+        opportunityDistricts: oD,
+        score: score
+    };
+    return mS;
+}
+exports.evalMinorityOpportunity = evalMinorityOpportunity;
+function scoreMinority(oD, pD) {
+    const bonus = C.minorityBonus();
+    const score = (pD > 0) ? Math.round((Math.min(oD, pD) / pD) * bonus) : 0;
+    return score;
+}
+exports.scoreMinority = scoreMinority;
+function calcDistrictsByDemo(MfArray, N) {
+    const districtsByDemo = MfArray.map(v => calcProportionalDistricts(v, N));
+    return districtsByDemo;
+}
+exports.calcDistrictsByDemo = calcDistrictsByDemo;
+// NOTE - Shift minority proportions up, so 37% minority scores like 49% share,
+//   but use the uncompressed seat probability distribution. This makes a 37% 
+//   district have a 40% chance of winning, a 42% district have an 84% chance,
+//   and a 50% district have a 99% chance. Below 37% has no chance.
+//
+function estMinorityOpportunity(Mf) {
+    // NOTE - Switch to compress the probability distribution
+    const bCompress = false;
+    const dist = bCompress ? C.minorityOpportunityDistribution() : [0.0, 1.0];
+    const range = C.minorityOpportunityRange();
+    const _normalizer = new normalize_1.Normalizer(Mf);
+    const shift = C.minorityShift();
+    _normalizer.wipNum += shift;
+    _normalizer.clip(dist[C.BEG], dist[C.END]);
+    _normalizer.unitize(dist[C.BEG], dist[C.END]);
+    const oppty = (Mf < range[C.BEG]) ? 0.0 : partisan_1.estSeatProbability(_normalizer.wipNum, dist);
+    return oppty;
+}
+exports.estMinorityOpportunity = estMinorityOpportunity;
+// HELPERS
+function exceedsMinimumThreshold(Mf) {
+    const threshold = C.minorityOpportunityRange()[C.BEG];
+    return Mf >= threshold;
+}
+function exceedsMaximumThreshold(Mf) {
+    const threshold = C.minorityOpportunityRange()[C.END];
+    return Mf > threshold;
+}
+function calcProportionalDistricts(proportion, nDistricts) {
+    // TODO - Bump up to get a statewide proportion on the bubble to rate one district?
+    const roundUp = 0.0;
+    const fractional = proportion * nDistricts;
+    const integral = Math.round(fractional + roundUp);
+    return integral;
+}
+exports.calcProportionalDistricts = calcProportionalDistricts;
+
+
+/***/ }),
+
+/***/ "./src/normalize.ts":
+/*!**************************!*\
+  !*** ./src/normalize.ts ***!
+  \**************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+//
+// NORMALIZATION UTILITIES
+//
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const S = __importStar(__webpack_require__(/*! ./settings */ "./src/settings.ts"));
+class Normalizer {
+    constructor(rawValue) {
+        this.rawNum = rawValue;
+        this.wipNum = this.rawNum;
+    }
+    // *Don't* transform the input.
+    identity() {
+        return this.wipNum;
+    }
+    positive() {
+        this.wipNum = Math.abs(this.wipNum);
+        return this.wipNum;
+    }
+    // Invert a value in the unit range [0.0–1.0] (so that bigger is better).
+    invert() {
+        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
+        console.assert(((this.wipNum >= 0.0) && (this.wipNum <= 1.0)), "Inverting: " + S.OUT_OF_RANGE_MSG, this.wipNum);
+        this.wipNum = 1.0 - this.wipNum;
+        return this.wipNum;
+    }
+    // Constrain the value to be within a specified range.
+    clip(begin_range, end_range) {
+        // Handle the ends of the range being given either order
+        const min_range = Math.min(begin_range, end_range);
+        const max_range = Math.max(begin_range, end_range);
+        this.wipNum = Math.max(Math.min(this.wipNum, max_range), min_range);
+        return this.wipNum;
+    }
+    // Recast the value as the delta from a baseline value. NOOP if it is zero.
+    // NOTE - Values can be + or -.
+    rebase(base) {
+        this.wipNum = this.wipNum - base;
+        return this.wipNum;
+    }
+    // Re-scale a value into the [0.0 – 1.0] range, using a given range.
+    // NOTE - This assumes that values have alrady been clipped into the range.
+    unitize(begin_range, end_range) {
+        const min_range = Math.min(begin_range, end_range);
+        const max_range = Math.max(begin_range, end_range);
+        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
+        console.assert(((this.wipNum >= min_range) && (this.wipNum <= max_range)), "Unitizing: " + S.OUT_OF_RANGE_MSG, this.wipNum);
+        const ranged = this.wipNum - min_range;
+        this.wipNum = Math.abs(ranged / (end_range - begin_range));
+        return this.wipNum;
+    }
+    // Decay a value in the unit range [0.0–1.0] by its distance from zero.
+    // NOTE - If the range is already such that "bigger is better," then the closer
+    //   the value is to 1.0 (the best) the *less* it will decay.
+    decay(fn = 0 /* Gravity */) {
+        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
+        console.assert(((this.wipNum >= 0.0) && (this.wipNum <= 1.0)), "Decaying: " + S.OUT_OF_RANGE_MSG, this.wipNum);
+        switch (fn) {
+            case 0 /* Gravity */: {
+                this.wipNum = Math.pow(this.wipNum, S.DISTANCE_WEIGHT);
+                return this.wipNum;
+            }
+            default: {
+                throw new Error("Decay function not recognized.");
+            }
+        }
+    }
+    // Translate a value in the unit range to the user-friendly range [0 – 100].
+    rescale() {
+        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
+        console.assert(((this.wipNum >= 0.0) && (this.wipNum <= 1.0)), "Rescaling: " + S.OUT_OF_RANGE_MSG, this.wipNum);
+        this.normalizedNum = Math.round(this.wipNum * S.NORMALIZED_RANGE);
+        return this.normalizedNum;
+    }
+}
+exports.Normalizer = Normalizer;
+
+
+/***/ }),
+
+/***/ "./src/partisan.ts":
+/*!*************************!*\
+  !*** ./src/partisan.ts ***!
+  \*************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -89865,117 +90349,218 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
 const S = __importStar(__webpack_require__(/*! ./settings */ "./src/settings.ts"));
+const C = __importStar(__webpack_require__(/*! ./config */ "./src/config.ts"));
 const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts");
 // NOTE - I'm passing T.VfArray's into everything. District indices = array indices.
 // NOTE - I do not (cannot) assume that the values are sorted.
 // SCORE BIAS & COMPETITIVENESS
 /* SCORECARD FIELDS:
 
-* ^S# [BestS] = the Democratic seats closest to proportional
-* ^S% [BestSf] = the corresponding Democratic seat share
-* F# [FptpS] = the estimated number of Democratic seats using first past the post
-* S# [ProbableS] = the estimated Democratic seats, using seat probabilities
-* S% [ProbableSf] = the estimated Democratic seat share fraction, calculated as S# / N
-* B% [Bias]= the bias calculated as S% – ^S%
-* B$ [BiasScore] = the bias score normalized [0–100]
-
-* R# [R] = the responsiveness at V%
-* Rd [Rd] = the estimated # of responsive districts (using probabilities)
-* Rd% [Rdf] = the estimated # of responsive districts, as a fraction of N
-* Cd [Cd] = the estimated # of competitive districts, using probabilities & a narrower [0.25–0.75] range
-* Cd% [Cdf] = the estimated # of competitive districts, as a fraction of N
-* Md% [Mdf] = the probability that the marginal seats will flip, so S% => ^S%
-* C$ [CompetitiveScore] = the competitiveness score normalized [0–100]
-
-* $$$ = the combined partisan score normalize [0–100]
+* ^S# [propS] = the Democratic seats closest to proportional
+* ^S% [propSf] = the corresponding Democratic seat share
+* S! [fptpS] = the estimated number of Democratic seats using first past the post
+* S# [estS] = the estimated Democratic seats, using seat probabilities
+* S% [estSf] = the estimated Democratic seat share fraction, calculated as S# / N
+
+* Bs50 [s50V] = Seat bias as a fraction of N
+* Bv50 [v50S] = Votes bias as a fraction
+* decl [decl] = Declination
+* gSym [gSym] = Global symmetry
+
+* EG [EG] = Efficiency gap as a fraction
+* sVg [BsGf] = Seats bias @ <V> (geometric)
+* prop [prop] = Disproportionality
+* MM [mMs] = Mean – median difference using statewide Vf
+* TO [tOf] = Turnout bias
+* MM' [mMd] = Mean – median difference using average district v
+* LO [LO] = Lopsided outcomes
+
+* B% [bias]= the bias calculated as S% – ^S%
+* B$ [bias.score] = the bias score normalized [0–100]
+
+* UE# [unearnedS] = the number of unearned seats (R = positive; D = negative)
+* I$ [impact.score] -- the unearned seats normalized [0–100] as impact
+
+* R [bigR] = Overall responsiveness
+* r [littleR] = The point responsiveness at V%
+* MIR [MIR] = Minimal inverse responsiveness
+* rD [rD] = the estimated # of responsive districts (using probabilities)
+* rD% [rDf] = the estimated # of responsive districts, as a fraction of N
+
+* C [c] = the number of districts that fall into the range [45–55%]
+* cD [cD] = the estimated # of competitive districts, using probabilities & a narrower [0.25–0.75] range
+* cD% [cDf] = the estimated # of competitive districts, as a fraction of N
+* beg/end [mRange] = the 1–N indices for the first and last district that separate the likely result and the proportional result
+* Md [mD] = the competitiveness of the marginal districts
+* Md% [mDf] = the probability that the marginal seats will flip, so S% => ^S%
+* C$ [competitiveness.score] = the competitiveness score normalized [0–100]
+
+* <P$ [score] = the combined partisan score used to compare plans *across* states
+* >P$ [score2] = the combined partisan score used to compare plans *within* a state, along with traditional districting principles
 
 */
-function scorePartisan(Vf, VfArray, all = false) {
+function scorePartisan(Vf, VfArray, options) {
+    const bAlternateMetrics = options.alternates;
+    const bConstrained = options.constrained;
+    const shift = options.shift;
     const N = VfArray.length;
-    const BestS = bestSeats(N, Vf);
-    const BestSf = bestSeatShare(BestS, N);
-    const FptpS = all ? estFPTPSeats(VfArray) : undefined;
-    const ProbableS = estProbableSeats(VfArray);
-    const ProbableSf = estProbableSeatShare(ProbableS, N);
-    const Bias = estBias(ProbableSf, BestSf);
-    const normalizedBias = scoreBias(Bias, Vf, ProbableSf, N);
-    const inferredSVpoints = all ? inferSVpoints(Vf, VfArray) : undefined;
-    const R = all ? estResponsiveness(Vf, inferredSVpoints) : undefined;
-    const Rd = all ? estResponsiveDistricts(VfArray) : undefined;
-    const Rdf = all ? estResponsiveDistrictsShare(Rd, N) : undefined;
-    const Cd = estCompetitiveDistricts(VfArray);
-    const Cdf = estCompetitiveDistrictsShare(Cd, N);
-    const Mdf = estMarginalCompetitiveShare(Vf, VfArray, N);
-    const normalizedCompetitiveness = scoreCompetitiveness(Mdf, Cdf);
-    const biasScoring = {
-        BestS: BestS,
-        BestSf: BestSf,
-        FptpS: FptpS,
-        ProbableS: ProbableS,
-        ProbableSf: ProbableSf,
-        Bias: Bias,
-        normalized: normalizedBias
+    const propS = propSeats(N, Vf);
+    const propSf = propSeatShare(propS, N);
+    const fptpS = bAlternateMetrics ? estFPTPSeats(VfArray) : undefined;
+    const range = bConstrained ? C.competitiveDistribution() : undefined;
+    const estS = estSeats(VfArray, range);
+    const estSf = estSeatShare(estS, N);
+    const bias = estBias(estSf, propSf);
+    const biasScore = scorebias(bias, Vf, estSf);
+    const unearnedS = estUnearnedSeats(propS, estS);
+    const impactScore = scoreImpact(unearnedS, Vf, N);
+    // Calculate additional alternate metrics for reference
+    // NOTE - Use the uncompressed seat probability function
+    const inferredSVpoints = bAlternateMetrics ? inferSVpoints(Vf, VfArray, shift) : undefined;
+    const TOf = bAlternateMetrics ? calcTurnoutBias(Vf, VfArray) : undefined;
+    const Bs50 = bAlternateMetrics ? estPartisanBias(inferredSVpoints, N) : undefined;
+    const Bs50f = (!(Bs50 === undefined)) ? U.trim(Bs50 / N) : undefined;
+    const Bv50f = bAlternateMetrics ? estVotesBias(inferredSVpoints, N) : undefined;
+    const decl = bAlternateMetrics ? calcDeclination(VfArray) : undefined;
+    const gSym = bAlternateMetrics ? calcGlobalSymmetry(inferredSVpoints, Bs50f) : undefined;
+    const EG = bAlternateMetrics ? calcEfficiencyGap(Vf, estSf) : undefined;
+    const BsGf = bAlternateMetrics ? estGeometricSeatsBias(Vf, inferredSVpoints) : undefined;
+    const prop = bAlternateMetrics ? calcDisproportionality(Vf, estSf) : undefined;
+    const mMs = bAlternateMetrics ? estMeanMedianDifference(VfArray, Vf) : undefined;
+    const mMd = bAlternateMetrics ? estMeanMedianDifference(VfArray) : undefined;
+    const LO = bAlternateMetrics ? calcLopsidedOutcomes(VfArray) : undefined;
+    // Calculate alternate responsiveness metrics for reference
+    const bigR = bAlternateMetrics ? calcBigR(Vf, estSf) : undefined;
+    const littleR = bAlternateMetrics ? estResponsiveness(Vf, inferredSVpoints) : undefined;
+    const MIR = bAlternateMetrics ? calcMinimalInverseResponsiveness(Vf, littleR) : undefined;
+    const rD = (!bConstrained || bAlternateMetrics) ? estResponsiveDistricts(VfArray) : undefined;
+    const rDf = bAlternateMetrics ? estResponsiveDistrictsShare(rD, N) : undefined;
+    const Cn = countCompetitiveDistricts(VfArray);
+    const cD = bConstrained ? estCompetitiveDistricts(VfArray) : rD;
+    const cDf = estCompetitiveDistrictsShare(cD, N);
+    const Mrange = findMarginalDistricts(Vf, VfArray, N);
+    const Md = estMarginalCompetitiveDistricts(Mrange, VfArray);
+    const Mdf = estMarginalCompetitiveShare(Md, Mrange);
+    const competitivenessScore = scoreCompetitiveness(Mdf, cDf);
+    let biasScoring = {
+        propS: propS,
+        propSf: propSf,
+        estS: estS,
+        estSf: estSf,
+        bias: bias,
+        score: biasScore
     };
-    let competitiveScoring;
-    if (all) {
-        competitiveScoring = {
-            R: R,
-            Rd: Rd,
-            Rdf: Rdf,
-            Cd: Cd,
-            Cdf: Cdf,
-            Mdf: Mdf,
-            normalized: normalizedCompetitiveness
-        };
-    }
-    else {
-        competitiveScoring = {
-            Cd: Cd,
-            Cdf: Cdf,
-            Mdf: Mdf,
-            normalized: normalizedCompetitiveness
-        };
-    }
+    const impactScoring = {
+        unearnedS: unearnedS,
+        score: impactScore
+    };
+    let competitiveScoring = {
+        c: Cn,
+        cD: cD,
+        cDf: cDf,
+        mRange: Mrange,
+        mD: Md,
+        mDf: Mdf,
+        score: competitivenessScore
+    };
+    if (bAlternateMetrics) {
+        biasScoring.tOf = TOf;
+        biasScoring.fptpS = fptpS;
+        biasScoring.s50V = Bs50f;
+        biasScoring.v50S = Bv50f;
+        biasScoring.decl = decl;
+        biasScoring.gSym = gSym;
+        biasScoring.eG = EG;
+        biasScoring.sVg = BsGf;
+        biasScoring.prop = prop;
+        biasScoring.mMs = mMs;
+        biasScoring.mMd = mMd;
+        biasScoring.lO = LO;
+        competitiveScoring.bigR = bigR;
+        competitiveScoring.littleR = littleR;
+        competitiveScoring.mIR = MIR;
+        competitiveScoring.rD = rD;
+        competitiveScoring.rDf = rDf;
+    }
+    // Weight bias, impact, and competitiveness into partisan scores to compare
+    // plans across states and within a state.
+    const bS = biasScoring.score;
+    const iS = impactScoring.score;
+    const cS = competitiveScoring.score;
+    const acrossStatesPartisanScore = weightPartisan(bS, iS, cS, 0 /* AcrossStates */);
+    const withinStatesPartisanScore = weightPartisan(bS, iS, cS, 1 /* WithinAState */);
     const s = {
         bias: biasScoring,
-        competitiveness: competitiveScoring
+        impact: impactScoring,
+        competitiveness: competitiveScoring,
+        score: acrossStatesPartisanScore,
+        score2: withinStatesPartisanScore
     };
     return s;
 }
 exports.scorePartisan = scorePartisan;
-function weightPartisan(b, c) {
-    return Math.round(((S.BIAS_WEIGHT * b) + (S.COMPETITIVE_WEIGHT * c)) / (S.BIAS_WEIGHT + S.COMPETITIVE_WEIGHT));
+function weightPartisan(bS, iS, cS, context) {
+    const bW = C.biasWeight(context);
+    const iW = C.impactWeight(context);
+    const cW = C.competitivenessWeight(context);
+    const score = Math.round(((bS * bW) + (iS * iW) + (cS * cW)) / (bW + iW + cW));
+    return score;
 }
 exports.weightPartisan = weightPartisan;
-function printFairScorecardHeader() {
-    console.log('XX, Name, N, V%, ^S#, ^S%, F#, S#, S%, B%, B$, R#, Rd, Rd%, Cd, Cd%, Md%, C$, $$$');
-}
-exports.printFairScorecardHeader = printFairScorecardHeader;
-function printFairScorecard(xx, name, N, Vf, s) {
-    console.log('%s, %s, %i, %f, %i, %f, %i, %f, %f, %f, %i, %f, %f, %f, %f, %f, %f, %f, %i', xx, name, N, Vf, s.bias.BestS, s.bias.BestSf, s.bias.FptpS, s.bias.ProbableS, s.bias.ProbableSf, s.bias.Bias, s.bias.normalized, s.competitiveness.R, s.competitiveness.Rd, s.competitiveness.Rdf, s.competitiveness.Cd, s.competitiveness.Cdf, s.competitiveness.Mdf, s.competitiveness.normalized, s.score);
+function extraBonus(Vf) {
+    const okExtra = (0.5 - Vf) * (C.winnerBonus() - 1.0);
+    return U.trim(okExtra);
 }
-exports.printFairScorecard = printFairScorecard;
-function scoreBias(rawBias, Vf, Sf, N) {
+exports.extraBonus = extraBonus;
+function scorebias(rawBias, Vf, Sf) {
     if (isAntimajoritarian(Vf, Sf)) {
         return 0;
     }
     else {
-        const _normalizer = new normalize_1.Normalizer(rawBias);
-        const oneSeatFraction = 1 / N;
-        const worst = Math.min(oneSeatFraction, S.BIAS_WORST);
-        const best = S.BIAS_BEST;
+        // Adjust bias to incorporate an acceptable winner's bonus based on Vf
+        const extra = extraBonus(Vf);
+        const adjusted = adjustBias(Vf, rawBias, extra);
+        // Then normalize
+        const _normalizer = new normalize_1.Normalizer(adjusted);
+        const worst = C.biasRange()[C.BEG];
+        const best = C.biasRange()[C.END];
+        _normalizer.positive();
         _normalizer.clip(worst, best);
         _normalizer.unitize(worst, best);
         _normalizer.invert();
-        // TODO - SCORE: Would also decaying raw values (e.g., by squaring them) be too
-        //   much with a small range (like 10% or one seat)?
-        // _normalizer.decay();
         _normalizer.rescale();
         const score = _normalizer.normalizedNum;
         return score;
     }
 }
-exports.scoreBias = scoreBias;
+exports.scorebias = scorebias;
+// Adjust bias to account for a winner's bonus
+function adjustBias(Vf, bias, extra) {
+    if (Vf > 0.5)
+        return Math.min(bias - extra, 0);
+    else
+        return Math.max(bias - extra, 0);
+}
+exports.adjustBias = adjustBias;
+// Normalize unearned seats
+function scoreImpact(rawUE, Vf, N) {
+    // Adjust impact to incorporate an acceptable winner's bonus based on Vf
+    const extra = extraBonus(Vf);
+    const adjustedBias = adjustBias(Vf, rawUE / N, extra);
+    const adjustedImpact = adjustedBias * N;
+    // Then normalize
+    const _normalizer = new normalize_1.Normalizer(adjustedImpact);
+    const worst = C.unearnedThreshold();
+    const best = 0.0;
+    _normalizer.positive();
+    _normalizer.clip(worst, best);
+    _normalizer.unitize(worst, best);
+    _normalizer.invert();
+    _normalizer.rescale();
+    const score = _normalizer.normalizedNum;
+    return score;
+}
+exports.scoreImpact = scoreImpact;
 function isAntimajoritarian(Vf, Sf) {
     const bDem = ((Vf < 0.5) && (Sf > 0.5)) ? true : false;
     const bRep = (((1 - Vf) < 0.5) && ((1 - Sf) > 0.5)) ? true : false;
@@ -89987,16 +90572,24 @@ function scoreCompetitiveness(rawMarginal, rawOverall) {
     // But the practical max is more like 2/3's, so unitize that range to [0.0–1.0].
     // Then scale the values to [0–100].
     const _overall = new normalize_1.Normalizer(rawOverall);
-    _overall.clip(S.COMPETITIVE_WORST, S.COMPETITIVE_BEST);
-    _overall.unitize(S.COMPETITIVE_WORST, S.COMPETITIVE_BEST);
+    let worst = C.overallCompetitivenessRange()[C.BEG];
+    let best = C.overallCompetitivenessRange()[C.END];
+    _overall.clip(worst, best);
+    _overall.unitize(worst, best);
     _overall.rescale();
-    const overall = _overall.normalizedNum;
+    const ocS = _overall.normalizedNum;
     // Normalize marginal competitiveness
     const _marginal = new normalize_1.Normalizer(rawMarginal);
+    worst = C.marginalCompetitivenessRange()[C.BEG];
+    best = C.marginalCompetitivenessRange()[C.END];
+    _marginal.clip(worst, best);
+    _marginal.unitize(worst, best);
     _marginal.rescale();
-    const marginal = _marginal.normalizedNum;
+    const mcS = _marginal.normalizedNum;
+    const mcW = C.marginalCompetitivenessWeight();
+    const ocW = C.overallCompetitivenessWeight();
     // Then combine the results
-    const score = Math.round(((S.MARGINAL_WEIGHT * marginal) + (S.OVERALL_WEIGHT * overall)) / (S.MARGINAL_WEIGHT + S.OVERALL_WEIGHT));
+    const score = Math.round(((mcW * mcS) + (ocW * ocS)) / (mcW + ocW));
     return score;
 }
 exports.scoreCompetitiveness = scoreCompetitiveness;
@@ -90006,30 +90599,56 @@ const { erf } = __webpack_require__(/*! mathjs */ "./node_modules/mathjs/main/es
 // console.log("erf(-0.5) =", erf(-0.5));  // returns -0.5204998778130465
 // console.log("erf(4) =", erf(4));        // returns 0.9999999845827421
 // Estimate the probability of a seat win for district, given a Vf
-function estSeatProbability(Vf) {
+function estSeatProbability(Vf, range) {
+    if (range) {
+        // If a range is provided, it defines end points of a compressed probability
+        // distribution. These *aren't* the points where races start or stop being
+        // contested, just the end points of a distribution that yields the desired
+        // probabilities in the typical competitive range [45-55%].
+        const _normalizer = new normalize_1.Normalizer(Vf);
+        const distBeg = range[C.BEG];
+        const distEnd = range[C.END];
+        _normalizer.clip(distBeg, distEnd);
+        _normalizer.unitize(distBeg, distEnd);
+        return seatProbabilityFn(_normalizer.wipNum);
+    }
+    else {
+        // Otherwise, use the full probability distribution.
+        return seatProbabilityFn(Vf);
+    }
+}
+exports.estSeatProbability = estSeatProbability;
+function seatProbabilityFn(Vf) {
     // Python: 0.5 * (1 + erf((vpi - 0.50) / (0.02 * sqrt(8))))
     return U.trim(0.5 * (1.0 + erf((Vf - 0.50) / (0.02 * Math.sqrt(8)))));
 }
-exports.estSeatProbability = estSeatProbability;
 // Estimate the number of responsive districts [R(d)], given a set of Vf's
 function estDistrictResponsiveness(Vf) {
     // Python: 1 - 4 * (est_seat_probability(vpi) - 0.5)**2
     return U.trim(1.0 - 4.0 * Math.pow((estSeatProbability(Vf) - 0.5), 2));
 }
 exports.estDistrictResponsiveness = estDistrictResponsiveness;
-function inferSVpoints(Vf, VfArray) {
+function inferSVpoints(Vf, VfArray, shift, range) {
     const nDistricts = VfArray.length;
     let SVpoints = [];
     for (let shiftedVf of shiftRange()) {
-        const shiftedVPI = shiftDistricts(Vf, VfArray, shiftedVf);
-        const shiftedSf = estProbableSeats(shiftedVPI) / nDistricts;
+        const shiftedVPI = shiftDistricts(Vf, VfArray, shiftedVf, shift);
+        const shiftedSf = estSeats(shiftedVPI, range) / nDistricts;
         SVpoints.push({ v: shiftedVf, s: shiftedSf });
+        // TODO - Why can't I trim these? Why does that only break the Hypotheticals?!?
+        // SVpoints.push({v: U.trim(Number(shiftedVf)), s: shiftedSf});
     }
     return SVpoints;
 }
 exports.inferSVpoints = inferSVpoints;
-// Shift districts *proportionally*
-function shiftDistricts(Vf, VfArray, shiftedVf) {
+function shiftDistricts(Vf, VfArray, shiftedVf, shift) {
+    if (shift == 0 /* Proportional */)
+        return shiftProportionally(Vf, VfArray, shiftedVf);
+    else
+        return shiftUniformly(Vf, VfArray, shiftedVf);
+}
+// Shift districts proportionally
+function shiftProportionally(Vf, VfArray, shiftedVf) {
     let shiftedVfArray;
     if (shiftedVf < Vf) {
         // Shift down: D's to R's
@@ -90047,39 +90666,48 @@ function shiftDistricts(Vf, VfArray, shiftedVf) {
     }
     return shiftedVfArray;
 }
-// Generate v's from 0.25 to 0.75 in 0.005 (1/2%) increments
+// Shift districts uniformly
+function shiftUniformly(Vf, VfArray, shiftedVf) {
+    const shift = shiftedVf - Vf;
+    const shiftedVfArray = VfArray.map((v => v + shift));
+    return shiftedVfArray;
+}
+// Generate a range of v's in 1/2% increments
 function shiftRange() {
-    const range = [];
-    const lower = 25 / 100;
-    const upper = 75 / 100;
+    const range = [0.25, 0.75];
+    const axisRange = [];
     const step = (1 / 100) / 2;
-    for (let v = lower; v <= upper + S.EPSILON; v += step) {
-        range.push(v);
+    for (let v = range[0]; v <= range[1] + S.EPSILON; v += step) {
+        axisRange.push(v);
     }
-    return range;
+    return axisRange;
 }
-// ESTIMATE BIAS ("FAIR")
+// ESTIMATE BIAS
+//
+// NOTE: By convention, '+' = R bias; '-' = D bias.
+//
 // ^S# - The # of Democratic seats closest to proportional @ statewide Vf
-function bestSeats(N, Vf) {
-    return Math.round(N * Vf);
+// The "expected number of seats" from http://bit.ly/2Fcuf4q
+function propSeats(N, Vf) {
+    return Math.round((N * Vf) - S.EPSILON);
 }
-exports.bestSeats = bestSeats;
+exports.propSeats = propSeats;
 // ^S% - The corresponding Democratic seat share 
-function bestSeatShare(bestS, N) {
+function propSeatShare(bestS, N) {
     return U.trim(bestS / N);
 }
-exports.bestSeatShare = bestSeatShare;
-// S# - The estimated # of Democratic seats @ statewide Vf, using seat probabilities
-function estProbableSeats(VfArray) {
+exports.propSeatShare = propSeatShare;
+// S# - The estimated # of Democratic seats, using seat probabilities
+function estSeats(VfArray, range) {
     // Python: sum([est_seat_probability(vpi) for vpi in vpi_by_district])
-    return U.trim(U.sumArray(VfArray.map(v => estSeatProbability(v))));
+    return U.trim(U.sumArray(VfArray.map(v => estSeatProbability(v, range))));
 }
-exports.estProbableSeats = estProbableSeats;
-// S% - The estimated Democratic seat share fraction @ statewide Vf
-function estProbableSeatShare(probableS, N) {
-    return U.trim(probableS / N);
+exports.estSeats = estSeats;
+// S% - The estimated Democratic seat share fraction
+function estSeatShare(estS, N) {
+    return U.trim(estS / N);
 }
-exports.estProbableSeatShare = estProbableSeatShare;
+exports.estSeatShare = estSeatShare;
 // F# - The estimated number of Democratic seats using first past the post
 function estFPTPSeats(VfArray) {
     // Python: sum([1.0 for vpi in vpi_by_district if (vpi > 0.5)])
@@ -90093,27 +90721,33 @@ function estFPTPSeats(VfArray) {
     }));
 }
 exports.estFPTPSeats = estFPTPSeats;
-// B% - Tthe bias calculated as S% – ^S%
-function estBias(estSeatShare, bestSeatShare) {
-    return U.trim(Math.abs(estSeatShare - bestSeatShare));
+// B% - The bias calculated as ^S% — S%
+function estBias(estSf, propSf) {
+    return U.trim(propSf - estSf);
 }
 exports.estBias = estBias;
+// UE# - The estimated # of unearned seats
+// UE_# from http://bit.ly/2Fcuf4q
+function estUnearnedSeats(proportional, probable) {
+    return U.trim(proportional - probable);
+}
+exports.estUnearnedSeats = estUnearnedSeats;
 // ESTIMATE RESPONSIVENESS ("COMPETITIVE")
 // R# - Estimate responsiveness at the statewide vote share
 function estResponsiveness(Vf, inferredSVpoints) {
-    // Python:
-    // V1, S1 = lower_bracket(sv_curve_pts, statewide_vote_share, VOTE_SHARE)
-    // V2, S2 = upper_bracket(sv_curve_pts, statewide_vote_share, VOTE_SHARE)
-    // R = ((S2 - S1) / total_seats) / (V2 - V1)
-    // Note - Seat values are already fractions [0.0–1.0] here.
-    const lowerPt = findLowerBracket(Vf, inferredSVpoints);
-    const upperPt = findUpperBracket(Vf, inferredSVpoints);
-    const R = ((upperPt.s - lowerPt.s) / (upperPt.v - lowerPt.v));
-    return U.trim(R);
+    let R = undefined;
+    // NOTE - Seat values are already fractions [0.0–1.0] here.
+    const lowerPt = findBracketingLowerVf(Vf, inferredSVpoints);
+    const upperPt = findBracketingUpperVf(Vf, inferredSVpoints);
+    if (!(U.areRoughlyEqual((upperPt.v - lowerPt.v), 0, S.EPSILON))) {
+        R = ((upperPt.s - lowerPt.s) / (upperPt.v - lowerPt.v));
+        R = U.trim(R);
+    }
+    return R;
 }
 exports.estResponsiveness = estResponsiveness;
 // Find the S(V) point that brackets a Vf value on the lower end
-function findLowerBracket(Vf, inferredSVpoints) {
+function findBracketingLowerVf(Vf, inferredSVpoints) {
     let lowerPt = inferredSVpoints[0];
     let smallerPoints = [];
     for (let pt of inferredSVpoints) {
@@ -90129,7 +90763,7 @@ function findLowerBracket(Vf, inferredSVpoints) {
     return lowerPt;
 }
 // Find the S(V) point that brackets a Vf value on the upper end
-function findUpperBracket(Vf, inferredSVpoints) {
+function findBracketingUpperVf(Vf, inferredSVpoints) {
     let upperPt = inferredSVpoints[-1];
     for (let pt of inferredSVpoints) {
         if (pt.v >= Vf) {
@@ -90140,19 +90774,56 @@ function findUpperBracket(Vf, inferredSVpoints) {
     }
     return upperPt;
 }
-// Rd -  Estimate the number of responsive districts, given a set of Vf's
+// The corresponding functions via the Sf y-axis (vs. Vf x-axis)
+// Find the S(V) point that brackets a Sf value on the lower end
+function findBracketingLowerSf(Sf, inferredSVpoints) {
+    let lowerPt = inferredSVpoints[0];
+    let smallerPoints = [];
+    for (let pt of inferredSVpoints) {
+        if (pt.s <= Sf) {
+            smallerPoints.push(pt);
+        }
+        else {
+            break;
+        }
+    }
+    // The last smaller point
+    lowerPt = smallerPoints.slice(-1)[0];
+    return lowerPt;
+}
+// Find the S(V) point that brackets a Sf value on the upper end
+function findBracketingUpperSf(Sf, inferredSVpoints) {
+    let upperPt = inferredSVpoints[-1];
+    for (let pt of inferredSVpoints) {
+        if (pt.s >= Sf) {
+            // The first bigger point
+            upperPt = { v: pt.v, s: pt.s };
+            break;
+        }
+    }
+    return upperPt;
+}
+// rD -  Estimate the number of responsive districts, given a set of Vf's
 function estResponsiveDistricts(VfArray) {
     // Python: sum([est_district_responsiveness(vpi) for vpi in vpi_by_district])
     return U.trim(U.sumArray(VfArray.map(v => estDistrictResponsiveness(v))));
 }
 exports.estResponsiveDistricts = estResponsiveDistricts;
-// Rd% - The estimated # of responsive districts, as a fraction of N
-function estResponsiveDistrictsShare(Rd, N) {
-    return U.trim(Rd / N);
+// rD% - The estimated # of responsive districts, as a fraction of N
+function estResponsiveDistrictsShare(rD, N) {
+    return U.trim(rD / N);
 }
 exports.estResponsiveDistrictsShare = estResponsiveDistrictsShare;
 // ESTIMATE COMPETITIVENESS (ENHANCED)
-// Cd - The estimated # of competitive districts
+// C - Count the # of competitive districts, defined as v in [45–55%]
+function countCompetitiveDistricts(VfArray) {
+    return U.trim(U.sumArray(VfArray.map(v => isCompetitive(v))));
+}
+exports.countCompetitiveDistricts = countCompetitiveDistricts;
+function isCompetitive(v) {
+    return ((v >= C.competitiveRange()[C.BEG]) && (v <= C.competitiveRange()[C.END])) ? 1 : 0;
+}
+// cD - The estimated # of competitive districts
 function estCompetitiveDistricts(VfArray) {
     return U.trim(U.sumArray(VfArray.map(v => estDistrictCompetitiveness(v))));
 }
@@ -90160,21 +90831,48 @@ exports.estCompetitiveDistricts = estCompetitiveDistricts;
 // Re-scale a Democratic vote share to the competitive range (e.g., 45–55%).
 function estDistrictCompetitiveness(Vf) {
     const _normalizer = new normalize_1.Normalizer(Vf);
-    _normalizer.clip(S.MIN_CONTESTED, S.MAX_CONTESTED);
-    _normalizer.unitize(S.MIN_CONTESTED, S.MAX_CONTESTED);
+    // The end points of a compressed probability distribution
+    // NOTE - These aren't the points where races start or stop being contested,
+    //   just the end points of a distribution that yields the desired behavior
+    //   in the typical competitive range [45-55%].
+    const distBeg = C.competitiveDistribution()[C.BEG];
+    const distEnd = C.competitiveDistribution()[C.END];
+    _normalizer.clip(distBeg, distEnd);
+    _normalizer.unitize(distBeg, distEnd);
     const dC = estDistrictResponsiveness(_normalizer.wipNum);
     return dC;
 }
 exports.estDistrictCompetitiveness = estDistrictCompetitiveness;
-// Cd% - The estimated # of competitive districts, as a fraction of N
-function estCompetitiveDistrictsShare(Cd, N) {
-    return U.trim(Cd / N);
+// cD% - The estimated # of competitive districts, as a fraction of N
+function estCompetitiveDistrictsShare(cD, N) {
+    return U.trim(cD / N);
 }
 exports.estCompetitiveDistrictsShare = estCompetitiveDistrictsShare;
+// Md - The estimated # of "marginal" districts in and around the likely FPTP
+//   seats & the best seat split that are competitive.
+function estMarginalCompetitiveDistricts(Mrange, VfArray) {
+    const minId = Mrange[C.BEG];
+    const maxId = Mrange[C.END];
+    // Sort the array values, and subset it to those districts
+    // NOTE - I'm *not* keeping track of the district indexes right now
+    let subsetVfArray = VfArray.sort().slice(minId - 1, maxId);
+    // Est. competitive districts on that array
+    const Md = U.sumArray(subsetVfArray.map(v => estDistrictCompetitiveness(v)));
+    return U.trim(Md);
+}
+exports.estMarginalCompetitiveDistricts = estMarginalCompetitiveDistricts;
 // Md% - The estimated competitiveness of the "marginal" districts in and around
 //   the likely FPTP seats & the best seat split as a fraction
-function estMarginalCompetitiveShare(Vf, VfArray, N) {
-    const bestS = bestSeats(N, Vf);
+function estMarginalCompetitiveShare(Md, Mrange) {
+    const minId = Mrange[C.BEG];
+    const maxId = Mrange[C.END];
+    // Est. competitive district share on that result
+    const MdShare = U.trim(estCompetitiveDistrictsShare(Md, maxId - minId + 1));
+    return U.trim(MdShare);
+}
+exports.estMarginalCompetitiveShare = estMarginalCompetitiveShare;
+function findMarginalDistricts(Vf, VfArray, N) {
+    const bestS = propSeats(N, Vf);
     const fptpS = estFPTPSeats(VfArray);
     // Find the marginal districts IDs (indexed 1–N)
     let minId;
@@ -90192,137 +90890,331 @@ function estMarginalCompetitiveShare(Vf, VfArray, N) {
         minId = Math.max((N - bestS) - 1, 1);
         maxId = Math.min((N - bestS) + 1, N);
     }
-    const deltaS = maxId - minId + 1;
-    // Sort the array values, and subset it to those districts
-    // NOTE - I'm *not* keeping track of the district indexes right now
-    let subsetVfArray = VfArray.sort().slice(minId - 1, maxId);
-    // Est. competitive districts on that array
-    const Md = U.sumArray(subsetVfArray.map(v => estDistrictCompetitiveness(v)));
-    // Est. competitive district share on that result
-    const MdShare = U.trim(estCompetitiveDistrictsShare(Md, deltaS));
-    return U.trim(MdShare);
+    return [minId, maxId];
 }
-exports.estMarginalCompetitiveShare = estMarginalCompetitiveShare;
-
-
-/***/ }),
-
-/***/ "./src/index.ts":
-/*!**********************!*\
-  !*** ./src/index.ts ***!
-  \**********************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-//
-// SCORE PACKAGE API
-//
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+exports.findMarginalDistricts = findMarginalDistricts;
+// ADVANCED/ALTERNATE METRICS FOR REFERENCE
+function calcTurnoutBias(statewideVf, VfArray) {
+    const districtAvg = U.avgArray(VfArray);
+    const turnoutBias = statewideVf - districtAvg;
+    return U.trim(turnoutBias);
 }
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(/*! ./_api */ "./src/_api.ts"));
-var types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
-exports.sampleProfile = types_1.sampleProfile;
-exports.sampleScorecard = types_1.sampleScorecard;
-
-
-/***/ }),
-
-/***/ "./src/normalize.ts":
-/*!**************************!*\
-  !*** ./src/normalize.ts ***!
-  \**************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-//
-// NORMALIZATION UTILITIES
+exports.calcTurnoutBias = calcTurnoutBias;
+// PARTISAN BIAS - I'm using John Nagle's simple seat bias below, which is what
+//    PlanScore is doing:
 //
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const S = __importStar(__webpack_require__(/*! ./settings */ "./src/settings.ts"));
-class Normalizer {
-    constructor(rawValue) {
-        this.rawNum = rawValue;
-        this.wipNum = this.rawNum;
-    }
-    // *Don't* transform the input.
-    identity() {
-        return this.wipNum;
-    }
-    // TODO - Do I need this? If so, add TEST cases.
-    positive() {
-        this.wipNum = Math.abs(this.wipNum);
-        return this.wipNum;
-    }
-    // Invert a value in the unit range [0.0–1.0] (so that bigger is better).
-    invert() {
-        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
-        console.assert(((this.wipNum >= 0.0) && (this.wipNum <= 1.0)), S.OUT_OF_RANGE_MSG);
-        this.wipNum = 1.0 - this.wipNum;
-        return this.wipNum;
+//   "Partisan bias is the difference between each party’s seat share and 50 %
+//    in a hypothetical, perfectly tied election.For example, if a party would
+//    win 55 % of a plan’s districts if it received 50 % of the statewide vote,
+//    then the plan would have a bias of 5 % in this party’s favor.To calculate
+//    partisan bias, the observed vote share in each district is shifted by the
+//    amount necessary to simulate a tied statewide election.Each party’s seat
+//    share in this hypothetical election is then determined. The difference
+//    between each party’s seat share and 50 % is partisan bias."
+// 
+//    This is *not* King's & others' geometric partisan bias metric per se.
+//    That is below.
+function estPartisanBias(inferredSVpoints, nDistricts) {
+    return estSeatBias(inferredSVpoints, nDistricts);
+}
+exports.estPartisanBias = estPartisanBias;
+// SEATS BIAS -- John Nagle's simple seat bias @ 50% (alpha), a fractional # of seats.
+function estSeatBias(inferredSVpoints, nDistricts) {
+    const half = 0.5;
+    const tolerance = 0.001;
+    let dSeats = 0;
+    for (let pt of inferredSVpoints) {
+        if (U.areRoughlyEqual(pt.v, half, tolerance)) {
+            dSeats = pt.s * nDistricts;
+            break;
+        }
     }
-    // Constrain the value to be within a specified range.
-    clip(begin_range, end_range) {
-        // Handle the ends of the range being given either order
-        const min_range = Math.min(begin_range, end_range);
-        const max_range = Math.max(begin_range, end_range);
-        this.wipNum = Math.max(Math.min(this.wipNum, max_range), min_range);
-        return this.wipNum;
+    const rSeats = nDistricts - dSeats;
+    const Bs = (rSeats - dSeats) / 2.0;
+    // NOTE - That is the same as (N/2) - S(0.5).
+    // const BsAlt = (nDistricts / 2.0) - dSeats;
+    return U.trim(Bs);
+}
+exports.estSeatBias = estSeatBias;
+// VOTES BIAS -- John Nagle's simple vote bias @ 50% (alpha2), a percentage.
+function estVotesBias(inferredSVpoints, nDistricts) {
+    let extraVf = 0.0;
+    // Interpolate the extra Vf required @ Sf = 0.5
+    const lowerPt = findBracketingLowerSf(0.5, inferredSVpoints);
+    const upperPt = findBracketingUpperSf(0.5, inferredSVpoints);
+    if ((upperPt.s - lowerPt.s) != 0) {
+        const ratio = (upperPt.v - lowerPt.v) / (upperPt.s - lowerPt.s);
+        const deltaS = 0.5 - lowerPt.s;
+        extraVf = lowerPt.v + (ratio * deltaS) - 0.5;
+    }
+    extraVf = U.trim(extraVf);
+    return extraVf;
+}
+exports.estVotesBias = estVotesBias;
+// GEOMETRIC SEATS BIAS (@ V = statewide vote share)
+function estGeometricSeatsBias(Vf, inferredSVpoints) {
+    const bgsSVpoints = inferGeometricSeatsBiasPoints(inferredSVpoints);
+    // Interpolate the seat fraction @ Vf
+    const lowerPt = findBracketingLowerVf(Vf, bgsSVpoints);
+    const upperPt = findBracketingUpperVf(Vf, bgsSVpoints);
+    const ratio = (upperPt.s - lowerPt.s) / (upperPt.v - lowerPt.v);
+    const deltaV = Vf - lowerPt.v;
+    const deltaS = ratio * deltaV;
+    const BsGf = lowerPt.s + deltaS;
+    return U.trim(BsGf);
+}
+exports.estGeometricSeatsBias = estGeometricSeatsBias;
+function inferGeometricSeatsBiasPoints(inferredSVpoints) {
+    const nPoints = inferredSVpoints.length;
+    const inverseSVpoints = invertSVPoints(inferredSVpoints);
+    let bgsSVpoints = [];
+    for (let i = 0; i < nPoints; i++) {
+        const Vf = inferredSVpoints[i].v;
+        const sD = inferredSVpoints[i].s;
+        const sR = inverseSVpoints[i].s;
+        const BsGf = 0.5 * (sR - sD);
+        bgsSVpoints.push({ v: Vf, s: BsGf });
+    }
+    return bgsSVpoints;
+}
+exports.inferGeometricSeatsBiasPoints = inferGeometricSeatsBiasPoints;
+function invertSVPoints(inferredSVpoints) {
+    let invertedSVpoints = [];
+    for (let pt of inferredSVpoints) {
+        const Vd = pt.v;
+        const Sd = pt.s;
+        const Vr = U.trim(1.0 - Vd);
+        const Sr = 1.0 - Sd;
+        invertedSVpoints.push({ v: Vr, s: Sr });
+    }
+    invertedSVpoints.sort(function (a, b) {
+        return a.v - b.v;
+    });
+    return invertedSVpoints;
+}
+exports.invertSVPoints = invertSVPoints;
+// EFFICIENCY GAP -- note the formulation used. Also, to accommodate turnout bias,
+//   we would need to have D & R votes, not just shares.
+function calcEfficiencyGap(Vf, Sf, shareType = 0 /* Democratic */) {
+    let efficiencyGap;
+    if (shareType == 1 /* Republican */) {
+        // NOTE - This is the  common formulation:
+        //
+        //   EG = (Sf – 0.5)  – (2 × (Vf – 0.5))
+        //
+        //   in which it is implied that '-' = R bias; '+' = D bias.
+        efficiencyGap = U.trim((Sf - 0.5) - (2.0 * (Vf - 0.5)));
     }
-    // Recast the value as the delta from a baseline value. NOOP if it is zero.
-    // NOTE - Values can be + or -.
-    rebase(base) {
-        this.wipNum = this.wipNum - base;
-        return this.wipNum;
+    else {
+        // NOTE - This is the alternate formulation in which '+' = R bias; '-' = D bias,
+        //   which is consistent with all our other metrics.
+        efficiencyGap = U.trim((2.0 * (Vf - 0.5)) - (Sf - 0.5));
     }
-    // Re-scale a value into the [0.0 – 1.0] range, using a given range.
-    // NOTE - This assumes that values have alrady been clipped into the range.
-    unitize(begin_range, end_range) {
-        const min_range = Math.min(begin_range, end_range);
-        const max_range = Math.max(begin_range, end_range);
-        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
-        console.assert(((this.wipNum >= min_range) && (this.wipNum <= max_range)), S.OUT_OF_RANGE_MSG);
-        const ranged = this.wipNum - min_range;
-        this.wipNum = Math.abs(ranged / (end_range - begin_range));
-        return this.wipNum;
+    return U.trim(efficiencyGap);
+}
+exports.calcEfficiencyGap = calcEfficiencyGap;
+// MEAN–MEDIAN DIFFERENCE
+// 
+// From PlanScore.org: "The mean-median difference is a party’s median vote share
+//   minus its mean vote share, across all of a plan’s districts. For example, if
+//   a party has a median vote share of 45 % and a mean vote share of 50 %, then
+//   the plan has a mean - median difference of 5 % against this party. When the
+//   mean and the median diverge significantly, the district distribution is skewed
+//   in favor of one party and against its opponent. Conversely, when the mean and
+//   the median are close, the district distribution is more symmetric."
+//
+// From Princeton Gerrymandering Project: "The mean-median difference is calculated
+//   by subtracting the average vote share of either party across all districts from
+//   the median vote share of the same party across all districts. A negative mean - 
+//   median difference indicates that the examined party has an advantage; a positive
+//   difference indicates that the examined party is disadvantaged."
+//
+// So:
+// * With D VPI, '+' = R bias; '-' = D bias <<< We're using this convention.
+// * With R VPI, '-' = R bias; '+' = D bias.
+function estMeanMedianDifference(VfArray, Vf) {
+    const meanVf = Vf ? Vf : U.avgArray(VfArray);
+    const medianVf = U.medianArray(VfArray);
+    // NOTE - Switched order to get the signs correct
+    const difference = meanVf - medianVf;
+    // const difference: number = medianVf - meanVf;
+    return U.trim(difference);
+}
+exports.estMeanMedianDifference = estMeanMedianDifference;
+// HELPERS FOR DECLINATION & LOPSIDED OUTCOMES
+// Key r(v) points, defined in Fig. 19:
+// * VfArray are Democratic seat shares (by convention).
+// * But the x-axis of r(v) graphs us Republican seat share.
+// * So, you have to invert the D/R axis for Vb; and
+// * Invert the D/R probabilities for Va.
+function keyRVpoints(VfArray) {
+    const nDistricts = VfArray.length;
+    const estS = estSeats(VfArray);
+    const Sb = estSeatShare(estS, nDistricts);
+    // TODO - Understand why the corresponding V to Sb is always @ 0.5.
+    //   John Nagle: "This is the dividing vote for party A vs party B wins defined
+    //   by Warrington.My modification just puts fractions of districts to the each side."
+    const Rb = Sb / 2;
+    const Ra = (1 + Sb) / 2;
+    const Vb = 1.0 - (U.sumArray(VfArray.map(v => estSeatProbability(v) * v))) / estS;
+    const Va = (U.sumArray(VfArray.map(v => estSeatProbability(1 - v) * (1 - v)))) / (nDistricts - estS);
+    const keyPoints = {
+        Sb: Sb,
+        Ra: Ra,
+        Rb: Rb,
+        Va: Va,
+        Vb: Vb
+    };
+    return keyPoints;
+}
+exports.keyRVpoints = keyRVpoints;
+function isASweep(Sf, nDistricts) {
+    const oneDistrict = 1 / nDistricts;
+    const bSweep = ((Sf > (1 - oneDistrict)) || (Sf < oneDistrict)) ? true : false;
+    return bSweep;
+}
+exports.isASweep = isASweep;
+function radiansToDegrees(radians) {
+    const degrees = radians * (180 / Math.PI);
+    return degrees;
+}
+exports.radiansToDegrees = radiansToDegrees;
+// DECLINATION
+// 
+// Declination is calculated using the key r(v) points, defined in Fig. 19.
+// Note that district vote shares are D shares, so party A = Rep & B = Dem.
+function calcDeclination(VfArray) {
+    const { Sb, Ra, Rb, Va, Vb } = keyRVpoints(VfArray);
+    const bSweep = isASweep(Sb, VfArray.length);
+    const bTooFewDistricts = (VfArray.length < 5) ? true : false;
+    const bVaAt50 = (U.areRoughlyEqual((Va - 0.5), 0.0, S.EPSILON)) ? true : false;
+    const bVbAt50 = (U.areRoughlyEqual((0.5 - Vb), 0.0, S.EPSILON)) ? true : false;
+    let decl;
+    if (bSweep || bTooFewDistricts || bVaAt50 || bVbAt50) {
+        decl = undefined;
     }
-    // Decay a value in the unit range [0.0–1.0] by its distance from zero.
-    // NOTE - If the range is already such that "bigger is better," then the closer
-    //   the value is to 1.0 (the best) the *less* it will decay.
-    decay(fn = 0 /* Gravity */) {
-        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
-        console.assert(((this.wipNum >= 0.0) && (this.wipNum <= 1.0)), S.OUT_OF_RANGE_MSG);
-        switch (fn) {
-            case 0 /* Gravity */: {
-                this.wipNum = Math.pow(this.wipNum, S.DISTANCE_WEIGHT);
-                return this.wipNum;
-            }
-            default: {
-                throw new Error("Decay function not recognized.");
-            }
-        }
+    else {
+        const lTan = (Sb - Rb) / (0.5 - Vb);
+        const rTan = (Ra - Sb) / (Va - 0.5);
+        const lAngle = radiansToDegrees(Math.atan(lTan));
+        const rAngle = radiansToDegrees(Math.atan(rTan));
+        decl = rAngle - lAngle;
+        decl = U.trim(decl);
     }
-    // Translate a value in the unit range to the user-friendly range [0 – 100].
-    rescale() {
-        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
-        console.assert(((this.wipNum >= 0.0) && (this.wipNum <= 1.0)), S.OUT_OF_RANGE_MSG);
-        this.normalizedNum = Math.round(this.wipNum * S.NORMALIZED_RANGE);
-        return this.normalizedNum;
+    return decl;
+}
+exports.calcDeclination = calcDeclination;
+// LOPSIDED OUTCOMES
+//
+// This is a measure of packing bias is:
+//
+//   LO = (1⁄2 - vB) - (vA – 1⁄2)     Eq. 5.4.1 on P. 26
+//
+// "The ideal for this measure is that the excess vote share for districts
+//  won by party A averaged over those districts equals the excess vote share
+//  for districts won by party B averaged over those districts.
+//  A positive value of LO indicates greater packing of party B voters and,
+//  therefore, indicates a bias in favor of party A."
+function calcLopsidedOutcomes(VfArray) {
+    const { Sb, Ra, Rb, Va, Vb } = keyRVpoints(VfArray);
+    const bSweep = isASweep(Sb, VfArray.length);
+    let LO;
+    if (bSweep) {
+        LO = undefined;
     }
+    else {
+        LO = (0.5 - Vb) - (Va - 0.5);
+        LO = U.trim(LO);
+    }
+    return LO;
+}
+exports.calcLopsidedOutcomes = calcLopsidedOutcomes;
+// TODO - Add unit tests <<< Depends on S(V)
+// GLOBAL SYMMETRY - Fig. 17 in Section 5.1
+function calcGlobalSymmetry(inferredSVpoints, S50V) {
+    const invertedSVpoints = invertSVPoints(inferredSVpoints);
+    let gSym = 0.0;
+    for (let i in inferredSVpoints) {
+        gSym += Math.abs(inferredSVpoints[i].s - invertedSVpoints[i].s) / 2;
+    }
+    const sign = (S50V < 0) ? -1 : 1;
+    gSym *= sign;
+    return U.trim(gSym);
+}
+exports.calcGlobalSymmetry = calcGlobalSymmetry;
+// RAW DISPROPORTIONALITY
+//
+// gamma = Sf – Vf     : Eq.C.1.1 on P. 42
+function calcDisproportionality(Vf, Sf) {
+    const gamma = Vf - Sf;
+    // const gamma = Sf - Vf;
+    return U.trim(gamma);
+}
+exports.calcDisproportionality = calcDisproportionality;
+// TODO - Add unit tests <<< Depends on S(V)
+// BIG 'R': Defined in Footnote 22 on P. 10
+function calcBigR(Vf, Sf) {
+    let bigR = undefined;
+    if (!(U.areRoughlyEqual(Vf, 0.5, S.EPSILON))) {
+        bigR = (Sf - 0.5) / (Vf - 0.5);
+        bigR = U.trim(bigR);
+    }
+    return bigR;
+}
+exports.calcBigR = calcBigR;
+// TODO - Add unit tests <<< Depends on S(V)
+// MINIMAL INVERSE RESPONSIVENESS
+//
+// zeta = (1 / r) - (1 / r_sub_max)     : Eq. 5.2.1
+//
+// where r_sub_max = 10 or 20 for balanced and unbalanced states, respectively.
+function calcMinimalInverseResponsiveness(Vf, r) {
+    let MIR = undefined;
+    if (!(U.areRoughlyEqual(r, 0, S.EPSILON))) {
+        const bBalanced = isBalanced(Vf);
+        const ideal = bBalanced ? 0.1 : 0.2;
+        MIR = (1 / r) - ideal;
+        MIR = U.trim(MIR);
+    }
+    return MIR;
+}
+exports.calcMinimalInverseResponsiveness = calcMinimalInverseResponsiveness;
+function isBalanced(Vf) {
+    const [lower, upper] = C.competitiveRange();
+    const bBalanced = ((Vf > upper) || (Vf < lower)) ? false : true;
+    return bBalanced;
 }
-exports.Normalizer = Normalizer;
+// HELPERS
+function printPartisanScorecardHeader() {
+    console.log('XX, Name, N, V%, ^S#, S#, B%, B$, UE#, I$, C#, Cd, Md, C$, <P$');
+}
+exports.printPartisanScorecardHeader = printPartisanScorecardHeader;
+function printPartisanScorecardRow(xx, name, N, Vf, s) {
+    console.log('%s, %s, %i, %f, %i, %f, %f, %i, %f, %i, %i, %f, %f, %i, %i', xx, // 1
+    name, // 2
+    N, // 3
+    Vf, // 4
+    s.bias.propS, // 5
+    s.bias.estS, // 6
+    s.bias.bias, // 7
+    s.bias.score, s.impact.unearnedS, // 9
+    s.impact.score, s.competitiveness.c, // 11
+    s.competitiveness.cD, s.competitiveness.mD, s.competitiveness.score, s.score // 15
+    );
+}
+exports.printPartisanScorecardRow = printPartisanScorecardRow;
+// Generate partisan details (Table 1)
+function printPartisanDetailsHeader() {
+    console.log('XX, <V>, S(<V>), S50V, V50S, Decl, B_G, EG, Beta, l-gamma, mM, TO, mM\', LO, R, r, Zeta');
+}
+exports.printPartisanDetailsHeader = printPartisanDetailsHeader;
+function printPartisanDetailsRow(xx, name, N, Vf, s) {
+    console.log('%s, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f', xx, Vf, s.bias.estSf, s.bias.s50V, s.bias.v50S, s.bias.decl, s.bias.gSym, s.bias.eG, s.bias.sVg, // Beta
+    s.bias.prop, // Lower-gamma
+    s.bias.mMs, s.bias.tOf, s.bias.mMd, s.bias.lO, s.competitiveness.bigR, s.competitiveness.littleR, s.competitiveness.mIR // Zeta
+    );
+}
+exports.printPartisanDetailsRow = printPartisanDetailsRow;
 
 
 /***/ }),
@@ -90348,73 +91240,129 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const S = __importStar(__webpack_require__(/*! ./settings */ "./src/settings.ts"));
+const C = __importStar(__webpack_require__(/*! ./config */ "./src/config.ts"));
 const compact_1 = __webpack_require__(/*! ./compact */ "./src/compact.ts");
 const cohesive_1 = __webpack_require__(/*! ./cohesive */ "./src/cohesive.ts");
 const equal_1 = __webpack_require__(/*! ./equal */ "./src/equal.ts");
-const fair_1 = __webpack_require__(/*! ./fair */ "./src/fair.ts");
-// TODO - Score opportunity for minority representation
+const partisan_1 = __webpack_require__(/*! ./partisan */ "./src/partisan.ts");
+const minority_1 = __webpack_require__(/*! ./minority */ "./src/minority.ts");
 function scorePlan(p, overridesJSON) {
-    // BEST subcategories - compactness, splitting, population deviation
+    // TRADITIONAL DISTRICTING PRINCIPLES ("best") subcategories - compactness, splitting, population deviation
     // Compactness
-    const reockM = compact_1.doReock(p.compactnessProfile.GeometryByDistrict);
-    const polsbyM = compact_1.doPolsbyPopper(p.compactnessProfile.GeometryByDistrict);
-    const compactnessScore = Math.round(((S.REOCK_WEIGHT * reockM.normalized) + (S.POLSBY_WEIGHT * polsbyM.normalized)) / (S.REOCK_WEIGHT + S.POLSBY_WEIGHT));
+    const reockM = compact_1.doReock(p.compactnessProfile.geometryByDistrict);
+    const polsbyM = compact_1.doPolsbyPopper(p.compactnessProfile.geometryByDistrict);
+    const compactnessScore = weightCompactness(reockM.normalized, polsbyM.normalized);
     const cS = {
         score: compactnessScore,
         reock: reockM,
         polsby: polsbyM
     };
     // Splitting
-    const CxD = p.splittingProfile.CountyPopByDistrict;
+    const CxD = p.splittingProfile.countyPopByDistrict;
     const dT = cohesive_1.totalDistricts(CxD);
     const cT = cohesive_1.totalCounties(CxD);
     const countyM = cohesive_1.doCountySplittingReduced(CxD, dT, cT);
     const districtM = cohesive_1.doDistrictSplittingReduced(CxD, dT, cT);
-    const splittingScore = Math.round(((S.COUNTY_WEIGHT * countyM.normalized) + (S.DISTANCE_WEIGHT * districtM.normalized)) / (S.COUNTY_WEIGHT + S.DISTANCE_WEIGHT));
+    const splittingScore = weightSplitting(countyM.normalized, districtM.normalized);
     const sS = {
         score: splittingScore,
         county: countyM,
         district: districtM
     };
     // Population deviation
-    const eS = equal_1.doPopulationDeviation(p.populationProfile.TotalPopByDistrict, p.populationProfile.targetSize, p.legislativeDistricts);
-    // Combine compactness, splitting, & population deviation into a "best" score
-    const bestScore = Math.round(((S.COMPACTNESS_WEIGHT * cS.score) + (S.SPLITTING_WEIGHT * sS.score) + (S.POPDEV_WEIGHT * eS.normalized)) / (S.COMPACTNESS_WEIGHT + S.SPLITTING_WEIGHT + S.POPDEV_WEIGHT));
-    // Populate the "best" scorecard
-    const bS = {
-        BestScore: bestScore,
+    const pdS = equal_1.doPopulationDeviation(p.populationProfile.totalPopByDistrict, p.populationProfile.targetSize, p.legislativeDistricts);
+    // Combine traditional principles into a score to compare plans w/in a state
+    const tpScore = weightTradtionalPrinciples(cS.score, sS.score, pdS.normalized, 1 /* WithinAState */);
+    // Populate the "best" traditional principles scorecard
+    const tpS = {
+        score: tpScore,
         compactness: cS,
         splitting: sS,
-        populationDeviation: eS
+        populationDeviation: pdS
+    };
+    // PARTISAN ("fair") subcategories - bias, impact, & competitiveness (plus lots of supporting measures)
+    const options = {
+        alternates: true,
+        constrained: true,
+        shift: 0 /* Proportional */
     };
-    // FAIR subcategories - bias & competitiveness
-    // NOTE - This calculates a # of measures of bias & competitiveness.
-    const pS = fair_1.scorePartisan(p.partisanProfile.statewideVf, p.partisanProfile.VfArray);
-    pS.score = fair_1.weightPartisan(pS.bias.normalized, pS.competitiveness.normalized);
-    // Combine "best" and "fair" scores into an overall score for the plan
-    const score = Math.round(((S.FAIR_WEIGHT * pS.score) + (S.BEST_WEIGHT * bS.BestScore)) / (S.FAIR_WEIGHT + S.BEST_WEIGHT));
+    const pS = partisan_1.scorePartisan(p.partisanProfile.statewideVf, p.partisanProfile.vfArray, options);
+    // Combine the partisan/partisan & traditional principles/best scores into an overall
+    // score for comparing plans w/in a state
+    let score = weightOverall(pS.score2, tpS.score, 1 /* WithinAState */);
+    const mS = minority_1.evalMinorityOpportunity(p);
+    // Add minority bonus, keeping score it to the range [0–100]
+    score = mixinMinorityBonus(score, mS.score);
     // Roll up an overall scorecard
     const scorecard = {
-        score: score,
-        best: bS,
-        fair: pS
+        partisan: pS,
+        minority: mS,
+        traditionalPrinciples: tpS,
+        score: score
     };
     return scorecard;
 }
 exports.scorePlan = scorePlan;
+// HELPERS
+function weightCompactness(rS, ppS) {
+    const rW = C.reockWeight();
+    const ppW = C.polsbyWeight();
+    const score = Math.round(((rS * rW) + (ppS * ppW)) / (rW + ppW));
+    return score;
+}
+exports.weightCompactness = weightCompactness;
+function weightSplitting(csS, dsS) {
+    const csW = C.countySplittingWeight();
+    const dsW = C.districtSplittingWeight();
+    const score = Math.round(((csS * csW) + (dsS * dsW)) / (csW + dsW));
+    return score;
+}
+exports.weightSplitting = weightSplitting;
+function weightTradtionalPrinciples(cS, sS, pdS, context) {
+    const cW = C.compactnessWeight(context);
+    const sW = C.splittingWeight(context);
+    const pdW = C.popdevWeight(context);
+    const score = Math.round(((cS * cW) + (sS * sW) + (pdS * pdW)) / (cW + sW + pdW));
+    return score;
+}
+exports.weightTradtionalPrinciples = weightTradtionalPrinciples;
+function weightOverall(pS, tpS, context) {
+    const pW = C.partisanWeight(context);
+    const tpW = C.traditionalPrinciplesWeight(context);
+    const score = Math.round(((pS * pW) + (tpS * tpW)) / (pW + tpW));
+    return score;
+}
+exports.weightOverall = weightOverall;
+function mixinMinorityBonus(score, minorityBonus) {
+    const modifiedScore = Math.min(score + minorityBonus, S.NORMALIZED_RANGE);
+    return modifiedScore;
+}
+exports.mixinMinorityBonus = mixinMinorityBonus;
+function printScorecardHeader() {
+    console.log('XX, Name, N, V%, ^S#, S#, B%, B$, UE#, I$, C#, Cd, Md, C$, >P$, Rc, Rc$, Pc, Pc$, G$, Cs, Cs$, Ds, Ds$, S$, Eq, Eq$, T$, Od, M$, $$$');
+}
+exports.printScorecardHeader = printScorecardHeader;
+function printScorecardRow(xx, name, N, Vf, s) {
+    console.log('%s, %s, %i, %f, %i, %f, %f, %i, %f, %i, %i, %f, %f, %i, %i, %f, %i, %f, %i, %i, %f, %i, %f, %i, %i, %f, %i, %i, %f, %i, %i', xx, // 1
+    name, // 2
+    N, // 3
+    Vf, // 4
+    s.partisan.bias.propS, // 5
+    s.partisan.bias.estS, // 6
+    s.partisan.bias.bias, // 7
+    s.partisan.bias.score, s.partisan.impact.unearnedS, // 9
+    s.partisan.impact.score, s.partisan.competitiveness.c, // 11
+    s.partisan.competitiveness.cD, s.partisan.competitiveness.mD, s.partisan.competitiveness.score, s.partisan.score2, // 15
+    s.traditionalPrinciples.compactness.reock.raw, s.traditionalPrinciples.compactness.reock.normalized, s.traditionalPrinciples.compactness.polsby.raw, s.traditionalPrinciples.compactness.polsby.normalized, s.traditionalPrinciples.compactness.score, s.traditionalPrinciples.splitting.county.raw, s.traditionalPrinciples.splitting.county.normalized, s.traditionalPrinciples.splitting.district.raw, s.traditionalPrinciples.splitting.district.normalized, s.traditionalPrinciples.splitting.score, s.traditionalPrinciples.populationDeviation.raw, s.traditionalPrinciples.populationDeviation.normalized, s.traditionalPrinciples.score, 
+    // s.minority.nOpportunity1,
+    // s.minority.nOpportunity2,
+    s.minority.opportunityDistricts, 
+    // s.minority.nProportional,
+    s.minority.score, s.score);
+}
+exports.printScorecardRow = printScorecardRow;
 
 
-/***/ }),
-
-/***/ "./src/settings.json":
-/*!***************************!*\
-  !*** ./src/settings.json ***!
-  \***************************/
-/*! exports provided: fair, best, default */
-/***/ (function(module) {
-
-module.exports = JSON.parse("{\"fair\":{\"unbiased\":{\"worst\":0.1,\"best\":0,\"weight\":80},\"competitive\":{\"worst\":0,\"best\":0.67,\"weight\":20,\"min\":0.25,\"max\":0.75,\"marginal\":75,\"overall\":25},\"weight\":80},\"best\":{\"compact\":{\"reock\":{\"worst\":0.25,\"best\":0.5,\"weight\":50},\"polsby\":{\"worst\":0.1,\"best\":0.5,\"weight\":50},\"weight\":50},\"cohesive\":{\"county\":{\"best\":1,\"worst\":1.71,\"allowableSplitsMultiplier\":1.5,\"weight\":50},\"district\":{\"best\":1,\"worst\":1.5,\"weight\":50},\"weight\":50},\"equal\":{\"worst\":0.0075,\"best\":0.002,\"stateLeg\":{\"worst\":0.1},\"weight\":0},\"weight\":20}}");
-
 /***/ }),
 
 /***/ "./src/settings.ts":
@@ -90429,16 +91377,13 @@ module.exports = JSON.parse("{\"fair\":{\"unbiased\":{\"worst\":0.1,\"best\":0,\
 //
 // GLOBAL CONSTANTS
 //
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 // Normalized scores [0-100]
 exports.NORMALIZED_RANGE = 100;
 // Square deviations from the ideal
 exports.DISTANCE_WEIGHT = 2;
 // Out of range message
-exports.OUT_OF_RANGE_MSG = "# out of range";
+exports.OUT_OF_RANGE_MSG = "%f out of range";
 // A small delta to use when testing ranges of values
 exports.EPSILON = 1 / Math.pow(10, 6);
 // Keep 4 decimals for fractions [0.0–1.0], i.e., 2 for %'s [0–100]
@@ -90446,62 +91391,6 @@ exports.PRECISION = 4;
 // "Roughly equal" = average census block size / 2
 exports.AVERAGE_BLOCK_SIZE = 30;
 exports.EQUAL_TOLERANCE = exports.AVERAGE_BLOCK_SIZE / 2;
-// SCORING PARAMETERS
-const settings_json_1 = __importDefault(__webpack_require__(/*! ./settings.json */ "./src/settings.json"));
-// TODO - DELETE
-function readOverrides() {
-    return undefined;
-}
-const overrides = readOverrides();
-// SETTINGS FOR PARTISAN SCORING
-exports.MIN_CONTESTED = overrides ? overrides.fair.competitive.min : settings_json_1.default.fair.competitive.min;
-exports.MAX_CONTESTED = overrides ? overrides.fair.competitive.max : settings_json_1.default.fair.competitive.max;
-// SCALES FOR NORMALIZING RAW VALUES
-// Compactness scales
-exports.REOCK_WORST = overrides ? overrides.best.compact.reock.worst : settings_json_1.default.best.compact.reock.worst;
-exports.REOCK_BEST = overrides ? overrides.best.compact.reock.best : settings_json_1.default.best.compact.reock.best;
-exports.POLSBY_WORST = overrides ? overrides.best.compact.polsby.worst : settings_json_1.default.best.compact.polsby.worst;
-exports.POLSBY_BEST = overrides ? overrides.best.compact.polsby.best : settings_json_1.default.best.compact.polsby.best;
-// County-District splitting scales (not inverted)
-exports.COUNTY_BEST = overrides ? overrides.best.cohesive.county.best : settings_json_1.default.best.cohesive.county.best;
-exports.COUNTY_WORST = overrides ? overrides.best.cohesive.county.worst : settings_json_1.default.best.cohesive.county.worst;
-exports.ALLOWABLE_SPLITS_MULTIPLIER = overrides ? overrides.best.cohesive.county.allowableSplitsMultiplier : settings_json_1.default.best.cohesive.county.allowableSplitsMultiplier;
-exports.DISTRICT_BEST = overrides ? overrides.best.cohesive.district.best : settings_json_1.default.best.cohesive.district.best;
-exports.DISTRICT_WORST = overrides ? overrides.best.cohesive.district.worst : settings_json_1.default.best.cohesive.district.worst;
-// Population deviation thresholds & scales (inverted)
-exports.POPDEV_WORST = overrides ? overrides.best.equal.worst : settings_json_1.default.best.equal.worst;
-exports.POPDEV_BEST = overrides ? overrides.best.equal.best : settings_json_1.default.best.equal.best;
-exports.POPEQ_MIN = 1.0 - exports.POPDEV_WORST;
-exports.POPEQ_MAX = 1.0 - exports.POPDEV_BEST;
-exports.POPDEV_WORST_LD = overrides ? overrides.best.equal.stateLeg.worst : settings_json_1.default.best.equal.stateLeg.worst;
-exports.POPDEV_BEST_LD = ((exports.POPDEV_BEST / exports.POPDEV_WORST) * exports.POPDEV_WORST_LD);
-exports.POPEQ_MIN_LD = 1.0 - exports.POPDEV_WORST_LD;
-exports.POPEQ_MAX_LD = 1.0 - exports.POPDEV_BEST_LD;
-// Bias & competitiveness scales
-// TODO - SCORE:
-// * How wide a range do we want for bias? 10%? 20%?
-// * Do we want it to be state-specific? E.g., one seat?
-exports.BIAS_WORST = overrides ? overrides.fair.unbiased.worst : settings_json_1.default.fair.unbiased.worst;
-exports.BIAS_BEST = overrides ? overrides.fair.unbiased.best : settings_json_1.default.fair.unbiased.best;
-// The range for raw overall competitiveness values
-exports.COMPETITIVE_WORST = overrides ? overrides.fair.competitive.worst : settings_json_1.default.fair.competitive.worst;
-exports.COMPETITIVE_BEST = overrides ? overrides.fair.competitive.best : settings_json_1.default.fair.competitive.best;
-// WEIGHTS FOR COMBINING NORMALIZED VALUES
-exports.REOCK_WEIGHT = overrides ? overrides.best.compact.reock.weight : settings_json_1.default.best.compact.reock.weight;
-exports.POLSBY_WEIGHT = overrides ? overrides.best.compact.polsby.weight : settings_json_1.default.best.compact.polsby.weight;
-exports.COUNTY_WEIGHT = overrides ? overrides.best.cohesive.county.weight : settings_json_1.default.best.cohesive.county.weight;
-exports.DISTRICT_WEIGHT = overrides ? overrides.best.cohesive.district.weight : settings_json_1.default.best.cohesive.district.weight;
-exports.COMPACTNESS_WEIGHT = overrides ? overrides.best.compact.weight : settings_json_1.default.best.compact.weight;
-exports.SPLITTING_WEIGHT = overrides ? overrides.best.cohesive.weight : settings_json_1.default.best.cohesive.weight;
-exports.POPDEV_WEIGHT = overrides ? overrides.best.equal.weight : settings_json_1.default.best.equal.weight;
-// TODO - SCORE: What kind of relative weighting do we want between marginal and
-//   overall competitiveness?
-exports.MARGINAL_WEIGHT = overrides ? overrides.fair.competitive.marginal : settings_json_1.default.fair.competitive.marginal;
-exports.OVERALL_WEIGHT = overrides ? overrides.fair.competitive.overall : settings_json_1.default.fair.competitive.overall;
-exports.BIAS_WEIGHT = overrides ? overrides.fair.unbiased.weight : settings_json_1.default.fair.unbiased.weight;
-exports.COMPETITIVE_WEIGHT = overrides ? overrides.fair.competitive.weight : settings_json_1.default.fair.competitive.weight;
-exports.FAIR_WEIGHT = overrides ? overrides.fair.weight : settings_json_1.default.fair.weight;
-exports.BEST_WEIGHT = overrides ? overrides.best.weight : settings_json_1.default.best.weight;
 
 
 /***/ }),
@@ -90522,10 +91411,70 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const sample_profile_json_1 = __importDefault(__webpack_require__(/*! ../testdata/profiles/sample-profile.json */ "./testdata/profiles/sample-profile.json"));
+const sample_profile_json_1 = __importDefault(__webpack_require__(/*! ../testdata/samples/sample-profile.json */ "./testdata/samples/sample-profile.json"));
 exports.sampleProfile = sample_profile_json_1.default;
-const sample_scorecard_json_1 = __importDefault(__webpack_require__(/*! ../testdata/profiles/sample-scorecard.json */ "./testdata/profiles/sample-scorecard.json"));
+const sample_scorecard_json_1 = __importDefault(__webpack_require__(/*! ../testdata/samples/sample-scorecard.json */ "./testdata/samples/sample-scorecard.json"));
 exports.sampleScorecard = sample_scorecard_json_1.default;
+exports.Metrics = {
+    // PARTISAN
+    // Bias metrics
+    Vf: { label: "Statewide D vote share", abbr: "V" },
+    estS: { label: "Probable D seats", abbr: "S_V" },
+    estSf: { label: "Probable D seat share", units: 1 /* Percentage */, abbr: "S%" },
+    propS: { label: "D seats closest to proportional", abbr: "^S" },
+    propSf: { label: "D seat share closest to proportional", units: 1 /* Percentage */, abbr: "^S%" },
+    fptpS: { label: "Probable FPTP D seats", abbr: "S!" },
+    bias: { label: "Effective bias", units: 1 /* Percentage */, abbr: "B%", description: "Calculated as S% – ^S%" },
+    biasScore: { label: "Bias score", abbr: "B$", description: "Bias score normalized [0–100]" },
+    // Additional bias metrics
+    s50v: { label: "Seats bias", units: 1 /* Percentage */, abbr: "BS_50", symbol: "\u{03B1}" },
+    v50s: { label: "Votes bias", units: 1 /* Percentage */, abbr: "BV_50", symbol: "\u{03B1}2" },
+    decl: { label: "Declination", units: 2 /* Degrees */, abbr: "decl", symbol: "\u{03B4}" },
+    gSym: { label: "Global symmetry", abbr: "GS", symbol: "\u{0393}" },
+    EG: { label: "Efficiency gap", units: 1 /* Percentage */, abbr: "EG", symbol: "\u{03B3}2" },
+    BsGf: { label: "Partisan bias", units: 1 /* Percentage */, abbr: "BS_V", symbol: "\u{03D0}" },
+    prop: { label: "Disproprtionality", units: 1 /* Percentage */, abbr: "prop", symbol: "\u{03B3}" },
+    MM: { label: "Mean–median", abbr: "MM" },
+    LO: { label: "Lopsided outcomes", abbr: "LO" },
+    // Impact metrics
+    unearnedS: { label: "Unearned seats", abbr: "UE" },
+    impactScore: { label: "Impact score", abbr: "I$", description: "Impact score normalized to [0–100]" },
+    // Competitiveness/responsiveness metrics
+    c: { label: "Simple competitive districts", abbr: "C", description: "Count of districts in the range [45–55%]" },
+    cD: { label: "Probable competitive districts", abbr: "Cd", description: "Probable competitive districts, using probabilities" },
+    cDf: { label: "Probable competitive districts share", units: 1 /* Percentage */, abbr: "Cdf" },
+    mD: { label: "Competitive marginal districts", abbr: "Md", description: "Probable competitive marginal districts, using probabilities" },
+    mDf: { label: "Competitive marginal districts share", units: 1 /* Percentage */, abbr: "Mdf" },
+    competitivenessScore: { label: "Competitiveness score", abbr: "C$", description: "Competitiveness score normalized to [0–100]" },
+    // Additional competitiveness/responsiveness metrics
+    rD: { label: "Responsive districts", abbr: "Rd" },
+    rDf: { label: "Responsive districts %", abbr: "Rd%" },
+    bigR: { label: "Overall responsiveness", abbr: "R" /*, symbol: "\u{}" */ },
+    littleR: { label: "Point responsiveness", abbr: "r", symbol: "\u{03C1}" },
+    MIR: { label: "Minimal inverse responsiveness", abbr: "MIR", symbol: "\u{03B6}" },
+    partisanScore: { label: "Partisan score", abbr: "P$" },
+    // * <P$ [score] = the combined partisan score used to compare plans *across* states
+    // * >P$ [score2] = the combined partisan score used to compare plans *within* a state, along with traditional districting principles
+    // MINORITY
+    oD: { label: "Opportunity districts", abbr: "Od" },
+    minorityBonus: { label: "Minority bonus", abbr: "M$" },
+    // TRADITIONAL DISTRICTING PRINCIPLES
+    reockRaw: { label: "Reock", abbr: "Rc" },
+    reockNormalized: { label: "Reock", abbr: "Rc$", description: "Reock normalized to [0–100]" },
+    polsbyRaw: { label: "Polsby-Popper", abbr: "Pc" },
+    polsbyNormalized: { label: "Polsby-Popper", abbr: "Pc$", description: "Polsby-Popper normalized to [0–100]" },
+    compactnessScore: { label: "Compactness score", abbr: "G$" },
+    countySplittingRaw: { label: "County splitting", abbr: "Cs" },
+    countySplittingNormalized: { label: "County splitting", abbr: "Cs$", description: "County splitting normalized to [0–100]" },
+    districtSplittingRaw: { label: "District splitting", abbr: "Ds" },
+    districtSplittingNormalized: { label: "District splitting", abbr: "Ds$", description: "District splitting normalized to [0–100]" },
+    splittingScore: { label: "Splitting score", abbr: "S$" },
+    populationDeviationRaw: { label: "Population deviation", abbr: "Eq" },
+    populationDeviationNormalized: { label: "County splitting", abbr: "Eq$", description: "Population deviation normalized to [0–100]" },
+    traditionalPrinciplesScore: { label: "Traditional districting principles score", abbr: "T$", description: "Traditional principles score normalized to [0–100]" },
+    // OVERALL SCORE
+    score: { label: "Overall score", abbr: "$$$" }
+};
 
 
 /***/ }),
@@ -90568,11 +91517,31 @@ function maxArray(arr) {
     return Math.max(...arr);
 }
 exports.maxArray = maxArray;
+// Modified from https://jsfiddle.net/Lucky500/3sy5au0c/
+function medianArray(arr) {
+    if (arr.length === 0)
+        return 0;
+    arr.sort(function (a, b) {
+        return a - b;
+    });
+    var half = Math.floor(arr.length / 2);
+    if (arr.length % 2)
+        return arr[half];
+    return (arr[half - 1] + arr[half]) / 2.0;
+}
+exports.medianArray = medianArray;
 function initArray(n, value) {
     return Array.from(Array(n), () => value);
 }
 exports.initArray = initArray;
 // MISCELLANEOUS
+// Deal with decimal census "counts" due to disagg/re-agg
+function areRoughlyEqual(x, y, tolerance) {
+    let delta = Math.abs(x - y);
+    let result = (delta < tolerance) ? true : false;
+    return result;
+}
+exports.areRoughlyEqual = areRoughlyEqual;
 // Round a fractional number [0-1] to the desired level of PRECISION.
 function trim(fullFraction, digits = undefined) {
     if (digits == 0) {
@@ -90606,25 +91575,25 @@ exports.deepCopy = deepCopy;
 
 /***/ }),
 
-/***/ "./testdata/profiles/sample-profile.json":
-/*!***********************************************!*\
-  !*** ./testdata/profiles/sample-profile.json ***!
-  \***********************************************/
+/***/ "./testdata/samples/sample-profile.json":
+/*!**********************************************!*\
+  !*** ./testdata/samples/sample-profile.json ***!
+  \**********************************************/
 /*! exports provided: state, planName, nDistricts, nCounties, legislativeDistricts, populationProfile, compactnessProfile, splittingProfile, partisanProfile, demographicProfile, default */
 /***/ (function(module) {
 
-module.exports = JSON.parse("{\"state\":\"NC\",\"planName\":\"Sample profile\",\"nDistricts\":13,\"nCounties\":100,\"legislativeDistricts\":false,\"populationProfile\":{\"TotalPopByDistrict\":[725807,721754,732627,733218,730051,729580,728476,729721,731507,724085,733447,730845,729710],\"targetSize\":729294},\"compactnessProfile\":{\"GeometryByDistrict\":[[1.5773977911324972,10.187637000340999,2.6574300583946115],[0.7058475358440041,7.6543777040386445,1.7632772181381422],[2.920140664739499,9.983421957097065,2.733997011824872],[0.19139679136850038,3.5473804553379114,0.9224411598627837],[1.0389865962844946,6.505473449741405,2.1061393959539023],[1.0334553158144995,6.472595447414713,1.6394147493749138],[1.6241801669130118,8.040301088673953,1.952917034583555],[0.7706765524270006,7.015983900119356,2.1886348192462464],[0.9976965229710011,8.405282685068,2.5604335810665138],[0.676265120610002,5.866361656441843,1.7264712385837822],[1.719226531340005,10.410671767954964,3.1586859214584764],[0.11329460131899982,2.3038812649606695,0.5379072920877442],[0.48373856130249987,5.267369326010034,1.45173753753012]]},\"splittingProfile\":{\"CountyPopByDistrict\":[[0,0,0,0,0,0,0,0,21282,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,240299,56552,0,0,0,12197,0,59916,0,0,54691,0,0,0,24669,0,0,0,0,0,0,0,0,0,0,0,0,24505,0,0,0,0,0,0,22099,0,0,0,0,0,0,0,74235,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,45422,0,20972,13228,0,0,0,55740,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,60619,0,0,0,0,0,0,0,114678,0,0,0,0,0,0,0,109245,0,0,0,0,0,0,0,0,0,0,0,0,95840,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,324879,0,0,0,0,0,16493,0,0],[0,0,0,0,0,0,0,47759,0,0,0,0,0,0,0,9980,66469,0,0,0,0,14793,0,0,0,103505,0,23547,33920,0,0,0,0,0,0,0,0,0,0,0,21362,0,0,0,0,0,0,0,5810,0,0,0,10153,0,59495,0,0,0,0,0,0,0,0,0,0,0,0,177772,0,13144,40661,0,13453,0,86397,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4407,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27288,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,133801,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,572129,0,0,0,0,0,0,0,0],[0,0,37198,11155,0,27281,17797,0,0,0,0,0,0,0,0,0,0,0,6051,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,350670,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,47401,73673,0,0,0,0,0,0,0,0,51079,0,69340,0,38406,0],[0,151131,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23719,0,63505,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,158500,0,0,0,0,0,0,0,0,0,0,0,57866,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,39464,0,0,141752,0,0,93643,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,8316,107431,0,0,0,0,0,0,0,0,0,0,0,0,0,58098,0,0,0,0,0,0,58505,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,55188,0,0,0,0,0,0,0,0,0,0,0,0,0,202667,0,0,0,0,0,52217,0,0,0,0,0,0,0,0,0,0,63431,0,0,0,0,0,0,0,0,0,0,0,0,0,122623,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,178011,0,0,0,0,0,0,0,0,0,0,0,0,242290,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,46952,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27798,88247,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85838,0,0,0,60585,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,26948,0,0,0,0,25045,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,75524,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,185734,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,46639,134168,0,0,0,0,36157,0,0,0,0,0,0,201292,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,108857,0,0,0,0,0,0,144479,0,0,0,0,98078,0,0,0,0,0,0,0,0,0,0,0,0,206086,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,78265,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20510,0,0,0,0,0,67810,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,126417,90912,0,83029,0,0,0,0,0,27444,0,10587,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8861,0,0,0,0,0,59036,106740,0,0,0,0,40271,0,0,0,0,0,44996,33922,20764,0,0,15579,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13981,33090,0,0,0,0,0,0,0,0,0,0,0,17818],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,730845,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,162878,41240,0,0,0,0,0,0,0,0,0,0,325932,0,0,0,0,0,0,0,150509,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,49151,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]},\"partisanProfile\":{\"statewideVf\":0.515036,\"VfArray\":[0.4235,0.428588,0.43388,0.443866,0.454505,0.456985,0.458005,0.458134,0.463947,0.473144,0.718314,0.73662,0.775817]},\"demographicProfile\":{\"DemographicsByDistrict\":[[0.462,0.538,0.0659,0.4445,0.0219,0.0009,0.013],[0.7063,0.2937,0.0714,0.1968,0.0203,0.001,0.0113],[0.7125,0.2875,0.0537,0.2118,0.0163,0.0021,0.0104],[0.6162,0.3838,0.0869,0.2239,0.0715,0.0012,0.0101],[0.7767,0.2233,0.0669,0.1402,0.013,0.0008,0.0077],[0.7112,0.2888,0.0715,0.1985,0.0136,0.0008,0.0102],[0.7086,0.2914,0.0695,0.2023,0.0097,0.0011,0.0142],[0.6698,0.3302,0.0725,0.224,0.0229,0.0029,0.0188],[0.6406,0.3594,0.0594,0.1962,0.0222,0.001,0.0862],[0.8193,0.1807,0.0451,0.1158,0.0141,0.0007,0.008],[0.8956,0.1044,0.0433,0.0327,0.0103,0.0012,0.0197],[0.4657,0.5343,0.1215,0.3618,0.0507,0.0017,0.011],[0.698,0.302,0.0572,0.2117,0.0286,0.0009,0.0095]]}}");
+module.exports = JSON.parse("{\"state\":\"NC\",\"planName\":\"NC 116th Congressional\",\"nDistricts\":13,\"nCounties\":100,\"legislativeDistricts\":false,\"populationProfile\":{\"totalPopByDistrict\":[733499,733499,733498,733499,733499,733498,733499,733499,733498,733499,733499,733498,733499],\"targetSize\":733499},\"compactnessProfile\":{\"geometryByDistrict\":[[1.577393519870778,10.159603194222512,2.6574239327900613],[0.7058443860242223,7.806818205304456,1.7632772181381422],[2.9200833695730037,9.972779463090355,2.733997011824872],[0.1913918462294299,3.5460738146162076,0.9224411598627837],[1.039017192939366,6.4920493759205495,2.1060599512212406],[1.0334601456545682,6.466840626614781,1.6394147493749138],[1.6241884494008865,7.988593581066711,1.9529170345835551],[0.7706777049448708,6.980189925133433,2.188634395661598],[0.9976766364327585,8.350880983965949,2.5604199958307654],[0.6762837622380331,5.8543721706585545,1.7264608756890525],[1.719230725216499,10.37139670690812,3.1586859214584764],[0.11329839503948308,2.2954988975477066,0.5379072920877442],[0.48371245467321944,5.3384017624136435,1.4517375375301198]]},\"splittingProfile\":{\"countyPopByDistrict\":[[0,0,0,0,0,0,0,21282,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,240299,56552,0,0,0,12197,0,59916,0,0,54691,0,0,0,24669,0,0,0,0,0,0,0,0,0,0,0,0,24505,0,0,0,0,0,0,22099,0,0,0,0,0,0,0,80880,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,45422,0,20972,13228,0,0,0,56787,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,60619,0,0,0,0,0,0,0,114678,0,0,0,0,0,0,0,109332,0,0,0,0,0,0,0,0,0,0,0,0,95840,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,328583,0,0,0,0,0,24447,0,0],[0,0,0,0,0,0,47759,0,0,0,0,0,0,0,9980,66469,0,0,0,0,14793,0,0,0,103505,0,23547,33920,0,0,0,0,0,0,0,0,0,0,0,21362,0,0,0,0,0,0,0,5810,0,0,0,10153,0,59495,0,0,0,0,0,0,0,0,0,0,0,0,177772,0,13144,40661,0,13453,0,87268,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4407,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27288,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,133801,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,572410,0,0,0,0,0,0,0,0],[0,37198,11155,0,27281,17797,0,0,0,0,0,0,0,0,0,0,0,9499,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,350670,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,47401,73673,0,0,0,0,0,0,0,0,51079,0,69340,0,38406,0],[151131,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23719,0,63505,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,162418,0,0,0,0,0,0,0,0,0,0,0,57866,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,39464,0,0,141752,0,0,93643,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,8981,107431,0,0,0,0,0,0,0,0,0,0,0,0,0,58098,0,0,0,0,0,0,58505,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,59546,0,0,0,0,0,0,0,0,0,0,0,0,0,202667,0,0,0,0,0,52217,0,0,0,0,0,0,0,0,0,0,63431,0,0,0,0,0,0,0,0,0,0,0,0,0,122623,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,178011,0,0,0,0,0,0,0,0,0,0,0,0,243476,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,46952,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27798,88247,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,88430,0,0,0,60585,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,26948,0,0,0,0,26209,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,75955,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,186130,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,46639,134168,0,0,0,0,36157,0,0,0,0,0,0,201292,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,111849,0,0,0,0,0,0,144859,0,0,0,0,98078,0,0,0,0,0,0,0,0,0,0,0,0,206086,0,0,0,0,0,0,0,0,0,0,0,0,6042,0,0,0,0,0,78265,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20510,0,0,0,0,0,67810,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,126469,90912,0,83029,0,0,0,0,0,27444,0,10587,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8861,0,0,0,0,0,59036,106740,0,0,0,0,40271,0,0,0,0,0,44996,33922,20764,0,0,15579,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13981,33090,0,0,0,0,0,0,0,0,0,0,0,17818],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,733498,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,162878,41240,0,0,0,0,0,0,0,0,0,0,325988,0,0,0,0,0,0,0,153395,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,49998,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]},\"partisanProfile\":{\"statewideVf\":0.488799,\"vfArray\":[0.38133475250631976,0.3849820112175976,0.3932778243643098,0.4232536822067312,0.42479562842958446,0.43309446651496813,0.43760621455968074,0.43980028165892326,0.4545677480810613,0.4642133701735491,0.6853270858231137,0.6938881738049054,0.6953207231271951]},\"demographicProfile\":{\"stateMfArray\":[0.684371246819619,0.31562875318038097,0.21168281993226215,0.06787156278984616,0.0012540930000187486,0.024136155044881008,0.017483272326632705],\"mfArrayByDistrict\":[[0.46201994876162167,0.5379800512383783,0.44446912914151915,0.065885219684988,0.0009221497550043815,0.0218600624522836,0.01298238746863721],[0.7062964810448031,0.2937035189551968,0.19676408791341676,0.07140508797387993,0.0009787472035794184,0.02027027027027027,0.011283934941653062],[0.7125415968218078,0.2874584031781921,0.21181863608495496,0.05374539732717163,0.002106863519897368,0.01628256424250371,0.010404964330393058],[0.6162003899079305,0.3837996100920695,0.22386087117385056,0.08687191382180923,0.0012060108434249284,0.07153885560599377,0.010091002234143982],[0.7766842620090415,0.22331573799095852,0.14015703622760559,0.06690518783542039,0.0007790124871119258,0.013001753659331847,0.007680851626320752],[0.7111584046318987,0.2888415953681012,0.19851813634865356,0.07148666466027488,0.0008061395588804333,0.013621967123837368,0.010186021181764765],[0.7086112059348308,0.2913887940651691,0.20229594619799895,0.06953648210647081,0.001149028868250555,0.009700759801937688,0.014166663733974303],[0.6697822118227867,0.33021778817721326,0.2240088599271958,0.07249565635824667,0.002909229825482943,0.022877125445843145,0.01884938491094157],[0.6406346877484486,0.35936531225155144,0.19622106825202063,0.059419121439330605,0.0010389455633486816,0.02217720538538736,0.08616917683114156],[0.8192767260107778,0.18072327398922214,0.11582505713398979,0.045060025957170666,0.0006806703721468273,0.014117738340433936,0.008000521964844963],[0.8956213645578734,0.1043786354421266,0.032662784268536554,0.04329373425036473,0.0012436075643032956,0.010267513422177209,0.019651410943402076],[0.46574079494234033,0.5342592050576597,0.36183998712169996,0.12151883451384417,0.001650032195750161,0.050651598079962536,0.010997775566352515],[0.6979595109954735,0.3020404890045265,0.21171009017357523,0.0572352710553516,0.0008767865416830024,0.028566846063370996,0.009525252165235058]]}}");
 
 /***/ }),
 
-/***/ "./testdata/profiles/sample-scorecard.json":
-/*!*************************************************!*\
-  !*** ./testdata/profiles/sample-scorecard.json ***!
-  \*************************************************/
-/*! exports provided: score, best, fair, default */
+/***/ "./testdata/samples/sample-scorecard.json":
+/*!************************************************!*\
+  !*** ./testdata/samples/sample-scorecard.json ***!
+  \************************************************/
+/*! exports provided: score, partisan, minority, traditionalPrinciples, default */
 /***/ (function(module) {
 
-module.exports = JSON.parse("{\"score\":5,\"best\":{\"BestScore\":18,\"compactness\":{\"score\":35,\"reock\":{\"raw\":0.3373,\"normalized\":35,\"notes\":{}},\"polsby\":{\"raw\":0.2418,\"normalized\":35,\"notes\":{}}},\"splitting\":{\"score\":0,\"county\":{\"raw\":1.1474,\"normalized\":0,\"notes\":{}},\"district\":{\"raw\":1.4839,\"normalized\":3,\"notes\":{}}},\"populationDeviation\":{\"raw\":0.016,\"normalized\":0,\"notes\":{\"maxDeviation\":11693}}},\"fair\":{\"bias\":{\"BestS\":7,\"BestSf\":0.5385,\"ProbableS\":4.1925,\"ProbableSf\":0.3225,\"Bias\":0.216,\"normalized\":0,\"notes\":{}},\"competitiveness\":{\"Cd\":0.7266,\"Cdf\":0.0559,\"Mdf\":0.1019,\"normalized\":10,\"notes\":{}},\"score\":2,\"notes\":{}}}");
+module.exports = JSON.parse("{\"score\":5,\"partisan\":{\"bias\":{\"propS\":7,\"propSf\":0.5385,\"estS\":4.1925,\"estSf\":0.3225,\"bias\":0.216,\"tOf\":-0.0023,\"fptpS\":3,\"s50V\":0.2172,\"v50S\":0.045,\"decl\":36.5164,\"gSym\":6.6602,\"eG\":0.2846,\"sVg\":0.2098,\"prop\":0.2695,\"mMd\":0.0593,\"mMs\":0.057,\"lO\":0.1106,\"score\":0},\"impact\":{\"unearnedS\":2.8075,\"score\":0},\"competitiveness\":{\"bigR\":-16.926,\"littleR\":4.3523,\"mIR\":0.1298,\"rD\":4.0207,\"rDf\":0.3093,\"c\":6,\"cD\":0.7266,\"cDf\":0.0559,\"mRange\":[5,11],\"mD\":0.7134,\"mDf\":0.1019,\"score\":10},\"score\":3,\"score2\":2},\"minority\":{\"report\":{\"bucketsByDemographic\":[[10,14],[3,0],[1,9],[0,0],[0,0],[0,0]],\"averageDVf\":0.6737588682747838},\"nProportional\":18,\"opportunityDistricts\":12.9424,\"score\":14},\"traditionalPrinciples\":{\"score\":18,\"compactness\":{\"score\":35,\"reock\":{\"raw\":0.3373,\"normalized\":35,\"notes\":{}},\"polsby\":{\"raw\":0.2418,\"normalized\":35,\"notes\":{}}},\"splitting\":{\"score\":0,\"county\":{\"raw\":1.1474,\"normalized\":0,\"notes\":{}},\"district\":{\"raw\":1.4839,\"normalized\":3,\"notes\":{}}},\"populationDeviation\":{\"raw\":0.016,\"normalized\":0,\"notes\":{\"maxDeviation\":11693}}}}");
 
 /***/ })
 
@@ -100410,6 +101379,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const Score = __importStar(__webpack_require__(/*! @dra2020/dra-score */ "./node_modules/@dra2020/dra-score/dist/dra-score.bundle.js"));
 const preprocess_1 = __webpack_require__(/*! ./preprocess */ "./src/preprocess.ts");
 const analyze_1 = __webpack_require__(/*! ./analyze */ "./src/analyze.ts");
 const score_1 = __webpack_require__(/*! ./score */ "./src/score.ts");
@@ -100603,9 +101573,13 @@ class AnalyticsSession {
             return 1 - this.testScales[4 /* PopulationDeviation */]['scale'][0];
         }
         else {
+            // NOTE - This assumes the plan has been profiled
+            const scorer = new Score.Scorer();
+            const popdev = scorer.populationDeviationThreshold(this.legislativeDistricts);
+            return popdev;
             // TODO - SCORE: Temporary HACK. Query dra-score for threshold.
             // NOTE - The plan may not have been scored yet, i.e., no scorecard yet.
-            return 1 - this.testScales[4 /* PopulationDeviation */]['scale'][0];
+            // return 1 - this.testScales[T.Test.PopulationDeviation]['scale'][0];
         }
     }
 }
@@ -102815,7 +103789,9 @@ function doAnalyzePostProcessing(s, bLog = false) {
         // Just populate the normalized population deviation score in the test
         const scorecard = s._scorecard;
         let test = s.getTest(4 /* PopulationDeviation */);
-        test['normalizedScore'] = scorecard.best.populationDeviation.normalized;
+        test['normalizedScore'] = scorecard.traditionalPrinciples.populationDeviation.normalized;
+        // TODO - DELETE
+        // test['normalizedScore'] = scorecard.best.populationDeviation.normalized;
     }
     // Derive secondary tests
     analyze_1.doDeriveSecondaryTests(s, bLog);
@@ -102861,9 +103837,10 @@ function profilePlan(s, bLog = false) {
     const geoPropsByDistrict = makeArrayOfGeoProps(s, bLog);
     const splits = makeNakedCxD(s);
     const summaryRow = s.districts.numberOfRows() - 1;
-    const statewideVf = s.districts.statistics[D.DistrictField.DemPct][summaryRow];
+    const statewideVf = U.trim(s.districts.statistics[D.DistrictField.DemPct][summaryRow], 6);
     const vpiArray = U.deepCopy(s.districts.statistics[D.DistrictField.DemPct].slice(1, -1));
-    const demographicsByDistrict = makeArrayOfDemographics(s);
+    const statewideDemographics = getStatewideDemographics(s);
+    const demographicsByDistrict = getDemographicsByDistrict(s);
     const profile = {
         state: state,
         planName: planName,
@@ -102871,21 +103848,22 @@ function profilePlan(s, bLog = false) {
         nCounties: nCounties,
         legislativeDistricts: s.legislativeDistricts,
         populationProfile: {
-            TotalPopByDistrict: popByDistrict,
+            totalPopByDistrict: popByDistrict,
             targetSize: targetSize
         },
         compactnessProfile: {
-            GeometryByDistrict: geoPropsByDistrict
+            geometryByDistrict: geoPropsByDistrict
         },
         splittingProfile: {
-            CountyPopByDistrict: splits
+            countyPopByDistrict: splits
         },
         partisanProfile: {
             statewideVf: statewideVf,
-            VfArray: vpiArray
+            vfArray: vpiArray
         },
         demographicProfile: {
-            DemographicsByDistrict: demographicsByDistrict
+            stateMfArray: statewideDemographics,
+            mfArrayByDistrict: demographicsByDistrict
         }
     };
     return profile;
@@ -102919,7 +103897,7 @@ function makeArrayOfGeoProps(s, bLog = false) {
     }
     return geometryByDistrict;
 }
-function makeArrayOfDemographics(s, bLog = false) {
+function getDemographicsByDistrict(s, bLog = false) {
     let demographicsArray = [];
     // Remove the unassigned & total dummy "districts"
     for (let districtID = 1; districtID <= s.state.nDistricts; districtID++) {
@@ -102936,6 +103914,19 @@ function makeArrayOfDemographics(s, bLog = false) {
     }
     return demographicsArray;
 }
+function getStatewideDemographics(s, bLog = false) {
+    const summaryRow = s.districts.numberOfRows() - 1;
+    const demographicsArray = [
+        U.deepCopy(s.districts.statistics[D.DistrictField.WhitePct][summaryRow]),
+        U.deepCopy(s.districts.statistics[D.DistrictField.MinorityPct][summaryRow]),
+        U.deepCopy(s.districts.statistics[D.DistrictField.BlackPct][summaryRow]),
+        U.deepCopy(s.districts.statistics[D.DistrictField.HispanicPct][summaryRow]),
+        U.deepCopy(s.districts.statistics[D.DistrictField.PacificPct][summaryRow]),
+        U.deepCopy(s.districts.statistics[D.DistrictField.AsianPct][summaryRow]),
+        U.deepCopy(s.districts.statistics[D.DistrictField.NativePct][summaryRow])
+    ];
+    return demographicsArray;
+}
 // SCORE A PLAN
 function scorePlan(s, p, bLog = false, overridesJSON) {
     let scorer = new Score.Scorer();
@@ -102945,11 +103936,14 @@ function scorePlan(s, p, bLog = false, overridesJSON) {
     //   calling sequence.
     let test = s.getTest(4 /* PopulationDeviation */);
     // TODO - SCORE: U.trim(popDev)???
+    // const popDev = scorecard.best.populationDeviation.raw;
     // Get the raw population deviation
-    const popDev = scorecard.best.populationDeviation.raw;
+    const popDev = scorecard.traditionalPrinciples.populationDeviation.raw;
     // Populate the test entry
     test['score'] = popDev;
-    test['details'] = { 'maxDeviation': scorecard.best.populationDeviation.notes['maxDeviation'] };
+    test['details'] = { 'maxDeviation': scorecard.traditionalPrinciples.populationDeviation.notes['maxDeviation'] };
+    // TODO - DELETE
+    // test['details'] = { 'maxDeviation': scorecard.best.populationDeviation.notes['maxDeviation'] };
     // 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];