cssstyle 5.3.6 → 6.0.0

package/lib/normalize.js

@@ -3,6 +3,8 @@
 const propertyDefinitions = require("./generated/propertyDefinitions");
 const { hasVarFunc, isGlobalKeyword, isValidPropertyValue, splitValue } = require("./parsers");
 const background = require("./properties/background");
+const backgroundColor = require("./properties/backgroundColor");
+const backgroundSize = require("./properties/backgroundSize");
 const border = require("./properties/border");
 const borderWidth = require("./properties/borderWidth");
 const borderStyle = require("./properties/borderStyle");
@@ -16,19 +18,8 @@ const font = require("./properties/font");
 const margin = require("./properties/margin");
 const padding = require("./properties/padding");
 
-/* constants */
-const BACKGROUND = "background";
-const BACKGROUND_COLOR = "background-color";
-const BACKGROUND_SIZE = "background-size";
-const BORDER = "border";
-const BORDER_BOTTOM = "border-bottom";
-const BORDER_COLOR = "border-color";
+// Constants
 const BORDER_IMAGE = "border-image";
-const BORDER_LEFT = "border-left";
-const BORDER_RIGHT = "border-right";
-const BORDER_STYLE = "border-style";
-const BORDER_TOP = "border-top";
-const BORDER_WIDTH = "border-width";
 const TOP = "top";
 const RIGHT = "right";
 const BOTTOM = "bottom";
@@ -44,37 +35,31 @@ const TRBL_INDICES = {
   [LEFT]: 3
 };
 
-/* shorthands */
 const shorthandProperties = new Map([
-  [BACKGROUND, background],
+  [background.property, background],
   [
-    BORDER,
+    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]])
     }
   ],
-  [BORDER_WIDTH, borderWidth],
-  [BORDER_STYLE, borderStyle],
-  [BORDER_COLOR, borderColor],
-  [BORDER_TOP, borderTop],
-  [BORDER_RIGHT, borderRight],
-  [BORDER_BOTTOM, borderBottom],
-  [BORDER_LEFT, borderLeft],
+  [borderWidth.property, borderWidth],
+  [borderStyle.property, borderStyle],
+  [borderColor.property, borderColor],
+  [borderTop.property, borderTop],
+  [borderRight.property, borderRight],
+  [borderBottom.property, borderBottom],
+  [borderLeft.property, borderLeft],
   ["flex", flex],
   ["font", font],
   ["margin", margin],
   ["padding", padding]
 ]);
 
-/* borders */
 const borderProperties = new Set([
-  BORDER,
+  border.property,
   BORDER_IMAGE,
   ...border.shorthandFor.keys(),
   ...border.positionShorthandFor.keys(),
@@ -83,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.
@@ -183,26 +202,25 @@ 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);
-  const bgValues = background.parse(shorthandValue, opt);
+  const { value: shorthandValue } = properties.get(background.property);
+  const bgValues = background.parse(shorthandValue);
   const bgLength = bgValues.length;
-  if (property === BACKGROUND_COLOR) {
+  if (property === backgroundColor.property) {
     bgValues[bgLength - 1][property] = parsedValue[0];
   } else {
     for (let i = 0; i < bgLength; i++) {
@@ -216,7 +234,7 @@ const replaceBackgroundShorthand = (property, properties, opt) => {
       if (!value || value === background.initialValues.get(longhand)) {
         continue;
       }
-      if (longhand === BACKGROUND_SIZE) {
+      if (longhand === backgroundSize.property) {
         bg.push(`/ ${value}`);
       } else {
         bg.push(value);
@@ -225,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.
@@ -233,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
       };
@@ -287,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.
@@ -306,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) {
@@ -497,36 +501,22 @@ 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, properties);
+  const shorthandItem = getPropertyItem(border.property, properties);
   const imageItem = getPropertyItem(BORDER_IMAGE, properties);
   // Handle longhand properties.
   if (prop3) {
@@ -554,23 +544,17 @@ 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 = "";
       }
     }
-    borderItems.set(BORDER, shorthandItem);
+    borderItems.set(border.property, shorthandItem);
     borderItems.set(BORDER_IMAGE, imageItem);
     borderItems.set(lineProperty, lineItem);
     borderItems.set(positionProperty, positionItem);
@@ -607,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;
       }
     }
@@ -639,7 +611,7 @@ const prepareBorderStringValue = ({
       longhandItem.priority = priority;
       borderItems.set(longhandProperty, longhandItem);
     }
-    borderItems.set(BORDER, shorthandItem);
+    borderItems.set(border.property, shorthandItem);
     borderItems.set(BORDER_IMAGE, imageItem);
     borderItems.set(lineWidthProperty, lineWidthItem);
     borderItems.set(lineStyleProperty, lineStyleItem);
@@ -665,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 = "";
       }
@@ -678,7 +646,7 @@ const prepareBorderStringValue = ({
       borderItems.set(positionProperty, positionItem);
       borderItems.set(longhandProperty, longhandItem);
     }
-    borderItems.set(BORDER, shorthandItem);
+    borderItems.set(border.property, shorthandItem);
     borderItems.set(BORDER_IMAGE, imageItem);
     borderItems.set(lineProperty, lineItem);
     // Handle border shorthand.
@@ -709,30 +677,24 @@ 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;
   }
-  const shorthandItem = getPropertyItem(BORDER, properties);
+  const shorthandItem = getPropertyItem(border.property, properties);
   const imageItem = getPropertyItem(BORDER_IMAGE, properties);
   const lineProperty = `${prop1}-${prop2}`;
   const lineItem = getPropertyItem(lineProperty, properties);
@@ -742,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 {
@@ -790,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);
@@ -803,45 +757,31 @@ const prepareBorderArrayValue = ({ value, priority, properties, parts, opt, bord
     borderItems.set(positionProperty, positionItem);
     borderItems.set(longhandProperty, longhandItem);
   }
-  borderItems.set(BORDER, shorthandItem);
+  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) {
     if (!borderPositions.has(prop2)) {
       return;
     }
-    const shorthandItem = getPropertyItem(BORDER, properties);
+    const shorthandItem = getPropertyItem(border.property, properties);
     const lineWidthProperty = `${prop1}-width`;
     const lineWidthItem = getPropertyItem(lineWidthProperty, properties);
     const lineStyleProperty = `${prop1}-style`;
@@ -852,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;
         }
@@ -867,29 +807,17 @@ 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;
       borderItems.set(longhandProperty, longhandItem);
     }
-    borderItems.set(BORDER, shorthandItem);
+    borderItems.set(border.property, shorthandItem);
     borderItems.set(BORDER_IMAGE, imageItem);
     borderItems.set(lineWidthProperty, lineWidthItem);
     borderItems.set(lineStyleProperty, lineStyleItem);
@@ -951,33 +879,32 @@ 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;
   }
-  if (!property.startsWith(BORDER)) {
+  if (!property.startsWith(border.property)) {
     return;
   }
   let prop2, prop3;
-  if (property.length > BORDER.length) {
+  if (property.length > border.property.length) {
     // Check if next char is '-'
-    if (property.charCodeAt(BORDER.length) !== 45) {
+    if (property.charCodeAt(border.property.length) !== 45) {
       return;
     }
     // property is like "border-..."
-    const remainder = property.substring(BORDER.length + 1);
+    const remainder = property.substring(border.property.length + 1);
     const hyphenIndex = remainder.indexOf("-");
     if (hyphenIndex !== -1) {
       prop2 = remainder.substring(0, hyphenIndex);
@@ -986,14 +913,11 @@ 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 = {
-    prop1: BORDER,
+    prop1: border.property,
     prop2,
     prop3
   };
@@ -1005,7 +929,6 @@ const prepareBorderProperties = (property, value, priority, properties, opt = {}
       priority,
       properties,
       parts,
-      opt,
       borderItems
     });
   } else if (Array.isArray(value)) {
@@ -1014,7 +937,6 @@ const prepareBorderProperties = (property, value, priority, properties, opt = {}
       priority,
       properties,
       parts,
-      opt,
       borderItems
     });
   } else if (value && typeof value === "object") {
@@ -1024,35 +946,32 @@ const prepareBorderProperties = (property, value, priority, properties, opt = {}
       priority,
       properties,
       parts,
-      opt,
       borderItems
     });
   }
-  if (!borderItems.has(BORDER)) {
+  if (!borderItems.has(border.property)) {
     return;
   }
-  const borderProps = new Map([[BORDER, borderItems.get(BORDER)]]);
+  const borderProps = new Map([[border.property, borderItems.get(border.property)]]);
   for (const line of borderLines) {
-    const lineProperty = `${BORDER}-${line}`;
+    const lineProperty = `${border.property}-${line}`;
     const lineItem = borderItems.get(lineProperty) ?? getPropertyItem(lineProperty, properties);
     borderProps.set(lineProperty, lineItem);
   }
   for (const position of borderPositions) {
-    const positionProperty = `${BORDER}-${position}`;
-    const positionItem =
-      borderItems.get(positionProperty) ?? getPropertyItem(positionProperty, properties);
+    const positionProperty = `${border.property}-${position}`;
+    const positionItem = borderItems.get(positionProperty) ?? getPropertyItem(positionProperty, properties);
     borderProps.set(positionProperty, positionItem);
     for (const line of borderLines) {
-      const longhandProperty = `${BORDER}-${position}-${line}`;
-      const longhandItem =
-        borderItems.get(longhandProperty) ?? getPropertyItem(longhandProperty, properties);
+      const longhandProperty = `${border.property}-${position}-${line}`;
+      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.
@@ -1062,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;
@@ -1070,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.
@@ -1080,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;
@@ -1088,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.
@@ -1098,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: BORDER_WIDTH,
-    generator: generateBorderLineShorthand
-  },
-  [STYLE]: {
-    shorthand: BORDER_STYLE,
-    generator: generateBorderLineShorthand
-  },
-  [COLOR]: {
-    shorthand: BORDER_COLOR,
-    generator: generateBorderLineShorthand
-  },
-  [TOP]: {
-    shorthand: BORDER_TOP,
-    generator: generateBorderPositionShorthand
-  },
-  [RIGHT]: {
-    shorthand: BORDER_RIGHT,
-    generator: generateBorderPositionShorthand
-  },
-  [BOTTOM]: {
-    shorthand: BORDER_BOTTOM,
-    generator: generateBorderPositionShorthand
-  },
-  [LEFT]: {
-    shorthand: BORDER_LEFT,
-    generator: generateBorderPositionShorthand
-  }
-};
+}
 
 /**
  * Processes and consolidates border-related longhands into shorthands where possible.
@@ -1143,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] = {
@@ -1217,15 +1105,14 @@ const prepareBorderShorthands = (properties) => {
   const mixedPriorities = shorthandItems.length && shorthandPriorityItems.length;
   const imageItem = createPropertyItem(BORDER_IMAGE, NONE);
   if (shorthandItems.length === 4) {
-    const [property, item] = generateBorderShorthand(shorthandItems, BORDER) ?? [];
+    const [property, item] = generateBorderShorthand(shorthandItems, border.property) ?? [];
     if (property && item) {
       properties.set(property, item);
       properties.delete(BORDER_IMAGE);
       properties.set(BORDER_IMAGE, imageItem);
     }
   } else if (shorthandPriorityItems.length === 4) {
-    const [property, item] =
-      generateBorderShorthand(shorthandPriorityItems, BORDER, "important") ?? [];
+    const [property, item] = generateBorderShorthand(shorthandPriorityItems, border.property, "important") ?? [];
     if (property && item) {
       properties.set(property, item);
       properties.delete(BORDER_IMAGE);
@@ -1265,7 +1152,7 @@ const prepareBorderShorthands = (properties) => {
     properties.set(BORDER_IMAGE, imageItem);
   }
   return properties;
-};
+}
 
 /**
  * Processes shorthand properties from the shorthands map.
@@ -1273,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);
@@ -1291,7 +1178,7 @@ const processShorthandProperties = (shorthands) => {
     }
   }
   return shorthandItems;
-};
+}
 
 /**
  * Updates the longhand properties map with a new property item.
@@ -1299,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) {
@@ -1312,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) {
-        const lineItems = border.parse(value, parseOpt);
+      if (property === border.property) {
+        const lineItems = border.parse(value);
         for (const [key, initialValue] of border.initialValues) {
           if (!Object.hasOwn(lineItems, key)) {
             lineItems[key] = initialValue;
@@ -1357,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("-");
@@ -1398,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();
@@ -1443,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;
@@ -1458,31 +1338,22 @@ 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) {
-        if (property === BACKGROUND) {
+        if (property === background.property) {
           hasPrecedingBackground = true;
         }
         parsedProperties.set(property, createPropertyItem(property, value, priority));
@@ -1490,17 +1361,13 @@ const prepareProperties = (properties, opt = {}) => {
     } else {
       parsedProperties.set(property, createPropertyItem(property, value, priority));
       if (hasPrecedingBackground) {
-        const { value: shorthandValue, priority: shorthandPriority } = properties.get(BACKGROUND);
+        const { value: shorthandValue, priority: shorthandPriority } = properties.get(background.property);
         if ((!shorthandPriority || priority) && !hasVarFunc(shorthandValue)) {
-          const replacedShorthandValue = replaceBackgroundShorthand(
-            property,
-            parsedProperties,
-            parseOpt
-          );
-          properties.delete(BACKGROUND);
+          const replacedShorthandValue = replaceBackgroundShorthand(property, parsedProperties);
+          properties.delete(background.property);
           properties.set(
-            BACKGROUND,
-            createPropertyItem(BACKGROUND, replacedShorthandValue, shorthandPriority)
+            background.property,
+            createPropertyItem(background.property, replacedShorthandValue, shorthandPriority)
           );
         }
       }
@@ -1513,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.
@@ -1527,36 +1394,36 @@ const prepareProperties = (properties, opt = {}) => {
  * @param {Map} properties - The map of properties to normalize.
  * @returns {Map} The normalized properties map.
  */
-const normalizeProperties = (properties) => {
-  if (properties.has(BORDER)) {
+function normalizeProperties(properties) {
+  if (properties.has(border.property)) {
     for (const line of borderLines) {
-      properties.delete(`${BORDER}-${line}`);
+      properties.delete(`${border.property}-${line}`);
     }
     for (const position of borderPositions) {
-      properties.delete(`${BORDER}-${position}`);
+      properties.delete(`${border.property}-${position}`);
       for (const line of borderLines) {
-        properties.delete(`${BORDER}-${position}-${line}`);
+        properties.delete(`${border.property}-${position}-${line}`);
       }
     }
-    properties.delete(`${BORDER}-image`);
+    properties.delete(`${border.property}-image`);
   }
   for (const line of borderLines) {
-    const lineProperty = `${BORDER}-${line}`;
+    const lineProperty = `${border.property}-${line}`;
     if (properties.has(lineProperty)) {
       for (const position of borderPositions) {
-        const positionProperty = `${BORDER}-${position}`;
-        const longhandProperty = `${BORDER}-${position}-${line}`;
+        const positionProperty = `${border.property}-${position}`;
+        const longhandProperty = `${border.property}-${position}-${line}`;
         properties.delete(positionProperty);
         properties.delete(longhandProperty);
       }
     }
   }
   for (const position of borderPositions) {
-    const positionProperty = `${BORDER}-${position}`;
+    const positionProperty = `${border.property}-${position}`;
     if (properties.has(positionProperty)) {
       const longhandProperties = [];
       for (const line of borderLines) {
-        const longhandProperty = `${BORDER}-${position}-${line}`;
+        const longhandProperty = `${border.property}-${position}-${line}`;
         longhandProperties.push(longhandProperty);
       }
       if (longhandProperties.length === 3) {
@@ -1569,7 +1436,7 @@ const normalizeProperties = (properties) => {
     }
   }
   return properties;
-};
+}
 
 module.exports = {
   borderProperties,