@dra2020/district-analytics 14.1.2 → 15.0.0

package/dist/district-analytics.js

@@ -44,16 +44,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AnalyticsSession = void 0;
 const baseclient_1 = __webpack_require__(/*! @dra2020/baseclient */ "@dra2020/baseclient");
+// LEGACY - DELETE
 // import * as DT from '@dra2020/dra-types';
-const Score = __importStar(__webpack_require__(/*! @dra2020/dra-score */ "@dra2020/dra-score"));
+// LEGACY - DELETE
+// import * as Score from '@dra2020/dra-score';
+const dra_analytics_1 = __webpack_require__(/*! @dra2020/dra-analytics */ "@dra2020/dra-analytics");
 const preprocess_1 = __webpack_require__(/*! ./preprocess */ "./src/preprocess.ts");
 const analyze_1 = __webpack_require__(/*! ./analyze */ "./src/analyze.ts");
+// LEGACY - DELETE
+// import { profilePlan, scorePlan, computeMetrics, rateKeyDimensions, thunkScorecard, compareScorecards } from './score'
 const score_1 = __webpack_require__(/*! ./score */ "./src/score.ts");
 const results_1 = __webpack_require__(/*! ./results */ "./src/results.ts");
 const results_2 = __webpack_require__(/*! ./results */ "./src/results.ts");
 const minority_1 = __webpack_require__(/*! ./minority */ "./src/minority.ts");
 const D = __importStar(__webpack_require__(/*! ./_data */ "./src/_data.ts"));
+const M = __importStar(__webpack_require__(/*! ./minority */ "./src/minority.ts"));
 const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
+// LEGACY - DELETE
 // import * as S from './settings';
 class AnalyticsSession {
     constructor(SessionRequest) {
@@ -108,13 +115,69 @@ class AnalyticsSession {
             (0, analyze_1.doAnalyzeDistricts)(this, bLog);
             // This does a little stuff that didn't get factored out into dra-score and then dra-analytics
             (0, analyze_1.doAnalyzePlan)(this, bLog);
-            // The main analytics are next
-            // Run legacy analytics
+            // THE MAIN ANALYTICS ARE NEXT
+            // Even though we don't save the profile (as I thought we would),
+            // we allow it to be exported, so keep generating it, and use it
+            // to gather the inputs to new analytics (as well as the legacy).
             this._profile = (0, score_1.profilePlan)(this, bLog);
-            this._scorecard = (0, score_1.scorePlan)(this, this._profile, bLog, overridesJSON);
-            // TODO: Run new analytics
-            // TODO: Compare the new & legacy scorecards
-            // TODO: Set a scorecard
+            // LEGACY - DELETE
+            // let legacyScorecard = {} as Score.Scorecard;
+            let legacyScorecardAlt = {};
+            let newScorecard = {};
+            // LEGACY - DELETE: Run legacy analytics
+            /*
+            if (this.config.legacyanalytics)
+            {
+              if (bLog) console.log("Running legacy analytics ...");
+              legacyScorecard = scorePlan(this, this._profile, bLog, overridesJSON);
+            }
+            */
+            // Construct a new/alternate scorecard
+            // LEGACY - DELETE
+            // if (this.config.newanalytics) 
+            // {
+            //   if (bLog) console.log("Running new analytics ...");
+            newScorecard = (0, score_1.computeMetrics)(this._profile, this.getGoodShapes(), bLog); // w/o ratings
+            newScorecard = (0, score_1.rateKeyDimensions)(newScorecard, this._profile, bLog); // w/  ratings
+            legacyScorecardAlt = (0, score_1.thunkScorecard)(newScorecard, bLog);
+            // Add minority notes
+            legacyScorecardAlt.minority.details['majorityMinority'] = M.getMajorityMinority(this);
+            legacyScorecardAlt.minority.details['vraPreclearance'] = M.getVRASection5(this);
+            // LEGACY - DELETE
+            // // Compare the new & legacy scorecards
+            // compareScorecards(legacyScorecardAlt, legacyScorecard, bLog);
+            // }
+            // LEGACY - DELETE
+            // Use the new scorecard, after creating it
+            // this._scorecard = (this.config.newanalytics) ? legacyScorecardAlt : legacyScorecard;
+            this._scorecard = legacyScorecardAlt;
+            // Post-scorecard housekeeping - copied from scorePlan()
+            // LEGACY - DELETE
+            // if (this.config.newanalytics) 
+            // {
+            // Before returning, create a dummy population deviation test, for 
+            // doHasEqualPopulations() to use later.This is preserving the old calling sequence.
+            let test = this.getTest(4 /* PopulationDeviation */);
+            // Get the raw population deviation
+            const popDev = this._scorecard.populationDeviation.raw;
+            // Populate the test entry
+            test['score'] = popDev;
+            test['details'] = { 'maxDeviation': this._scorecard.populationDeviation.notes['maxDeviation'] };
+            // Populate the N+1 summary "district" in district.statistics
+            let totalPop = this.districts.table.totalPop;
+            let popDevPct = this.districts.table.popDevPct;
+            let totalVAP = this.districts.table.totalVAP;
+            const summaryRow = this.districts.numberOfRows() - 1;
+            totalPop[summaryRow] = this._profile.population.targetSize;
+            popDevPct[summaryRow] = popDev;
+            totalVAP[summaryRow] = Math.round(totalVAP[summaryRow] / this._profile.nDistricts);
+            // Added w/ new scorecard
+            // Use 'roughly' equal population from dra-analytics
+            let test2 = this.getTest(3 /* EqualPopulation */);
+            test2['score'] = newScorecard.populationDeviation.roughlyEqual;
+            // LEGACY - DELETE
+            // }
+            // END main analytics
             (0, results_1.doAnalyzePostProcessing)(this, bLog);
         }
         catch (e) {
@@ -124,6 +187,29 @@ class AnalyticsSession {
         }
         return true;
     }
+    getGoodShapes() {
+        const rawShapes = this.districts.getDistrictShapes();
+        // Filter the real shapes & throw everything else away
+        let goodShapes = {};
+        goodShapes['type'] = "FeatureCollection";
+        goodShapes['features'] = [];
+        for (let i = 0; i < rawShapes.features.length; i++) {
+            const shape = rawShapes.features[i];
+            if (isAShape(shape)) {
+                const d = baseclient_1.Poly.polyDescribe(shape);
+                let f = {
+                    type: 'Feature',
+                    properties: { districtID: `${i + 1}` },
+                    geometry: {
+                        type: (d.npoly > 1) ? 'MultiPolygon' : 'Polygon',
+                        coordinates: shape.geometry.coordinates
+                    }
+                };
+                goodShapes.features.push(f);
+            }
+        }
+        return goodShapes;
+    }
     // 11-03-2020 - Added for racially polarized voting analysis
     // NOTE - This assumes that analyzePlan() has been run!
     analyzeRacialPolarization(districtID, groups, bLog = false) {
@@ -196,15 +282,32 @@ class AnalyticsSession {
         // Return a pointer to the the test entry for this test
         return this.tests[testID];
     }
+    // LEGACY - Threshold defined in dra-analytics for new analytics
     // NOTE - Not sure why this has to be up here ...
     populationDeviationThreshold() {
-        // NOTE - This assumes the plan has been profiled
-        const scorer = new Score.Scorer();
-        const threshold = scorer.populationDeviationThreshold(this.legislativeDistricts); // TODO - 2020
+        // LEGACY - DELETE
+        // let threshold: number;
+        // if (this.config.legacyanalytics && !this.config.newanalytics)
+        // {
+        //   // NOTE - This assumes the plan has been profiled
+        //   const scorer = new Score.Scorer();
+        //   threshold = scorer.populationDeviationThreshold(this.legislativeDistricts);  // TODO - 2020
+        // }
+        // else 
+        // {
+        const threshold = dra_analytics_1.Rate.popdevThreshold(this.legislativeDistricts);
+        // }
         return threshold;
     }
 }
 exports.AnalyticsSession = AnalyticsSession;
+function isAShape(poly) {
+    if (poly == null)
+        return false;
+    if (baseclient_1.Poly.polyNull(poly))
+        return false;
+    return poly.geometry && poly.geometry.coordinates && !U.isArrayEmpty(poly.geometry.coordinates);
+}
 
 
 /***/ }),
@@ -1449,6 +1552,7 @@ function isAShape(poly) {
     return poly.geometry && poly.geometry.coordinates && !U.isArrayEmpty(poly.geometry.coordinates);
 }
 // SCORE KIWYSI COMPACTNESS
+// LEGACY
 function scoreKIWYSICompactness(s, bLog = false) {
     const rawShapes = s.districts.getDistrictShapes();
     // Filter the real shapes & throw everything else away
@@ -1528,17 +1632,26 @@ function doHasEqualPopulations(s, bLog = false) {
     let popDevTest = s.getTest(4 /* PopulationDeviation */);
     const popDevPct = popDevTest['score'];
     const popDevNormalized = popDevTest['normalizedScore'];
-    // 09-19-2020 - Added to catch edge case of only one non-empty district
-    const p = s._profile;
-    const totPopByDistrict = p.population.byDistrict.filter(x => x > 0);
-    const bTwoOrMoreDistricts = (totPopByDistrict.length > 1) ? true : false;
-    // Populate the test entry
-    if (bTwoOrMoreDistricts && (popDevNormalized > 0)) {
+    // LEGACY - DELETE: Has 'roughly' equal populations is calculated in dra-analytics
+    /*
+    if (s.config.legacyanalytics && !s.config.newanalytics)
+    {
+      // 09-19-2020 - Added to catch edge case of only one non-empty district
+      const p = s._profile as L.Profile;
+      const totPopByDistrict = p.population.byDistrict.filter(x => x > 0);
+      const bTwoOrMoreDistricts: boolean = (totPopByDistrict.length > 1) ? true : false;
+  
+      // Populate the test entry
+      if (bTwoOrMoreDistricts && (popDevNormalized > 0))
+      {
         test['score'] = true;
-    }
-    else {
+      }
+      else
+      {
         test['score'] = false;
+      }
     }
+    */
     test['details']['deviation'] = popDevPct;
     test['details']['thresholds'] = popDevTest['details']['scale'];
     // Populate the N+1 summary "district" in district.statistics
@@ -1573,7 +1686,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.uncertaintyOfMembership = exports.effectiveSplits = exports.avgSVError = exports.isAntimajoritarian = exports.ratePartisanBias = exports.inferSelectedMinority = exports.fieldForFeature = exports.geoIDForFeature = void 0;
+exports.uncertaintyOfMembership = exports.effectiveSplits = exports.avgSVError = exports.isAntimajoritarian = exports.ratePartisanBias = exports.estSeatProbability = exports.inferSelectedMinority = exports.fieldForFeature = exports.geoIDForFeature = void 0;
 __exportStar(__webpack_require__(/*! ./_api */ "./src/_api.ts"), exports);
 var _data_1 = __webpack_require__(/*! ./_data */ "./src/_data.ts");
 Object.defineProperty(exports, "geoIDForFeature", ({ enumerable: true, get: function () { return _data_1.geoIDForFeature; } }));
@@ -1584,6 +1697,7 @@ __exportStar(__webpack_require__(/*! ./types */ "./src/types.ts"), exports);
 __exportStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"), exports);
 // Re-export RPV types and COI splitting functions
 const dra_analytics_1 = __webpack_require__(/*! @dra2020/dra-analytics */ "@dra2020/dra-analytics");
+exports.estSeatProbability = dra_analytics_1.Partisan.estSeatProbability;
 exports.ratePartisanBias = dra_analytics_1.Rate.ratePartisanBias;
 exports.isAntimajoritarian = dra_analytics_1.Rate.isAntimajoritarian;
 exports.avgSVError = dra_analytics_1.Rate.avgSVError;
@@ -2028,6 +2142,7 @@ function doAnalyzePostProcessing(s, bLog = false) {
     scorecard.splitting.details['countiesWithSplits'] = simpleSplits['details']['countiesWithSplits'];
     // NOTE - Add split precincts in dra-client directly
     // Derive secondary tests
+    // Note - The only secondary test is 'roughly equal population (true/false)
     (0, analyze_1.doDeriveSecondaryTests)(s, bLog);
     // Toggle the semaphore, so postprocessing isn't for both the testlog & scorecard
     s.bPostProcessingDone = true;
@@ -2067,11 +2182,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.scorePlan = exports.getStatewideDemographics = exports.profilePlan = void 0;
-const Score = __importStar(__webpack_require__(/*! @dra2020/dra-score */ "@dra2020/dra-score"));
+exports.thunkScorecard = exports.rateKeyDimensions = exports.computeMetrics = exports.getStatewideDemographics = exports.profilePlan = void 0;
 const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
-const M = __importStar(__webpack_require__(/*! ./minority */ "./src/minority.ts"));
-const C = __importStar(__webpack_require__(/*! ./compact */ "./src/compact.ts"));
+const dra_analytics_1 = __webpack_require__(/*! @dra2020/dra-analytics */ "@dra2020/dra-analytics");
 // PROFILE A PLAN
 const KEEP_DECIMALS = 6;
 function profilePlan(s, bLog = false) {
@@ -2183,50 +2296,555 @@ function getStatewideDemographics(s, bLog = false) {
     return demographics;
 }
 exports.getStatewideDemographics = getStatewideDemographics;
-// SCORE A PLAN
-function scorePlan(s, p, bLog = false, overridesJSON) {
-    let scorer = new Score.Scorer();
-    const scorecard = scorer.score(p, overridesJSON);
-    // Before returning, create a dummy population deviation test, for 
+// SCORE A PLAN - Legacy using dra-score
+// LEGACY - DELETE
+/*
+export function scorePlan(s: AnalyticsSession, p: Score.Profile, bLog: boolean = false, overridesJSON?: any): Score.Scorecard
+{
+  let scorer = new Score.Scorer();
+  const scorecard: Score.Scorecard = scorer.score(p, overridesJSON);
+
+  // LEGACY POST-SCORECARD HOUSEKEEPING
+  if (s.config.legacyanalytics && !s.config.newanalytics)
+  {
+    // Before returning, create a dummy population deviation test, for
     // doHasEqualPopulations() to use later.This is preserving the old calling sequence.
-    let test = s.getTest(4 /* PopulationDeviation */);
+    let test = s.getTest(T.Test.PopulationDeviation) as T.TestEntry;
+
     // Get the raw population deviation
     const popDev = scorecard.populationDeviation.raw;
+
     // Populate the test entry
     test['score'] = popDev;
     test['details'] = { 'maxDeviation': scorecard.populationDeviation.notes['maxDeviation'] };
+
     // Populate the N+1 summary "district" in district.statistics
     let totalPop = s.districts.table.totalPop;
     let popDevPct = s.districts.table.popDevPct;
     let totalVAP = s.districts.table.totalVAP;
+
     const summaryRow = s.districts.numberOfRows() - 1;
     totalPop[summaryRow] = p.population.targetSize;
     popDevPct[summaryRow] = popDev;
     totalVAP[summaryRow] = Math.round(totalVAP[summaryRow] / p.nDistricts);
-    // Add minority notes
-    scorecard.minority.details['majorityMinority'] = M.getMajorityMinority(s);
-    scorecard.minority.details['vraPreclearance'] = M.getVRASection5(s);
-    try {
-        // Add KIWYSI compactness score
-        const kiwysiScores = C.scoreKIWYSICompactness(s, bLog);
-        // 10-21-2020 - Computing the average score here
-        const avgKIWYSIScore = Math.round(U.avgArray(kiwysiScores));
-        scorecard.compactness.details['kiwysi'] = avgKIWYSIScore;
-        // 10-21-2020 - Added KIWYSI scores to the by-district details
-        let byDistrict = scorecard.compactness.details['byDistrict'];
-        const nDistricts = byDistrict.length;
-        for (let districtID = 1; districtID <= nDistricts; districtID++) {
-            byDistrict[districtID - 1].kiwysiScore = kiwysiScores[districtID - 1];
-        }
-    }
-    catch (e) {
-        console.log("Exception caught scoring KIWYSI compactness.");
-        console.log(e.message);
-        // throw e;
+
+  } // end
+
+  // Add minority notes
+  scorecard.minority.details['majorityMinority'] = M.getMajorityMinority(s);
+  scorecard.minority.details['vraPreclearance'] = M.getVRASection5(s);
+
+  try
+  {
+    // Add KIWYSI compactness score
+    const kiwysiScores: number[] = C.scoreKIWYSICompactness(s, bLog);
+    // 10-21-2020 - Computing the average score here
+    const avgKIWYSIScore: number = Math.round(U.avgArray(kiwysiScores));
+    scorecard.compactness.details['kiwysi'] = avgKIWYSIScore;
+
+    // 10-21-2020 - Added KIWYSI scores to the by-district details
+    let byDistrict: Score.CompactnessByDistrict[] = scorecard.compactness.details['byDistrict'];
+    const nDistricts = byDistrict.length;
+
+    for (let districtID = 1; districtID <= nDistricts; districtID++)
+    {
+      byDistrict[districtID - 1].kiwysiScore = kiwysiScores[districtID - 1];
+
+      // 09-17-21 - Fix the normalized Polsby–Popper score!
+      const rawPolsby = byDistrict[districtID - 1].rawPolsby;
+      byDistrict[districtID - 1].normalizedPolsby = Rate.ratePolsby(rawPolsby);
     }
+  }
+  catch (e)
+  {
+    console.log("Exception caught scoring KIWYSI compactness.");
+    console.log((<Error>e).message);
+    // throw e;
+  }
+
+  return scorecard;
+}
+*/
+// SCORE A PLAN - New using dra-analytics
+function computeMetrics(p, districtShapes, bLog = false) {
+    if (bLog)
+        console.log("Computing metrics ...");
+    const bLegislative = p.bStateLeg;
+    // Calculate bias & responsiveness metrics ...
+    const byDistrictVf = p.partisanship.byDistrict;
+    const statewideVf = p.partisanship.statewide;
+    let _pS = dra_analytics_1.Partisan.makePartisanScorecard(statewideVf, byDistrictVf, bLog);
+    // Calculate minority representation metrics ...
+    const statewideDemos = p.demographics.statewide;
+    const byDistrictDemos = p.demographics.byDistrict;
+    let _mS = dra_analytics_1.Minority.makeMinorityScorecard(statewideDemos, byDistrictDemos, bLog);
+    // Calculate compactness metrics ...
+    let _cS = dra_analytics_1.Compactness.makeCompactnessScorecard(districtShapes, bLog);
+    // Calculate county-district splitting metrics ...
+    const CxD = p.counties;
+    const _sS = dra_analytics_1.Splitting.makeSplittingScorecard(CxD, bLog);
+    // Calculate population deviation-related metrics ...
+    const totPopByDistrict = p.population.byDistrict;
+    const targetSize = p.population.targetSize;
+    const _pdS = dra_analytics_1.Equal.makePopulationScorecard(totPopByDistrict, targetSize, bLegislative, bLog);
+    const details = {};
+    // Assemble the pieces into new scorecard
+    const scorecard = {
+        partisan: _pS,
+        minority: _mS,
+        compactness: _cS,
+        splitting: _sS,
+        populationDeviation: _pdS,
+        details: details,
+        scratchpad: {} // Hack to pass legacy values between processing steps
+    };
+    return scorecard;
+}
+exports.computeMetrics = computeMetrics;
+function rateKeyDimensions(scorecard, p, bLog = false) {
+    if (bLog)
+        console.log("Rating key dimensions ...");
+    const bLegislative = p.bStateLeg;
+    // Rate proportionality
+    const statewideVf = p.partisanship.statewide;
+    const Sf = scorecard.partisan.bias.estSf;
+    scorecard.partisan.bias.score = dra_analytics_1.Rate.rateProportionality(scorecard.partisan.bias.deviation, statewideVf, Sf);
+    // Rate competititveness
+    scorecard.partisan.responsiveness.score = dra_analytics_1.Rate.rateCompetitiveness(scorecard.partisan.responsiveness.cDf);
+    // Rate minority representation
+    const rawOd = scorecard.minority.opportunityDistricts;
+    const pOd = scorecard.minority.proportionalOpportunities;
+    const rawCd = scorecard.minority.coalitionDistricts;
+    const pCd = scorecard.minority.proportionalCoalitions;
+    scorecard.minority.score = dra_analytics_1.Rate.rateMinorityRepresentation(rawOd, pOd, rawCd, pCd);
+    // Rate compactness
+    const avgReock = scorecard.compactness.avgReock;
+    const avgPolsby = scorecard.compactness.avgPolsby;
+    const reockRating = dra_analytics_1.Rate.rateReock(avgReock);
+    const polsbyRating = dra_analytics_1.Rate.ratePolsby(avgPolsby);
+    scorecard.compactness.score = dra_analytics_1.Rate.rateCompactness(reockRating, polsbyRating);
+    // Rate county- & district-splitting
+    const rawCountySplitting = scorecard.splitting.county;
+    const rawDistrictSplitting = scorecard.splitting.district;
+    const nCounties = p.nCounties;
+    const nDistricts = p.nDistricts;
+    const countyRating = dra_analytics_1.Rate.rateCountySplitting(rawCountySplitting, nCounties, nDistricts, bLegislative);
+    const districtRating = dra_analytics_1.Rate.rateDistrictSplitting(rawDistrictSplitting, bLegislative);
+    const unadjusted = dra_analytics_1.Rate.rateSplitting(countyRating, districtRating);
+    scorecard.splitting.score = dra_analytics_1.Rate.adjustSplittingRating(unadjusted, rawCountySplitting, rawDistrictSplitting);
+    // Rate population deviation
+    const rawDeviation = scorecard.populationDeviation.deviation;
+    scorecard.populationDeviation.score = dra_analytics_1.Rate.ratePopulationDeviation(rawDeviation, bLegislative);
+    // Squirrel away normalized compactness & splitting ratings for the legacy scorecard
+    const keep = {
+        reockScore: reockRating,
+        polsbyScore: polsbyRating,
+        countyScore: countyRating,
+        districtScore: districtRating
+    };
+    scorecard.scratchpad = keep;
+    return scorecard;
+}
+exports.rateKeyDimensions = rateKeyDimensions;
+function thunkScorecard(newScorecard, bLog = false) {
+    if (bLog)
+        console.log("Thunking new scorecard into legacy structure ...");
+    const scratchpad = newScorecard.scratchpad;
+    // Partisan scorecard
+    const pS = U.deepCopy(newScorecard.partisan);
+    // Minority scorecard
+    const mS = U.deepCopy(newScorecard.minority);
+    // Compactness scorecard
+    const reockM = {
+        raw: newScorecard.compactness.avgReock,
+        normalized: scratchpad.reockScore,
+        notes: {}
+    };
+    const polsbyM = {
+        raw: newScorecard.compactness.avgPolsby,
+        normalized: scratchpad.polsbyScore,
+        notes: {}
+    };
+    let cS = {
+        score: newScorecard.compactness.score,
+        reock: reockM,
+        polsby: polsbyM,
+        details: U.deepCopy(newScorecard.compactness.details)
+    };
+    // Relocate byDistrict compactness #'s
+    cS.details.byDistrict = U.deepCopy(newScorecard.compactness.byDistrict);
+    // Add KIWYSI compactness score
+    cS.details['kiwysi'] = newScorecard.compactness.avgKWIWYSI;
+    // Splitting scorecard
+    const countyM = {
+        raw: newScorecard.splitting.county,
+        normalized: scratchpad.countyScore,
+        notes: {}
+    };
+    const districtM = {
+        raw: newScorecard.splitting.district,
+        normalized: scratchpad.districtScore,
+        notes: {}
+    };
+    const sS = {
+        score: newScorecard.splitting.score,
+        county: countyM,
+        district: districtM,
+        details: U.deepCopy(newScorecard.splitting.details)
+    };
+    // Population (equality) scorecard
+    const pdM = {
+        raw: newScorecard.populationDeviation.deviation,
+        normalized: newScorecard.populationDeviation.score,
+        notes: newScorecard.populationDeviation.notes
+    };
+    const pdS = pdM;
+    const scorecard = {
+        partisan: pS,
+        minority: mS,
+        compactness: cS,
+        splitting: sS,
+        populationDeviation: pdS,
+        details: newScorecard.details
+    };
     return scorecard;
 }
-exports.scorePlan = scorePlan;
+exports.thunkScorecard = thunkScorecard;
+// LEGACY - DELETE
+/*
+export function compareScorecards(altLegacyScorecard: Score.Scorecard, legacyScorecard: Score.Scorecard, bLog: boolean = false): void
+{
+  if (bLog) console.log("Comparing new & legacy scorecards ...");
+
+  // A pretty loose tolerance, because we're not trimming values in the new analytics
+  const DECIMAL_PLACES = 2;
+  const DEFAULT_TOLERANCE = toleranceFn(DECIMAL_PLACES);
+
+  // COMPARE PARTISAN SCORECARD
+
+  // Compare BIAS section
+
+  matchFloats("bestS", altLegacyScorecard.partisan.bias.bestS, legacyScorecard.partisan.bias.bestS, DEFAULT_TOLERANCE);
+  matchFloats("bestSf", altLegacyScorecard.partisan.bias.bestSf, legacyScorecard.partisan.bias.bestSf, DEFAULT_TOLERANCE);
+  matchFloats("estS", altLegacyScorecard.partisan.bias.estS, legacyScorecard.partisan.bias.estS, DEFAULT_TOLERANCE);
+  matchFloats("estSf", altLegacyScorecard.partisan.bias.estSf, legacyScorecard.partisan.bias.estSf, DEFAULT_TOLERANCE);
+  matchFloats("deviation", altLegacyScorecard.partisan.bias.deviation, legacyScorecard.partisan.bias.deviation, DEFAULT_TOLERANCE);
+  matchInts("proportionality/score", altLegacyScorecard.partisan.bias.score, legacyScorecard.partisan.bias.score);
+
+  matchFloats("tOf", altLegacyScorecard.partisan.bias.tOf as number, legacyScorecard.partisan.bias.tOf as number, DEFAULT_TOLERANCE);
+  matchFloats("fptpS", altLegacyScorecard.partisan.bias.fptpS as number, legacyScorecard.partisan.bias.fptpS as number, DEFAULT_TOLERANCE);
+  matchFloats("bS50", altLegacyScorecard.partisan.bias.bS50 as number, legacyScorecard.partisan.bias.bS50 as number, DEFAULT_TOLERANCE);
+  matchFloats("deviation", altLegacyScorecard.partisan.bias.deviation, legacyScorecard.partisan.bias.deviation, DEFAULT_TOLERANCE);
+  matchUndefinableFloats("decl", altLegacyScorecard.partisan.bias.decl, legacyScorecard.partisan.bias.decl, toleranceFn(1));
+
+  let rvPointsAlt = altLegacyScorecard.partisan.bias.rvPoints;
+  let rvPoints = legacyScorecard.partisan.bias.rvPoints;
+  if (matchUndefinedness("rvPoints", rvPointsAlt, rvPoints)) {
+    rvPointsAlt = rvPointsAlt as L.rVpoints;
+    rvPoints = rvPoints as L.rVpoints;
+    matchFloats("rvPoints/Sb", rvPointsAlt.Sb, rvPoints.Sb, DEFAULT_TOLERANCE);
+    matchFloats("rvPoints/Ra", rvPointsAlt.Ra, rvPoints.Ra, DEFAULT_TOLERANCE);
+    matchFloats("rvPoints/Rb", rvPointsAlt.Rb, rvPoints.Rb, DEFAULT_TOLERANCE);
+    matchFloats("rvPoints/Va", rvPointsAlt.Va, rvPoints.Va, DEFAULT_TOLERANCE);
+    matchFloats("rvPoints/Vb", rvPointsAlt.Vb, rvPoints.Vb, DEFAULT_TOLERANCE);
+  }
+
+  matchFloats("gSym", altLegacyScorecard.partisan.bias.gSym as number, legacyScorecard.partisan.bias.gSym as number, DEFAULT_TOLERANCE);
+  matchUndefinableFloats("gamma", altLegacyScorecard.partisan.bias.gamma, legacyScorecard.partisan.bias.gamma, DEFAULT_TOLERANCE);
+  matchFloats("eG", altLegacyScorecard.partisan.bias.eG as number, legacyScorecard.partisan.bias.eG as number, DEFAULT_TOLERANCE);
+  matchUndefinableFloats("bSV", altLegacyScorecard.partisan.bias.bSV, legacyScorecard.partisan.bias.bSV, DEFAULT_TOLERANCE);
+  matchFloats("prop", altLegacyScorecard.partisan.bias.prop as number, legacyScorecard.partisan.bias.prop as number, DEFAULT_TOLERANCE);
+  matchFloats("mMs", altLegacyScorecard.partisan.bias.mMs as number, legacyScorecard.partisan.bias.mMs as number, DEFAULT_TOLERANCE);
+  matchFloats("mMd", altLegacyScorecard.partisan.bias.mMd as number, legacyScorecard.partisan.bias.mMd as number, DEFAULT_TOLERANCE);
+  matchUndefinableFloats("lO", altLegacyScorecard.partisan.bias.lO, legacyScorecard.partisan.bias.lO, DEFAULT_TOLERANCE);
+  
+  // Compare Impact section
+
+  matchFloats("unearnedS", altLegacyScorecard.partisan.impact.unearnedS, legacyScorecard.partisan.impact.unearnedS, DEFAULT_TOLERANCE);
+  // Note - We don't use the impact score, so we don't compute it in the new scorecard.
+  // matchInts("impact/score", altLegacyScorecard.partisan.impact.score as number, legacyScorecard.partisan.impact.score);
+
+  // Compare Responsiveness section
+
+  matchUndefinableFloats("bigR", altLegacyScorecard.partisan.responsiveness.bigR, legacyScorecard.partisan.responsiveness.bigR, DEFAULT_TOLERANCE);
+  matchUndefinableFloats("littleR", altLegacyScorecard.partisan.responsiveness.littleR, legacyScorecard.partisan.responsiveness.littleR, DEFAULT_TOLERANCE);
+  matchUndefinableFloats("mIR", altLegacyScorecard.partisan.responsiveness.mIR, legacyScorecard.partisan.responsiveness.mIR, DEFAULT_TOLERANCE);
+  matchFloats("rD", altLegacyScorecard.partisan.responsiveness.rD as number, legacyScorecard.partisan.responsiveness.rD as number, DEFAULT_TOLERANCE);
+  matchFloats("rDf", altLegacyScorecard.partisan.responsiveness.rDf as number, legacyScorecard.partisan.responsiveness.rDf as number, DEFAULT_TOLERANCE);
+  
+  matchFloats("cSimple", altLegacyScorecard.partisan.responsiveness.cSimple, legacyScorecard.partisan.responsiveness.cSimple, DEFAULT_TOLERANCE);
+  matchFloats("cD", altLegacyScorecard.partisan.responsiveness.cD, legacyScorecard.partisan.responsiveness.cD, DEFAULT_TOLERANCE);
+  matchFloats("cDf", altLegacyScorecard.partisan.responsiveness.cDf, legacyScorecard.partisan.responsiveness.cDf, DEFAULT_TOLERANCE);
+  matchInts("competitiveness/score", altLegacyScorecard.partisan.responsiveness.score as number, legacyScorecard.partisan.responsiveness.score);
+
+  matchPointArrays("dSVpoints", altLegacyScorecard.partisan.dSVpoints, legacyScorecard.partisan.dSVpoints, DEFAULT_TOLERANCE);
+  matchPointArrays("rSVpoints", altLegacyScorecard.partisan.rSVpoints, legacyScorecard.partisan.rSVpoints, DEFAULT_TOLERANCE);
+
+  matchUndefinableFloats("averageDVf", altLegacyScorecard.partisan.averageDVf, legacyScorecard.partisan.averageDVf, DEFAULT_TOLERANCE);
+  matchUndefinableFloats("averageRVf", altLegacyScorecard.partisan.averageRVf, legacyScorecard.partisan.averageRVf, DEFAULT_TOLERANCE);
+  matchDicts("partisan/details", altLegacyScorecard.partisan.details, legacyScorecard.partisan.details);
+
+  // COMPARE MINORITY SCORECARD
+
+  matchObjectsAndArrays("pivotByDemographic", altLegacyScorecard.minority.pivotByDemographic, legacyScorecard.minority.pivotByDemographic);
+  matchFloats("opportunityDistricts", altLegacyScorecard.minority.opportunityDistricts, legacyScorecard.minority.opportunityDistricts, DEFAULT_TOLERANCE);
+  matchFloats("coalitionDistricts", altLegacyScorecard.minority.coalitionDistricts, legacyScorecard.minority.coalitionDistricts, DEFAULT_TOLERANCE);
+  matchInts("minority/score", altLegacyScorecard.minority.score as number, legacyScorecard.minority.score);
+  matchDicts("minority/details", altLegacyScorecard.minority.details, legacyScorecard.minority.details);
+  
+  // COMPARE COMPACTNESS SCORECARD
+
+  matchFloats("reock", altLegacyScorecard.compactness.reock.raw, legacyScorecard.compactness.reock.raw, DEFAULT_TOLERANCE);
+  matchInts("reock/normalized", altLegacyScorecard.compactness.reock.normalized, legacyScorecard.compactness.reock.normalized);
+  matchFloats("polsby", altLegacyScorecard.compactness.polsby.raw, legacyScorecard.compactness.polsby.raw, DEFAULT_TOLERANCE);
+  matchInts("polsby/normalized", altLegacyScorecard.compactness.polsby.normalized, legacyScorecard.compactness.polsby.normalized);
+  matchInts("compactness/score", altLegacyScorecard.compactness.score as number, legacyScorecard.compactness.score);
+  // Compare 'byDistrict' results separately
+  const _altCompactnessByDistrict = Utils.deepCopy(altLegacyScorecard.compactness.details['byDistrict']);
+  const _CompactnessByDistrict = Utils.deepCopy(legacyScorecard.compactness.details['byDistrict']);
+  const _altCompactnessDetails = Utils.deepCopy(altLegacyScorecard.compactness.details);
+  const _CompactnessDetails = Utils.deepCopy(legacyScorecard.compactness.details);
+  delete _altCompactnessDetails['byDistrict'];
+  delete _CompactnessDetails['byDistrict'];
+  matchDicts("compactness/details", _altCompactnessDetails, _CompactnessDetails);
+  matchCompactnessByDistrict("compactness/byDistrict", _altCompactnessByDistrict, _CompactnessByDistrict, DEFAULT_TOLERANCE);
+
+  // COMPARE SPLITTING SCORECARD
+
+  matchFloats("county", altLegacyScorecard.splitting.county.raw, legacyScorecard.splitting.county.raw, DEFAULT_TOLERANCE);
+  matchInts("county/normalized", altLegacyScorecard.splitting.county.normalized, legacyScorecard.splitting.county.normalized);
+  matchFloats("district", altLegacyScorecard.splitting.district.raw, legacyScorecard.splitting.district.raw, DEFAULT_TOLERANCE);
+  matchInts("district/normalized", altLegacyScorecard.splitting.district.normalized, legacyScorecard.splitting.district.normalized);
+  matchInts("splitting/score", altLegacyScorecard.splitting.score as number, legacyScorecard.splitting.score);
+  matchDicts("splitting/details", altLegacyScorecard.splitting.details, legacyScorecard.splitting.details);
+
+  // COMPARE POPULATION SCORECARD
+
+  matchFloats("popdev", altLegacyScorecard.populationDeviation.raw, legacyScorecard.populationDeviation.raw, DEFAULT_TOLERANCE);
+  matchInts("popdev/score", altLegacyScorecard.populationDeviation.normalized, legacyScorecard.populationDeviation.normalized);
+  matchDicts("popdev/notes", altLegacyScorecard.populationDeviation.notes, legacyScorecard.populationDeviation.notes);
+
+  matchDicts("details", altLegacyScorecard.details, legacyScorecard.details);
+}
+*/
+// LEGACY - DELETE
+/*
+// Matching helpers
+
+function matchFloats(property: string, received: number, good: number, tolerance: number): boolean
+{
+  if (Utils.areRoughlyEqual(received, good, tolerance)) {
+    return true;
+  }
+  else {
+    console.log(`${property} does not match: ${good} expected. Received ${received}.`);
+    return false;
+  }
+}
+
+function toleranceFn (places: number): number{
+  return 0.5 / Math.pow(10, places)
+}
+
+function matchInts(property: string, received: number, good: number): boolean
+{
+  if (received == good) {
+    return true;
+  }
+  else {
+    console.log(`${property} does not match: ${good} expected. Received ${received}.`);
+    return false;
+  }
+}
+
+function matchUndefinableFloats(property: string, received: number | undefined, good: number | undefined, tolerance: number): boolean
+{
+  if ((received === undefined) && (good === undefined)) return true;
+  if ((received === undefined) || (good === undefined)) {
+    console.log(`${property} does not match: ${good} expected. Received ${received}.`);
+    return false;
+  }
+
+  return matchFloats(property, received as number, good as number, tolerance);
+}
+
+// https://stackoverflow.com/questions/13142968/deep-comparison-of-objects-arrays
+function matchObjectsAndArrays (property: string, received: object | undefined, good: object | undefined): boolean
+{
+  if ((received === undefined) && (good === undefined)) return true;                          // Both undefined
+
+  if ((received === undefined) || (good === undefined)) {                                     // One undefined but not the other
+    console.log(`${property} does not match: ${good} expected. Received ${received}.`);
+    return false;
+  }
+
+  if ((Object.keys(received).length === 0) && (Object.keys(good).length === 0)) return true;  // Both empty
+
+  if (JSON.stringify(received) === JSON.stringify(good)) return true;                         // Contents match
+
+  console.log(`${property} objects or arrays do not match.`);                                 // Contents don't match
+  return false;
+}
+
+function matchDicts (property: string, received: L.Dict, good: L.Dict): boolean
+{
+  if ((Object.keys(received).length === 0) && (Object.keys(good).length === 0)) return true;  // Both empty
+
+  const receivedStr: string = JSON.stringify(received);
+  const goodStr = JSON.stringify(good);
+  if (receivedStr === goodStr) return true;                                                  // Contents match
+                            
+  console.log(`${property} does not match: ${goodStr} expected. Received ${receivedStr}.`);  // Contents don't match
+
+  return false;
+}
+
+function matchUndefinedness(property: string, received: any | undefined, good: any | undefined): boolean
+{
+  if ((received === undefined) && (good === undefined)) return true;
+
+  if ((received === undefined) || (good === undefined)) return false;
+
+  return true;
+}
+
+function matchPointArrays(property: string, received: L.SVpoint[], good: L.SVpoint[], tolerance: number): boolean
+{
+  if (received.length != good.length)
+  {
+    console.log(`${property} does not match: Different number of points.`);
+    return false;
+  }
+
+  for (var i = 0; i < received.length; i++)
+  {
+    const vLabel: string = property + '/' + i.toString() + '/' + 'v';
+    const sLabel: string = property + '/' + i.toString() + '/' + 's';
+    if (!matchFloats(vLabel, received[i].v, good[i].v, tolerance)) return false;
+    if (!matchFloats(sLabel, received[i].s, good[i].s, tolerance)) return false;
+  }
+
+  return true;
+}
+
+function matchCompactnessByDistrict(property: string, received: L.CompactnessByDistrict[], good: L.CompactnessByDistrict[], tolerance: number): boolean
+{
+  if (received.length != good.length)
+  {
+    console.log(`${property} does not match: Different number of districts.`);
+    return false;
+  }
+
+  let bMismatched = false;
+  for (var i = 0; i < received.length; i++)
+  {
+    const rawReock: string = property + '/' + i.toString() + '/' + 'rawReock';
+    if (!matchFloats(rawReock, received[i].rawReock, good[i].rawReock, tolerance)) bMismatched = true;
+
+    const normalizedReock: string = property + '/' + i.toString() + '/' + 'normalizedReock';
+    if (!matchInts(normalizedReock, received[i].normalizedReock, good[i].normalizedReock)) bMismatched = true;
+
+    const rawPolsby: string = property + '/' + i.toString() + '/' + 'rawPolsby';
+    if (!matchFloats(rawPolsby, received[i].rawPolsby, good[i].rawPolsby, tolerance)) bMismatched = true;
+
+    // TODO
+    // 09-17-21 - By-district Polsby–Popper ratings from dra-score in production are wrong!
+    const normalizedPolsby: string = property + '/' + i.toString() + '/' + 'normalizedPolsby';
+    if (!matchInts(normalizedPolsby, received[i].normalizedPolsby, good[i].normalizedPolsby)) bMismatched = true;
+
+    const kiwysiScore: string = property + '/' + i.toString() + '/' + 'kiwysiScore';
+    if (!matchInts(kiwysiScore, received[i].kiwysiScore as number, good[i].kiwysiScore as number)) bMismatched = true;
+  }
+  if (bMismatched = true) return false;
+
+  return true;
+}
+*/
+// LEGACY - DELETE
+// Not used, after all
+/* Modeled after David Sielaff's Jest extension 'toBeArrayWithValuesCloseTo'
+
+function matchFloatArrays(property: string, received: Array<any>, expected: Array<any>, tolerance: number): boolean
+{
+  // Note - Not sure what this check was for ...
+  // if (expected.length == 0) {
+  //     return {
+  //         message: () => `expected arrays of same size`,
+  //         pass: received.length == 0
+  //     }
+  // }
+
+  if (typeof expected[0] === "number")
+  {
+    if (typeof received[0] === "number") return matchArrays1d(property, received, expected, tolerance);
+
+    console.log(`${property} does not match: array doesn't contain numbers.`);
+    return false;
+  }
+
+  // Note - Ditto
+  // if (expected[0].length == 0) {
+  //     return {
+  //         message: () => `expected arrays of same size`,
+  //         pass: received[0].length == 0
+  //     }
+  // }
+
+  if (expected[0] instanceof Array && typeof expected[0][0] === "number")
+  {
+    if (received[0] instanceof Array && typeof received[0][0] === "number") return matchArrays2d(property, received, expected, tolerance);
+
+    console.log(`${property} does not match: arrays don't have the same dimensionality and content.`);
+    return false;
+  }
+
+  console.log(`${property}: Expected 1d or 2d arrays.`);
+  return false;
+}
+
+function matchArrays1d(property: string, received: number[], expected: number[], tolerance: number): boolean
+{
+  if (received.length != expected.length)
+  {
+    console.log(`${property} does not match: arrays have different lengths.`);
+    return false;
+  }
+
+  for (var index = 0; index < received.length; index++)
+  {
+    const cell: string = property + '/' + index.toString();
+    if (!matchFloats(cell, received[index], expected[index], tolerance)) return false;
+  }
+
+  return true;
+}
+
+function matchArrays2d(property: string, received: number[][], expected: number[][], tolerance: number): boolean
+{
+  if (received.length != expected.length)
+  {
+    console.log(`${property} does not match: arrays have different lengths.`);
+    return false;
+  }
+
+  for (var index = 0; index < received.length; index++)
+  {
+    if (received[index].length != expected[index].length)
+    {
+      console.log(`${property} does not match: arrays have different lengths.`);
+      return false;
+    }
+
+    for (var inner = 0; inner < received[index].length; inner++)
+    {
+      const cell: string = property + '/' + index.toString() + '/' + inner.toString();
+      if (!matchFloats(cell, received[index][inner], expected[index][inner], tolerance)) return false;
+    }
+  }
+
+  return true;
+}
+*/ 
 
 
 /***/ }),
@@ -2242,24 +2860,27 @@ exports.scorePlan = scorePlan;
 // GLOBAL CONSTANTS
 //
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DISTRICT_SPLITTING_WEIGHT = exports.COUNTY_SPLITTING_WEIGHT = exports.EQUAL_TOLERANCE = exports.OUT_OF_STATE = exports.NUMBER_OF_ITEMS_TO_REPORT = exports.NOT_ASSIGNED = exports.NORMALIZED_RANGE = exports.PRECISION = void 0;
+exports.OUT_OF_STATE = exports.NUMBER_OF_ITEMS_TO_REPORT = exports.NOT_ASSIGNED = exports.PRECISION = void 0;
 // Keep four decimal places for fractions [0–1], i.e.,
 // keep two decimal places for %'s [0–100].
 exports.PRECISION = 4;
+// LEGACY - Not used
 // Normalized scores [0-100]
-exports.NORMALIZED_RANGE = 100;
+// export const NORMALIZED_RANGE: number = 100;
 // The dummy district ID for features not assigned districts yet
 exports.NOT_ASSIGNED = 0;
 // # of items to report as problematic (e.g., features, districts, etc.)
 exports.NUMBER_OF_ITEMS_TO_REPORT = 10;
 // The virtual geoID for "neighbors" in other states
 exports.OUT_OF_STATE = "OUT_OF_STATE";
+// LEGACY - Not used
 // "Roughly equal" = average census block size / 2
-const AVERAGE_BLOCK_SIZE = 30;
-exports.EQUAL_TOLERANCE = AVERAGE_BLOCK_SIZE / 2;
+// const AVERAGE_BLOCK_SIZE = 30;
+// export const EQUAL_TOLERANCE: number = AVERAGE_BLOCK_SIZE / 2;
+// LEGACY - Not used
 // County & district splitting weights
-exports.COUNTY_SPLITTING_WEIGHT = 0.8;
-exports.DISTRICT_SPLITTING_WEIGHT = 1.0 - exports.COUNTY_SPLITTING_WEIGHT;
+// export const COUNTY_SPLITTING_WEIGHT = 0.8;
+// export const DISTRICT_SPLITTING_WEIGHT = 1.0 - COUNTY_SPLITTING_WEIGHT;
 // 2020
 // export const SHAPES = "2010 VTD shapes";
 
@@ -2270,16 +2891,20 @@ exports.DISTRICT_SPLITTING_WEIGHT = 1.0 - exports.COUNTY_SPLITTING_WEIGHT;
 /*!**********************!*\
   !*** ./src/types.ts ***!
   \**********************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ ((__unused_webpack_module, exports) => {
 
 
 //
 // TYPE DEFINITIONS
 //
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.estSeatProbability = void 0;
-var dra_score_1 = __webpack_require__(/*! @dra2020/dra-score */ "@dra2020/dra-score");
-Object.defineProperty(exports, "estSeatProbability", ({ enumerable: true, get: function () { return dra_score_1.estSeatProbability; } }));
+// LEGACY - DELETE
+// export
+// {
+//   Profile, Scorecard,
+//   // LEGACY - DELETE
+//   // estSeatProbability
+// } from '@dra2020/dra-score';
 // END
 
 
@@ -2315,21 +2940,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.depthof = exports.deepCopy = exports.shallowCopy = exports.countEnumValues = exports.objectContains = exports.arrayContains = exports.getSelectObjectKeys = exports.getNumericObjectKeys = exports.getObjectKeys = exports.isArrayEmpty = exports.isSetEmpty = exports.isObjectEmpty = exports.keyExists = exports.andArray = exports.initArray = exports.maxArray = exports.minArray = exports.avgArray = exports.sumArray = exports.trim = exports.isUninhabited = exports.isWaterOnly = exports.parseGeoID = exports.getDistrict = exports.isOutOfState = exports.isInState = void 0;
+exports.depthof = exports.deepCopy = exports.shallowCopy = exports.countEnumValues = exports.objectContains = exports.arrayContains = exports.getSelectObjectKeys = exports.getNumericObjectKeys = exports.getObjectKeys = exports.isArrayEmpty = exports.isSetEmpty = exports.isObjectEmpty = exports.keyExists = exports.andArray = exports.initArray = exports.maxArray = exports.minArray = exports.avgArray = exports.sumArray = exports.trim = exports.isUninhabited = exports.isWaterOnly = exports.parseGeoID = exports.getDistrict = void 0;
 const DT = __importStar(__webpack_require__(/*! @dra2020/dra-types */ "@dra2020/dra-types"));
 const _data_1 = __webpack_require__(/*! ./_data */ "./src/_data.ts");
 const S = __importStar(__webpack_require__(/*! ./settings */ "./src/settings.ts"));
 // PLAN HELPERS
+// LEGACY - Not used
 // Is a "neighbor" in state?
-function isInState(geoID) {
-    return geoID != S.OUT_OF_STATE;
-}
-exports.isInState = isInState;
+// export function isInState(geoID: string): boolean
+// {
+//   return geoID != S.OUT_OF_STATE;
+// }
+// LEGACY - Not used
 // Is a "neighbor" out of state?
-function isOutOfState(geoID) {
-    return geoID == S.OUT_OF_STATE;
-}
-exports.isOutOfState = isOutOfState;
+// export function isOutOfState(geoID: string): boolean
+// {
+//   return geoID == S.OUT_OF_STATE;
+// }
 // Get the districtID to which a geoID is assigned
 function getDistrict(plan, geoID) {
     // All geoIDs in a state *should be* assigned to a district (including the
@@ -2780,16 +3407,6 @@ module.exports = require("@dra2020/dra-analytics");
 
 /***/ }),
 
-/***/ "@dra2020/dra-score":
-/*!*************************************!*\
-  !*** external "@dra2020/dra-score" ***!
-  \*************************************/
-/***/ ((module) => {
-
-module.exports = require("@dra2020/dra-score");
-
-/***/ }),
-
 /***/ "@dra2020/dra-types":
 /*!*************************************!*\
   !*** external "@dra2020/dra-types" ***!