@mapbox/mapbox-gl-style-spec 14.14.0 → 14.15.0-beta.1

package/dist/index.cjs

@@ -2872,6 +2872,7 @@
   		doc: "Name of image in sprite to use for drawing an image background.",
   		tokens: true,
   		appearance: true,
+  		"use-theme": true,
   		"sdk-support": {
   			"basic functionality": {
   				js: "0.10.0",
@@ -13878,19 +13879,40 @@
   }
 
   function getType(val) {
-      if (val instanceof Number) {
-          return 'number';
-      } else if (val instanceof String) {
+      if (isString(val))
           return 'string';
-      } else if (val instanceof Boolean) {
+      if (isNumber(val))
+          return 'number';
+      if (isBoolean(val))
           return 'boolean';
-      } else if (Array.isArray(val)) {
+      if (Array.isArray(val))
           return 'array';
-      } else if (val === null) {
+      if (val === null)
           return 'null';
-      } else {
-          return typeof val;
+      if (isObject(val))
+          return 'object';
+      return typeof val;
+  }
+  function isObject(value) {
+      if (value === null || value === void 0)
+          return false;
+      if (Array.isArray(value))
+          return false;
+      if (typeof value === 'function')
+          return false;
+      if (value instanceof String || value instanceof Number || value instanceof Boolean) {
+          return false;
       }
+      return typeof value === 'object';
+  }
+  function isString(value) {
+      return typeof value === 'string' || value instanceof String;
+  }
+  function isNumber(value) {
+      return typeof value === 'number' || value instanceof Number;
+  }
+  function isBoolean(value) {
+      return typeof value === 'boolean' || value instanceof Boolean;
   }
 
   const types = {
@@ -13930,7 +13952,7 @@
               for (let i = 0; i < arrayLength; i++) {
                   const member = args[1][i];
                   let parsedMember;
-                  if (getType(member) === 'array') {
+                  if (Array.isArray(member)) {
                       parsedMember = context.parse(member, void 0, type.itemType);
                   } else {
                       const memberType = getType(member);
@@ -14044,7 +14066,7 @@
       'Polygon'
   ];
   class EvaluationContext {
-      constructor(scope, options) {
+      constructor(scope, options, iconImageUseTheme) {
           this.globals = null;
           this.feature = null;
           this.featureState = null;
@@ -14056,6 +14078,7 @@
           this.featureDistanceData = null;
           this.scope = scope;
           this.options = options;
+          this.iconImageUseTheme = iconImageUseTheme;
       }
       id() {
           return this.feature && this.feature.id !== void 0 ? this.feature.id : null;
@@ -14144,7 +14167,7 @@
                   continue;
               overloadParams.push(params);
               overloadIndex++;
-              signatureContext = new ParsingContext(context.registry, context.path, null, context.scope, void 0, context._scope, context.options);
+              signatureContext = new ParsingContext(context.registry, context.path, null, context.scope, void 0, context._scope, context.options, context.iconImageUseTheme);
               const parsedArgs = [];
               let argParseFailed = false;
               for (let i = 1; i < args.length; i++) {
@@ -16280,7 +16303,7 @@
   }
 
   class ParsingContext {
-      constructor(registry, path = [], expectedType, scope = new Scope(), errors = [], _scope, options) {
+      constructor(registry, path = [], expectedType, scope = new Scope(), errors = [], _scope, options, iconImageUseTheme) {
           this.registry = registry;
           this.path = path;
           this.key = path.map(part => {
@@ -16294,6 +16317,7 @@
           this.expectedType = expectedType;
           this._scope = _scope;
           this.options = options;
+          this.iconImageUseTheme = iconImageUseTheme;
       }
       /**
      * @param expr the JSON expression to parse
@@ -16356,7 +16380,7 @@
                       }
                   }
                   if (!(parsed instanceof Literal) && parsed.type.kind !== 'resolvedImage' && isConstant(parsed)) {
-                      const ec = new EvaluationContext(this._scope, this.options);
+                      const ec = new EvaluationContext(this._scope, this.options, this.iconImageUseTheme);
                       try {
                           parsed = new Literal(parsed.type, parsed.evaluate(ec));
                       } catch (e) {
@@ -16390,7 +16414,7 @@
           let path = typeof index === 'number' ? this.path.concat(index) : this.path;
           path = typeof key === 'string' ? path.concat(key) : path;
           const scope = bindings ? this.scope.concat(bindings) : this.scope;
-          return new ParsingContext(this.registry, path, expectedType || null, scope, this.errors, this._scope, this.options);
+          return new ParsingContext(this.registry, path, expectedType || null, scope, this.errors, this._scope, this.options, this.iconImageUseTheme);
       }
       /**
      * Push a parsing (or type checking) error into the `this.errors`
@@ -17042,13 +17066,13 @@
           const index = this.index.evaluate(ctx);
           const array2 = this.input.evaluate(ctx);
           if (index < 0) {
-              throw new RuntimeError(`Array index out of bounds: ${ index } < 0.`);
+              throw new RuntimeError(`Array index out of bounds: negative index`);
           }
           if (index >= array2.length) {
-              throw new RuntimeError(`Array index out of bounds: ${ index } > ${ array2.length - 1 }.`);
+              throw new RuntimeError(`Array index out of bounds: index exceeds array size`);
           }
           if (index !== Math.floor(index)) {
-              throw new RuntimeError(`Array index must be an integer, but found ${ index } instead. Use at-interpolated to retrieve interpolated result with a fractional index.`);
+              throw new RuntimeError(`Array index must be an integer. Use at-interpolated for fractional indices`);
           }
           return array2[index];
       }
@@ -18703,7 +18727,7 @@
       return coalesce$1(evaluated, parameters.default, propertySpec.default);
   }
   function evaluateIntervalFunction(parameters, propertySpec, input) {
-      if (getType(input) !== 'number')
+      if (!isNumber(input))
           return coalesce$1(parameters.default, propertySpec.default);
       const n = parameters.stops.length;
       if (n === 1)
@@ -18717,7 +18741,7 @@
   }
   function evaluateExponentialFunction(parameters, propertySpec, input) {
       const base = parameters.base !== void 0 ? parameters.base : 1;
-      if (getType(input) !== 'number')
+      if (!isNumber(input))
           return coalesce$1(parameters.default, propertySpec.default);
       const n = parameters.stops.length;
       if (n === 1)
@@ -18774,10 +18798,10 @@
   }
 
   class StyleExpression {
-      constructor(expression, propertySpec, scope, options) {
+      constructor(expression, propertySpec, scope, options, iconImageUseTheme) {
           this.expression = expression;
           this._warningHistory = {};
-          this._evaluator = new EvaluationContext(scope, options);
+          this._evaluator = new EvaluationContext(scope, options, iconImageUseTheme);
           this._defaultValue = propertySpec ? getDefaultValue(propertySpec) : null;
           this._enumValues = propertySpec && propertySpec.type === 'enum' ? propertySpec.values : null;
           this.configDependencies = getConfigDependencies(expression);
@@ -18793,7 +18817,7 @@
           this._evaluator.featureDistanceData = featureDistanceData || null;
           return this.expression.evaluate(this._evaluator);
       }
-      evaluate(globals, feature, featureState, canonical, availableImages, formattedSection, featureTileCoord, featureDistanceData) {
+      evaluate(globals, feature, featureState, canonical, availableImages, formattedSection, featureTileCoord, featureDistanceData, iconImageUseTheme) {
           this._evaluator.globals = globals;
           this._evaluator.feature = feature || null;
           this._evaluator.featureState = featureState || null;
@@ -18802,6 +18826,7 @@
           this._evaluator.formattedSection = formattedSection || null;
           this._evaluator.featureTileCoord = featureTileCoord || null;
           this._evaluator.featureDistanceData = featureDistanceData || null;
+          this._evaluator.iconImageUseTheme = iconImageUseTheme || null;
           try {
               const val = this.expression.evaluate(this._evaluator);
               if (val === null || val === void 0 || typeof val === 'number' && val !== val) {
@@ -18825,13 +18850,13 @@
   function isExpression(expression) {
       return Array.isArray(expression) && expression.length > 0 && typeof expression[0] === 'string' && expression[0] in expressions;
   }
-  function createExpression(expression, propertySpec, scope, options) {
-      const parser = new ParsingContext(expressions, [], propertySpec ? getExpectedType(propertySpec) : void 0, void 0, void 0, scope, options);
+  function createExpression(expression, propertySpec, scope, options, iconImageUseTheme) {
+      const parser = new ParsingContext(expressions, [], propertySpec ? getExpectedType(propertySpec) : void 0, void 0, void 0, scope, options, iconImageUseTheme);
       const parsed = parser.parse(expression, void 0, void 0, void 0, propertySpec && propertySpec.type === 'string' ? { typeAnnotation: 'coerce' } : void 0);
       if (!parsed) {
           return error(parser.errors);
       }
-      return success(new StyleExpression(parsed, propertySpec, scope, options));
+      return success(new StyleExpression(parsed, propertySpec, scope, options, iconImageUseTheme));
   }
   class ZoomConstantExpression {
       constructor(kind, expression, isLightConstant, isLineProgressConstant) {
@@ -18845,8 +18870,8 @@
       evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection) {
           return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState, canonical, availableImages, formattedSection);
       }
-      evaluate(globals, feature, featureState, canonical, availableImages, formattedSection) {
-          return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection);
+      evaluate(globals, feature, featureState, canonical, availableImages, formattedSection, iconImageUseTheme) {
+          return this._styleExpression.evaluate(globals, feature, featureState, canonical, availableImages, formattedSection, void 0, void 0, iconImageUseTheme);
       }
   }
   class ZoomDependentExpression {
@@ -18874,8 +18899,8 @@
           }
       }
   }
-  function createPropertyExpression(expression, propertySpec, scope, options) {
-      expression = createExpression(expression, propertySpec, scope, options);
+  function createPropertyExpression(expression, propertySpec, scope, options, iconImageUseTheme) {
+      expression = createExpression(expression, propertySpec, scope, options, iconImageUseTheme);
       if (expression.result === 'error') {
           return expression;
       }
@@ -18931,11 +18956,11 @@
           };
       }
   }
-  function normalizePropertyExpression(value, specification, scope, options) {
+  function normalizePropertyExpression(value, specification, scope, options, iconImageUseTheme) {
       if (isFunction(value)) {
           return new StylePropertyFunction(value, specification);
       } else if (isExpression(value) || Array.isArray(value) && value.length > 0) {
-          const expression = createPropertyExpression(value, specification, scope, options);
+          const expression = createPropertyExpression(value, specification, scope, options, iconImageUseTheme);
           if (expression.result === 'error') {
               throw new Error(expression.value.map(err => `${ err.key }: ${ err.message }`).join(', '));
           }
@@ -20601,58 +20626,12 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
   }
 
-  function validateObject(options) {
-      const key = options.key;
-      const object = options.value;
-      const elementSpecs = options.valueSpec || {};
-      const elementValidators = options.objectElementValidators || {};
-      const style = options.style;
-      const styleSpec = options.styleSpec;
-      let errors = [];
-      const type = getType(object);
-      if (type !== 'object') {
-          return [new ValidationError(key, object, `object expected, ${ type } found`)];
-      }
-      for (const objectKey in object) {
-          const elementSpecKey = objectKey.split('.')[0];
-          const elementSpec = elementSpecs[elementSpecKey] || elementSpecs['*'];
-          let validateElement;
-          if (elementValidators[elementSpecKey]) {
-              validateElement = elementValidators[elementSpecKey];
-          } else if (elementSpecs[elementSpecKey]) {
-              validateElement = validate;
-          } else if (elementValidators['*']) {
-              validateElement = elementValidators['*'];
-          } else if (elementSpecs['*']) {
-              validateElement = validate;
-          }
-          if (!validateElement) {
-              errors.push(new ValidationWarning(key, object[objectKey], `unknown property "${ objectKey }"`));
-              continue;
-          }
-          errors = errors.concat(validateElement({
-              key: (key ? `${ key }.` : key) + objectKey,
-              value: object[objectKey],
-              valueSpec: elementSpec,
-              style,
-              styleSpec,
-              object,
-              objectKey
-          }, object));
-      }
-      for (const elementSpecKey in elementSpecs) {
-          if (elementValidators[elementSpecKey]) {
-              continue;
-          }
-          if (elementSpecs[elementSpecKey].required && elementSpecs[elementSpecKey]['default'] === void 0 && object[elementSpecKey] === void 0) {
-              errors.push(new ValidationError(key, object, `missing required property "${ elementSpecKey }"`));
-          }
-      }
-      return errors;
-  }
-
   function validateImport(options) {
+      const key = options.key;
       const {value, styleSpec} = options;
+      if (!isObject(value)) {
+          return [new ValidationError(key, value, `import must be an object`)];
+      }
       const {data, ...importSpec} = value;
       Object.defineProperty(importSpec, '__line__', {
           value: value.__line__,
@@ -20663,12 +20642,12 @@ ${ JSON.stringify(filterExp, null, 2) }
           valueSpec: styleSpec.import
       }));
       if (unbundle(importSpec.id) === '') {
-          const key = `${ options.key }.id`;
-          errors.push(new ValidationError(key, importSpec, `import id can't be an empty string`));
+          const key2 = `${ options.key }.id`;
+          errors.push(new ValidationError(key2, importSpec, `import id can't be an empty string`));
       }
       if (data) {
-          const key = `${ options.key }.data`;
-          errors = errors.concat(validateStyle$2(data, styleSpec, { key }));
+          const key2 = `${ options.key }.data`;
+          errors = errors.concat(validateStyle$2(data, styleSpec, { key: key2 }));
       }
       return errors;
   }
@@ -20680,7 +20659,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       const styleSpec = options.styleSpec;
       const key = options.key;
       const validateArrayElement = options.arrayElementValidator || validate;
-      if (getType(array) !== 'array') {
+      if (!Array.isArray(array)) {
           return [new ValidationError(key, array, `array expected, ${ getType(array) } found`)];
       }
       if (arraySpec.length && array.length !== arraySpec.length) {
@@ -20690,16 +20669,16 @@ ${ JSON.stringify(filterExp, null, 2) }
           return [new ValidationError(key, array, `array length at least ${ arraySpec['min-length'] } expected, length ${ array.length } found`)];
       }
       let arrayElementSpec = {
-          'type': arraySpec.value,
-          'values': arraySpec.values,
-          'minimum': arraySpec.minimum,
-          'maximum': arraySpec.maximum,
+          type: arraySpec.value,
+          values: arraySpec.values,
+          minimum: arraySpec.minimum,
+          maximum: arraySpec.maximum,
           function: void 0
       };
       if (styleSpec.$version < 7) {
           arrayElementSpec.function = arraySpec.function;
       }
-      if (getType(arraySpec.value) === 'object') {
+      if (isObject(arraySpec.value)) {
           arrayElementSpec = arraySpec.value;
       }
       let errors = [];
@@ -20721,16 +20700,15 @@ ${ JSON.stringify(filterExp, null, 2) }
       const key = options.key;
       const value = options.value;
       const valueSpec = options.valueSpec;
-      let type = getType(value);
-      if (type === 'number' && value !== value) {
-          type = 'NaN';
+      if (!isNumber(value)) {
+          return [new ValidationError(key, value, `number expected, ${ getType(value) } found`)];
       }
-      if (type !== 'number') {
-          return [new ValidationError(key, value, `number expected, ${ type } found`)];
+      if (value !== value) {
+          return [new ValidationError(key, value, `number expected, NaN found`)];
       }
       if ('minimum' in valueSpec) {
           let specMin = valueSpec.minimum;
-          if (getType(valueSpec.minimum) === 'array') {
+          if (Array.isArray(valueSpec.minimum)) {
               const i = options.arrayIndex;
               specMin = valueSpec.minimum[i];
           }
@@ -20740,7 +20718,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
       if ('maximum' in valueSpec) {
           let specMax = valueSpec.maximum;
-          if (getType(valueSpec.maximum) === 'array') {
+          if (Array.isArray(valueSpec.maximum)) {
               const i = options.arrayIndex;
               specMax = valueSpec.maximum[i];
           }
@@ -20751,16 +20729,25 @@ ${ JSON.stringify(filterExp, null, 2) }
       return [];
   }
 
+  function hasObjectStops(value) {
+      const stops = value['stops'];
+      return Array.isArray(stops) && Array.isArray(stops[0]) && isObject(stops[0][0]);
+  }
   function validateFunction(options) {
+      const key = options.key;
+      const value = options.value;
+      if (!isObject(value)) {
+          return [new ValidationError(key, value, `object expected, ${ getType(value) } found`)];
+      }
       const functionValueSpec = options.valueSpec;
-      const functionType = unbundle(options.value.type);
+      const functionType = unbundle(value.type);
       let stopKeyType;
       let stopDomainValues = {};
       let previousStopDomainValue;
       let previousStopDomainZoom;
-      const isZoomFunction = functionType !== 'categorical' && options.value.property === void 0;
+      const isZoomFunction = functionType !== 'categorical' && value.property === void 0;
       const isPropertyFunction = !isZoomFunction;
-      const isZoomAndPropertyFunction = getType(options.value.stops) === 'array' && getType(options.value.stops[0]) === 'array' && getType(options.value.stops[0][0]) === 'object';
+      const isZoomAndPropertyFunction = hasObjectStops(value);
       const errors = validateObject({
           key: options.key,
           value: options.value,
@@ -20775,20 +20762,20 @@ ${ JSON.stringify(filterExp, null, 2) }
       if (functionType === 'identity' && isZoomFunction) {
           errors.push(new ValidationError(options.key, options.value, 'missing required property "property"'));
       }
-      if (functionType !== 'identity' && !options.value.stops) {
+      if (functionType !== 'identity' && !value.stops) {
           errors.push(new ValidationError(options.key, options.value, 'missing required property "stops"'));
       }
-      if (functionType === 'exponential' && options.valueSpec.expression && !supportsInterpolation(options.valueSpec)) {
+      if (functionType === 'exponential' && functionValueSpec.expression && !supportsInterpolation(functionValueSpec)) {
           errors.push(new ValidationError(options.key, options.value, 'exponential functions not supported'));
       }
       if (options.styleSpec.$version >= 8) {
-          if (isPropertyFunction && !supportsPropertyExpression(options.valueSpec)) {
+          if (isPropertyFunction && !supportsPropertyExpression(functionValueSpec)) {
               errors.push(new ValidationError(options.key, options.value, 'property functions not supported'));
-          } else if (isZoomFunction && !supportsZoomExpression(options.valueSpec)) {
+          } else if (isZoomFunction && !supportsZoomExpression(functionValueSpec)) {
               errors.push(new ValidationError(options.key, options.value, 'zoom functions not supported'));
           }
       }
-      if ((functionType === 'categorical' || isZoomAndPropertyFunction) && options.value.property === void 0) {
+      if ((functionType === 'categorical' || isZoomAndPropertyFunction) && value.property === void 0) {
           errors.push(new ValidationError(options.key, options.value, '"property" property is required'));
       }
       return errors;
@@ -20797,46 +20784,47 @@ ${ JSON.stringify(filterExp, null, 2) }
               return [new ValidationError(options2.key, options2.value, 'identity function may not have a "stops" property')];
           }
           let errors2 = [];
-          const value = options2.value;
+          const value2 = options2.value;
           errors2 = errors2.concat(validateArray({
               key: options2.key,
-              value,
+              value: value2,
               valueSpec: options2.valueSpec,
               style: options2.style,
               styleSpec: options2.styleSpec,
               arrayElementValidator: validateFunctionStop
           }));
-          if (getType(value) === 'array' && value.length === 0) {
-              errors2.push(new ValidationError(options2.key, value, 'array must have at least one stop'));
+          if (Array.isArray(value2) && value2.length === 0) {
+              errors2.push(new ValidationError(options2.key, value2, 'array must have at least one stop'));
           }
           return errors2;
       }
       function validateFunctionStop(options2) {
           let errors2 = [];
-          const value = options2.value;
-          const key = options2.key;
-          if (getType(value) !== 'array') {
-              return [new ValidationError(key, value, `array expected, ${ getType(value) } found`)];
+          const value2 = options2.value;
+          const key2 = options2.key;
+          if (!Array.isArray(value2)) {
+              return [new ValidationError(key2, value2, `array expected, ${ getType(value2) } found`)];
           }
-          if (value.length !== 2) {
-              return [new ValidationError(key, value, `array length 2 expected, length ${ value.length } found`)];
+          if (value2.length !== 2) {
+              return [new ValidationError(key2, value2, `array length 2 expected, length ${ value2.length } found`)];
           }
           if (isZoomAndPropertyFunction) {
-              if (getType(value[0]) !== 'object') {
-                  return [new ValidationError(key, value, `object expected, ${ getType(value[0]) } found`)];
+              if (!isObject(value2[0])) {
+                  return [new ValidationError(key2, value2, `object expected, ${ getType(value2[0]) } found`)];
               }
-              if (value[0].zoom === void 0) {
-                  return [new ValidationError(key, value, 'object stop key must have zoom')];
+              const stopKey = value2[0];
+              if (stopKey.zoom === void 0) {
+                  return [new ValidationError(key2, value2, 'object stop key must have zoom')];
               }
-              if (value[0].value === void 0) {
-                  return [new ValidationError(key, value, 'object stop key must have value')];
+              if (stopKey.value === void 0) {
+                  return [new ValidationError(key2, value2, 'object stop key must have value')];
               }
-              const nextStopDomainZoom = unbundle(value[0].zoom);
+              const nextStopDomainZoom = unbundle(stopKey.zoom);
               if (typeof nextStopDomainZoom !== 'number') {
-                  return [new ValidationError(key, value[0].zoom, 'stop zoom values must be numbers')];
+                  return [new ValidationError(key2, stopKey.zoom, 'stop zoom values must be numbers')];
               }
               if (previousStopDomainZoom && previousStopDomainZoom > nextStopDomainZoom) {
-                  return [new ValidationError(key, value[0].zoom, 'stop zoom values must appear in ascending order')];
+                  return [new ValidationError(key2, stopKey.zoom, 'stop zoom values must appear in ascending order')];
               }
               if (nextStopDomainZoom !== previousStopDomainZoom) {
                   previousStopDomainZoom = nextStopDomainZoom;
@@ -20844,8 +20832,8 @@ ${ JSON.stringify(filterExp, null, 2) }
                   stopDomainValues = {};
               }
               errors2 = errors2.concat(validateObject({
-                  key: `${ key }[0]`,
-                  value: value[0],
+                  key: `${ key2 }[0]`,
+                  value: value2[0],
                   valueSpec: { zoom: {} },
                   style: options2.style,
                   styleSpec: options2.styleSpec,
@@ -20856,18 +20844,18 @@ ${ JSON.stringify(filterExp, null, 2) }
               }));
           } else {
               errors2 = errors2.concat(validateStopDomainValue({
-                  key: `${ key }[0]`,
-                  value: value[0],
+                  key: `${ key2 }[0]`,
+                  value: value2[0],
                   style: options2.style,
                   styleSpec: options2.styleSpec
-              }, value));
+              }, value2));
           }
-          if (isExpression(deepUnbundle(value[1]))) {
-              return errors2.concat([new ValidationError(`${ key }[1]`, value[1], 'expressions are not allowed in function stops.')]);
+          if (isExpression(deepUnbundle(value2[1]))) {
+              return errors2.concat([new ValidationError(`${ key2 }[1]`, value2[1], 'expressions are not allowed in function stops.')]);
           }
           return errors2.concat(validate({
-              key: `${ key }[1]`,
-              value: value[1],
+              key: `${ key2 }[1]`,
+              value: value2[1],
               valueSpec: functionValueSpec,
               style: options2.style,
               styleSpec: options2.styleSpec
@@ -20875,14 +20863,14 @@ ${ JSON.stringify(filterExp, null, 2) }
       }
       function validateStopDomainValue(options2, stop) {
           const type = getType(options2.value);
-          const value = unbundle(options2.value);
+          const value2 = unbundle(options2.value);
           const reportValue = options2.value !== null ? options2.value : stop;
           if (!stopKeyType) {
               stopKeyType = type;
           } else if (type !== stopKeyType) {
               return [new ValidationError(options2.key, reportValue, `${ type } stop domain type must match previous stop domain type ${ stopKeyType }`)];
           }
-          if (type !== 'number' && type !== 'string' && type !== 'boolean' && typeof value !== 'number' && typeof value !== 'string' && typeof value !== 'boolean') {
+          if (type !== 'number' && type !== 'string' && type !== 'boolean' && typeof value2 !== 'number' && typeof value2 !== 'string' && typeof value2 !== 'boolean') {
               return [new ValidationError(options2.key, reportValue, 'stop domain value must be a number, string, or boolean')];
           }
           if (type !== 'number' && functionType !== 'categorical') {
@@ -20892,18 +20880,18 @@ ${ JSON.stringify(filterExp, null, 2) }
               }
               return [new ValidationError(options2.key, reportValue, message)];
           }
-          if (functionType === 'categorical' && type === 'number' && (typeof value !== 'number' || !isFinite(value) || Math.floor(value) !== value)) {
-              return [new ValidationError(options2.key, reportValue, `integer expected, found ${ String(value) }`)];
+          if (functionType === 'categorical' && type === 'number' && (typeof value2 !== 'number' || !isFinite(value2) || Math.floor(value2) !== value2)) {
+              return [new ValidationError(options2.key, reportValue, `integer expected, found ${ String(value2) }`)];
           }
-          if (functionType !== 'categorical' && type === 'number' && typeof value === 'number' && typeof previousStopDomainValue === 'number' && previousStopDomainValue !== void 0 && value < previousStopDomainValue) {
+          if (functionType !== 'categorical' && type === 'number' && typeof value2 === 'number' && typeof previousStopDomainValue === 'number' && previousStopDomainValue !== void 0 && value2 < previousStopDomainValue) {
               return [new ValidationError(options2.key, reportValue, 'stop domain values must appear in ascending order')];
           } else {
-              previousStopDomainValue = value;
+              previousStopDomainValue = value2;
           }
-          if (functionType === 'categorical' && value in stopDomainValues) {
+          if (functionType === 'categorical' && value2 in stopDomainValues) {
               return [new ValidationError(options2.key, reportValue, 'stop domain values must be unique')];
           } else {
-              stopDomainValues[value] = true;
+              stopDomainValues[value2] = true;
           }
           return [];
       }
@@ -20979,19 +20967,15 @@ ${ JSON.stringify(filterExp, null, 2) }
   function validateBoolean(options) {
       const value = options.value;
       const key = options.key;
-      const type = getType(value);
-      if (type !== 'boolean') {
-          return [new ValidationError(key, value, `boolean expected, ${ type } found`)];
+      if (!isBoolean(value)) {
+          return [new ValidationError(key, value, `boolean expected, ${ getType(value) } found`)];
       }
       return [];
   }
 
-  function validateColor(options) {
-      const key = options.key;
-      const value = options.value;
-      const type = getType(value);
-      if (type !== 'string') {
-          return [new ValidationError(key, value, `color expected, ${ type } found`)];
+  function validateColor({key, value}) {
+      if (!isString(value)) {
+          return [new ValidationError(key, value, `color expected, ${ getType(value) } found`)];
       }
       if (csscolorparserExports.parseCSSColor(value) === null) {
           return [new ValidationError(key, value, `color expected, "${ value }" found`)];
@@ -21030,22 +21014,18 @@ ${ JSON.stringify(filterExp, null, 2) }
   function validateNonExpressionFilter(options) {
       const value = options.value;
       const key = options.key;
-      if (getType(value) !== 'array') {
+      if (!Array.isArray(value)) {
           return [new ValidationError(key, value, `array expected, ${ getType(value) } found`)];
       }
-      const styleSpec = options.styleSpec;
-      let type;
-      let errors = [];
       if (value.length < 1) {
           return [new ValidationError(key, value, 'filter array must have at least 1 element')];
       }
-      errors = errors.concat(validateEnum({
+      const styleSpec = options.styleSpec;
+      let errors = validateEnum({
           key: `${ key }[0]`,
           value: value[0],
-          valueSpec: styleSpec.filter_operator,
-          style: options.style,
-          styleSpec: options.styleSpec
-      }));
+          valueSpec: styleSpec.filter_operator
+      });
       switch (unbundle(value[0])) {
       case '<':
       case '<=':
@@ -21066,23 +21046,19 @@ ${ JSON.stringify(filterExp, null, 2) }
       case 'in':
       case '!in':
           if (value.length >= 2) {
-              type = getType(value[1]);
-              if (type !== 'string') {
-                  errors.push(new ValidationError(`${ key }[1]`, value[1], `string expected, ${ type } found`));
+              if (!isString(value[1])) {
+                  errors.push(new ValidationError(`${ key }[1]`, value[1], `string expected, ${ getType(value[1]) } found`));
               }
           }
           for (let i = 2; i < value.length; i++) {
-              type = getType(value[i]);
               if (unbundle(value[1]) === '$type') {
                   errors = errors.concat(validateEnum({
                       key: `${ key }[${ i }]`,
                       value: value[i],
-                      valueSpec: styleSpec.geometry_type,
-                      style: options.style,
-                      styleSpec: options.styleSpec
+                      valueSpec: styleSpec.geometry_type
                   }));
-              } else if (type !== 'string' && type !== 'number' && type !== 'boolean') {
-                  errors.push(new ValidationError(`${ key }[${ i }]`, value[i], `string, number, or boolean expected, ${ type } found`));
+              } else if (!isString(value[i]) && !isNumber(value[i]) && !isBoolean(value[i])) {
+                  errors.push(new ValidationError(`${ key }[${ i }]`, value[i], `string, number, or boolean expected, ${ getType(value[i]) } found.`));
               }
           }
           break;
@@ -21100,11 +21076,10 @@ ${ JSON.stringify(filterExp, null, 2) }
           break;
       case 'has':
       case '!has':
-          type = getType(value[1]);
           if (value.length !== 2) {
               errors.push(new ValidationError(key, value, `filter array for "${ value[0] }" operator must have 2 elements`));
-          } else if (type !== 'string') {
-              errors.push(new ValidationError(`${ key }[1]`, value[1], `string expected, ${ type } found`));
+          } else if (!isString(value[1])) {
+              errors.push(new ValidationError(`${ key }[1]`, value[1], `string expected, ${ getType(value[1]) } found`));
           }
           break;
       }
@@ -21122,7 +21097,7 @@ ${ JSON.stringify(filterExp, null, 2) }
       if (!layerSpec)
           return [];
       const useThemeMatch = propertyKey.match(/^(.*)-use-theme$/);
-      if (propertyType === 'paint' && useThemeMatch && layerSpec[useThemeMatch[1]]) {
+      if (useThemeMatch && layerSpec[useThemeMatch[1]]) {
           if (isExpression(value)) {
               const errors2 = [];
               return errors2.concat(validate({
@@ -21169,7 +21144,7 @@ ${ JSON.stringify(filterExp, null, 2) }
           return [new ValidationWarning(key, value, `unknown property "${ propertyKey }"`)];
       }
       let tokenMatch;
-      if (getType(value) === 'string' && supportsPropertyExpression(valueSpec) && !valueSpec.tokens && (tokenMatch = /^{([^}]+)}$/.exec(value))) {
+      if (isString(value) && supportsPropertyExpression(valueSpec) && !valueSpec.tokens && (tokenMatch = /^{([^}]+)}$/.exec(value))) {
           const example = `\`{ "type": "identity", "property": ${ tokenMatch ? JSON.stringify(tokenMatch[1]) : '"_"' } }\``;
           return [new ValidationError(key, value, `"${ propertyKey }" does not support interpolation syntax
 Use an identity property function instead: ${ example }.`)];
@@ -21219,6 +21194,9 @@ Use an identity property function instead: ${ example }.`)];
       const key = options.key;
       const style = options.style;
       const styleSpec = options.styleSpec;
+      if (!isObject(layer)) {
+          return [new ValidationError(key, layer, `object expected`)];
+      }
       if (!layer.type && !layer.ref) {
           errors.push(new ValidationError(key, layer, 'either "type" or "ref" is required'));
       }
@@ -21229,7 +21207,7 @@ Use an identity property function instead: ${ example }.`)];
           for (let i = 0; i < options.arrayIndex; i++) {
               const otherLayer = style.layers[i];
               if (unbundle(otherLayer.id) === layerId) {
-                  errors.push(new ValidationError(key, layer.id, `duplicate layer id "${ layer.id }", previously used at line ${ otherLayer.id.__line__ }`));
+                  errors.push(new ValidationError(key, layer.id, `duplicate layer id "${ layerId }", previously used at line ${ otherLayer.id.__line__ }`));
               }
           }
       }
@@ -21261,6 +21239,8 @@ Use an identity property function instead: ${ example }.`)];
       } else if (!(type === 'background' || type === 'sky' || type === 'slot')) {
           if (!layer.source) {
               errors.push(new ValidationError(key, layer, 'missing required property "source"'));
+          } else if (!isString(layer.source)) {
+              errors.push(new ValidationError(`${ key }.source`, layer.source, '"source" must be a string'));
           } else {
               const source = style.sources && style.sources[layer.source];
               const sourceType = source && unbundle(source.type);
@@ -21350,14 +21330,11 @@ Use an identity property function instead: ${ example }.`)];
       return errors;
   }
 
-  function validateString(options) {
-      const value = options.value;
-      const key = options.key;
-      const type = getType(value);
-      if (type !== 'string') {
-          return [new ValidationError(key, value, `string expected, ${ type } found`)];
+  function validateString({key, value}) {
+      if (isString(value)) {
+          return [];
       }
-      return [];
+      return [new ValidationError(key, value, `string expected, ${ getType(value) } found`)];
   }
 
   const objectElementValidators = { promoteId: validatePromoteId };
@@ -21366,7 +21343,10 @@ Use an identity property function instead: ${ example }.`)];
       const key = options.key;
       const styleSpec = options.styleSpec;
       const style = options.style;
-      if (!value.type) {
+      if (!isObject(value)) {
+          return [new ValidationError(key, value, `object expected, ${ getType(value) } found`)];
+      }
+      if (!('type' in value)) {
           return [new ValidationError(key, value, '"type" is required')];
       }
       const type = unbundle(value.type);
@@ -21377,7 +21357,7 @@ Use an identity property function instead: ${ example }.`)];
               'raster-dem',
               'raster-array'
           ].includes(type)) {
-          if (!value.url && !value.tiles) {
+          if (!('url' in value) && !('tiles' in value)) {
               errors.push(new ValidationWarning(key, value, 'Either "url" or "tiles" is required.'));
           }
       }
@@ -21404,9 +21384,16 @@ Use an identity property function instead: ${ example }.`)];
               styleSpec,
               objectElementValidators
           });
-          if (value.cluster) {
+          if ('cluster' in value && 'clusterProperties' in value) {
+              if (!isObject(value.clusterProperties)) {
+                  return [new ValidationError(`${ key }.clusterProperties`, value, `object expected, ${ getType(value) } found`)];
+              }
               for (const prop in value.clusterProperties) {
-                  const [operator, mapExpr] = value.clusterProperties[prop];
+                  const propValue = value.clusterProperties[prop];
+                  if (!Array.isArray(propValue)) {
+                      return [new ValidationError(`${ key }.clusterProperties.${ prop }`, propValue, 'array expected')];
+                  }
+                  const [operator, mapExpr] = propValue;
                   const reduceExpr = typeof operator === 'string' ? [
                       operator,
                       ['accumulated'],
@@ -21463,18 +21450,19 @@ Use an identity property function instead: ${ example }.`)];
       }, []);
   }
   function validatePromoteId({key, value}) {
-      if (getType(value) === 'string') {
+      if (isString(value)) {
           return validateString({
               key,
               value
           });
-      } else if (Array.isArray(value)) {
-          const errors = [];
+      }
+      if (Array.isArray(value)) {
+          const errors2 = [];
           const unbundledValue = deepUnbundle(value);
           const expression = createExpression(unbundledValue);
           if (expression.result === 'error') {
               expression.value.forEach(err => {
-                  errors.push(new ValidationError(`${ key }${ err.key }`, null, `${ err.message }`));
+                  errors2.push(new ValidationError(`${ key }${ err.key }`, null, `${ err.message }`));
               });
           }
           const parsed = expression.value.expression;
@@ -21492,19 +21480,21 @@ Use an identity property function instead: ${ example }.`)];
               'raster-particle-speed'
           ]);
           if (!onlyFeatureDependent) {
-              errors.push(new ValidationError(`${ key }`, null, 'promoteId expression should be only feature dependent'));
+              errors2.push(new ValidationError(`${ key }`, null, 'promoteId expression should be only feature dependent'));
           }
-          return errors;
-      } else {
-          const errors = [];
-          for (const prop in value) {
-              errors.push(...validatePromoteId({
-                  key: `${ key }.${ prop }`,
-                  value: value[prop]
-              }));
-          }
-          return errors;
+          return errors2;
       }
+      if (!isObject(value)) {
+          return [new ValidationError(key, value, `string, expression or object expected, "${ getType(value) }" found`)];
+      }
+      const errors = [];
+      for (const prop in value) {
+          errors.push(...validatePromoteId({
+              key: `${ key }.${ prop }`,
+              value: value[prop]
+          }));
+      }
+      return errors;
   }
 
   function isValidUrl(str, allowRelativeUrls) {
@@ -21518,19 +21508,16 @@ Use an identity property function instead: ${ example }.`)];
   }
   function validateModel(options) {
       const url = options.value;
-      let errors = [];
       if (!url) {
-          return errors;
+          return [];
       }
-      const type = getType(url);
-      if (type !== 'string') {
-          errors = errors.concat([new ValidationError(options.key, url, `string expected, "${ type }" found`)]);
-          return errors;
+      if (!isString(url)) {
+          return [new ValidationError(options.key, url, `string expected, "${ getType(url) }" found`)];
       }
       if (!isValidUrl(url, true)) {
-          errors = errors.concat([new ValidationError(options.key, url, `invalid url "${ url }"`)]);
+          return [new ValidationError(options.key, url, `invalid url "${ url }"`)];
       }
-      return errors;
+      return [];
   }
 
   function validateLight(options) {
@@ -21538,14 +21525,13 @@ Use an identity property function instead: ${ example }.`)];
       const styleSpec = options.styleSpec;
       const lightSpec = styleSpec.light;
       const style = options.style;
-      let errors = [];
-      const rootType = getType(light);
       if (light === void 0) {
-          return errors;
-      } else if (rootType !== 'object') {
-          errors = errors.concat([new ValidationError('light', light, `object expected, ${ rootType } found`)]);
-          return errors;
+          return [];
+      }
+      if (!isObject(light)) {
+          return [new ValidationError('light', light, `object expected, ${ getType(light) } found`)];
       }
+      let errors = [];
       for (const key in light) {
           const transitionMatch = key.match(/^(.*)-transition$/);
           const useThemeMatch = key.match(/^(.*)-use-theme$/);
@@ -21582,30 +21568,32 @@ Use an identity property function instead: ${ example }.`)];
 
   function validateLights(options) {
       const light = options.value;
-      let errors = [];
       if (!light) {
-          return errors;
+          return [];
       }
-      const type = getType(light);
-      if (type !== 'object') {
-          errors = errors.concat([new ValidationError('light-3d', light, `object expected, ${ type } found`)]);
-          return errors;
+      const key = options.key;
+      if (!isObject(light)) {
+          return [new ValidationError(key, light, `object expected, ${ getType(light) } found`)];
       }
+      let errors = [];
       const styleSpec = options.styleSpec;
       const lightSpec = styleSpec['light-3d'];
-      const key = options.key;
       const style = options.style;
       const lights = options.style.lights;
-      for (const key2 of [
+      for (const prop of [
               'type',
               'id'
           ]) {
-          if (!(key2 in light)) {
-              errors = errors.concat([new ValidationError('light-3d', light, `missing property ${ key2 } on light`)]);
+          if (!(prop in light)) {
+              errors = errors.concat([new ValidationError(key, light, `missing property "${ prop }"`)]);
               return errors;
           }
       }
-      if (light.type && lights) {
+      if (!isString(light.type)) {
+          errors = errors.concat([new ValidationError(`${ key }.type`, light.type, `string expected`)]);
+          return errors;
+      }
+      if (lights) {
           for (let i = 0; i < options.arrayIndex; i++) {
               const lightType2 = unbundle(light.type);
               const otherLight = lights[i];
@@ -21614,18 +21602,17 @@ Use an identity property function instead: ${ example }.`)];
               }
           }
       }
-      const lightType = `properties_light_${ light['type'] }`;
+      const lightType = `properties_light_${ light.type }`;
       if (!(lightType in styleSpec)) {
-          errors = errors.concat([new ValidationError('light-3d', light, `Invalid light type ${ light['type'] }`)]);
+          errors = errors.concat([new ValidationError(`${ key }.type`, light, `Invalid light type ${ light.type }`)]);
           return errors;
       }
       const lightPropertySpec = styleSpec[lightType];
       for (const key2 in light) {
           if (key2 === 'properties') {
               const properties = light[key2];
-              const propertiesType = getType(properties);
-              if (propertiesType !== 'object') {
-                  errors = errors.concat([new ValidationError('properties', properties, `object expected, ${ propertiesType } found`)]);
+              if (!isObject(properties)) {
+                  errors = errors.concat([new ValidationError('properties', properties, `object expected, ${ getType(properties) } found`)]);
                   return errors;
               }
               for (const propertyKey in properties) {
@@ -21682,16 +21669,13 @@ Use an identity property function instead: ${ example }.`)];
       const style = options.style;
       const styleSpec = options.styleSpec;
       const terrainSpec = styleSpec.terrain;
-      let errors = [];
-      const rootType = getType(terrain);
-      if (terrain === void 0) {
-          return errors;
-      } else if (rootType === 'null') {
-          return errors;
-      } else if (rootType !== 'object') {
-          errors = errors.concat([new ValidationError('terrain', terrain, `object expected, ${ rootType } found`)]);
-          return errors;
+      if (terrain == null) {
+          return [];
+      }
+      if (!isObject(terrain)) {
+          return [new ValidationError('terrain', terrain, `object expected, ${ getType(terrain) } found`)];
       }
+      let errors = [];
       for (const key2 in terrain) {
           const transitionMatch = key2.match(/^(.*)-transition$/);
           const useThemeMatch = key2.match(/^(.*)-use-theme$/);
@@ -21725,13 +21709,15 @@ Use an identity property function instead: ${ example }.`)];
       }
       if (!terrain.source) {
           errors.push(new ValidationError(key, terrain, `terrain is missing required property "source"`));
+      } else if (!isString(terrain.source)) {
+          errors.push(new ValidationError(`${ key }.source`, terrain.source, `source must be a string`));
       } else {
           const source = style.sources && style.sources[terrain.source];
           const sourceType = source && unbundle(source.type);
           if (!source) {
-              errors.push(new ValidationError(key, terrain.source, `source "${ terrain.source }" not found`));
+              errors.push(new ValidationError(`${ key }.source`, terrain.source, `source "${ terrain.source }" not found`));
           } else if (sourceType !== 'raster-dem') {
-              errors.push(new ValidationError(key, terrain.source, `terrain cannot be used with a source of type ${ String(sourceType) }, it only be used with a "raster-dem" source type`));
+              errors.push(new ValidationError(`${ key }.source`, terrain.source, `terrain cannot be used with a source of type ${ sourceType }, it only be used with a "raster-dem" source type`));
           }
       }
       return errors;
@@ -21742,14 +21728,13 @@ Use an identity property function instead: ${ example }.`)];
       const style = options.style;
       const styleSpec = options.styleSpec;
       const fogSpec = styleSpec.fog;
-      let errors = [];
-      const rootType = getType(fog);
       if (fog === void 0) {
-          return errors;
-      } else if (rootType !== 'object') {
-          errors = errors.concat([new ValidationError('fog', fog, `object expected, ${ rootType } found`)]);
-          return errors;
+          return [];
+      }
+      if (!isObject(fog)) {
+          return [new ValidationError('fog', fog, `object expected, ${ getType(fog) } found`)];
       }
+      let errors = [];
       for (const key in fog) {
           const transitionMatch = key.match(/^(.*)-transition$/);
           const useThemeMatch = key.match(/^(.*)-use-theme$/);
@@ -21785,14 +21770,16 @@ Use an identity property function instead: ${ example }.`)];
   }
 
   function validateFormatted(options) {
-      if (validateString(options).length === 0) {
+      const errors = validateString(options);
+      if (errors.length === 0) {
           return [];
       }
       return validateExpression(options);
   }
 
   function validateImage(options) {
-      if (validateString(options).length === 0) {
+      const errors = validateString(options);
+      if (errors.length === 0) {
           return [];
       }
       return validateExpression(options);
@@ -21803,9 +21790,8 @@ Use an identity property function instead: ${ example }.`)];
       const styleSpec = options.styleSpec;
       const projectionSpec = styleSpec.projection;
       const style = options.style;
-      let errors = [];
-      const rootType = getType(projection);
-      if (rootType === 'object') {
+      if (isObject(projection)) {
+          let errors = [];
           for (const key in projection) {
               errors = errors.concat(validate({
                   key,
@@ -21815,17 +21801,25 @@ Use an identity property function instead: ${ example }.`)];
                   styleSpec
               }));
           }
-      } else if (rootType !== 'string') {
-          errors = errors.concat([new ValidationError('projection', projection, `object or string expected, ${ rootType } found`)]);
+          return errors;
       }
-      return errors;
+      if (!isString(projection)) {
+          return [new ValidationError('projection', projection, `object or string expected, ${ getType(projection) } found`)];
+      }
+      return [];
   }
 
+  function isSourceIconset(type, iconset) {
+      return !!(type === 'source' && iconset.source);
+  }
   function validateIconset(options) {
       const iconset = options.value;
       const key = options.key;
       const styleSpec = options.styleSpec;
       const style = options.style;
+      if (!isObject(iconset)) {
+          return [new ValidationError(key, iconset, 'object expected')];
+      }
       if (!iconset.type) {
           return [new ValidationError(key, iconset, '"type" is required')];
       }
@@ -21838,7 +21832,7 @@ Use an identity property function instead: ${ example }.`)];
           style,
           styleSpec
       }));
-      if (type === 'source' && iconset.source) {
+      if (isSourceIconset(type, iconset)) {
           const source = style.sources && style.sources[iconset.source];
           const sourceType = source && unbundle(source.type);
           if (!source) {
@@ -21878,49 +21872,98 @@ Use an identity property function instead: ${ example }.`)];
       const value = options.value;
       const valueSpec = options.valueSpec;
       const styleSpec = options.styleSpec;
-      if (valueSpec.expression && isFunction(unbundle(value))) {
-          return validateFunction(options);
-      } else if (valueSpec.expression && isExpression(deepUnbundle(value))) {
-          return validateExpression(options);
-      } else if (valueSpec.type && VALIDATORS[valueSpec.type]) {
-          const valid = VALIDATORS[valueSpec.type](options);
-          if (arrayAsExpression === true && valid.length > 0 && getType(options.value) === 'array') {
+      if (valueSpec.expression) {
+          if (isFunction(unbundle(value)))
+              return validateFunction(options);
+          if (isExpression(deepUnbundle(value)))
+              return validateExpression(options);
+      }
+      if (valueSpec.type && VALIDATORS[valueSpec.type]) {
+          const errors2 = VALIDATORS[valueSpec.type](options);
+          if (arrayAsExpression === true && errors2.length > 0 && Array.isArray(options.value)) {
               return validateExpression(options);
-          } else {
-              return valid;
           }
-      } else {
-          const valid = validateObject(extend({}, options, { valueSpec: valueSpec.type ? styleSpec[valueSpec.type] : valueSpec }));
-          return valid;
+          return errors2;
       }
+      const errors = validateObject(Object.assign({}, options, { valueSpec: valueSpec.type ? styleSpec[valueSpec.type] : valueSpec }));
+      return errors;
   }
 
-  function validateGlyphsURL (options) {
-      const value = options.value;
+  function validateObject(options) {
       const key = options.key;
-      const errors = validateString(options);
+      const object = options.value;
+      const elementSpecs = options.valueSpec || {};
+      const elementValidators = options.objectElementValidators || {};
+      const style = options.style;
+      const styleSpec = options.styleSpec;
+      if (!isObject(object)) {
+          return [new ValidationError(key, object, `object expected, ${ getType(object) } found`)];
+      }
+      let errors = [];
+      for (const objectKey in object) {
+          const elementSpecKey = objectKey.split('.')[0];
+          const elementSpec = elementSpecs[elementSpecKey] || elementSpecs['*'];
+          let validateElement;
+          if (elementValidators[elementSpecKey]) {
+              validateElement = elementValidators[elementSpecKey];
+          } else if (elementSpecs[elementSpecKey]) {
+              validateElement = validate;
+          } else if (elementValidators['*']) {
+              validateElement = elementValidators['*'];
+          } else if (elementSpecs['*']) {
+              validateElement = validate;
+          }
+          if (!validateElement) {
+              errors.push(new ValidationWarning(key, object[objectKey], `unknown property "${ objectKey }"`));
+              continue;
+          }
+          errors = errors.concat(validateElement({
+              key: (key ? `${ key }.` : key) + objectKey,
+              value: object[objectKey],
+              valueSpec: elementSpec,
+              style,
+              styleSpec,
+              object,
+              objectKey
+          }, object));
+      }
+      for (const elementSpecKey in elementSpecs) {
+          if (elementValidators[elementSpecKey]) {
+              continue;
+          }
+          if (elementSpecs[elementSpecKey].required && elementSpecs[elementSpecKey]['default'] === void 0 && object[elementSpecKey] === void 0) {
+              errors.push(new ValidationError(key, object, `missing required property "${ elementSpecKey }"`));
+          }
+      }
+      return errors;
+  }
+
+  function validateGlyphsUrl({key, value}) {
+      const errors = validateString({
+          key,
+          value
+      });
       if (errors.length)
           return errors;
-      if (value.indexOf('{fontstack}') === -1) {
+      const str = value;
+      if (str.indexOf('{fontstack}') === -1) {
           errors.push(new ValidationError(key, value, '"glyphs" url must include a "{fontstack}" token'));
       }
-      if (value.indexOf('{range}') === -1) {
+      if (str.indexOf('{range}') === -1) {
           errors.push(new ValidationError(key, value, '"glyphs" url must include a "{range}" token'));
       }
       return errors;
   }
 
   function validateStyle$2(style, styleSpec = v8, options = {}) {
-      const errors = validate({
+      const errors = validateObject({
           key: options.key || '',
           value: style,
-          valueSpec: styleSpec.$root,
+          valueSpec: Object.assign(styleSpec.$root, // Skip validation of the root properties that are not defined in the style spec (e.g. 'owner').
+          { '*': { type: '*' } }),
           styleSpec,
           style,
-          objectElementValidators: {
-              glyphs: validateGlyphsURL,
-              '*': () => []
-          }
+          objectElementValidators: { glyphs: validateGlyphsUrl }
       });
       return errors;
   }
@@ -23027,7 +23070,7 @@ Use an identity property function instead: ${ example }.`)];
   const SUPPORTED_SPEC_VERSION = 8;
   const MAX_SOURCES_IN_STYLE = 15;
   function isValid(value, regex) {
-      if (!value || getType(value) !== 'string')
+      if (!value || !isString(value))
           return true;
       return !!value.match(regex);
   }
@@ -23160,7 +23203,7 @@ Use an identity property function instead: ${ example }.`)];
       if (!isValid(style.visibility, visibilityPattern)) {
           errors.push(new ValidationError('visibility', style.visibility, 'Style visibility must be public or private'));
       }
-      if (style.protected !== void 0 && getType(style.protected) !== 'boolean') {
+      if (style.protected !== void 0 && !isBoolean(style.protected)) {
           errors.push(new ValidationError('protected', style.protected, 'Style protection must be true or false'));
       }
       return errors;