@dra2020/district-analytics 7.1.6 → 8.0.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Alec Ramsay
+Copyright (c) 2020 Dave's Redistricting, LLC.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/cli.js

@@ -89056,7 +89056,7 @@ exports.scorePolsbyPopper = scorePolsbyPopper;
 /*! exports provided: partisan, minority, compactness, splitting, popdev, default */
 /***/ (function(module) {
 
-module.exports = JSON.parse("{\"partisan\":{\"bias\":{\"range\":[0,0.2],\"weight\":[50,80]},\"impact\":{\"weight\":[50,0],\"threshold\":4},\"competitiveness\":{\"range\":[0,0.75],\"distribution\":[0.25,0.75],\"simpleRange\":[0.45,0.55],\"weight\":[0,20]},\"bonus\":2},\"minority\":{\"range\":[0.37,0.5],\"distribution\":[0.25,0.75],\"shift\":0.15,\"coalition\":{\"weight\":0.5}},\"compactness\":{\"reock\":{\"range\":[0.25,0.5],\"weight\":50},\"polsby\":{\"range\":[0.1,0.5],\"weight\":50}},\"splitting\":{\"county\":{\"range\":[[1.26,1.68],[1.09,1.45]],\"weight\":50},\"district\":{\"range\":[[1.26,1.68],[1.09,1.45]],\"weight\":50}},\"popdev\":{\"range\":[[0.0075,0.002],[0.1,-1]]}}");
+module.exports = JSON.parse("{\"partisan\":{\"bias\":{\"range\":[0,0.2],\"weight\":[50,80]},\"impact\":{\"weight\":[50,0],\"threshold\":4},\"competitiveness\":{\"range\":[0,0.75],\"distribution\":[0.25,0.75],\"simpleRange\":[0.45,0.55],\"weight\":[0,20]},\"bonus\":2},\"minority\":{\"range\":[0.37,0.5],\"distribution\":[0.25,0.75],\"shift\":[0.15,0.5],\"coalition\":{\"weight\":0.5}},\"compactness\":{\"reock\":{\"range\":[0.25,0.5],\"weight\":50},\"polsby\":{\"range\":[0.1,0.5],\"weight\":50}},\"splitting\":{\"county\":{\"range\":[[1.26,1.68],[1.09,1.45]],\"weight\":50},\"district\":{\"range\":[[1.26,1.68],[1.09,1.45]],\"weight\":50}},\"popdev\":{\"range\":[[0.0075,0.002],[0.1,-1]]}}");
 
 /***/ }),
 
@@ -89160,11 +89160,20 @@ function minorityOpportunityDistribution(overridesJSON) {
     return dist;
 }
 exports.minorityOpportunityDistribution = minorityOpportunityDistribution;
+// For Black VAP %
 function minorityShift(overridesJSON) {
-    const shift = config_json_1.default.minority.shift;
+    const BLACK = 0;
+    const shift = config_json_1.default.minority.shift[BLACK];
     return shift;
 }
 exports.minorityShift = minorityShift;
+// Dilution for other demos
+function minorityShiftDilution(overridesJSON) {
+    const DILUTION = 1;
+    const shift = config_json_1.default.minority.shift[DILUTION];
+    return shift;
+}
+exports.minorityShiftDilution = minorityShiftDilution;
 function coalitionDistrictWeight(overridesJSON) {
     const weight = config_json_1.default.minority.coalition.weight;
     return weight;
@@ -89357,47 +89366,36 @@ const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts")
 const partisan_1 = __webpack_require__(/*! ./partisan */ "./src/partisan.ts");
 function evalMinorityOpportunity(p, bLog = false) {
     // Initialize arrays for results
-    const offset = 1; // Don't process 'White'
-    const nDemos = 6 /* Total */; // Ditto
-    // const nDemos = T.DemographicField.Native + 1 - offset;  // Ditto
+    const nDemos = 5 /* Native */ + 1; // Profile includes 'White'
+    const offset = 1; // But don't process 'White'
     const demosByDistrict = p.demographicProfile.mfArrayByDistrict;
     // Initialize the demographic buckets
     // Get the statewide minority VAP/CVAP % (ignore 'White')
     const vapPctArray = p.demographicProfile.stateMfArray.slice(1);
     // Determine proportional minority districts by demographic (ignoring'White')
     const districtsByDemo = calcDistrictsByDemo(vapPctArray, p.nDistricts);
-    let bucketsByDemo = new Array(nDemos + 1); // Add a row for the 'Total' row
+    let bucketsByDemo = new Array(nDemos);
     let totalProportional = 0;
     for (let j = 0; j < nDemos; j++) {
         const vapPct = vapPctArray[j];
         const prop = districtsByDemo[j];
-        // Accumulate the proportional values for each demographic, ignoring the first
-        // all Minority demographic.
+        bucketsByDemo[j] = [0, 0, 0, 0, 0, 0, vapPct, prop];
+        // Sum the prop for each individual race/ethnicity demographic
         if (j > 0)
             totalProportional += prop;
-        bucketsByDemo[j] = [0, 0, 0, vapPct, prop]; // Five conceptual columns for each demographic
     }
-    // Add a 'Total' row
-    bucketsByDemo[nDemos] = [0, 0, 0, 0, totalProportional];
     let opptyByDemo = U.initArray(nDemos, 0.0); // A state-level value
     // 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]); // Skip the 'White' entries
-            if (exceedsMinimumThreshold(proportion)) {
+            const Mf = demosByDistrict[i][j + offset]; // Skip the 'White' entries
+            const bucket = bucketVAPPct(Mf);
+            if (bucket > 0) {
                 // Bucket opportunity districts for each demographic
-                const bucket = (exceedsMaximumThreshold(proportion)) ? 1 : 0;
-                bucketsByDemo[j][bucket] += 1;
-                bucketsByDemo[j][2 /* Total */] += 1;
+                bucketsByDemo[j][bucket - 1] += 1; // Zero-based array
                 // Accumulate seat probabilities
-                opptyByDemo[j] += estMinorityOpportunity(proportion);
-                // Also accumulate the 'Total' row summing the opportunities for each demographic,
-                // ignoring the first all Minority demographic.
-                if (j > 0) {
-                    bucketsByDemo[nDemos][bucket] += 1;
-                    bucketsByDemo[nDemos][2 /* Total */] += 1;
-                }
+                opptyByDemo[j] += estMinorityOpportunity(Mf, j);
             }
         }
     }
@@ -89405,8 +89403,8 @@ function evalMinorityOpportunity(p, bLog = false) {
     const oD = U.sumArray(opptyByDemo.slice(1)); // Sum individual demos, skipping all minorities
     const cD = opptyByDemo[0 /* Minority */]; // All minorities
     // The # of proportional districts for each separate demographic and all minorities
-    const pOd = bucketsByDemo[6 /* Total */][4 /* PropSeats */];
-    const pCd = bucketsByDemo[0 /* Minority */][4 /* PropSeats */];
+    const pOd = totalProportional;
+    const pCd = bucketsByDemo[0 /* Minority */][7 /* PropSeats */];
     // Score opportunity
     const score = scoreMinority(oD, pOd, cD, pCd);
     let mS = {
@@ -89447,13 +89445,15 @@ exports.calcDistrictsByDemo = calcDistrictsByDemo;
 // NOTE - Sam Wang suggest 90% probability for a 37% district. That seems a little
 //   too abrupt and all or nothing, so I backed off to the ~70%.
 //
-function estMinorityOpportunity(Mf) {
+function estMinorityOpportunity(Mf, demo) {
     // 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();
+    let shift = C.minorityShift(); // For Black VAP % (and Minority)
+    if (demo && (demo > 1)) // For other non-Black demos,
+        shift *= C.minorityShiftDilution(); //   dilute the Black shift (by half)
     _normalizer.wipNum += shift;
     _normalizer.clip(dist[C.BEG], dist[C.END]);
     _normalizer.unitize(dist[C.BEG], dist[C.END]);
@@ -89462,13 +89462,21 @@ function estMinorityOpportunity(Mf) {
 }
 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 bucketVAPPct(Mf) {
+    if (Mf < 0.35)
+        return 0;
+    else if ((Mf >= 0.35) && (Mf < 0.40))
+        return 1;
+    else if ((Mf >= 0.40) && (Mf < 0.45))
+        return 2;
+    else if ((Mf >= 0.45) && (Mf < 0.50))
+        return 3;
+    else if ((Mf >= 0.50) && (Mf < 0.55))
+        return 4;
+    else if ((Mf >= 0.55) && (Mf < 0.60))
+        return 5;
+    else // Mf >= 0.60
+        return 6;
 }
 function calcProportionalDistricts(proportion, nDistricts) {
     const roundUp = 0.0;
@@ -93801,6 +93809,7 @@ __export(__webpack_require__(/*! ./quad */ "./lib/quad.ts"));
 __export(__webpack_require__(/*! ./polylabel */ "./lib/polylabel.ts"));
 __export(__webpack_require__(/*! ./polysimplify */ "./lib/polysimplify.ts"));
 __export(__webpack_require__(/*! ./polypack */ "./lib/polypack.ts"));
+__export(__webpack_require__(/*! ./polybin */ "./lib/polybin.ts"));
 __export(__webpack_require__(/*! ./boundbox */ "./lib/boundbox.ts"));
 __export(__webpack_require__(/*! ./blend */ "./lib/blend.ts"));
 __export(__webpack_require__(/*! ./cartesian */ "./lib/cartesian.ts"));
@@ -93878,7 +93887,7 @@ function boundboxExtend(bbox, x, y) {
 }
 function boundboxExtendPacked(pp, bbox) {
     let buffer = pp.buffer;
-    let offset = pp.buffer[pp.offset + 1];
+    let offset = pp.buffer[pp.offset + 1] + pp.offset;
     let end = pp.offset + pp.length;
     for (; offset < end; offset += 2)
         boundboxExtend(bbox, buffer[offset], buffer[offset + 1]);
@@ -94517,6 +94526,151 @@ function npoints(poly) {
 exports.npoints = npoints;
 
 
+/***/ }),
+
+/***/ "./lib/polybin.ts":
+/*!************************!*\
+  !*** ./lib/polybin.ts ***!
+  \************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const PP = __webpack_require__(/*! ./polypack */ "./lib/polypack.ts");
+// Only under Node. TextEncoder/Decoder implemented directly in browser.
+const ServerCoding = __webpack_require__(/*! util */ "util");
+// Packed Buffer format:
+//
+//  (strings are packed as UTF8 bytes, padded to 4 byte boundary)
+//
+//  { 4 byte size (byte offset to packed coordinate buffer) }
+//  { 4 byte length: property name,
+//    4 byte length: json string }*
+//  { 4 byte length: 'features' }
+//  { 4 byte length: length of 'features' array }
+//    { 4 byte length: property name,
+//      4 byte length: json string }*
+//  { padding to 8 byte boundary }
+//  { packed buffer coordinates in polypack format (indexed by geometry.packed above) }
+//
+const MagicInt = 17;
+const MagicFloat = 17.17;
+let encoder = ServerCoding.TextEncoder ? (new ServerCoding.TextEncoder()) : (new TextEncoder());
+let decoder = ServerCoding.TextDecoder ? (new ServerCoding.TextDecoder('utf-8')) : (new TextDecoder('utf-8'));
+function pad(n, pad) {
+    let mod = n % pad;
+    return mod ? pad - mod : 0;
+}
+function sizeOfString(s) {
+    let s8 = encoder.encode(s);
+    return 4 + s8.length + pad(s8.length, 4);
+}
+function packString(buf8, buf32, offset, s) {
+    let s8 = encoder.encode(s);
+    buf32[offset >> 2] = s8.length;
+    offset += 4;
+    let i;
+    for (i = 0; i < s8.length; i++)
+        buf8[offset++] = s8[i];
+    offset += pad(offset, 4);
+    return offset;
+}
+function unpackString(buf8, buf32, offset) {
+    let size = buf32[offset >> 2];
+    let s = decoder.decode(buf8.subarray(offset + 4, offset + 4 + size));
+    return s;
+}
+function packCollection(col) {
+    // Compute size
+    let pp = PP.featurePack(col);
+    let buffer = col.features.length ? col.features[0].geometry.packed.buffer : null; // to restore, below
+    let size = 16; // int endiness, offset to coordinates, float endiness
+    col.features.forEach((f) => { delete f.geometry.packed.buffer; }); // reconstructed when unpacking
+    let j = JSON.stringify(col);
+    size += sizeOfString(j);
+    size += pad(size, 8);
+    let fullsize = size + pp.length * 8; // add space for coordinates
+    // Now pack it
+    let ab = new ArrayBuffer(fullsize);
+    let buf8 = new Uint8Array(ab);
+    let buf32 = new Int32Array(ab);
+    let buf64 = new Float64Array(ab);
+    let offset = 0;
+    buf32[0] = MagicInt;
+    offset += 4;
+    buf32[1] = size;
+    offset += 4;
+    buf64[1] = MagicFloat; // Note that buf64[0] has the two ints stored above
+    offset += 8;
+    offset = packString(buf8, buf32, offset, j);
+    offset += pad(offset, 8);
+    if (offset != size)
+        throw 'Oops, packing error.';
+    let foff = offset >> 3;
+    let buf = pp.buffer;
+    for (let i = 0; i < pp.length; i++)
+        buf64[foff++] = buf[i];
+    // Now restore
+    col.features.forEach((f) => { f.geometry.packed.buffer = buffer; });
+    PP.featureUnpack(col);
+    return ab;
+}
+exports.packCollection = packCollection;
+function reverse(buf8, s, n) {
+    let e = s + n - 1;
+    while (s < e) {
+        let t = buf8[s];
+        buf8[s] = buf8[e];
+        buf8[e] = t;
+        s++, e--;
+    }
+}
+function enforceEndianness(ab) {
+    let buf8 = new Uint8Array(ab);
+    let buf32 = new Int32Array(ab);
+    let buf64 = new Float64Array(ab);
+    let reverseInts = false;
+    if (buf32[0] != MagicInt) {
+        reverseInts = true;
+        reverse(buf8, 0, 4);
+        if (buf32[0] != MagicInt)
+            throw 'unpackCollection: badly formatted buffer';
+        reverse(buf8, 4, 4); // size of non-floats
+    }
+    let reverseFloats = false;
+    if (buf64[1] != MagicFloat) {
+        reverseFloats = true;
+        reverse(buf8, 8, 8);
+        if (buf64[1] != MagicFloat)
+            throw 'unpackCollection: badly formatted buffer';
+    }
+    if (reverseInts)
+        reverse(buf8, 16, 4); // JSON string length
+    if (reverseFloats) {
+        let s = buf32[1]; // Offset to floats
+        let e = ab.byteLength;
+        for (; s < e; s += 8)
+            reverse(buf8, s, 8);
+    }
+}
+function unpackCollection(ab) {
+    enforceEndianness(ab);
+    let col = {};
+    let buf8 = new Uint8Array(ab);
+    let buf32 = new Int32Array(ab);
+    let size = buf32[1];
+    let buf64 = new Float64Array(ab, size); // offset to start of packed coordinates
+    let offset = 16;
+    let j = unpackString(buf8, buf32, offset);
+    col = JSON.parse(j);
+    col.features.forEach((f) => { f.geometry.packed.buffer = buf64; });
+    return col;
+}
+exports.unpackCollection = unpackCollection;
+
+
 /***/ }),
 
 /***/ "./lib/polylabel.ts":
@@ -94728,7 +94882,7 @@ function polyPackEachRing(pack, cb) {
     let b = pack.buffer;
     let iRing;
     let iOffset = pack.offset;
-    let cOffset = b[iOffset + 1];
+    let cOffset = b[iOffset + 1] + pack.offset;
     // Grab number of polygons
     let nPoly = b[iOffset++];
     // Move past header length
@@ -94805,7 +94959,7 @@ function polyPack(coords, prepack) {
             af[z++] = p[j].length;
     }
     // set header size back in header
-    af[prepack.offset + 1] = z;
+    af[prepack.offset + 1] = z - prepack.offset;
     // Fill in coords
     for (i = 0; i < coords.length; i++) {
         p = coords[i];
@@ -94831,7 +94985,7 @@ function polyUnpack(prepack) {
     let coords = [];
     let h = prepack.offset;
     nPolys = af[h++];
-    let z = af[h++]; // start of coordinates
+    let z = af[h++] + prepack.offset; // start of coordinates
     for (i = 0; i < nPolys; i++) {
         p = [];
         coords[i] = p;
@@ -95099,6 +95253,7 @@ class FsmQuadTree extends FSM.Fsm {
     constructor(env, options, col) {
         super(env);
         this.options = Util.shallowAssignImmutable(Poly.DefaultTickOptions, options);
+        this.work = { nUnion: 0, nDifference: 0, ms: 0 };
         this.initialize(col);
     }
     initialize(col) {
@@ -95107,6 +95262,7 @@ class FsmQuadTree extends FSM.Fsm {
         this.isempty = true;
         if (col != null) {
             let features = col.features ? col.features : col;
+            this.work.nUnion = features.length;
             this.isempty = features.length == 0;
             // Compute BoundBox for each feature
             let wrapped = features.map((f) => { return { box: BB.boundbox(f), p: featureCoords(f) }; });
@@ -95134,11 +95290,13 @@ class FsmQuadTree extends FSM.Fsm {
                     break;
                 case FSM.FSM_PENDING:
                     let tickCounter = { ticks: this.options.tickStep };
+                    let elapsed = new Util.Elapsed();
                     if (!this.isempty && this.asyncUnion === undefined) {
                         this.quad.tickUnion(tickCounter);
                         if (tickCounter.ticks != 0)
                             this.result;
                     }
+                    this.work.ms += elapsed.ms();
                     if (this.asyncUnion !== undefined)
                         this.setState(FSM.FSM_DONE);
                     else
@@ -95316,6 +95474,7 @@ exports.polyIntersects = polyIntersects;
 class FsmDifference extends FSM.Fsm {
     constructor(env, accum, polys) {
         super(env);
+        this.work = { nUnion: 0, nDifference: 0, ms: 0 };
         this.initialize(accum, polys);
     }
     initialize(accum, polys) {
@@ -95323,8 +95482,10 @@ class FsmDifference extends FSM.Fsm {
         this.polys = polys;
         if (polys == null || polys.length == 0)
             this.setState(FSM.FSM_DONE);
-        else
+        else {
+            this.work.nDifference = polys.length;
             this.setState(FSM.FSM_STARTING);
+        }
     }
     cancel() {
         this.accum = null;
@@ -95344,7 +95505,9 @@ class FsmDifference extends FSM.Fsm {
                         this.setState(FSM_COMPUTING);
                     break;
                 case FSM_COMPUTING:
+                    let elapsed = new Util.Elapsed();
                     this.accum = _difference(this.accum, this.polys);
+                    this.work.ms = elapsed.ms();
                     this.polys = null;
                     this.setState(FSM.FSM_DONE);
                     break;
@@ -95421,10 +95584,20 @@ class FsmIncrementalUnion extends FSM.Fsm {
             if (this.toSub.length == 0)
                 this.toSub = null;
         }
-        this.fsmUnion = new Q.FsmQuadTree(this.env, this.options, polys);
-        this.waitOn(this.fsmUnion);
-        this.setState(FSM_UNION);
-        this.map = map;
+        // Short-circuit when no work to be done
+        if (polys.length == 1 && this.toSub == null && this.lastCompleteResult) {
+            this.work = { nUnion: 0, nDifference: 0, ms: 0 };
+            this.result = this.lastCompleteResult;
+            this.map = this.lastCompleteMap;
+            this.setState(FSM.FSM_DONE);
+        }
+        else {
+            this.work = { nUnion: polys.length - 1, nDifference: this.toSub ? this.toSub.length : 0, ms: 0 };
+            this.fsmUnion = new Q.FsmQuadTree(this.env, this.options, polys);
+            this.waitOn(this.fsmUnion);
+            this.setState(FSM_UNION);
+            this.map = map;
+        }
     }
     cancel() {
         if (this.fsmUnion) {
@@ -95449,6 +95622,8 @@ class FsmIncrementalUnion extends FSM.Fsm {
                     this.setState(FSM.FSM_DONE);
                     break;
                 case FSM_UNION:
+                    if (this.fsmUnion)
+                        this.work.ms += this.fsmUnion.work.ms;
                     this.fsmDifference = new FsmDifference(this.env, this.fsmUnion.result, this.toSub);
                     this.waitOn(this.fsmDifference);
                     this.toSub = null;
@@ -95457,6 +95632,7 @@ class FsmIncrementalUnion extends FSM.Fsm {
                     break;
                 case FSM_DIFFERENCE:
                     this.result = this.fsmDifference.result;
+                    this.work.ms += this.fsmDifference.work.ms;
                     this.lastCompleteResult = this.result;
                     this.lastCompleteMap = this.map;
                     this.fsmDifference = null;
@@ -95471,10 +95647,11 @@ class FsmUnion extends FSM.Fsm {
         super(env);
         this.options = Util.shallowAssignImmutable(Poly.DefaultTickOptions, options);
         this.unions = [];
+        this.work = { nUnion: 0, nDifference: 0, ms: 0 };
     }
     get result() {
         if (this.unions.length > 0 && this.state === FSM.FSM_DONE)
-            return this.unions.map((i) => ({ key: i.key, poly: i.result }));
+            return this.unions.map((i) => ({ key: i.key, poly: i.result, work: i.work }));
         else
             return null;
     }
@@ -95485,6 +95662,15 @@ class FsmUnion extends FSM.Fsm {
         this.unions = [];
         this.setState(FSM.FSM_DONE);
     }
+    cancelOne(key) {
+        for (let i = 0; i < this.unions.length; i++) {
+            let u = this.unions[i];
+            if (u.matches(key)) {
+                u.cancel();
+                return;
+            }
+        }
+    }
     recompute(key, map) {
         let fsm = this.unions.find((i) => i.matches(key));
         if (fsm == null) {
@@ -95493,6 +95679,8 @@ class FsmUnion extends FSM.Fsm {
         }
         else
             fsm.recompute(map);
+        this.work = { nUnion: 0, nDifference: 0, ms: 0 };
+        this.unions.forEach((u) => { this.work.nUnion += u.work.nUnion; this.work.nDifference += u.work.nDifference; });
         this.waitOn(fsm);
         this.setState(FSM_COMPUTING);
     }
@@ -95501,6 +95689,8 @@ class FsmUnion extends FSM.Fsm {
             switch (this.state) {
                 case FSM.FSM_STARTING:
                 case FSM_COMPUTING:
+                    if (this.unions)
+                        this.unions.forEach((u) => { this.work.ms += u.work.ms; });
                     this.setState(FSM.FSM_DONE);
                     break;
             }
@@ -98068,6 +98258,17 @@ module.exports = __webpack_require__(/*! @dra2020/fsm */ "./node_modules/@dra202
 
 module.exports = __webpack_require__(/*! @dra2020/util */ "./node_modules/@dra2020/util/dist/util.js");
 
+/***/ }),
+
+/***/ "util":
+/*!***********************!*\
+  !*** external "util" ***!
+  \***********************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = __webpack_require__(/*! util */ "util");
+
 /***/ })
 
 /******/ });
@@ -103221,6 +103422,8 @@ class Features {
         this._session = s;
         this._data = data;
         this._keys = keys;
+        // For debugging PVI
+        // console.log("Election dataset =", this._keys[Dataset.ELECTION]);
     }
     nFeatures() { return this._data.features.length; }
     featureByIndex(i) { return this._data.features[i]; }
@@ -103231,8 +103434,15 @@ class Features {
         return value;
     }
     fieldForFeature(f, dt, fk) {
-        let dk = this._keys[dt];
-        return _getFeatures(f, dk, fk);
+        const dk = this._keys[dt];
+        let result = undefined;
+        // 07-31-2020 - Fix to post-process PVI into the expected election composite format.
+        if (dk === 'P16GPR') {
+            result = (_getFeatures(f, dk, (fk === 'D' ? 'D12' : 'R12')) + _getFeatures(f, dk, (fk === 'D' ? 'D16' : 'R16'))) / 2;
+        }
+        else
+            result = _getFeatures(f, dk, fk);
+        return result;
     }
     resetDataset(d, k) {
         this._keys[d] = k;
@@ -103795,8 +104005,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const majority_minority_json_1 = __importDefault(__webpack_require__(/*! ../static/majority-minority.json */ "./static/majority-minority.json"));
 const vra5_preclearance_json_1 = __importDefault(__webpack_require__(/*! ../static/vra5-preclearance.json */ "./static/vra5-preclearance.json"));
-// import stateContacts from '../static/state-contacts.json';
-// import demographicDefs from '../static/demographic-defns.json';
 // TODO - 2020: Update/revise this, when the update comes out in September:
 // Sources for majority-minority info:
 // - https://en.wikipedia.org/wiki/List_of_majority-minority_United_States_congressional_districts
@@ -105051,12 +105259,16 @@ const S = __importStar(__webpack_require__(/*! ../src/settings */ "./src/setting
 const D = __importStar(__webpack_require__(/*! ../src/_data */ "./src/_data.ts"));
 // Simulate DRA unioning district shapes in the background
 function addToPoly(poly, polys) {
-    // TODO - POLY: Fix 'poly' import, so I don't have to do this workaround.
-    // return PC.union(poly, ...polys);
-    let union = PC.union;
-    if (union === undefined)
-        union = PC.default.union;
-    return union(poly, ...polys);
+    // Terry's workaround
+    let _union = undefined;
+    let anyPC = PC;
+    if (anyPC.union)
+        _union = anyPC.union;
+    if (anyPC.default.union)
+        _union = anyPC.default.union;
+    if (_union === undefined)
+        throw 'Unable to load union function from polygon-clipping';
+    return _union(poly, ...polys);
 }
 console.log("Starting command @ ", new Date());
 // COMMAND LINE
@@ -105500,6 +105712,17 @@ module.exports = require("stream");
 
 /***/ }),
 
+/***/ "util":
+/*!***********************!*\
+  !*** external "util" ***!
+  \***********************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("util");
+
+/***/ }),
+
 /***/ "yargs":
 /*!************************!*\
   !*** external "yargs" ***!