@dra2020/dra-types 1.8.133 → 1.8.136

package/dist/alldt.d.ts

@@ -13,3 +13,4 @@ export * from './reverse';
 export * from './groups';
 export * from './datasets';
 export * from './precincts';
+export * from './cities';

package/dist/cities.d.ts

@@ -0,0 +1,22 @@
+export interface Cities {
+    id?: string;
+    state?: string;
+    datasource?: string;
+    geoids?: string[];
+    name?: string;
+    description?: string;
+    labels?: string[];
+    createdBy?: string;
+    createTime?: string;
+    modifyTime?: string;
+    publishTime?: string;
+    deleted?: boolean;
+    published?: string;
+    official?: boolean;
+    supersets?: string[];
+    subsets?: string[];
+    conflicts?: string[];
+}
+export type CitiesIndex = {
+    [id: string]: Cities;
+};

package/dist/dra-types.js

@@ -49,6 +49,7 @@ __exportStar(__webpack_require__(/*! ./reverse */ "./lib/reverse.ts"), exports);
 __exportStar(__webpack_require__(/*! ./groups */ "./lib/groups.ts"), exports);
 __exportStar(__webpack_require__(/*! ./datasets */ "./lib/datasets.ts"), exports);
 __exportStar(__webpack_require__(/*! ./precincts */ "./lib/precincts.ts"), exports);
+__exportStar(__webpack_require__(/*! ./cities */ "./lib/cities.ts"), exports);
 
 
 /***/ }),
@@ -97,6 +98,18 @@ exports.BucketMap = {
 };
 
 
+/***/ }),
+
+/***/ "./lib/cities.ts":
+/*!***********************!*\
+  !*** ./lib/cities.ts ***!
+  \***********************/
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
 /***/ }),
 
 /***/ "./lib/colormgr.ts":
@@ -276,10 +289,9 @@ function ethnicBackgroundColor(index, pd) {
 function ToAllEthnicColor(agg, dc, pd) {
     var _a;
     // Use VAP/CVAP if it exists
-    const dataset = dc.primeVDS ? dc.primeVDS : dc.primeDDS;
-    const did = PF.toDatasetID(dataset);
-    const builtin = ((_a = dc.dsMeta[did]) === null || _a === void 0 ? void 0 : _a.builtin) || dataset;
-    return AggregateEthnicColor(PF.ToGetter(agg, dc, did, dataset), pd, builtin.endsWith('NH'));
+    const did = dc.primeVDS ? dc.primeVDS : dc.primeDDS;
+    const builtin = ((_a = dc.dsMeta[did]) === null || _a === void 0 ? void 0 : _a.builtin) || did;
+    return AggregateEthnicColor(PF.ToGetter(agg, dc, did), pd, builtin.endsWith('NH'));
 }
 function ToPartisanColorStr(agg, dc, pd) {
     return ToPartisanColor(agg, dc, partisanStops(exports.PartisanPrecinctStops, pd));
@@ -288,25 +300,8 @@ function ToPartisanDistrictColor(agg, dc, pd) {
     return ToPartisanColor(agg, dc, partisanDistrictStops(exports.PartisanDistrictStops, pd));
 }
 function ToPartisanColor(agg, dc, stops) {
-    const did = PF.toDatasetID(dc.primeEDS);
-    if (dc.primeEDS === PF.DS_PVI2020) {
-        const getter16 = PF.ToGetter(agg, dc, did, PF.DS_PRES2016);
-        const getter20 = PF.ToGetter(agg, dc, did, PF.DS_PRES2020);
-        const pviRaw = PF.calcRaw2020Pvi(getter16, getter20);
-        const color = ColorFromRGBPcts((1 - pviRaw / 100), 0, pviRaw / 100, stops);
-        //console.log('Pvi (r, d, color): (' + (1 - pviRaw/100) + ', ' + pviRaw/100 + ', ' + color + ')');
-        return color;
-    }
-    else if (dc.primeEDS === PF.DS_PVI2016) {
-        const getter = PF.ToGetter(agg, dc, did, dc.primeEDS);
-        const pviRaw = PF.calcRawPvi(getter);
-        const color = ColorFromRGBPcts((1 - pviRaw / 100), 0, pviRaw / 100, stops);
-        return color;
-    }
-    else {
-        const getter = PF.ToGetter(agg, dc, did, dc.primeEDS);
-        return AggregatePartisanColorStr(getter, stops);
-    }
+    const getter = PF.ToGetter(agg, dc, dc.primeEDS);
+    return AggregatePartisanColorStr(getter, stops);
 }
 function ToPartisanShiftColor(agg, dc, datasets, pd, isDistrict) {
     if (!datasets || datasets.length < 2)
@@ -327,9 +322,8 @@ function ToEthnicColorStr(agg, dc, pd, detail) {
     let ethnic = 'Wh';
     let total = 'Tot';
     let bInvert = false;
-    const dataset = dc.primeVDS ? dc.primeVDS : dc.primeDDS;
-    const did = PF.toDatasetID(dataset);
-    const builtin = ((_a = dc.dsMeta[did]) === null || _a === void 0 ? void 0 : _a.builtin) || dataset;
+    const did = dc.primeVDS ? dc.primeVDS : dc.primeDDS;
+    const builtin = ((_a = dc.dsMeta[did]) === null || _a === void 0 ? void 0 : _a.builtin) || did;
     switch (detail) {
         case null:
         case '':
@@ -369,7 +363,7 @@ function ToEthnicColorStr(agg, dc, pd, detail) {
             break;
         default: break;
     }
-    const getter = PF.ToGetter(agg, dc, did, dataset);
+    const getter = PF.ToGetter(agg, dc, did);
     let den = getter(total);
     let num = getter(ethnic);
     if (den === undefined || isNaN(den) || num === undefined || isNaN(num))
@@ -613,7 +607,7 @@ function ToExtendedColor(agg, dc, colorBy) {
             colors = safeColors('');
         }
         let o = {};
-        let getter = PF.ToGetter(agg, dc, datasetid, datasetid);
+        let getter = PF.ToGetter(agg, dc, datasetid);
         Object.keys(meta.fields).forEach(f => o[f] = getter(f));
         let formatter = new baseclient_1.Detail.FormatDetail(dscolor.expr);
         let result = formatter.format(baseclient_1.Detail.FormatDetail.prepare(o));
@@ -621,7 +615,7 @@ function ToExtendedColor(agg, dc, colorBy) {
         return baseclient_1.Util.execGradient(makeStops(stops, colors), intensity);
     }
     else {
-        let getter = PF.ToGetter(agg, dc, datasetid, datasetid);
+        let getter = PF.ToGetter(agg, dc, datasetid);
         let fields = PF.sortedFieldList(meta);
         let den = 0;
         if (meta.fields['Tot'])
@@ -1562,19 +1556,17 @@ exports.fGet = fGet;
 exports.sortedFieldList = sortedFieldList;
 exports.getDatasetField = getDatasetField;
 exports.computeMetaIndex = computeMetaIndex;
-exports.initPackedFields = initPackedFields;
-exports.computePackedFields = computePackedFields;
 exports.computeOnePackedFields = computeOnePackedFields;
+exports.initPackedFields = initPackedFields;
 exports.clearPackedFields = clearPackedFields;
 exports.hasPackedFields = hasPackedFields;
 exports.setPackedFields = setPackedFields;
 exports.isExtDataset = isExtDataset;
-exports.toDatasetID = toDatasetID;
+exports.pushExtPackedFields = pushExtPackedFields;
 exports.featurePushExtPackedFields = featurePushExtPackedFields;
 exports.featurePushedExtPackedFields = featurePushedExtPackedFields;
 exports.pushedExtPackedFields = pushedExtPackedFields;
 exports.retrievePackedFields = retrievePackedFields;
-exports.retrievePackedIndex = retrievePackedIndex;
 exports.zeroPackedFields = zeroPackedFields;
 exports.zeroPackedCopy = zeroPackedCopy;
 exports.packedCopy = packedCopy;
@@ -1586,8 +1578,6 @@ exports.getPackedField = getPackedField;
 exports.findPackedField = findPackedField;
 exports.fieldGetterNotLoaded = fieldGetterNotLoaded;
 exports.ToGetter = ToGetter;
-exports.ToGetterPvi16 = ToGetterPvi16;
-exports.ToGetterPvi20 = ToGetterPvi20;
 exports.calcShift = calcShift;
 exports.calcRawPvi = calcRawPvi;
 exports.pviStr = pviStr;
@@ -1632,17 +1622,15 @@ function sortedFieldList(ds) {
     let kv = keys.map(k => { return { k, v: ds.fields[k] }; }).sort((a, b) => { return (a.v.order || 0) - (b.v.order || 0); });
     return kv.map(kv => kv.k);
 }
-function getDatasetField(f, dataset, field) {
+function getDatasetField(f, did, field) {
     let pf = retrievePackedFields(f);
-    let dxGroup = retrievePackedIndex(f);
-    let did = toDatasetID(dataset);
-    return getPackedField(dxGroup, pf, did, dataset, field);
+    return getPackedField(pf, did, field);
 }
-function computeMetaIndex(datasetid, meta) {
+function computeMetaIndex(did, meta) {
     if (meta == null)
         return null;
     let offset = 1; // first entry is count of aggregates
-    let index = { length: 0, fields: {}, getDatasetField: null };
+    let index = { length: 0, fields: {} };
     Object.keys(meta).forEach((datasetKey) => {
         let dataset = meta[datasetKey];
         let fieldsIndex = {};
@@ -1652,46 +1640,9 @@ function computeMetaIndex(datasetid, meta) {
         index.fields[datasetKey] = fieldsIndex;
     });
     index.length = offset;
-    index.getDatasetField = getDatasetField;
     return index;
 }
-let nAlloc = 0;
-function allocPackedFieldsArray(length) {
-    let ab = new ArrayBuffer(8 * length);
-    let af = new Float64Array(ab);
-    nAlloc++;
-    //if ((nAlloc % 10000) == 0) console.log(`allocPackedFieldsArray: ${nAlloc} allocs`);
-    return af;
-}
-function initPackedFields(f) {
-    if (f.properties.packedFields !== undefined)
-        throw 'Packed fields already set';
-    f.properties.packedIndex = {};
-    f.properties.packedFields = {};
-    f.properties.getDatasetField = getDatasetField;
-}
-function computePackedFields(f, index) {
-    if (f.properties.packedFields)
-        return f.properties.packedFields;
-    let af = allocPackedFieldsArray(index.length);
-    af[0] = 0; // count of number of aggregates
-    Object.keys(index.fields).forEach((dataset) => {
-        let fields = index.fields[dataset];
-        Object.keys(fields).forEach((field) => {
-            let n = fGetW(f, dataset, field);
-            if (isNaN(n))
-                n = 0;
-            af[fields[field]] = n;
-        });
-    });
-    f.properties.packedIndex = { ['']: index };
-    f.properties.packedFields = { ['']: af }; // cache here
-    f.properties.getDatasetField = index.getDatasetField;
-    // Major memory savings to delete this after packing
-    delete f.properties.datasets;
-    return f.properties.packedFields;
-}
-function computeOnePackedFields(f, index, did, datasetKey) {
+function computeOnePackedFields(f, dsGroup, index, did, datasetKey) {
     let af = allocPackedFieldsArray(index.length);
     af[0] = 0; // count of number of aggregates
     let fields = index.fields[did];
@@ -1701,45 +1652,47 @@ function computeOnePackedFields(f, index, did, datasetKey) {
             n = 0;
         af[fields[field]] = n;
     });
-    if (!f.properties.packedIndex)
-        initPackedFields(f);
-    f.properties.packedIndex[did] = index;
-    f.properties.packedFields[did] = af;
-    f.properties.getDatasetField = index.getDatasetField;
+    if (!f.properties.packedFields)
+        initPackedFields(f, dsGroup);
+    f.properties.packedFields.data[did] = af;
     return f.properties.packedFields;
 }
+let nAlloc = 0;
+function allocPackedFieldsArray(length) {
+    let ab = new ArrayBuffer(8 * length);
+    let af = new Float64Array(ab);
+    nAlloc++;
+    //if ((nAlloc % 10000) == 0) console.log(`allocPackedFieldsArray: ${nAlloc} allocs`);
+    return af;
+}
+function initPackedFields(f, dsGroup) {
+    if (f.properties.packedFields !== undefined)
+        throw 'Packed fields already set';
+    f.properties.packedFields = { dsGroup, data: {} };
+}
 function clearPackedFields(f) {
-    delete f.properties.packedIndex;
     delete f.properties.packedFields;
-    delete f.properties.getDatasetField;
 }
 function hasPackedFields(f) {
     return f.properties.packedFields !== undefined;
 }
-function setPackedFields(f, pf, fIndex) {
+function setPackedFields(f, pf) {
     if (f.properties.packedFields !== undefined)
         throw 'Packed fields already set';
-    f.properties.packedIndex = fIndex.properties.packedIndex;
     f.properties.packedFields = pf;
-    f.properties.getDatasetField = fIndex.properties.getDatasetField;
 }
 const reExtDataset = /^.*\.ds$/;
 function isExtDataset(did) {
     return did && reExtDataset.test(did);
 }
-function toDatasetID(datasetKey) {
-    return isExtDataset(datasetKey) ? datasetKey : '';
-}
-function featurePushExtPackedFields(f, datasetid, index, data, card) {
-    var _a;
-    let blocks = ((_a = f === null || f === void 0 ? void 0 : f.properties) === null || _a === void 0 ? void 0 : _a.blocks) || (card.has(f.properties.id) ? [f.properties.id] : null);
+function pushExtPackedFields(blocks, pf, did, index, data, card) {
     if (!blocks)
         return;
-    if (!f.properties.packedFields)
-        throw ('pushExtPackedFields: base datasets should be pushed first');
+    if (!pf)
+        throw ('pushExtPackedFields: packed fields should be initialized before push');
     if (card.size != data[0])
         throw ('pushExtPackedFields: packed fields and block cardinality do not match');
-    if (f.properties.packedFields[datasetid])
+    if (pf.data[did])
         return; // already pushed
     let nfields = data[1];
     let pfa = allocPackedFieldsArray(nfields + 1); // field count
@@ -1753,25 +1706,29 @@ function featurePushExtPackedFields(f, datasetid, index, data, card) {
         for (let i = 1; i <= nfields; i++)
             pfa[i] += (data[x++] << 0); // left shift by 0 to force unsigned to be interpreted as signed (used by prisoner-adjusted)
     });
-    f.properties.packedFields[datasetid] = pfa;
-    f.properties.packedIndex[datasetid] = index;
+    pf.data[did] = pfa;
+}
+function featurePushExtPackedFields(f, did, index, data, card) {
+    var _a;
+    let blocks = ((_a = f === null || f === void 0 ? void 0 : f.properties) === null || _a === void 0 ? void 0 : _a.blocks) || (card.has(f.properties.id) ? [f.properties.id] : null);
+    pushExtPackedFields(blocks, f.properties.packedFields, did, index, data, card);
 }
-function featurePushedExtPackedFields(f, datasetid, card) {
+function featurePushedExtPackedFields(f, did, card) {
     var _a;
     if (!f)
         return true;
     if (f.features)
-        return featurePushedExtPackedFields(f.features[0], datasetid, card);
+        return featurePushedExtPackedFields(f.features[0], did, card);
     if (!((_a = f === null || f === void 0 ? void 0 : f.properties) === null || _a === void 0 ? void 0 : _a.blocks) && !card.has(f.properties.id))
         return true;
     if (!f.properties.packedFields)
         return true;
-    return !!f.properties.packedFields[datasetid];
+    return !!f.properties.packedFields.data[did];
 }
 function pushedExtPackedFields(pf, datasetids) {
     if (pf && datasetids)
         for (let i = 0; i < datasetids.length; i++)
-            if (!pf[datasetids[i]])
+            if (!pf.data[datasetids[i]])
                 return false;
     return !!pf;
 }
@@ -1780,67 +1737,62 @@ function retrievePackedFields(f) {
         throw 'Feature should have pre-computed packed fields';
     return f.properties.packedFields;
 }
-function retrievePackedIndex(f) {
-    if (f.properties.packedIndex === undefined)
-        throw 'Feature should have pre-computed packed index';
-    return f.properties.packedIndex;
-}
-// The first entry in the PackedFields aggregate is the count of items aggregated.
+// The first entry in the PackedFieldsArray aggregate is the count of items aggregated.
 // Treat a null instance as just a single entry with no aggregates.
 let abZero = new ArrayBuffer(8);
 let afZero = new Float64Array(abZero);
 afZero[0] = 0;
-let pfZero = { ['']: afZero };
-function zeroPackedFields(index) {
-    if (index == null)
+let pfZero = { dsGroup: {}, data: { ['']: afZero } };
+function zeroPackedFields(dsGroup) {
+    if (dsGroup == null)
         return pfZero;
-    let pf = {};
-    Object.keys(index).forEach(datasetid => {
-        let af = allocPackedFieldsArray(index[datasetid].length);
+    let pf = { dsGroup, data: {} };
+    Object.keys(dsGroup).forEach(did => {
+        let af = allocPackedFieldsArray(dsGroup[did].length);
         for (let i = 0; i < af.length; i++)
             af[i] = 0;
-        pf[datasetid] = af;
+        pf.data[did] = af;
     });
     return pf;
 }
 function zeroPackedCopy(pf) {
     if (pf == null)
         return pfZero;
-    let copy = {};
-    Object.keys(pf).forEach(datasetid => {
-        let cf = allocPackedFieldsArray(pf[datasetid].length);
+    let copy = { dsGroup: pf.dsGroup, data: {} };
+    Object.keys(pf.data).forEach(did => {
+        let cf = allocPackedFieldsArray(pf.data[did].length);
         for (let i = 0; i < cf.length; i++)
             cf[i] = 0;
-        copy[datasetid] = cf;
+        copy.data[did] = cf;
     });
     return copy;
 }
 function packedCopy(pf) {
     if (pf == null)
         return null;
-    let copy = {};
-    Object.keys(pf).forEach(datasetid => {
-        let af = pf[datasetid];
+    let copy = { dsGroup: pf.dsGroup, data: {} };
+    Object.keys(pf.data).forEach(did => {
+        let af = pf.data[did];
         let cf = allocPackedFieldsArray(af.length);
         for (let i = 0; i < af.length; i++)
             cf[i] = af[i];
-        copy[datasetid] = cf;
+        copy.data[did] = cf;
     });
     return copy;
 }
 function aggregatePackedFields(agg, pf) {
     if (agg == null || pf == null)
         return agg;
-    Object.keys(pf).forEach(datasetid => {
-        let af = agg[datasetid];
-        let sf = pf[datasetid];
+    Object.keys(pf.data).forEach(did => {
+        let af = agg.data[did];
+        let sf = pf.data[did];
         if (sf && (!af || sf.length == af.length)) {
             if (!af) {
                 af = allocPackedFieldsArray(sf.length);
                 af[0] = 0;
                 for (let i = 1; i < sf.length; i++)
                     af[i] = sf[i];
-                agg[datasetid] = af;
+                agg.data[did] = af;
             }
             else {
                 let n = af.length;
@@ -1857,15 +1809,15 @@ function aggregateCount(agg) {
     // So we just pick the one that happens to be come up first.
     if (!agg)
         return 0;
-    let pfa = baseclient_1.Util.nthProperty(agg);
+    let pfa = baseclient_1.Util.nthProperty(agg.data);
     return pfa ? pfa[0] : 0;
 }
 function decrementPackedFields(agg, pf) {
     if (agg == null || pf == null)
         return agg;
-    Object.keys(agg).forEach(datasetid => {
-        let af = agg[datasetid];
-        let sf = pf[datasetid];
+    Object.keys(agg.data).forEach(did => {
+        let af = agg.data[did];
+        let sf = pf.data[did];
         if (sf && sf.length == af.length) {
             let n = af.length;
             for (let i = 1; i < n; i++)
@@ -1883,57 +1835,23 @@ function diffPackedFields(main, parts) {
     parts.forEach((pf) => decrementPackedFields(main, pf));
     return main;
 }
-function getPackedField(index, pf, datasetid, dataset, field) {
-    if (!index || !pf || !index[datasetid] || !pf[datasetid])
+function getPackedField(pf, did, field) {
+    if (!pf || !pf.dsGroup || !pf.dsGroup[did] || !pf.data[did])
         return 0;
-    let fields = index[datasetid].fields[dataset];
-    return fields ? (fields[field] !== undefined ? pf[datasetid][fields[field]] : 0) : 0;
+    let fields = pf.dsGroup[did].fields[did];
+    return fields ? (fields[field] !== undefined ? pf.data[did][fields[field]] : 0) : 0;
 }
-function findPackedField(index, pf, datasetid, dataset, field) {
-    let fields = index[datasetid].fields[dataset];
+function findPackedField(pf, did, field) {
+    let fields = pf.dsGroup[did].fields[did];
     return fields ? (fields[field] !== undefined ? fields[field] : -1) : -1;
 }
 function fieldGetterNotLoaded(f) { return undefined; }
-function ToGetter(agg, dc, datasetid, datasetKey) {
-    return (field) => { return getPackedField(dc.dsIndex, agg, datasetid, datasetKey, field); };
-}
-function ToGetterPvi16(agg, dc, datasetKey) {
-    return (field) => {
-        if (field === 'R')
-            return Math.round((getPackedField(dc.dsIndex, agg, '', datasetKey, 'R12') + getPackedField(dc.dsIndex, agg, '', datasetKey, 'R16')) / 2);
-        if (field === 'D')
-            return Math.round((getPackedField(dc.dsIndex, agg, '', datasetKey, 'D12') + getPackedField(dc.dsIndex, agg, '', datasetKey, 'D16')) / 2);
-        if (field === 'Tot')
-            return Math.round((getPackedField(dc.dsIndex, agg, '', datasetKey, 'R12') + getPackedField(dc.dsIndex, agg, '', datasetKey, 'R16') +
-                getPackedField(dc.dsIndex, agg, '', datasetKey, 'D12') + getPackedField(dc.dsIndex, agg, '', datasetKey, 'D16')) / 2);
-        return 0;
-    };
+function ToGetter(agg, dc, did) {
+    return (field) => { return getPackedField(agg, did, field); };
 }
-function ToGetterPvi20(agg, dc) {
-    return (field) => {
-        if (field === 'R')
-            return Math.round((getPackedField(dc.dsIndex, agg, '', exports.DS_PRES2016, 'R') + getPackedField(dc.dsIndex, agg, '', exports.DS_PRES2020, 'R')) / 2);
-        if (field === 'D')
-            return Math.round((getPackedField(dc.dsIndex, agg, '', exports.DS_PRES2016, 'D') + getPackedField(dc.dsIndex, agg, '', exports.DS_PRES2020, 'D')) / 2);
-        if (field === 'Tot')
-            return Math.round((getPackedField(dc.dsIndex, agg, '', exports.DS_PRES2016, 'R') + getPackedField(dc.dsIndex, agg, '', exports.DS_PRES2020, 'R') +
-                getPackedField(dc.dsIndex, agg, '', exports.DS_PRES2016, 'D') + getPackedField(dc.dsIndex, agg, '', exports.DS_PRES2020, 'D')) / 2);
-        return 0;
-    };
-}
-function calcShift(agg, dc, datasetOld, datasetNew) {
-    const didOld = toDatasetID(datasetOld);
-    const didNew = toDatasetID(datasetNew);
-    const getterOld = datasetOld === exports.DS_PVI2016 ?
-        ToGetterPvi16(agg, dc, datasetOld) :
-        datasetOld === exports.DS_PVI2020 ?
-            ToGetterPvi20(agg, dc) :
-            ToGetter(agg, dc, didOld, datasetOld);
-    const getterNew = datasetNew === exports.DS_PVI2016 ?
-        ToGetterPvi16(agg, dc, datasetNew) :
-        datasetNew === exports.DS_PVI2020 ?
-            ToGetterPvi20(agg, dc) :
-            ToGetter(agg, dc, didNew, datasetNew);
+function calcShift(agg, dc, didOld, didNew) {
+    const getterOld = ToGetter(agg, dc, didOld);
+    const getterNew = ToGetter(agg, dc, didNew);
     // Calc two-party Swing
     const repOld = getterOld('R');
     const demOld = getterOld('D');
@@ -2409,11 +2327,8 @@ function splitToGeoFeature(split, topoPrecinct, mbm) {
             baseclient_1.Util.deepAccum(f.properties.datasets, b.properties.datasets);
         }
         if (b.properties.packedFields) {
-            if (!f.properties.packedFields) {
+            if (!f.properties.packedFields)
                 f.properties.packedFields = PF.packedCopy(b.properties.packedFields);
-                f.properties.packedIndex = b.properties.packedIndex;
-                f.properties.getDatasetField = b.properties.getDatasetField;
-            }
             else
                 PF.aggregatePackedFields(f.properties.packedFields, b.properties.packedFields);
         }