cssstyle 5.3.7 → 6.0.0

package/lib/normalize.js

@@ -18,7 +18,7 @@ const font = require("./properties/font");
 const margin = require("./properties/margin");
 const padding = require("./properties/padding");
 
-/* constants */
+// Constants
 const BORDER_IMAGE = "border-image";
 const TOP = "top";
 const RIGHT = "right";
@@ -35,19 +35,14 @@ const TRBL_INDICES = {
   [LEFT]: 3
 };
 
-/* shorthands */
 const shorthandProperties = new Map([
   [background.property, background],
   [
     border.property,
     {
-      definition: border.definition,
+      descriptor: border.descriptor,
       parse: border.parse,
-      shorthandFor: new Map([
-        ...border.shorthandFor,
-        ...border.positionShorthandFor,
-        [BORDER_IMAGE, null]
-      ])
+      shorthandFor: new Map([...border.shorthandFor, ...border.positionShorthandFor, [BORDER_IMAGE, null]])
     }
   ],
   [borderWidth.property, borderWidth],
@@ -63,7 +58,6 @@ const shorthandProperties = new Map([
   ["padding", padding]
 ]);
 
-/* borders */
 const borderProperties = new Set([
   border.property,
   BORDER_IMAGE,
@@ -74,44 +68,78 @@ const borderProperties = new Set([
   ...borderBottom.shorthandFor.keys(),
   ...borderLeft.shorthandFor.keys()
 ]);
-const borderPositions = new Set([TOP, RIGHT, BOTTOM, LEFT]);
+
 const borderLines = new Set([WIDTH, STYLE, COLOR]);
 
+const borderPositions = new Set([TOP, RIGHT, BOTTOM, LEFT]);
+
+const borderCollectionConfig = {
+  [WIDTH]: {
+    shorthand: borderWidth.property,
+    generator: generateBorderLineShorthand
+  },
+  [STYLE]: {
+    shorthand: borderStyle.property,
+    generator: generateBorderLineShorthand
+  },
+  [COLOR]: {
+    shorthand: borderColor.property,
+    generator: generateBorderLineShorthand
+  },
+  [TOP]: {
+    shorthand: borderTop.property,
+    generator: generateBorderPositionShorthand
+  },
+  [RIGHT]: {
+    shorthand: borderRight.property,
+    generator: generateBorderPositionShorthand
+  },
+  [BOTTOM]: {
+    shorthand: borderBottom.property,
+    generator: generateBorderPositionShorthand
+  },
+  [LEFT]: {
+    shorthand: borderLeft.property,
+    generator: generateBorderPositionShorthand
+  }
+};
+
 /**
  * Ensures consistent object shape.
  *
  * @param {string} property - The property name.
  * @param {string} [value=""] - The property value.
  * @param {string} [priority=""] - The priority.
- * @returns {Object} The property item object.
+ * @returns {object} The property item object.
  */
-const createPropertyItem = (property, value = "", priority = "") => ({
-  property,
-  value,
-  priority
-});
+function createPropertyItem(property, value = "", priority = "") {
+  return {
+    property,
+    value,
+    priority
+  };
+}
 
 /**
  * Retrieves a property item from the map or creates a default one if it doesn't exist.
  *
  * @param {string} property - The name of the property.
  * @param {Map} properties - The map containing all properties.
- * @returns {Object} The property item containing name, value, and priority.
+ * @returns {object} The property item containing name, value, and priority.
  */
-const getPropertyItem = (property, properties) => {
+function getPropertyItem(property, properties) {
   const propertyItem = properties.get(property) ?? createPropertyItem(property);
   return propertyItem;
-};
+}
 
 /**
- * Calculates the value for a specific position (top, right, bottom, left)
- * based on the array of values provided for a shorthand property.
+ * Calculates the value for a specific position from shorthand values.
  *
  * @param {string[]} positionValues - The values extracted from the shorthand property.
  * @param {string} position - The specific position (top, right, bottom, left) to retrieve.
  * @returns {string} The calculated value for the position.
  */
-const getPositionValue = (positionValues, position) => {
+function getPositionValue(positionValues, position) {
   const [val1, val2, val3, val4] = positionValues;
   const index = TRBL_INDICES[position] ?? -1;
   // If a specific position (top, right, bottom, left) is requested.
@@ -174,24 +202,23 @@ const getPositionValue = (positionValues, position) => {
       return val1;
     }
   }
-};
+}
 
 /**
  * Replaces the background shorthand property based on individual longhand values.
  *
  * @param {string} property - The specific background longhand property being updated.
  * @param {Map} properties - The map of all properties.
- * @param {Object} opt - Parsing options including global object and configurations.
  * @returns {string} The constructed background shorthand string.
  */
-const replaceBackgroundShorthand = (property, properties, opt) => {
+function replaceBackgroundShorthand(property, properties) {
   const { value: propertyValue } = properties.get(property);
-  const parsedValue = background.shorthandFor.get(property).parse(propertyValue, opt);
+  const parsedValue = background.shorthandFor.get(property).parse(propertyValue);
   const values = splitValue(parsedValue, {
     delimiter: ","
   });
   const { value: shorthandValue } = properties.get(background.property);
-  const bgValues = background.parse(shorthandValue, opt);
+  const bgValues = background.parse(shorthandValue);
   const bgLength = bgValues.length;
   if (property === backgroundColor.property) {
     bgValues[bgLength - 1][property] = parsedValue[0];
@@ -216,7 +243,7 @@ const replaceBackgroundShorthand = (property, properties, opt) => {
     backgrounds.push(bg.join(" "));
   }
   return backgrounds.join(", ");
-};
+}
 
 /**
  * Checks if a property value matches the value within a border shorthand.
@@ -224,40 +251,29 @@ const replaceBackgroundShorthand = (property, properties, opt) => {
  * @param {string} property - The property to check.
  * @param {string} value - The value to compare.
  * @param {string} shorthandValue - The shorthand string to parse and compare against.
- * @param {Object} [opt={}] - Parsing options.
  * @returns {boolean} True if the value matches the shorthand's value.
  */
-const matchesBorderShorthandValue = (property, value, shorthandValue, opt = {}) => {
-  const { globalObject, options } = opt;
-  const obj = border.parse(shorthandValue, {
-    globalObject,
-    options
-  });
+function matchesBorderShorthandValue(property, value, shorthandValue) {
+  const obj = border.parse(shorthandValue);
   if (Object.hasOwn(obj, property)) {
     return value === obj[property];
   }
   return value === border.initialValues.get(property);
-};
+}
 
 /**
  * Replaces or updates a value within a border shorthand string.
  *
  * @param {string} value - The new value to insert.
  * @param {string} shorthandValue - The existing shorthand string.
- * @param {Object} [opt={}] - Parsing options.
  * @returns {string} The updated border shorthand string.
  */
-const replaceBorderShorthandValue = (value, shorthandValue, opt = {}) => {
-  const { globalObject, options } = opt;
+function replaceBorderShorthandValue(value, shorthandValue) {
   const borderFirstInitialKey = border.initialValues.keys().next().value;
   const borderFirstInitialValue = border.initialValues.get(borderFirstInitialKey);
-  const parseOpt = {
-    globalObject,
-    options
-  };
-  const valueObj = border.parse(value, parseOpt);
+  const valueObj = border.parse(value);
   const shorthandObj = shorthandValue
-    ? border.parse(shorthandValue, parseOpt)
+    ? border.parse(shorthandValue)
     : {
         [borderFirstInitialKey]: borderFirstInitialValue
       };
@@ -278,16 +294,13 @@ const replaceBorderShorthandValue = (value, shorthandValue, opt = {}) => {
       }
     } else {
       shorthandObj[key] = parsedValue;
-      if (
-        shorthandObj[borderFirstInitialKey] &&
-        shorthandObj[borderFirstInitialKey] === borderFirstInitialValue
-      ) {
+      if (shorthandObj[borderFirstInitialKey] && shorthandObj[borderFirstInitialKey] === borderFirstInitialValue) {
         delete shorthandObj[borderFirstInitialKey];
       }
     }
   }
   return Object.values(shorthandObj).join(" ");
-};
+}
 
 /**
  * Replaces a value at a specific position (top, right, bottom, left) within a position shorthand.
@@ -297,7 +310,7 @@ const replaceBorderShorthandValue = (value, shorthandValue, opt = {}) => {
  * @param {string} position - The position to update.
  * @returns {string} The updated shorthand string.
  */
-const replacePositionValue = (value, positionValues, position) => {
+function replacePositionValue(value, positionValues, position) {
   const index = TRBL_INDICES[position] ?? -1;
   let currentValues = positionValues;
   if (index !== -1) {
@@ -488,35 +501,21 @@ const replacePositionValue = (value, positionValues, position) => {
       return val1;
     }
   }
-};
+}
 
 /**
  * Handles border property preparation when the value is a string.
  *
- * @param {Object} params - The parameters object.
+ * @param {object} params - The parameters object.
  * @param {string} params.property - The property name.
  * @param {string} params.value - The property value.
  * @param {string} params.priority - The property priority.
  * @param {Map} params.properties - The map of properties.
- * @param {Object} params.parts - The split property name parts.
- * @param {Object} params.opt - Parsing options.
+ * @param {object} params.parts - The split property name parts.
  * @param {Map} params.borderItems - The map to store processed border items.
  */
-const prepareBorderStringValue = ({
-  property,
-  value,
-  priority,
-  properties,
-  parts,
-  opt,
-  borderItems
-}) => {
+function prepareBorderStringValue({ property, value, priority, properties, parts, borderItems }) {
   const { prop1, prop2, prop3 } = parts;
-  const { globalObject, options } = opt;
-  const parseOpt = {
-    globalObject,
-    options
-  };
   const shorthandItem = getPropertyItem(border.property, properties);
   const imageItem = getPropertyItem(BORDER_IMAGE, properties);
   // Handle longhand properties.
@@ -545,19 +544,13 @@ const prepareBorderStringValue = ({
         positionItem.value = "";
       }
     } else {
-      if (
-        shorthandItem.value &&
-        !matchesBorderShorthandValue(lineProperty, propertyValue, shorthandItem.value, parseOpt)
-      ) {
+      if (shorthandItem.value && !matchesBorderShorthandValue(lineProperty, propertyValue, shorthandItem.value)) {
         shorthandItem.value = "";
       }
       if (lineItem.value) {
         lineItem.value = replacePositionValue(propertyValue, splitValue(lineItem.value), prop2);
       }
-      if (
-        positionItem.value &&
-        !matchesBorderShorthandValue(lineProperty, propertyValue, positionItem.value, parseOpt)
-      ) {
+      if (positionItem.value && !matchesBorderShorthandValue(lineProperty, propertyValue, positionItem.value)) {
         positionItem.value = "";
       }
     }
@@ -598,28 +591,16 @@ const prepareBorderStringValue = ({
         lineColorItem.value = "";
       }
     } else {
-      if (
-        shorthandItem.value &&
-        !matchesBorderShorthandValue(property, propertyValue, shorthandItem.value, parseOpt)
-      ) {
+      if (shorthandItem.value && !matchesBorderShorthandValue(property, propertyValue, shorthandItem.value)) {
         shorthandItem.value = "";
       }
-      if (
-        lineWidthItem.value &&
-        isValidPropertyValue(lineWidthProperty, propertyValue, globalObject)
-      ) {
+      if (lineWidthItem.value && isValidPropertyValue(lineWidthProperty, propertyValue)) {
         lineWidthItem.value = propertyValue;
       }
-      if (
-        lineStyleItem.value &&
-        isValidPropertyValue(lineStyleProperty, propertyValue, globalObject)
-      ) {
+      if (lineStyleItem.value && isValidPropertyValue(lineStyleProperty, propertyValue)) {
         lineStyleItem.value = propertyValue;
       }
-      if (
-        lineColorItem.value &&
-        isValidPropertyValue(lineColorProperty, propertyValue, globalObject)
-      ) {
+      if (lineColorItem.value && isValidPropertyValue(lineColorProperty, propertyValue)) {
         lineColorItem.value = propertyValue;
       }
     }
@@ -656,11 +637,7 @@ const prepareBorderStringValue = ({
       const longhandProperty = `${prop1}-${position}-${prop2}`;
       const longhandItem = getPropertyItem(longhandProperty, properties);
       if (propertyValue) {
-        positionItem.value = replaceBorderShorthandValue(
-          propertyValue,
-          positionItem.value,
-          parseOpt
-        );
+        positionItem.value = replaceBorderShorthandValue(propertyValue, positionItem.value);
       } else {
         positionItem.value = "";
       }
@@ -700,26 +677,20 @@ const prepareBorderStringValue = ({
     borderItems.set(property, shorthandItem);
     borderItems.set(BORDER_IMAGE, imageItem);
   }
-};
+}
 
 /**
  * Handles border property preparation when the value is an array.
  *
- * @param {Object} params - The parameters object.
+ * @param {object} params - The parameters object.
  * @param {Array} params.value - The property value.
  * @param {string} params.priority - The property priority.
  * @param {Map} params.properties - The map of properties.
- * @param {Object} params.parts - The split property name parts.
- * @param {Object} params.opt - Parsing options.
+ * @param {object} params.parts - The split property name parts.
  * @param {Map} params.borderItems - The map to store processed border items.
  */
-const prepareBorderArrayValue = ({ value, priority, properties, parts, opt, borderItems }) => {
+function prepareBorderArrayValue({ value, priority, properties, parts, borderItems }) {
   const { prop1, prop2 } = parts;
-  const { globalObject, options } = opt;
-  const parseOpt = {
-    globalObject,
-    options
-  };
   if (!value.length || !borderLines.has(prop2)) {
     return;
   }
@@ -733,11 +704,7 @@ const prepareBorderArrayValue = ({ value, priority, properties, parts, opt, bord
       if (hasVarFunc(shorthandItem.value)) {
         shorthandItem.value = "";
       } else if (propertyValue) {
-        shorthandItem.value = replaceBorderShorthandValue(
-          propertyValue,
-          shorthandItem.value,
-          parseOpt
-        );
+        shorthandItem.value = replaceBorderShorthandValue(propertyValue, shorthandItem.value);
       }
     }
   } else {
@@ -781,11 +748,7 @@ const prepareBorderArrayValue = ({ value, priority, properties, parts, opt, bord
     const positionProperty = `${prop1}-${position}`;
     const positionItem = getPropertyItem(positionProperty, properties);
     if (positionItem.value && positionValues[position]) {
-      positionItem.value = replaceBorderShorthandValue(
-        positionValues[position],
-        positionItem.value,
-        parseOpt
-      );
+      positionItem.value = replaceBorderShorthandValue(positionValues[position], positionItem.value);
     }
     const longhandProperty = `${positionProperty}-${prop2}`;
     const longhandItem = getPropertyItem(longhandProperty, properties);
@@ -797,35 +760,21 @@ const prepareBorderArrayValue = ({ value, priority, properties, parts, opt, bord
   borderItems.set(border.property, shorthandItem);
   borderItems.set(BORDER_IMAGE, imageItem);
   borderItems.set(lineProperty, lineItem);
-};
+}
 
 /**
  * Handles border property preparation when the value is an object.
  *
- * @param {Object} params - The parameters object.
+ * @param {object} params - The parameters object.
  * @param {string} params.property - The property name.
- * @param {Object} params.value - The property value.
+ * @param {object} params.value - The property value.
  * @param {string} params.priority - The property priority.
  * @param {Map} params.properties - The map of properties.
- * @param {Object} params.parts - The split property name parts.
- * @param {Object} params.opt - Parsing options.
+ * @param {object} params.parts - The split property name parts.
  * @param {Map} params.borderItems - The map to store processed border items.
  */
-const prepareBorderObjectValue = ({
-  property,
-  value,
-  priority,
-  properties,
-  parts,
-  opt,
-  borderItems
-}) => {
+function prepareBorderObjectValue({ property, value, priority, properties, parts, borderItems }) {
   const { prop1, prop2 } = parts;
-  const { globalObject, options } = opt;
-  const parseOpt = {
-    globalObject,
-    options
-  };
   const imageItem = getPropertyItem(BORDER_IMAGE, properties);
   // Handle position shorthands.
   if (prop2) {
@@ -843,7 +792,7 @@ const prepareBorderObjectValue = ({
     const positionItem = getPropertyItem(positionProperty, properties);
     if (shorthandItem.value) {
       for (const positionValue of Object.values(value)) {
-        if (!matchesBorderShorthandValue(property, positionValue, shorthandItem.value, parseOpt)) {
+        if (!matchesBorderShorthandValue(property, positionValue, shorthandItem.value)) {
           shorthandItem.value = "";
           break;
         }
@@ -858,23 +807,11 @@ const prepareBorderObjectValue = ({
         ? value[longhandProperty]
         : border.initialValues.get(`${prop1}-${line}`);
       if (line === WIDTH && lineWidthItem.value) {
-        lineWidthItem.value = replacePositionValue(
-          itemValue,
-          splitValue(lineWidthItem.value),
-          prop2
-        );
+        lineWidthItem.value = replacePositionValue(itemValue, splitValue(lineWidthItem.value), prop2);
       } else if (line === STYLE && lineStyleItem.value) {
-        lineStyleItem.value = replacePositionValue(
-          itemValue,
-          splitValue(lineStyleItem.value),
-          prop2
-        );
+        lineStyleItem.value = replacePositionValue(itemValue, splitValue(lineStyleItem.value), prop2);
       } else if (line === COLOR && lineColorItem.value) {
-        lineColorItem.value = replacePositionValue(
-          itemValue,
-          splitValue(lineColorItem.value),
-          prop2
-        );
+        lineColorItem.value = replacePositionValue(itemValue, splitValue(lineColorItem.value), prop2);
       }
       longhandItem.value = itemValue;
       longhandItem.priority = priority;
@@ -942,19 +879,18 @@ const prepareBorderObjectValue = ({
     borderItems.set(lineStyleProperty, lineStyleItem);
     borderItems.set(lineColorProperty, lineColorItem);
   }
-};
+}
 
 /**
  * Prepares border properties by splitting shorthands and handling updates.
  *
  * @param {string} property - The border property name.
- * @param {string|Array|Object} value - The value of the property.
+ * @param {string|Array|object} value - The value of the property.
  * @param {string} priority - The priority of the property (e.g., "important").
  * @param {Map} properties - The map of all properties.
- * @param {Object} [opt={}] - Parsing options.
  * @returns {Map|undefined} A map of expanded or updated border properties.
  */
-const prepareBorderProperties = (property, value, priority, properties, opt = {}) => {
+function prepareBorderProperties(property, value, priority, properties) {
   if (typeof property !== "string" || value === null) {
     return;
   }
@@ -977,10 +913,7 @@ const prepareBorderProperties = (property, value, priority, properties, opt = {}
       prop2 = remainder;
     }
   }
-  if (
-    (borderPositions.has(prop2) && prop3 && !borderLines.has(prop3)) ||
-    (borderLines.has(prop2) && prop3)
-  ) {
+  if ((borderPositions.has(prop2) && prop3 && !borderLines.has(prop3)) || (borderLines.has(prop2) && prop3)) {
     return;
   }
   const parts = {
@@ -996,7 +929,6 @@ const prepareBorderProperties = (property, value, priority, properties, opt = {}
       priority,
       properties,
       parts,
-      opt,
       borderItems
     });
   } else if (Array.isArray(value)) {
@@ -1005,7 +937,6 @@ const prepareBorderProperties = (property, value, priority, properties, opt = {}
       priority,
       properties,
       parts,
-      opt,
       borderItems
     });
   } else if (value && typeof value === "object") {
@@ -1015,7 +946,6 @@ const prepareBorderProperties = (property, value, priority, properties, opt = {}
       priority,
       properties,
       parts,
-      opt,
       borderItems
     });
   }
@@ -1030,20 +960,18 @@ const prepareBorderProperties = (property, value, priority, properties, opt = {}
   }
   for (const position of borderPositions) {
     const positionProperty = `${border.property}-${position}`;
-    const positionItem =
-      borderItems.get(positionProperty) ?? getPropertyItem(positionProperty, properties);
+    const positionItem = borderItems.get(positionProperty) ?? getPropertyItem(positionProperty, properties);
     borderProps.set(positionProperty, positionItem);
     for (const line of borderLines) {
       const longhandProperty = `${border.property}-${position}-${line}`;
-      const longhandItem =
-        borderItems.get(longhandProperty) ?? getPropertyItem(longhandProperty, properties);
+      const longhandItem = borderItems.get(longhandProperty) ?? getPropertyItem(longhandProperty, properties);
       borderProps.set(longhandProperty, longhandItem);
     }
   }
   const borderImageItem = borderItems.get(BORDER_IMAGE) ?? createPropertyItem(BORDER_IMAGE);
   borderProps.set(BORDER_IMAGE, borderImageItem);
   return borderProps;
-};
+}
 
 /**
  * Generates a border line shorthand property if all line components are present.
@@ -1053,7 +981,7 @@ const prepareBorderProperties = (property, value, priority, properties, opt = {}
  * @param {string} [priority=""] - The priority of the property.
  * @returns {Array} A key-value pair for the generated property.
  */
-const generateBorderLineShorthand = (items, property, priority = "") => {
+function generateBorderLineShorthand(items, property, priority = "") {
   const values = [];
   for (const [, item] of items) {
     const { value: itemValue } = item;
@@ -1061,7 +989,7 @@ const generateBorderLineShorthand = (items, property, priority = "") => {
   }
   const value = getPositionValue(values);
   return [property, createPropertyItem(property, value, priority)];
-};
+}
 
 /**
  * Generates a border position shorthand property if all position components are present.
@@ -1071,7 +999,7 @@ const generateBorderLineShorthand = (items, property, priority = "") => {
  * @param {string} [priority=""] - The priority of the property.
  * @returns {Array} A key-value pair for the generated property.
  */
-const generateBorderPositionShorthand = (items, property, priority = "") => {
+function generateBorderPositionShorthand(items, property, priority = "") {
   const values = [];
   for (const [, item] of items) {
     const { value: itemValue } = item;
@@ -1079,7 +1007,7 @@ const generateBorderPositionShorthand = (items, property, priority = "") => {
   }
   const value = values.join(" ");
   return [property, createPropertyItem(property, value, priority)];
-};
+}
 
 /**
  * Generates a border shorthand property if all components match.
@@ -1089,44 +1017,13 @@ const generateBorderPositionShorthand = (items, property, priority = "") => {
  * @param {string} [priority=""] - The priority of the property.
  * @returns {Array|undefined} A key-value pair for the generated property or undefined.
  */
-const generateBorderShorthand = (items, property, priority = "") => {
+function generateBorderShorthand(items, property, priority = "") {
   const values = new Set(items);
   if (values.size === 1) {
-    const value = values.keys().next().value;
+    const { value } = values.keys().next();
     return [property, createPropertyItem(property, value, priority)];
   }
-};
-
-const borderCollectionConfig = {
-  [WIDTH]: {
-    shorthand: borderWidth.property,
-    generator: generateBorderLineShorthand
-  },
-  [STYLE]: {
-    shorthand: borderStyle.property,
-    generator: generateBorderLineShorthand
-  },
-  [COLOR]: {
-    shorthand: borderColor.property,
-    generator: generateBorderLineShorthand
-  },
-  [TOP]: {
-    shorthand: borderTop.property,
-    generator: generateBorderPositionShorthand
-  },
-  [RIGHT]: {
-    shorthand: borderRight.property,
-    generator: generateBorderPositionShorthand
-  },
-  [BOTTOM]: {
-    shorthand: borderBottom.property,
-    generator: generateBorderPositionShorthand
-  },
-  [LEFT]: {
-    shorthand: borderLeft.property,
-    generator: generateBorderPositionShorthand
-  }
-};
+}
 
 /**
  * Processes and consolidates border-related longhands into shorthands where possible.
@@ -1134,7 +1031,7 @@ const borderCollectionConfig = {
  * @param {Map} properties - The map of current properties.
  * @returns {Map} The updated map with consolidated border properties.
  */
-const prepareBorderShorthands = (properties) => {
+function prepareBorderShorthands(properties) {
   const borderCollections = {};
   for (const key of Object.keys(borderCollectionConfig)) {
     borderCollections[key] = {
@@ -1215,8 +1112,7 @@ const prepareBorderShorthands = (properties) => {
       properties.set(BORDER_IMAGE, imageItem);
     }
   } else if (shorthandPriorityItems.length === 4) {
-    const [property, item] =
-      generateBorderShorthand(shorthandPriorityItems, border.property, "important") ?? [];
+    const [property, item] = generateBorderShorthand(shorthandPriorityItems, border.property, "important") ?? [];
     if (property && item) {
       properties.set(property, item);
       properties.delete(BORDER_IMAGE);
@@ -1256,7 +1152,7 @@ const prepareBorderShorthands = (properties) => {
     properties.set(BORDER_IMAGE, imageItem);
   }
   return properties;
-};
+}
 
 /**
  * Processes shorthand properties from the shorthands map.
@@ -1264,7 +1160,7 @@ const prepareBorderShorthands = (properties) => {
  * @param {Map} shorthands - The map containing shorthand property groups.
  * @returns {Map} A map of processed shorthand properties.
  */
-const processShorthandProperties = (shorthands) => {
+function processShorthandProperties(shorthands) {
   const shorthandItems = new Map();
   for (const [property, item] of shorthands) {
     const shorthandItem = shorthandProperties.get(property);
@@ -1282,7 +1178,7 @@ const processShorthandProperties = (shorthands) => {
     }
   }
   return shorthandItems;
-};
+}
 
 /**
  * Updates the longhand properties map with a new property item.
@@ -1290,10 +1186,10 @@ const processShorthandProperties = (shorthands) => {
  * If the existing property has "important" priority, it will not be overwritten.
  *
  * @param {string} property - The CSS property name.
- * @param {Object} item - The property item object containing value and priority.
+ * @param {object} item - The property item object containing value and priority.
  * @param {Map} longhandProperties - The map of longhand properties to update.
  */
-const updateLonghandProperties = (property, item, longhandProperties) => {
+function updateLonghandProperties(property, item, longhandProperties) {
   if (longhandProperties.has(property)) {
     const { priority: longhandPriority } = longhandProperties.get(property);
     if (!longhandPriority) {
@@ -1303,22 +1199,21 @@ const updateLonghandProperties = (property, item, longhandProperties) => {
   } else {
     longhandProperties.set(property, item);
   }
-};
+}
 
 /**
  * Processes border properties from the borders map, expanding and normalizing them.
  *
  * @param {Map} borders - The map containing accumulated border properties.
- * @param {Object} parseOpt - Options for parsing values.
  * @returns {Map} A map of fully processed and normalized border properties.
  */
-const processBorderProperties = (borders, parseOpt) => {
+function processBorderProperties(borders) {
   const longhandProperties = new Map();
   for (const [property, item] of borders) {
     if (shorthandProperties.has(property)) {
       const { value, priority } = item;
       if (property === border.property) {
-        const lineItems = border.parse(value, parseOpt);
+        const lineItems = border.parse(value);
         for (const [key, initialValue] of border.initialValues) {
           if (!Object.hasOwn(lineItems, key)) {
             lineItems[key] = initialValue;
@@ -1348,7 +1243,7 @@ const processBorderProperties = (borders, parseOpt) => {
         }
       } else {
         const shorthandItem = shorthandProperties.get(property);
-        const parsedItem = shorthandItem.parse(value, parseOpt);
+        const parsedItem = shorthandItem.parse(value);
         if (Array.isArray(parsedItem)) {
           let namePart, linePart;
           const hyphenIndex = property.indexOf("-");
@@ -1389,21 +1284,15 @@ const processBorderProperties = (borders, parseOpt) => {
   }
   const borderItems = prepareBorderShorthands(longhandProperties);
   return borderItems;
-};
+}
 
 /**
  * Normalize and prepare CSS properties, handling shorthands and longhands.
  *
  * @param {Map} properties - The initial map of properties.
- * @param {Object} [opt={}] - Parsing options.
  * @returns {Map} The normalized map of properties.
  */
-const prepareProperties = (properties, opt = {}) => {
-  const { globalObject, options } = opt;
-  const parseOpt = {
-    globalObject,
-    options
-  };
+function prepareProperties(properties) {
   const parsedProperties = new Map();
   const shorthands = new Map();
   const borders = new Map();
@@ -1434,7 +1323,7 @@ const prepareProperties = (properties, opt = {}) => {
       parsedProperties.set(property, item);
     } else if (shorthandProperties.has(property)) {
       const shorthandItem = shorthandProperties.get(property);
-      const parsedValues = shorthandItem.parse(value, parseOpt);
+      const parsedValues = shorthandItem.parse(value);
       let omitShorthandProperty = false;
       if (Array.isArray(parsedValues)) {
         const [parsedValue] = parsedValues;
@@ -1449,27 +1338,18 @@ const prepareProperties = (properties, opt = {}) => {
             }
             const { position } = longhandItem;
             const longhandValue = getPositionValue([parsedValue], position);
-            parsedProperties.set(
-              longhandProperty,
-              createPropertyItem(longhandProperty, longhandValue, priority)
-            );
+            parsedProperties.set(longhandProperty, createPropertyItem(longhandProperty, longhandValue, priority));
           }
         } else if (parsedValue) {
           for (const longhandProperty of Object.keys(parsedValue)) {
             const longhandValue = parsedValue[longhandProperty];
-            parsedProperties.set(
-              longhandProperty,
-              createPropertyItem(longhandProperty, longhandValue, priority)
-            );
+            parsedProperties.set(longhandProperty, createPropertyItem(longhandProperty, longhandValue, priority));
           }
         }
       } else if (parsedValues && typeof parsedValues !== "string") {
         for (const longhandProperty of Object.keys(parsedValues)) {
           const longhandValue = parsedValues[longhandProperty];
-          parsedProperties.set(
-            longhandProperty,
-            createPropertyItem(longhandProperty, longhandValue, priority)
-          );
+          parsedProperties.set(longhandProperty, createPropertyItem(longhandProperty, longhandValue, priority));
         }
       }
       if (!omitShorthandProperty) {
@@ -1481,15 +1361,9 @@ const prepareProperties = (properties, opt = {}) => {
     } else {
       parsedProperties.set(property, createPropertyItem(property, value, priority));
       if (hasPrecedingBackground) {
-        const { value: shorthandValue, priority: shorthandPriority } = properties.get(
-          background.property
-        );
+        const { value: shorthandValue, priority: shorthandPriority } = properties.get(background.property);
         if ((!shorthandPriority || priority) && !hasVarFunc(shorthandValue)) {
-          const replacedShorthandValue = replaceBackgroundShorthand(
-            property,
-            parsedProperties,
-            parseOpt
-          );
+          const replacedShorthandValue = replaceBackgroundShorthand(property, parsedProperties);
           properties.delete(background.property);
           properties.set(
             background.property,
@@ -1506,13 +1380,13 @@ const prepareProperties = (properties, opt = {}) => {
     }
   }
   if (borders.size) {
-    const borderItems = processBorderProperties(borders, parseOpt);
+    const borderItems = processBorderProperties(borders);
     for (const [property, item] of borderItems) {
       parsedProperties.set(property, item);
     }
   }
   return parsedProperties;
-};
+}
 
 /**
  * Cleans up redundancy in border properties by removing longhands that are covered by shorthands.
@@ -1520,7 +1394,7 @@ const prepareProperties = (properties, opt = {}) => {
  * @param {Map} properties - The map of properties to normalize.
  * @returns {Map} The normalized properties map.
  */
-const normalizeProperties = (properties) => {
+function normalizeProperties(properties) {
   if (properties.has(border.property)) {
     for (const line of borderLines) {
       properties.delete(`${border.property}-${line}`);
@@ -1562,7 +1436,7 @@ const normalizeProperties = (properties) => {
     }
   }
   return properties;
-};
+}
 
 module.exports = {
   borderProperties,