text: // @ts-nocheck
  
  'use strict';
  
  const _ = require('lodash');
  const declarationValueIndex = require('../../utils/declarationValueIndex');
  const getUnitFromValueNode = require('../../utils/getUnitFromValueNode');
  const matchesStringOrRegExp = require('../../utils/matchesStringOrRegExp');
  const report = require('../../utils/report');
  const ruleMessages = require('../../utils/ruleMessages');
  const validateOptions = require('../../utils/validateOptions');
  const valueParser = require('postcss-value-parser');
  const vendor = require('../../utils/vendor');
  
  const ruleName = 'declaration-property-unit-disallowed-list';
  
  const messages = ruleMessages(ruleName, {
  	rejected: (property, unit) => `Unexpected unit "${unit}" for property "${property}"`,
  });
  
  function rule(list) {
  	return (root, result) => {
  		const validOptions = validateOptions(result, ruleName, {
  			actual: list,
  			possible: [_.isObject],
  		});
  
  		if (!validOptions) {
  			return;
  		}
  
  		root.walkDecls((decl) => {
  			const prop = decl.prop;
  			const value = decl.value;
  
  			const unprefixedProp = vendor.unprefixed(prop);
  
  			const propList = _.find(list, (units, propIdentifier) =>
  				matchesStringOrRegExp(unprefixedProp, propIdentifier),
  			);
  
  			if (!propList) {
  				return;
  			}
  
  			valueParser(value).walk((node) => {
  				// Ignore wrong units within `url` function
  				if (node.type === 'function' && node.value.toLowerCase() === 'url') {
  					return false;
  				}
  
  				if (node.type === 'string') {
  					return;
  				}
  
  				const unit = getUnitFromValueNode(node);
  
  				if (!unit || (unit && !propList.includes(unit.toLowerCase()))) {
  					return;
  				}
  
  				report({
  					message: messages.rejected(prop, unit),
  					node: decl,
  					index: declarationValueIndex(decl) + node.sourceIndex,
  					result,
  					ruleName,
  				});
  			});
  		});
  	};
  }
  
  rule.ruleName = ruleName;
  rule.messages = messages;
  module.exports = rule;
  