diff --git a/modules/basemap-layers/src/globe-layers.js b/modules/basemap-layers/src/globe-layers.js
index 07e9e63..cb96a12 100644
--- a/modules/basemap-layers/src/globe-layers.js
+++ b/modules/basemap-layers/src/globe-layers.js
@@ -45,26 +45,10 @@ const BASEMAP_RASTER_PARAMETERS = {
   blendEquation: [GL.FUNC_ADD, GL.FUNC_ADD]
 };
 
-const BACKGROUND_DATA = [
-  [
-    [-180, 90],
-    [0, 90],
-    [180, 90],
-    [180, -90],
-    [0, -90],
-    [-180, -90]
-  ]
-];
+const BACKGROUND_DATA = [[[-180, 90], [0, 90], [180, 90], [180, -90], [0, -90], [-180, -90]]];
 
 const BACKGROUND_NORTH_POLE_DATA = [
-  [
-    [-180, 90],
-    [0, 90],
-    [180, 90],
-    [180, 85],
-    [0, 85],
-    [-180, 85]
-  ]
+  [[-180, 90], [0, 90], [180, 90], [180, 85], [0, 85], [-180, 85]]
 ];
 
 // TODO: This could be expanded to search for matching layer names from any Mapbox style
diff --git a/modules/basemap-styles/jest.config.js b/modules/basemap-styles/jest.config.js
index 25c9bac..fa7322b 100644
--- a/modules/basemap-styles/jest.config.js
+++ b/modules/basemap-styles/jest.config.js
@@ -1,3 +1,3 @@
 module.exports = {
-  testEnvironment: 'node',
+  testEnvironment: 'node'
 };
diff --git a/modules/basemap-styles/rollup.config.js b/modules/basemap-styles/rollup.config.js
index 3d1f4ac..38db849 100644
--- a/modules/basemap-styles/rollup.config.js
+++ b/modules/basemap-styles/rollup.config.js
@@ -1,17 +1,17 @@
 import {terser} from 'rollup-plugin-terser';
 
 const config = (file, plugins = []) => ({
-    input: 'src/index.js',
-    output: {
-        name: 'deckgl-mapbox-style',
-        format: 'umd',
-        indent: false,
-        file
-    },
-    plugins
+  input: 'src/index.js',
+  output: {
+    name: 'deckgl-mapbox-style',
+    format: 'umd',
+    indent: false,
+    file
+  },
+  plugins
 });
 
 export default [
-    config('dist/deckgl-mapbox-style.js'),
-    config('dist/deckgl-mapbox-style.min.js', [terser()])
+  config('dist/deckgl-mapbox-style.js'),
+  config('dist/deckgl-mapbox-style.min.js', [terser()])
 ];
diff --git a/modules/basemap-styles/src/deck-layers/bitmap.js b/modules/basemap-styles/src/deck-layers/bitmap.js
index 8efbb89..9171c34 100644
--- a/modules/basemap-styles/src/deck-layers/bitmap.js
+++ b/modules/basemap-styles/src/deck-layers/bitmap.js
@@ -7,7 +7,7 @@
  */
 export function generateRasterLayer(sources, layer) {
   const source = sources[layer.source];
-  const { tileSize } = source;
+  const {tileSize} = source;
 
   const minzoom = layer.minzoom || source.minzoom || 0;
   const maxzoom = layer.maxzoom || source.maxzoom || 0;
@@ -19,7 +19,7 @@ export function generateRasterLayer(sources, layer) {
     tileSize,
     renderSubLayers: props => {
       const {
-        bbox: { west, south, east, north }
+        bbox: {west, south, east, north}
       } = props.tile;
 
       return new BitmapLayer(props, {
diff --git a/modules/basemap-styles/src/deck-layers/heatmap.js b/modules/basemap-styles/src/deck-layers/heatmap.js
index 6305e69..238a086 100644
--- a/modules/basemap-styles/src/deck-layers/heatmap.js
+++ b/modules/basemap-styles/src/deck-layers/heatmap.js
@@ -1,4 +1 @@
-
-export function generateHeatmapLayer(sources, layer) {
-  
-}
+export function generateHeatmapLayer(sources, layer) {}
diff --git a/modules/basemap-styles/src/deck-layers/icon.js b/modules/basemap-styles/src/deck-layers/icon.js
index 75d32a4..92447ce 100644
--- a/modules/basemap-styles/src/deck-layers/icon.js
+++ b/modules/basemap-styles/src/deck-layers/icon.js
@@ -2,6 +2,4 @@
  * Mapbox layers that generate deck.gl IconLayers
  */
 
-export function generateSymbolLayer(sources, layer) {
-
-}
+export function generateSymbolLayer(sources, layer) {}
diff --git a/modules/basemap-styles/src/deck-layers/mvt.js b/modules/basemap-styles/src/deck-layers/mvt.js
index 26246be..8b3189c 100644
--- a/modules/basemap-styles/src/deck-layers/mvt.js
+++ b/modules/basemap-styles/src/deck-layers/mvt.js
@@ -8,14 +8,9 @@ export function generateFillLayer(sources, layer, properties, dataTransform) {
     minzoom,
     maxzoom,
     dataTransform
-  })
-
+  });
 }
 
-export function generateLineLayer(sources, layer) {
-
-}
+export function generateLineLayer(sources, layer) {}
 
-export function generateCircleLayer(sources, layer) {
-
-}
+export function generateCircleLayer(sources, layer) {}
diff --git a/modules/basemap-styles/src/deck-layers/properties.js b/modules/basemap-styles/src/deck-layers/properties.js
index 3558a32..728492a 100644
--- a/modules/basemap-styles/src/deck-layers/properties.js
+++ b/modules/basemap-styles/src/deck-layers/properties.js
@@ -1,168 +1,168 @@
 const BACKGROUND_XW = {
-    // 'background-color': '',
-    'background-opacity': 'opacity',
-    // 'background-pattern': '',
-    'visibility': 'visible',
-}
+  // 'background-color': '',
+  'background-opacity': 'opacity',
+  // 'background-pattern': '',
+  visibility: 'visible'
+};
 
 const FILL_XW = {
-    // 'fill-antialias': '',
-    'fill-color': 'getFillColor',
-    'fill-opacity': 'opacity',
-    'fill-outline-color': 'getLineColor',
-    // 'fill-pattern': '',
-    // 'fill-sort-key': '',
-    // 'fill-translate': '',
-    // 'fill-translate-anchor': '',
-    'visibility': 'visible'
-}
+  // 'fill-antialias': '',
+  'fill-color': 'getFillColor',
+  'fill-opacity': 'opacity',
+  'fill-outline-color': 'getLineColor',
+  // 'fill-pattern': '',
+  // 'fill-sort-key': '',
+  // 'fill-translate': '',
+  // 'fill-translate-anchor': '',
+  visibility: 'visible'
+};
 
 const LINE_XW = {
-    // 'line-blur': '',
-    // 'line-cap': '',
-    'line-color': 'getColor',
-    // 'line-dasharray': '',
-    // 'line-gap-width': '',
-    // 'line-gradient': '',
-    // 'line-join': '',
-    // 'line-miter-limit': '',
-    // 'line-offset': '',
-    'line-opacity': 'opacity',
-    // 'line-pattern': '',
-    // 'line-round-limit': '',
-    // 'line-sort-key': '',
-    // 'line-translate': '',
-    // 'line-translate-anchor': '',
-    'line-width': 'getWidth',
-    'visibility': 'visible'
-}
+  // 'line-blur': '',
+  // 'line-cap': '',
+  'line-color': 'getColor',
+  // 'line-dasharray': '',
+  // 'line-gap-width': '',
+  // 'line-gradient': '',
+  // 'line-join': '',
+  // 'line-miter-limit': '',
+  // 'line-offset': '',
+  'line-opacity': 'opacity',
+  // 'line-pattern': '',
+  // 'line-round-limit': '',
+  // 'line-sort-key': '',
+  // 'line-translate': '',
+  // 'line-translate-anchor': '',
+  'line-width': 'getWidth',
+  visibility: 'visible'
+};
 
 const SYMBOL_XW = {
-    // 'icon-allow-overlap': '',
-    // 'icon-anchor': '',
-    // 'icon-color': '',
-    // 'icon-halo-blur': '',
-    // 'icon-halo-color': '',
-    // 'icon-halo-width': '',
-    // 'icon-ignore-placement': '',
-    // 'icon-image': '',
-    // 'icon-keep-upright': '',
-    // 'icon-offset': '',
-    // 'icon-opacity': 'opacity',
-    // 'icon-optional': '',
-    // 'icon-padding': '',
-    // 'icon-pitch-alignment': '',
-    // 'icon-rotate': '',
-    // 'icon-rotation-alignment': '',
-    // 'icon-size': '',
-    // 'icon-text-fit': '',
-    // 'icon-text-fit-padding': '',
-    // 'icon-translate': '',
-    // 'icon-translate-anchor': '',
-    // 'symbol-avoid-edges': '',
-    // 'symbol-placement': '',
-    // 'symbol-sort-key': '',
-    // 'symbol-spacing': '',
-    // 'symbol-z-order': '',
-    // 'text-allow-overlap': '',
-    // 'text-anchor': '',
-    // 'text-color': '',
-    // 'text-field': '',
-    // 'text-font': '',
-    // 'text-halo-blur': '',
-    // 'text-halo-color': '',
-    // 'text-halo-width': '',
-    // 'text-ignore-placement': '',
-    // 'text-justify': '',
-    // 'text-keep-upright': '',
-    // 'text-letter-spacing': '',
-    // 'text-line-height': '',
-    // 'text-max-angle': '',
-    // 'text-max-width': '',
-    // 'text-offset': '',
-    // 'text-opacity': 'opacity',
-    // 'text-optional': '',
-    // 'text-padding': '',
-    // 'text-pitch-alignment': '',
-    // 'text-radial-offset': '',
-    // 'text-rotate': '',
-    // 'text-rotation-alignment': '',
-    // 'text-size': '',
-    // 'text-transform': '',
-    // 'text-translate': '',
-    // 'text-translate-anchor': '',
-    // 'text-variable-anchor': '',
-    // 'text-writing-mode': '',
-    'visibility': 'visible',
-}
+  // 'icon-allow-overlap': '',
+  // 'icon-anchor': '',
+  // 'icon-color': '',
+  // 'icon-halo-blur': '',
+  // 'icon-halo-color': '',
+  // 'icon-halo-width': '',
+  // 'icon-ignore-placement': '',
+  // 'icon-image': '',
+  // 'icon-keep-upright': '',
+  // 'icon-offset': '',
+  // 'icon-opacity': 'opacity',
+  // 'icon-optional': '',
+  // 'icon-padding': '',
+  // 'icon-pitch-alignment': '',
+  // 'icon-rotate': '',
+  // 'icon-rotation-alignment': '',
+  // 'icon-size': '',
+  // 'icon-text-fit': '',
+  // 'icon-text-fit-padding': '',
+  // 'icon-translate': '',
+  // 'icon-translate-anchor': '',
+  // 'symbol-avoid-edges': '',
+  // 'symbol-placement': '',
+  // 'symbol-sort-key': '',
+  // 'symbol-spacing': '',
+  // 'symbol-z-order': '',
+  // 'text-allow-overlap': '',
+  // 'text-anchor': '',
+  // 'text-color': '',
+  // 'text-field': '',
+  // 'text-font': '',
+  // 'text-halo-blur': '',
+  // 'text-halo-color': '',
+  // 'text-halo-width': '',
+  // 'text-ignore-placement': '',
+  // 'text-justify': '',
+  // 'text-keep-upright': '',
+  // 'text-letter-spacing': '',
+  // 'text-line-height': '',
+  // 'text-max-angle': '',
+  // 'text-max-width': '',
+  // 'text-offset': '',
+  // 'text-opacity': 'opacity',
+  // 'text-optional': '',
+  // 'text-padding': '',
+  // 'text-pitch-alignment': '',
+  // 'text-radial-offset': '',
+  // 'text-rotate': '',
+  // 'text-rotation-alignment': '',
+  // 'text-size': '',
+  // 'text-transform': '',
+  // 'text-translate': '',
+  // 'text-translate-anchor': '',
+  // 'text-variable-anchor': '',
+  // 'text-writing-mode': '',
+  visibility: 'visible'
+};
 
 const RASTER_XW = {
-    // 'raster-brightness-max': '',
-    // 'raster-brightness-min': '',
-    // 'raster-contrast': '',
-    // 'raster-fade-duration': '',
-    // 'raster-hue-rotate': '',
-    'raster-opacity': 'opacity',
-    // 'raster-resampling': '',
-    // 'raster-saturation': '',
-    'visibility': 'visible'
-}
+  // 'raster-brightness-max': '',
+  // 'raster-brightness-min': '',
+  // 'raster-contrast': '',
+  // 'raster-fade-duration': '',
+  // 'raster-hue-rotate': '',
+  'raster-opacity': 'opacity',
+  // 'raster-resampling': '',
+  // 'raster-saturation': '',
+  visibility: 'visible'
+};
 
 const CIRCLE_XW = {
-    // 'circle-blur': '',
-    // 'circle-color': '',
-    'circle-opacity': 'opacity',
-    // 'circle-pitch-alignment': '',
-    // 'circle-pitch-scale': '',
-    // 'circle-radius': '',
-    // 'circle-sort-key': '',
-    // 'circle-stroke-color': '',
-    // 'circle-stroke-opacity': '',
-    // 'circle-stroke-width': '',
-    // 'circle-translate': '',
-    // 'circle-translate-anchor': '',
-    'visibility': 'visible'
-}
+  // 'circle-blur': '',
+  // 'circle-color': '',
+  'circle-opacity': 'opacity',
+  // 'circle-pitch-alignment': '',
+  // 'circle-pitch-scale': '',
+  // 'circle-radius': '',
+  // 'circle-sort-key': '',
+  // 'circle-stroke-color': '',
+  // 'circle-stroke-opacity': '',
+  // 'circle-stroke-width': '',
+  // 'circle-translate': '',
+  // 'circle-translate-anchor': '',
+  visibility: 'visible'
+};
 
 const FILL_EXTRUSTION_XW = {
-    // 'fill-extrusion-base': '',
-    'fill-extrusion-color': 'getColor',
-    'fill-extrusion-height': 'getElevation',
-    'fill-extrusion-opacity': 'opacity',
-    // 'fill-extrusion-pattern': '',
-    // 'fill-extrusion-translate': '',
-    // 'fill-extrusion-translate-anchor': '',
-    // 'fill-extrusion-vertical-gradient': '',
-    'visibility': 'visible'
-}
+  // 'fill-extrusion-base': '',
+  'fill-extrusion-color': 'getColor',
+  'fill-extrusion-height': 'getElevation',
+  'fill-extrusion-opacity': 'opacity',
+  // 'fill-extrusion-pattern': '',
+  // 'fill-extrusion-translate': '',
+  // 'fill-extrusion-translate-anchor': '',
+  // 'fill-extrusion-vertical-gradient': '',
+  visibility: 'visible'
+};
 
 const HEATMAP_XW = {
-    // 'heatmap-color': '',
-    // 'heatmap-intensity': '',
-    'heatmap-opacity': 'opacity',
-    // 'heatmap-radius': '',
-    // 'heatmap-weight': '',
-    'visibility': 'visible'
-}
+  // 'heatmap-color': '',
+  // 'heatmap-intensity': '',
+  'heatmap-opacity': 'opacity',
+  // 'heatmap-radius': '',
+  // 'heatmap-weight': '',
+  visibility: 'visible'
+};
 
 const HILLSHADE_XW = {
-    // 'hillshade-accent-color': '',
-    // 'hillshade-exaggeration': '',
-    // 'hillshade-highlight-color': '',
-    // 'hillshade-illumination-anchor': '',
-    // 'hillshade-illumination-direction': '',
-    // 'hillshade-shadow-color': '',
-    'visibility': 'visible'
-}
+  // 'hillshade-accent-color': '',
+  // 'hillshade-exaggeration': '',
+  // 'hillshade-highlight-color': '',
+  // 'hillshade-illumination-anchor': '',
+  // 'hillshade-illumination-direction': '',
+  // 'hillshade-shadow-color': '',
+  visibility: 'visible'
+};
 
 export const PROPERTY_XW = {
-    ...BACKGROUND_XW,
-    ...FILL_XW,
-    ...LINE_XW,
-    ...SYMBOL_XW,
-    ...RASTER_XW,
-    ...CIRCLE_XW,
-    ...FILL_EXTRUSTION_XW,
-    ...HEATMAP_XW,
-    ...HILLSHADE_XW,
-}
+  ...BACKGROUND_XW,
+  ...FILL_XW,
+  ...LINE_XW,
+  ...SYMBOL_XW,
+  ...RASTER_XW,
+  ...CIRCLE_XW,
+  ...FILL_EXTRUSTION_XW,
+  ...HEATMAP_XW,
+  ...HILLSHADE_XW
+};
diff --git a/modules/basemap-styles/src/index.js b/modules/basemap-styles/src/index.js
index bde0209..a30d9fc 100644
--- a/modules/basemap-styles/src/index.js
+++ b/modules/basemap-styles/src/index.js
@@ -1 +1 @@
-export { generateLayers } from "./parse-mapbox-style";
+export {generateLayers} from './parse-mapbox-style';
diff --git a/modules/basemap-styles/src/mapbox-style.js b/modules/basemap-styles/src/mapbox-style.js
index 52293c8..6e1a2df 100644
--- a/modules/basemap-styles/src/mapbox-style.js
+++ b/modules/basemap-styles/src/mapbox-style.js
@@ -1,9 +1,4 @@
-import {
-  latest as Reference,
-  featureFilter,
-  expression,
-  Color
-} from "@mapbox/mapbox-gl-style-spec";
+import {latest as Reference, featureFilter, expression, Color} from '@mapbox/mapbox-gl-style-spec';
 
 // See https://github.com/mapbox/vector-tile-spec/blob/b87a6a16abc3fcda9ea3f0a68264b40f48e039f3/2.1/vector_tile.proto#L7-L13
 const GEOM_TYPES = {
@@ -25,7 +20,7 @@ const GEOM_TYPES = {
  * @param  {object} globalProperties {zoom: current zoom}
  * @return {object[]}                Filtered features
  */
-export function filterFeatures({ features, filter, globalProperties = {} }) {
+export function filterFeatures({features, filter, globalProperties = {}}) {
   if (!features || features.length === 0) return [];
 
   // filterFn will be a function that returns a boolean
@@ -46,13 +41,9 @@ export function filterFeatures({ features, filter, globalProperties = {} }) {
 // object
 // features expected to be
 // {sourceName: {layerName: [features]}}
-export function findFeaturesStyledByLayer({
-  features,
-  layer,
-  globalProperties
-}) {
+export function findFeaturesStyledByLayer({features, layer, globalProperties}) {
   // features matching the source and source-layer
-  const sourceLayerFeatures = features[layer.source][layer["source-layer"]];
+  const sourceLayerFeatures = features[layer.source][layer['source-layer']];
   if (!sourceLayerFeatures) return [];
 
   if (layer.filter && layer.filter.length > 0) {
@@ -73,7 +64,7 @@ function visitProperties(layer, options, callback) {
     if (!properties) return;
     Object.keys(properties).forEach(key => {
       callback({
-        layer: layer,
+        layer,
         path: [layer.id, propertyType, key],
         key,
         value: properties[key],
@@ -86,10 +77,10 @@ function visitProperties(layer, options, callback) {
   }
 
   if (options.paint) {
-    inner(layer, "paint");
+    inner(layer, 'paint');
   }
   if (options.layout) {
-    inner(layer, "layout");
+    inner(layer, 'layout');
   }
 }
 
@@ -112,7 +103,7 @@ function getPropertyReference(propertyName) {
 export function parseProperties(layer, globalProperties) {
   // An array of Property objects for this specific layer
   const layerProperties = [];
-  visitProperties(layer, { paint: true }, property =>
+  visitProperties(layer, {paint: true}, property =>
     layerProperties.push(parseProperty(property, globalProperties))
   );
 
@@ -120,10 +111,7 @@ export function parseProperties(layer, globalProperties) {
 }
 
 function parseProperty(property, globalProperties) {
-  const exp = expression.normalizePropertyExpression(
-    property.value,
-    property.reference
-  );
+  const exp = expression.normalizePropertyExpression(property.value, property.reference);
   const result = exp.evaluate(globalProperties);
 
   // NOTE: eventually we could potentially return the function itself
@@ -135,8 +123,8 @@ function parseProperty(property, globalProperties) {
 
   // Coerce Color to rgba array
   if (result instanceof Color) {
-    return { [property["key"]]: result.toArray() };
+    return {[property.key]: result.toArray()};
   }
 
-  return { [property["key"]]: result };
+  return {[property.key]: result};
 }
diff --git a/modules/basemap-styles/src/parse-mapbox-style.js b/modules/basemap-styles/src/parse-mapbox-style.js
index a6af745..56d9c54 100644
--- a/modules/basemap-styles/src/parse-mapbox-style.js
+++ b/modules/basemap-styles/src/parse-mapbox-style.js
@@ -1,8 +1,8 @@
-import { findFeaturesStyledByLayer } from "./mapbox-style";
+import {findFeaturesStyledByLayer} from './mapbox-style';
 
 // globalProperties' type:
 // https://github.com/maplibre/maplibre-gl-js/blob/2112766af5d68a7ea885156c8c186c72a4e912ca/src/style-spec/expression/index.js#L41-L47
-const globalProperties = { zoom: 0 };
+const globalProperties = {zoom: 0};
 
 /**
  * Generate a new deck.gl layer for each StyleJSON layer
@@ -15,7 +15,7 @@ export function generateLayers(styleJson, globalProperties) {
   // TileJSON, whose properties need to be merged with the source defined in the
   // StyleJSON
   // In this case need to fetch the JSON
-  const { sources, layers } = styleJson;
+  const {sources, layers} = styleJson;
   const deckLayers = [];
 
   for (const layer of layers) {
@@ -25,13 +25,7 @@ export function generateLayers(styleJson, globalProperties) {
   return deckLayers;
 }
 
-const FILTERABLE_LAYERS = [
-  "fill",
-  "line",
-  "symbol",
-  "circle",
-  "fill-extrusion"
-];
+const FILTERABLE_LAYERS = ['fill', 'line', 'symbol', 'circle', 'fill-extrusion'];
 
 /**
  * Generate single deck.gl layer from Mapbox layer
@@ -42,7 +36,7 @@ const FILTERABLE_LAYERS = [
  * @return {object}                  deck.gl layer
  */
 function generateLayer(sources, layer, globalProperties) {
-  const { type } = layer;
+  const {type} = layer;
 
   // Parse property descriptions into values, resolving zoom
   const properties = parseProperties(layer, globalProperties);
@@ -67,37 +61,22 @@ function generateLayer(sources, layer, globalProperties) {
 
   // Render deck.gl layers
   switch (type) {
-    case "background":
-      return generateBackgroundLayer(
-        sources,
-        layer,
-        deckProperties,
-        dataTransform
-      );
-    case "fill":
+    case 'background':
+      return generateBackgroundLayer(sources, layer, deckProperties, dataTransform);
+    case 'fill':
       return generateFillLayer(sources, layer, deckProperties, dataTransform);
-    case "line":
+    case 'line':
       return generateLineLayer(sources, layer, deckProperties, dataTransform);
-    case "symbol":
+    case 'symbol':
       return generateSymbolLayer(sources, layer, deckProperties, dataTransform);
-    case "raster":
+    case 'raster':
       return generateRasterLayer(sources, layer, deckProperties, dataTransform);
-    case "circle":
+    case 'circle':
       return generateCircleLayer(sources, layer, deckProperties, dataTransform);
-    case "fill-extrusion":
-      return generateFillExtrusionLayer(
-        sources,
-        layer,
-        deckProperties,
-        dataTransform
-      );
-    case "heatmap":
-      return generateHeatmapLayer(
-        sources,
-        layer,
-        deckProperties,
-        dataTransform
-      );
+    case 'fill-extrusion':
+      return generateFillExtrusionLayer(sources, layer, deckProperties, dataTransform);
+    case 'heatmap':
+      return generateHeatmapLayer(sources, layer, deckProperties, dataTransform);
     // case "hillshade":
     //   return generateHillshadeLayer(sources, layer);
     default:
diff --git a/modules/basemap-styles/src/util.js b/modules/basemap-styles/src/util.js
index 438a011..be7a7dd 100644
--- a/modules/basemap-styles/src/util.js
+++ b/modules/basemap-styles/src/util.js
@@ -1,6 +1,6 @@
 // Convert an array of GeoJSON features to an object of features sorted by layer name
 export function featuresArrayToObject(options = {}) {
-  const { features, layerName, sourceName = null } = options;
+  const {features, layerName, sourceName = null} = options;
 
   const featuresByLayer = {};
   for (const feature of features) {
@@ -13,5 +13,5 @@ export function featuresArrayToObject(options = {}) {
     return featuresByLayer;
   }
 
-  return { [sourceName]: featuresByLayer };
+  return {[sourceName]: featuresByLayer};
 }
diff --git a/modules/basemap-styles/tests/mapbox-style.spec.js b/modules/basemap-styles/tests/mapbox-style.spec.js
index 679d971..c78192a 100644
--- a/modules/basemap-styles/tests/mapbox-style.spec.js
+++ b/modules/basemap-styles/tests/mapbox-style.spec.js
@@ -1,189 +1,189 @@
-import { filterFeatures } from "../src/mapbox-style";
+import {filterFeatures} from '../src/mapbox-style';
 
-describe("filterFeatures", () => {
-  describe("filter geometry correctly", () => {
-    describe("filter using geometry.type", () => {
-      test("filter true Point", () => {
+describe('filterFeatures', () => {
+  describe('filter geometry correctly', () => {
+    describe('filter using geometry.type', () => {
+      test('filter true Point', () => {
         const features = [
           {
-            type: "Feature",
+            type: 'Feature',
             geometry: {
-              type: "Point",
+              type: 'Point',
               coordinates: []
             },
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "Point"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'Point'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual(features);
       });
-      test("filter false Point", () => {
+      test('filter false Point', () => {
         const features = [
           {
-            type: "Feature",
+            type: 'Feature',
             geometry: {
-              type: "LineString",
+              type: 'LineString',
               coordinates: []
             },
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "Point"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'Point'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual([]);
       });
-      test("filter true LineString", () => {
+      test('filter true LineString', () => {
         const features = [
           {
-            type: "Feature",
+            type: 'Feature',
             geometry: {
-              type: "LineString",
+              type: 'LineString',
               coordinates: []
             },
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "LineString"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'LineString'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual(features);
       });
-      test("filter false LineString", () => {
+      test('filter false LineString', () => {
         const features = [
           {
-            type: "Feature",
+            type: 'Feature',
             geometry: {
-              type: "Point",
+              type: 'Point',
               coordinates: []
             },
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "LineString"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'LineString'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual([]);
       });
-      test("filter true Polygon", () => {
+      test('filter true Polygon', () => {
         const features = [
           {
-            type: "Feature",
+            type: 'Feature',
             geometry: {
-              type: "Polygon",
+              type: 'Polygon',
               coordinates: []
             },
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "Polygon"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'Polygon'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual(features);
       });
-      test("filter false Polygon", () => {
+      test('filter false Polygon', () => {
         const features = [
           {
-            type: "Feature",
+            type: 'Feature',
             geometry: {
-              type: "Point",
+              type: 'Point',
               coordinates: []
             },
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "Polygon"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'Polygon'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual([]);
       });
     });
 
-    describe("filter using provided numeric type", () => {
-      test("filter true Point", () => {
+    describe('filter using provided numeric type', () => {
+      test('filter true Point', () => {
         const features = [
           {
             type: 1,
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "Point"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'Point'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual(features);
       });
-      test("filter false Point", () => {
+      test('filter false Point', () => {
         const features = [
           {
             type: 2,
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "Point"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'Point'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual([]);
       });
-      test("filter true LineString", () => {
+      test('filter true LineString', () => {
         const features = [
           {
             type: 2,
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "LineString"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'LineString'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual(features);
       });
-      test("filter false LineString", () => {
+      test('filter false LineString', () => {
         const features = [
           {
             type: 1,
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "LineString"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'LineString'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual([]);
       });
-      test("filter true Polygon", () => {
+      test('filter true Polygon', () => {
         const features = [
           {
             type: 3,
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "Polygon"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'Polygon'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual(features);
       });
-      test("filter false Polygon", () => {
+      test('filter false Polygon', () => {
         const features = [
           {
             type: 1,
             properties: {
-              class: "minor"
+              class: 'minor'
             }
           }
         ];
-        const filter = ["==", "$type", "Polygon"];
-        const result = filterFeatures({ features, filter });
+        const filter = ['==', '$type', 'Polygon'];
+        const result = filterFeatures({features, filter});
         expect(result).toStrictEqual([]);
       });
     });