dataface 0.3.1.dev22__py3-none-any.whl → 0.3.1.dev78__py3-none-any.whl

d3_format/format.py

@@ -7,13 +7,18 @@ Key deviations from Python's standard number formatting:
 - SI type uses significant-digit precision (not decimal-place precision).
 - `d` type rounds to nearest integer using round-half-up.
 - `n` type is locale-aware `g` with grouping.
+
+``_apply_spec`` follows the shape of d3's own ``format(value)`` closure --
+prefix/suffix assembly, the integer/fraction split, grouping, then padding --
+because the order of those steps is observable: zero-fill is grouped along with
+the digits, and a currency symbol displaces the percent sign.
 """
 
 from __future__ import annotations
 
 import math
 from collections.abc import Callable
-from decimal import ROUND_HALF_UP, Decimal
+from decimal import ROUND_HALF_UP, Decimal, localcontext
 from typing import overload
 
 from d3_format.spec import FormatSpec, parse
@@ -45,6 +50,32 @@ _SI_PREFIXES = [
 ]
 _SI_PREFIX_OFFSET = 8  # index of the '' (10^0) entry
 
+# Type letters that select a formatter. Every other letter the grammar admits
+# falls back to ".12~g" (see _resolve_type); "n" is rewritten before this is
+# consulted, so it is deliberately absent.
+_KNOWN_TYPES = frozenset("%bcdefgoprsxX")
+
+# Types whose precision counts significant digits (clamped to [1, 21]) rather
+# than digits after the decimal point (clamped to [0, 20]).
+_SIGNIFICANT_PRECISION_TYPES = frozenset("gprs")
+
+# Types whose body may carry a fraction or exponent that must be held out of
+# thousands-grouping and zero-padding (d3's `maybeSuffix`).
+_SPLIT_SUFFIX_TYPES = frozenset("defgprs%")
+
+# Types the "#" alternate form marks with a radix prefix.
+_ALTERNATE_FORM_TYPES = frozenset("boxX")
+
+# Radix types → (base, uppercase output).
+_RADIX_TYPES: dict[str, tuple[int, bool]] = {
+    "b": (2, False),
+    "o": (8, False),
+    "x": (16, False),
+    "X": (16, True),
+}
+
+_RADIX_CONVERTERS: dict[int, Callable[[int], str]] = {2: bin, 8: oct, 16: hex}
+
 
 def _round_half_up(x: float, decimals: int) -> float:
     """Round x to `decimals` decimal places using round-half-up (like JS Math.round).
@@ -60,7 +91,44 @@ def _round_half_up(x: float, decimals: int) -> float:
     # Use Decimal(x) — the exact IEEE-754 binary value — so rounding matches d3/JS.
     # Decimal(repr(x)) would round "2.55" up to "2.6", but d3 rounds it down to "2.5"
     # because the binary value is 2.5499..., not 2.55.
-    return float(Decimal(x).quantize(quant, rounding=ROUND_HALF_UP))
+    d = Decimal(x)
+    with localcontext() as ctx:
+        # quantize raises InvalidOperation when the result needs more digits
+        # than the context allows, which the default 28 does not for a large
+        # magnitude (1e30 as an integer) or a deep precision (.20f).
+        ctx.prec = max(ctx.prec, d.adjusted() + decimals + 2)
+        return float(d.quantize(quant, rounding=ROUND_HALF_UP))
+
+
+def _js_number_to_string(v: float) -> str:
+    """Replicate JavaScript's ``String(number)``.
+
+    Python's ``repr`` yields the same shortest-round-trip digits but lays them
+    out with different thresholds (``1e-06`` where JS writes ``0.000001``,
+    ``255.0`` where JS writes ``255``), so the digits are re-rendered per
+    ECMA-262 Number::toString: exponential only outside 10^-6 .. 10^21.
+    """
+    if math.isnan(v):
+        return "NaN"
+    if math.isinf(v):
+        return "Infinity" if v > 0 else "-Infinity"
+    if v == 0:
+        return "0"  # JS String(-0) is "0"
+    sign = "-" if v < 0 else ""
+    parts = Decimal(repr(abs(v))).normalize().as_tuple()
+    digits = "".join(str(d) for d in parts.digits)
+    k = len(digits)
+    # ECMA writes the value as 0.<digits> x 10^n.
+    n = int(parts.exponent) + k
+    if k <= n <= 21:
+        return sign + digits + "0" * (n - k)
+    if 0 < n <= 21:
+        return sign + digits[:n] + "." + digits[n:]
+    if -6 < n <= 0:
+        return sign + "0." + "0" * -n + digits
+    mantissa = digits if k == 1 else digits[0] + "." + digits[1:]
+    exp = n - 1
+    return f"{sign}{mantissa}e{'+' if exp >= 0 else '-'}{abs(exp)}"
 
 
 def _fmt_fixed(abs_val: float, decimals: int) -> str:
@@ -69,35 +137,33 @@ def _fmt_fixed(abs_val: float, decimals: int) -> str:
     return f"{rounded:.{decimals}f}"
 
 
-def _format_group(digits: str, separator: str) -> str:
-    """Apply thousands grouping (groups of 3) to a digit string."""
-    n = len(digits)
-    first = n % 3 or 3
-    parts = [digits[:first]]
-    i = first
-    while i < n:
-        parts.append(digits[i : i + 3])
-        i += 3
-    return separator.join(parts)
+def _to_radix(abs_val: float, base: int, upper: bool) -> str:
+    """Replicate JS ``Math.round(x).toString(base)`` for base 2, 8 or 16."""
+    digits = _RADIX_CONVERTERS[base](int(_round_half_up(abs_val, 0)))[2:]
+    return digits.upper() if upper else digits
 
 
-def _apply_grouping(body: str, separator: str, decimal_pt: str) -> str:
-    """Apply thousands grouping to the integer part of a formatted number.
+def _group(value: str, width: float) -> str:
+    """Replicate d3's formatGroup for grouping [3] with a ',' separator.
 
-    Handles plain integers, decimals, and exponential notation.
+    ``width`` caps the grouped length; d3 passes infinity except when zero-fill
+    padding is grouped along with the digits, where it bounds the total.
     """
-    if "e" in body:
-        mantissa, exp_part = body.split("e", 1)
-        if decimal_pt in mantissa:
-            int_part, frac = mantissa.split(decimal_pt, 1)
-            return (
-                _format_group(int_part, separator) + decimal_pt + frac + "e" + exp_part
-            )
-        return _format_group(mantissa, separator) + "e" + exp_part
-    if decimal_pt in body:
-        int_part, frac = body.split(decimal_pt, 1)
-        return _format_group(int_part, separator) + decimal_pt + frac
-    return _format_group(body, separator)
+    i = len(value)
+    parts: list[str] = []
+    g = 3
+    length = 0
+    while i > 0 and g > 0:
+        if length + g + 1 > width:
+            g = max(1, int(width - length))
+        i -= g
+        parts.append(value[max(0, i) : i + g])
+        length += g + 1
+        if length > width:
+            break
+        g = 3
+    parts.reverse()
+    return ",".join(parts)
 
 
 def _apply_trim(body: str) -> str:
@@ -233,7 +299,7 @@ def _js_to_precision(abs_val: float, precision: int) -> str:
 
 
 def _format_rounded(abs_val: float, precision: int) -> str:
-    """Replicate d3's formatRounded(x, p) for 'r' type.
+    """Replicate d3's formatRounded(x, p), used by the 'r' and 'p' types.
 
     Always uses fixed notation (no e), rounds to p significant digits.
     """
@@ -252,273 +318,205 @@ def _format_rounded(abs_val: float, precision: int) -> str:
         return coefficient + "0" * (i - n)
 
 
-def _format_general(abs_val: float, precision: int) -> str:
-    """Format abs_val using d3's 'g' rule (x.toPrecision(p))."""
-    return _js_to_precision(abs_val, precision)
+def _format_exponential(abs_val: float, precision: int) -> str:
+    """Replicate JS Number.prototype.toExponential(p) for the 'e' type."""
+    if abs_val == 0.0:
+        mantissa = ("0." + "0" * precision) if precision > 0 else "0"
+        return mantissa + "e+0"
+    coefficient, exponent = _format_decimal_parts(abs_val, precision + 1)  # type: ignore[misc]
+    # Pad to precision+1 digits in case trailing zeros were stripped
+    coefficient = coefficient.ljust(precision + 1, "0")
+    if precision > 0:
+        mantissa = coefficient[0] + "." + coefficient[1 : precision + 1]
+    else:
+        mantissa = coefficient[0]
+    return f"{mantissa}e{'+' if exponent >= 0 else '-'}{abs(exponent)}"
 
 
-def _body_is_zero(body: str) -> bool:
-    """True if `body` contains no nonzero digit (e.g. '0', '0.0', '0.00e+0')."""
-    return not any(c.isdigit() and c != "0" for c in body)
+def _format_decimal(abs_val: float) -> str:
+    """Replicate d3's formatDecimal, used by the 'd' type."""
+    if abs_val >= 1e21:
+        # JS formatDecimal uses x.toLocaleString("en") for |x| >= 1e21.
+        # str(x) gives the shortest round-trip repr; Decimal(str()) expands
+        # exponential form to the "clean" integer string matching JS.
+        s = str(abs_val)
+        return str(int(Decimal(s))) if ("e" in s or "E" in s) else str(int(abs_val))
+    return str(int(_round_half_up(abs_val, 0)))
 
 
-def _format_number(spec: FormatSpec, v: float) -> tuple[str, str, str]:
-    """Format a finite, non-NaN float (v may be negative).
+def _format_type(spec: FormatSpec, abs_val: float, precision: int) -> tuple[str, str]:
+    """Replicate d3's ``formatTypes[type](abs_val, precision)``.
 
-    Returns (sign_char, body, suffix) where:
-    - sign_char: "−" | "+" | " " | ""
-    - body: formatted digit string
-    - suffix: SI prefix char, "%" or ""
+    Returns (body, si_prefix); si_prefix mirrors d3's prefixExponent side
+    channel and is empty for every type but 's'.
     """
-    is_neg = math.copysign(1.0, v) < 0
-    abs_val = abs(v)
-
-    # d3: negative values get minus; but -0 loses its minus unless sign is "+".
-    # (equivalent to d3's "if valueNegative && +formattedValue === 0 && sign !== '+'" logic)
-    # We handle this after formatting for non-zero; for zero it's always suppressed unless sign="+".
-    is_neg_zero = is_neg and abs_val == 0.0
-    if is_neg_zero and spec.sign != "+":
-        is_neg = False
-
-    if is_neg:
-        sign_char = _MINUS
-    elif spec.sign == "+":
-        sign_char = "+"
-    elif spec.sign == " ":
-        sign_char = " "
-    else:
-        sign_char = ""
+    if math.isinf(abs_val):
+        # d3 has no infinity branch — each formatter stringifies it. Only 'd'
+        # (via toLocaleString) and 'X' (via toUpperCase) diverge from "Infinity".
+        if spec.type == "d":
+            return _INF_SYMBOL, ""
+        return ("INFINITY" if spec.type == "X" else "Infinity"), ""
 
     t = spec.type
-    precision = spec.precision
-
     if t == "f":
-        prec = precision if precision is not None else 6
-        # JS Number.prototype.toFixed() falls back to toString() for |x| >= 10^21.
-        body = str(abs_val) if abs_val >= 1e21 else _fmt_fixed(abs_val, prec)
-        suffix = ""
-
-    elif t == "%":
-        prec = precision if precision is not None else 6
-        scaled = abs_val * 100.0
-        # toFixed fallback: |x * 100| >= 10^21 → toString(x * 100)
-        body = str(scaled) if scaled >= 1e21 else _fmt_fixed(scaled, prec)
-        suffix = "%"
-
-    elif t == "e":
-        prec = precision if precision is not None else 6
-        if abs_val == 0.0:
-            body = ("0." + "0" * prec if prec > 0 else "0") + "e+0"
-        else:
-            d = _format_decimal_parts(abs_val, prec + 1)
-            coefficient, exponent = d  # type: ignore[misc]
-            # Pad to prec+1 digits in case trailing zeros were stripped
-            coefficient = coefficient.ljust(prec + 1, "0")
-            if prec > 0:
-                mantissa = coefficient[0] + "." + coefficient[1 : prec + 1]
-            else:
-                mantissa = coefficient[0]
-            exp_sign = "+" if exponent >= 0 else "-"
-            body = f"{mantissa}e{exp_sign}{abs(exponent)}"
-        suffix = ""
-
-    elif t in ("g", ""):
-        # d3's formatDefault (empty type) uses toPrecision(12) as the default precision.
-        # 'g' type uses the spec precision (default 6).
-        prec = precision if precision is not None else (12 if t == "" else 6)
-        body = _format_general(abs_val, prec)
-        suffix = ""
-
-    elif t == "r":
-        prec = precision if precision is not None else 6
-        body = _format_rounded(abs_val, prec)
-        suffix = ""
-
-    elif t == "s":
-        prec = precision if precision is not None else 6
-        body, si_suffix = _format_si(abs_val, prec)
-        suffix = si_suffix
-
-    elif t == "d":
         if abs_val >= 1e21:
-            # JS formatDecimal uses x.toLocaleString("en") for |x| >= 1e21.
-            # str(x) gives the shortest round-trip repr; Decimal(str()) expands
-            # exponential form to the "clean" integer string matching JS.
-            s = str(abs_val)
-            body = str(int(Decimal(s))) if ("e" in s or "E" in s) else str(int(abs_val))
-        else:
-            body = str(int(_round_half_up(abs_val, 0)))
-        suffix = ""
-
-    else:  # t == "n"
-        # n type: alias for ",g" — locale-aware g (grouping handled later).
-        prec = precision if precision is not None else 6
-        body = _js_to_precision(abs_val, prec)
-        suffix = ""
-
-    # d3: "if (valueNegative && +formattedValue === 0 && sign !== '+') valueNegative = false"
-    # Drop the minus sign when the formatted body rounds to zero.
-    if is_neg and spec.sign != "+" and _body_is_zero(body):
-        is_neg = False
-        sign_char = " " if spec.sign == " " else ""
-
-    return sign_char, body, suffix
-
-
-def _assemble(
-    spec: FormatSpec,
-    sign_char: str,
-    body: str,
-    suffix: str,
-) -> str:
-    """Assemble sign + symbol + body + suffix, apply width/fill/align."""
-    currency = "$" if spec.symbol == "$" else ""
-
-    # Parens sign mode.
-    if spec.sign == "(" and sign_char == _MINUS:
-        paren_open = "("
-        paren_close = ")"
-        sign_char = ""
-    else:
-        paren_open = ""
-        paren_close = ""
+            return (
+                _js_number_to_string(abs_val),
+                "",
+            )  # JS toFixed falls back to toString
+        return _fmt_fixed(abs_val, precision), ""
+    if t == "%":
+        scaled = abs_val * 100.0
+        if scaled >= 1e21:
+            return _js_number_to_string(scaled), ""
+        return _fmt_fixed(scaled, precision), ""
+    if t == "p":
+        return _format_rounded(abs_val * 100.0, precision), ""
+    if t == "e":
+        return _format_exponential(abs_val, precision), ""
+    if t == "g":
+        return _js_to_precision(abs_val, precision), ""
+    if t == "r":
+        return _format_rounded(abs_val, precision), ""
+    if t == "s":
+        return _format_si(abs_val, precision)
+    if t == "d":
+        return _format_decimal(abs_val), ""
+    base, upper = _RADIX_TYPES[t]
+    return _to_radix(abs_val, base, upper), ""
 
-    # Assemble the non-padded string.
-    if paren_open:
-        full = paren_open + currency + body + suffix + paren_close
-    else:
-        full = sign_char + currency + body + suffix
 
-    if spec.width is None:
-        return full
+def _body_is_zero(body: str) -> bool:
+    """True when JS's ``+body`` coercion would be 0 (d3's rounds-to-zero test).
 
-    w = spec.width
-    current = len(full)
-    if current >= w:
-        return full
-    needed = w - current
+    A body JS coerces to NaN — a radix body like "ff", or "Infinity", or "∞" —
+    is not zero, so an unparseable body keeps its sign.
+    """
+    try:
+        return float(body) == 0.0
+    except ValueError:
+        return False
 
-    if spec.zero:
-        # Zero-pad: sign+currency, then zeros, then body+suffix.
-        # parens+zero is rejected at parse time, so paren_open is never set here.
-        prefix = sign_char + currency
-        rest = body + suffix
-        return prefix + "0" * needed + rest
 
-    if spec.align == "=":
-        prefix_str = (paren_open + currency) if paren_open else (sign_char + currency)
-        rest = body + suffix + paren_close
-        return prefix_str + spec.fill * needed + rest
+def _prefix(spec: FormatSpec) -> str:
+    """The leading unit: a currency symbol, or the alternate-form radix marker."""
+    if spec.symbol == "$":
+        return "$"
+    if spec.symbol == "#" and spec.type in _ALTERNATE_FORM_TYPES:
+        return "0" + spec.type.lower()
+    return ""
 
-    if spec.align == "<":
-        return full + spec.fill * needed
-    elif spec.align == ">":
-        return spec.fill * needed + full
-    else:  # "^"
-        left = needed // 2
-        right = needed - left
-        return spec.fill * left + full + spec.fill * right
-
-
-def _assemble_special(
-    spec: FormatSpec,
-    text: str,
-    is_neg: bool,
-) -> str:
-    """Assemble NaN or Infinity string with sign/currency/width.
-
-    NaN: sign chars from spec apply (+ shows +, space shows space).
-    Infinity: actual sign from is_neg.
-    """
-    if is_neg:
-        sign_char = _MINUS
-    elif spec.sign == "+":
-        sign_char = "+"
-    elif spec.sign == " ":
-        sign_char = " "
-    else:
-        sign_char = ""
 
-    currency = "$" if spec.symbol == "$" else ""
+def _value_suffix(spec: FormatSpec) -> str:
+    """The trailing unit. A currency symbol displaces the percent sign."""
+    if spec.symbol == "$":
+        return ""
+    return "%" if spec.type in ("%", "p") else ""
 
-    # Parens mode for negative infinity.
-    if spec.sign == "(" and is_neg:
-        full = "(" + currency + text + ")"
-        sign_char = ""
-    else:
-        full = sign_char + currency + text
 
-    if spec.width is None:
-        return full
+def _pad(spec: FormatSpec, value_prefix: str, value: str, value_suffix: str) -> str:
+    """Group the digits, then pad to width and align — d3's closing steps.
 
-    w = spec.width
-    current = len(full)
-    if current >= w:
-        return full
-    needed = w - current
+    Grouping appears twice for a reason: without zero-fill d3 groups the digits
+    alone, with zero-fill it groups the padding *and* the digits together so the
+    separators land inside the padded field.
+    """
+    if spec.comma and not spec.zero:
+        value = _group(value, math.inf)
+
+    length = len(value_prefix) + len(value) + len(value_suffix)
+    if spec.width is not None and spec.width > length:
+        padding = spec.fill * (spec.width - length)
+    else:
+        padding = ""
 
-    # For special values, zero-pad uses "0" as fill char.
-    if spec.zero:
-        prefix = sign_char + currency
-        return prefix + "0" * needed + text
+    if spec.comma and spec.zero:
+        width = (spec.width - len(value_suffix)) if padding and spec.width else math.inf
+        value = _group(padding + value, width)
+        padding = ""
 
     if spec.align == "<":
-        return full + spec.fill * needed
-    elif spec.align in (">", "="):
-        return spec.fill * needed + full
-    else:  # "^"
-        left = needed // 2
-        right = needed - left
-        return spec.fill * left + full + spec.fill * right
+        return value_prefix + value + value_suffix + padding
+    if spec.align == "=":
+        return value_prefix + padding + value + value_suffix
+    if spec.align == "^":
+        half = len(padding) // 2
+        return padding[:half] + value_prefix + value + value_suffix + padding[half:]
+    return padding + value_prefix + value + value_suffix
 
 
-def _apply_spec(spec: FormatSpec, v: float | int | Decimal) -> str:
-    """Apply a parsed FormatSpec to a numeric value."""
-    v = float(v)  # coerce int, Decimal, etc.; preserves -0 sign via IEEE 754
+def _resolve_type(spec: FormatSpec) -> None:
+    """Apply d3's type aliases in place, before any formatting decision.
 
-    # d and ,d type: use ∞ symbol for infinite values.
-    use_inf_symbol = spec.type in ("d",)
+    ``n`` is ``,g``. The empty type and any letter that selects no formatter are
+    alike ``.12~g`` — d3 does not reject an unrecognised type letter, it falls
+    back to a general-purpose format, so neither do we.
+    """
+    if spec.type == "n":
+        spec.comma = True
+        spec.type = "g"
+    elif spec.type not in _KNOWN_TYPES:
+        if spec.precision is None:
+            spec.precision = 12
+        spec.trim = True
+        spec.type = "g"
+
+
+def _resolve_precision(spec: FormatSpec) -> int:
+    """d3's precision default and per-type clamp. Call after ``_resolve_type``."""
+    if spec.precision is None:
+        return 6
+    if spec.type in _SIGNIFICANT_PRECISION_TYPES:
+        return max(1, min(21, spec.precision))
+    return max(0, min(20, spec.precision))
+
+
+def _apply_spec(spec: FormatSpec, precision: int, v: float | int | Decimal) -> str:
+    """Apply a resolved FormatSpec to a numeric value, mirroring d3's format()."""
+    value_prefix = _prefix(spec)
+    value_suffix = _value_suffix(spec)
+    x = float(v)  # coerce int, Decimal, etc.; preserves -0 sign via IEEE 754
+
+    if spec.type == "c":
+        # Character data: the value is stringified verbatim and carries its own
+        # ASCII hyphen, so the sign, trim and split steps are all skipped.
+        return _pad(spec, value_prefix, "", _js_number_to_string(x) + value_suffix)
+
+    if math.isnan(x):
+        # d3 short-circuits NaN ahead of the type function, which is why 'X'
+        # does not uppercase it the way it uppercases "INFINITY".
+        is_negative = False
+        body, si_prefix = "NaN", ""
+    else:
+        is_negative = x < 0 or math.copysign(1.0, x) < 0
+        body, si_prefix = _format_type(spec, abs(x), precision)
 
-    # The % type appends "%" even to NaN/Infinity.
-    type_suffix = "%" if spec.type == "%" else ""
+    if spec.trim:
+        body = _apply_trim(body)
 
-    # NaN.
-    if math.isnan(v):
-        return _assemble_special(spec, "NaN" + type_suffix, is_neg=False)
+    # A negative value that formats to zero loses its sign unless the spec asks
+    # for an explicit one.
+    if is_negative and spec.sign != "+" and _body_is_zero(body):
+        is_negative = False
 
-    # Infinity.
-    if math.isinf(v):
-        is_neg = v < 0
-        text = (_INF_SYMBOL if use_inf_symbol else "Infinity") + type_suffix
-        return _assemble_special(spec, text, is_neg=is_neg)
+    if is_negative:
+        value_prefix = ("(" if spec.sign == "(" else _MINUS) + value_prefix
+    elif spec.sign not in ("-", "("):
+        value_prefix = spec.sign + value_prefix
 
-    # Normal number.
-    sign_char, body, suffix = _format_number(spec, v)
+    value_suffix = si_prefix + value_suffix
+    if is_negative and spec.sign == "(":
+        value_suffix += ")"
 
-    # Trim trailing zeros: explicit ~ flag, or unconditionally for empty type.
-    # d3's formatDefault (empty type) always strips trailing zeros regardless of ~.
-    if spec.trim or spec.type == "":
-        body = _apply_trim(body)
+    if spec.type in _SPLIT_SUFFIX_TYPES:
+        # Hold the fraction/exponent out of grouping and zero-padding.
+        for i, char in enumerate(body):
+            if not "0" <= char <= "9":
+                value_suffix = body[i:] + value_suffix
+                body = body[:i]
+                break
 
-    # Comma grouping: for 'n' type always group; for all others respect spec.comma.
-    # For 's' type, comma is applied to the mantissa (matters for very large SI bodies).
-    use_comma = spec.comma or spec.type == "n"
-    if use_comma:
-        if spec.zero and spec.width is not None:
-            # d3 applies comma grouping to the zero-padded digits.
-            # Pre-pad body to the largest digit count that fits the target width.
-            sign_len = len(sign_char) + (1 if spec.symbol == "$" else 0)
-            available = spec.width - sign_len - len(suffix)
-            d = len(body)
-            while True:
-                nd = d + 1
-                if nd + (nd - 1) // 3 > available:
-                    break
-                d = nd
-            body = body.zfill(d)
-        body = _apply_grouping(body, ",", ".")
-
-    return _assemble(spec, sign_char, body, suffix)
+    return _pad(spec, value_prefix, body, value_suffix)
 
 
 @overload
@@ -548,12 +546,14 @@ def format(  # noqa: A001
         A ``Callable[[float], str]`` if value is None, else the formatted string.
 
     Raises:
-        D3FormatError: If spec_str is invalid or uses unsupported features.
+        D3FormatError: If spec_str does not match the d3-format grammar.
     """
     spec = parse(spec_str)
+    _resolve_type(spec)
+    precision = _resolve_precision(spec)
 
     def _fmt(v: float | int | Decimal) -> str:
-        return _apply_spec(spec, v)
+        return _apply_spec(spec, precision, v)
 
     if value is None:
         return _fmt