Casi cualquiera que intenta leer o cambiar las dimensiones de un elemento desde JavaScript por primera vez se queda desconcertado por una rareza de la API del navegador: para trabajar con números aquí hay que lidiar con cadenas de texto. Pides mediante getComputedStyle() la opacidad de un bloque esperando ver el número 0.2, y recibes la cadena '0.2'. Pides el ancho de un contenedor y llega el texto '120px'. Y en cuanto la tarea sale de la simple asignación —por ejemplo, leer el ancho de una tarjeta y sumarle 20px—, el código se llena de llamadas a parseFloat(), expresiones regulares y concatenación de sufijos.
Dentro del propio motor del navegador todas las medidas ya se guardan como números tipados, pero el viejo DOM se empeña en convertirlas a texto y viceversa. La especificación CSS Typed Object Model (Typed OM) de los estándares W3C CSS Houdini nació para librar al frontend de esta doble traducción, y el polyfill css-typed-om publicado en octubre de 2026 por el ingeniero de Google Chrome DevRel Bramus Van Damme (Bramus) eliminó el principal obstáculo para su adopción: el soporte desigual en los navegadores. Veamos por qué el intercambio de estilos basado en cadenas frena la interfaz y cómo pasar los cálculos de dimensiones a objetos con unidades.
El coste oculto del DOM de cadenas: doble parseo en cada fotograma
Dentro de Chromium, Safari y Firefox la hoja de estilos y la geometría se calculan en C++ o Rust. El ancho de un contenedor 120px reside en la memoria del motor como una estructura compacta: el número 120 y el código de unidad px.
Al acceder a getComputedStyle(el).width, el motor convierte el número interno en caracteres, añade px y reserva en la memoria de JavaScript la cadena '120px'. Luego tu script llama a parseFloat('120px'), recorta el sufijo, suma 20 y concatena la cadena '140px'. Al escribir en el.style.width, el navegador vuelve a ejecutar el parser de CSS, valida la gramática de la propiedad width y transforma el texto '140px' de nuevo en el número 140.
Es como dos contables en escritorios contiguos: en lugar de decirse la cifra en voz alta, el primero imprime el número en un formulario y lo mete en un sobre, y el segundo escanea la hoja, suma veinte con la calculadora y vuelve a imprimir otra carta. En un clic aislado el retraso no se nota, pero al arrastrar paneles, en gestos o en animaciones dentro de requestAnimationFrame (60–120 fotogramas por segundo), este parseo constante de cadenas carga la CPU y llena la memoria de basura para el recolector (GC). Parte de los cálculos geométricos hoy se resuelve de forma nativa —en el análisis sobre detección de solapamiento de elementos con anchor positioning y Style Queries vimos cómo sacar las lecturas del DOM del scroll—. Pero cuando los cálculos en JS son imprescindibles, Typed OM toma el relevo de las cadenas.
Cómo funcionan los mapas de estilos y los objetos con unidades
En CSS Typed OM, en lugar de element.style, el elemento tiene un mapa de estilos en línea element.attributeStyleMap, y window.getComputedStyle(element) cede su puesto al método element.computedStyleMap(). Todos sus valores heredan de CSSStyleValue:
CSSUnitValue— objeto con los camposvalue(número) yunit('px','em','percent'o'number'para magnitudes adimensionales comoopacity);CSSKeywordValueyCSSTransformValue— envoltorios para palabras clave ('block','auto') y matrices de transformación sin tener que parsearmatrix(...);- Factorías
CSS.*— métodosCSS.px(),CSS.em(),CSS.percent(),CSS.number(),CSS.deg(), que crean unCSSUnitValue.
Veamos con el ejemplo de un contenedor .my-element de 120px de ancho cómo lucen la lectura de estilos computados y la escritura de propiedades en línea mediante objetos Typed OM:
const box = document.querySelector('.my-element');
const styles = box.computedStyleMap();
const width = styles.get('width');
const opacity = styles.get('opacity');
console.log(width.value, width.unit); // 120, 'px'
console.log(opacity.value, opacity.unit); // 0.2, 'number'
box.attributeStyleMap.set('opacity', CSS.number(0.5));
box.attributeStyleMap.set('margin-top', CSS.px(20));
La llamada styles.get('width') devuelve directamente un CSSUnitValue, donde width.value contiene el número 120 y width.unit vale 'px'. La opacidad opacity se devuelve como { value: 0.2, unit: 'number' }. Escribir mediante box.attributeStyleMap.set('margin-top', CSS.px(20)) pasa la estructura directamente al motor y protege contra erratas: mientras que en element.style.width una cadena '140xp' o NaN se ignoran en silencio, CSS.px() valida de inmediato el tipo del argumento.
Aritmética de dimensiones: cálculos con CSSMathSum y CSSMathProduct
En el DOM clásico, sumar píxeles con porcentajes o analizar calc(100px + 10%) con parseFloat() es imposible: la llamada devuelve NaN. En CSS Typed OM la aritmética viene integrada en los objetos mediante las clases CSSMathSum, CSSMathProduct, CSSMathNegate y los métodos .add(), .sub(), .mul(), .div().
Leamos el ancho del contenedor .my-element (120px), aumentémoslo en 20px con CSSMathSum, escalémoslo y definamos un margen combinando píxeles y em:
import 'css-typed-om';
const box = document.querySelector('.my-element');
const currentWidth = box.computedStyleMap().get('width'); // CSSUnitValue { value: 120, unit: 'px' }
const expandedWidth = new CSSMathSum(currentWidth, CSS.px(20));
box.attributeStyleMap.set('width', expandedWidth);
const doubledWidth = currentWidth.add(CSS.px(20)).mul(2); // CSSUnitValue { value: 280, unit: 'px' }
const fluidMargin = CSS.px(20).add(CSS.em(2)); // CSSMathSum -> calc(20px + 2em)
box.attributeStyleMap.set('margin-top', fluidMargin);
Al sumar unidades idénticas en currentWidth.add(CSS.px(20)).mul(2) (mediante CSSMathProduct), se colapsan en un CSSUnitValue con el valor 280px. Y al sumar dimensiones distintas en CSS.px(20).add(CSS.em(2)) o CSS.px(100).add(CSS.percent(10)), el método construye un árbol CSSMathSum, equivalente a calc(20px + 2em), sin una sola plantilla de cadena. Un principio de tipado similar en hojas de estilo lo analizamos en el artículo sobre tematización dinámica de componentes con funciones CSS y la directiva @property: al conocer el tipo de la variable, el navegador la evalúa al vuelo.
Realidad entre navegadores, el polyfill de Bramus y límites de aplicabilidad
Los motores Chromium y WebKit soportan attributeStyleMap y computedStyleMap() de forma nativa (salvo algunas subclases de CSSColorValue como CSSRGB y CSSOKLCH), mientras que en Firefox la implementación sigue oculta tras el flag layout.css.typed-om.enabled (Firefox bug 1278697). Antes, los autores de bibliotecas —por ejemplo, del polyfill scroll-timeline, al que Johannes Odland portó partes de Typed OM para contar con CSS.px() y CSS.percent()— tenían que escribir sus propios envoltorios.
El paquete css-typed-om de Bramus Van Damme (el nombre en npm lo cedió Jonathan Neal) cerró esa brecha. El repositorio integra la batería de Web Platform Tests (WPT): el comando npm run test:wpt levanta un Firefox 157 headless con el flag layout.css.typed-om.enabled desactivado y ejecuta más de 400 archivos de prueba de /css/css-typed-om/. El polyfill supera 12 479 de 13 134 subpruebas, alrededor del 95% de la especificación.
El motivo por el que el resultado es 95% y no 100% revela dos principios fundamentales de cómo trabaja el navegador con los estilos:
- Delegación de la gramática al parser nativo. Para no inflar el bundle en más de 400 KB con una base de datos de todas las propiedades CSS,
css-typed-omdelega la validación sintáctica al parser nativo del navegador. Si WPT comprueba una palabra clave reciente que Firefox 157 aún no conoce (anchor-validen lugar deanchors-valid), el navegador la rechaza; a cambio, el polyfill se mantiene ligero y sincronizado conelement.style. - Irreversibilidad de los estilos computados. El polyfill lee
computedStyleMap()a través dewindow.getComputedStyle(), que devuelve valores ya resueltos:rgb(0, 0, 0)en vez decurrentcolor, y píxeles en vez dewidth: 50%oauto. Reconstruir la palabra clave original desde JS sin soporte nativo del motor es imposible.
En Chrome, Edge y Safari, CSS Typed OM aporta tanto una arquitectura de código estricta como una ganancia directa de velocidad al saltarse el parser de cadenas. En Firefox, el polyfill css-typed-om ofrece una API tipada unificada y matemáticas seguras con CSSMathSum, pero internamente recurre a getComputedStyle(), por lo que la aceleración del renderizado en Firefox solo llegará cuando se active la implementación nativa.
Ahora mismo puedes probar Typed OM sin instalar paquetes: abre la consola de DevTools en Chrome, Edge o Safari y ejecuta $0.computedStyleMap().get('width') y $0.attributeStyleMap.set('padding', CSS.px(16).add(CSS.em(1))). Y si en tu proyecto tienes sliders, gráficos o animaciones concatenando + 'px', instala el paquete con npm install css-typed-om (con import 'css-typed-om' global o import { CSSUnitValue } from 'css-typed-om' modular) y pasa los cálculos de dimensiones a objetos tipados.

