induscode 0.1.0__py3-none-any.whl

induscode/transcript_export/template.py

@@ -0,0 +1,319 @@
+'''Page-shell template — the standalone HTML/CSS scaffold the transcript
+publisher fills.
+
+Port of TS ``src/transcript-export/template.ts`` (constants verbatim; the
+embedded client renderer stays JavaScript).
+
+This module is a freshly authored single-file page: its own element names
+(``<main class="xscript">``, ``.turn``, ``.turn-tag``, ``.turn-body``,
+``.tool-frame``, ``.aside-note``), its own stylesheet, and its own
+``{{TOKEN}}`` placeholder names — the
+:data:`~induscode.transcript_export.contract.SHELL_SLOTS` values from the
+transcript-export contract (``THEME_VARS``/``PAGE_SURFACE``/…/``MARKED_LIB``/
+``HIGHLIGHT_LIB``). None of the class names, DOM structure, placeholder
+tokens, or color values are carried over from any prior export template.
+
+The publisher computes a value for every slot and calls :func:`fill` to splice
+them in. The page is self-contained: theme colors arrive as CSS custom
+properties in ``:root``, the library license notices are inlined, the session
+payload is embedded as base64, and a small client renderer (the ``SCRIPT``
+slot) hydrates the transcript on load.
+
+Port note: the TS client script carried an in-browser ``highlight.js``
+fallback (re-highlighting code fences when a turn arrived without
+pre-rendered HTML). In this port every turn ships fully rendered at publish
+time — markdown through markdown-it-py, fences through Pygments — so the
+in-browser highlighter path is dropped; the client renderer only decodes the
+payload and injects the already-built HTML.
+'''
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Final, TypeAlias
+
+from .contract import SHELL_SLOTS
+
+__all__ = [
+    "CLIENT_SCRIPT",
+    "PAGE_SHELL",
+    "PAGE_STYLES",
+    "SlotValues",
+    "fill",
+]
+
+
+# ---------------------------------------------------------------------------
+# Stylesheet
+# ---------------------------------------------------------------------------
+
+#: The page stylesheet, emitted into the ``STYLES`` slot. Reads its colors
+#: from the ``--x-*`` custom properties the ``THEME_VARS`` slot defines, so
+#: re-theming is a matter of changing the variables, not the rules. Class
+#: names are this page's own (``xscript``, ``turn``, ``tool-frame``,
+#: ``aside-note``, the ``sgr-*`` family the painter emits, and the highlight
+#: ``xhl`` block).
+PAGE_STYLES: Final[str] = """
+:root { color-scheme: dark light; }
+* { box-sizing: border-box; }
+html, body { margin: 0; padding: 0; }
+body {
+  background: var(--x-page-surface);
+  color: var(--x-ink);
+  font: 15px/1.6 ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+  -webkit-font-smoothing: antialiased;
+}
+.xscript {
+  max-width: 56rem;
+  margin: 0 auto;
+  padding: 2.5rem 1.25rem 6rem;
+  display: flex;
+  flex-direction: column;
+  gap: 1.25rem;
+}
+.xscript-head {
+  border-bottom: 1px solid var(--x-border);
+  padding-bottom: 1rem;
+  margin-bottom: 0.5rem;
+}
+.xscript-head h1 {
+  margin: 0;
+  font-size: 1.35rem;
+  font-weight: 650;
+  letter-spacing: -0.01em;
+}
+.xscript-head .xscript-meta {
+  margin-top: 0.35rem;
+  color: var(--x-ink-muted);
+  font-size: 0.85rem;
+}
+.turn {
+  background: var(--x-card-surface);
+  border: 1px solid var(--x-border);
+  border-radius: 0.65rem;
+  padding: 1rem 1.15rem;
+  overflow: hidden;
+}
+.turn[data-role="user"] { border-left: 3px solid var(--x-user-role); }
+.turn[data-role="agent"] { border-left: 3px solid var(--x-agent-role); }
+.turn[data-role="tool"] { border-left: 3px solid var(--x-tool-role); }
+.turn-tag {
+  display: inline-block;
+  font-size: 0.72rem;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  margin-bottom: 0.6rem;
+  color: var(--x-ink-muted);
+}
+.turn[data-role="user"] .turn-tag { color: var(--x-user-role); }
+.turn[data-role="agent"] .turn-tag { color: var(--x-agent-role); }
+.turn[data-role="tool"] .turn-tag { color: var(--x-tool-role); }
+.turn-body { word-break: break-word; }
+.turn-body > :first-child { margin-top: 0; }
+.turn-body > :last-child { margin-bottom: 0; }
+.turn-body a { color: var(--x-accent); text-decoration: none; }
+.turn-body a:hover { text-decoration: underline; }
+.turn-body p { margin: 0.6rem 0; }
+.turn-body img { max-width: 100%; border-radius: 0.4rem; }
+.turn-body code {
+  font-family: ui-monospace, "SF Mono", "JetBrains Mono", Menlo, monospace;
+  font-size: 0.88em;
+  background: var(--x-note-surface);
+  padding: 0.1em 0.35em;
+  border-radius: 0.3rem;
+}
+.turn-body pre {
+  background: var(--x-note-surface);
+  border: 1px solid var(--x-border);
+  border-radius: 0.5rem;
+  padding: 0.9rem 1rem;
+  overflow-x: auto;
+  margin: 0.75rem 0;
+}
+.turn-body pre code { background: none; padding: 0; }
+.tool-frame {
+  font-family: ui-monospace, "SF Mono", "JetBrains Mono", Menlo, monospace;
+  font-size: 0.85rem;
+  background: var(--x-note-surface);
+  border: 1px solid var(--x-border);
+  border-radius: 0.5rem;
+  padding: 0.85rem 1rem;
+  margin: 0.5rem 0;
+  overflow-x: auto;
+  white-space: pre-wrap;
+}
+.aside-note {
+  background: var(--x-note-surface);
+  border: 1px dashed var(--x-border);
+  border-radius: 0.5rem;
+  padding: 0.75rem 1rem;
+  color: var(--x-ink-muted);
+  font-size: 0.9rem;
+}
+.sgr-bold { font-weight: 700; }
+.sgr-dim { opacity: 0.72; }
+.sgr-italic { font-style: italic; }
+.sgr-underline { text-decoration: underline; }
+.sgr-strike { text-decoration: line-through; }
+.sgr-underline.sgr-strike { text-decoration: underline line-through; }
+.sgr-blink { animation: x-blink 1.1s steps(2, start) infinite; }
+.sgr-hidden { visibility: hidden; }
+@keyframes x-blink { 50% { opacity: 0; } }
+.xhl-keyword { color: var(--x-accent); }
+.xhl-string { color: var(--x-user-role); }
+.xhl-comment { color: var(--x-ink-muted); font-style: italic; }
+.xhl-number, .xhl-literal { color: var(--x-tool-role); }
+""".strip()
+
+
+# ---------------------------------------------------------------------------
+# Client renderer
+# ---------------------------------------------------------------------------
+
+#: The client-side renderer, emitted into the ``SCRIPT`` slot — JavaScript,
+#: kept as JavaScript. Decodes the base64 session payload, walks its turns,
+#: and injects each turn's already-built HTML into the ``.xscript`` root.
+#: Pre-rendered markdown, highlighted fences (the page's own ``xhl-*``
+#: classes), tool widgets, and SGR-painted text all arrive already-HTML in the
+#: payload and are inserted verbatim; a turn that somehow lacks ``html`` falls
+#: back to escaped text.
+CLIENT_SCRIPT: Final[str] = """
+(function () {
+  "use strict";
+  var root = document.getElementById("xscript-root");
+  if (!root) return;
+
+  var raw;
+  try {
+    raw = JSON.parse(decodeURIComponent(escape(atob(window.__XSCRIPT_PAYLOAD__ || ""))));
+  } catch (err) {
+    root.textContent = "Unable to decode transcript payload.";
+    return;
+  }
+
+  function md(text) {
+    var div = document.createElement("div");
+    div.textContent = text;
+    return div.innerHTML;
+  }
+
+  function el(tag, cls) {
+    var node = document.createElement(tag);
+    if (cls) node.className = cls;
+    return node;
+  }
+
+  function renderTurn(turn) {
+    if (turn.kind === "note") {
+      var note = el("div", "aside-note");
+      note.innerHTML = turn.html != null ? turn.html : md(turn.text || "");
+      return note;
+    }
+    var card = el("section", "turn");
+    card.setAttribute("data-role", turn.role || "agent");
+    var tag = el("span", "turn-tag");
+    tag.textContent = turn.label || turn.role || "";
+    card.appendChild(tag);
+    var body = el("div", "turn-body");
+    if (turn.html != null) {
+      body.innerHTML = turn.html;
+    } else if (turn.frame) {
+      var frame = el("div", "tool-frame");
+      frame.innerHTML = turn.frame;
+      body.appendChild(frame);
+    } else {
+      body.innerHTML = md(turn.text || "");
+    }
+    card.appendChild(body);
+    return card;
+  }
+
+  var turns = Array.isArray(raw.turns) ? raw.turns : [];
+  for (var i = 0; i < turns.length; i++) {
+    root.appendChild(renderTurn(turns[i]));
+  }
+})();
+""".strip()
+
+
+# ---------------------------------------------------------------------------
+# The shell
+# ---------------------------------------------------------------------------
+
+#: The HTML page shell carrying every :data:`SHELL_SLOTS` placeholder as a
+#: ``{{TOKEN}}`` marker. :func:`fill` replaces each marker with its computed
+#: value. The structure: a themed ``:root``, the inlined stylesheet, the two
+#: preserved library notices, the base64 payload bound to
+#: ``window.__XSCRIPT_PAYLOAD__``, and the client renderer that hydrates
+#: ``#xscript-root``.
+PAGE_SHELL: Final[str] = """<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Session Transcript</title>
+<style>
+:root {
+{{THEME_VARS}}
+  --x-page-surface: {{PAGE_SURFACE}};
+  --x-card-surface: {{CARD_SURFACE}};
+  --x-note-surface: {{NOTE_SURFACE}};
+}
+{{STYLES}}
+</style>
+</head>
+<body>
+<main class="xscript">
+  <header class="xscript-head">
+    <h1>Session Transcript</h1>
+    <div class="xscript-meta">Self-contained HTML export</div>
+  </header>
+  <div id="xscript-root"></div>
+</main>
+<script>
+/* {{MARKED_LIB}} */
+</script>
+<script>
+/* {{HIGHLIGHT_LIB}} */
+</script>
+<script>
+window.__XSCRIPT_PAYLOAD__ = "{{PAYLOAD}}";
+</script>
+<script>
+{{SCRIPT}}
+</script>
+</body>
+</html>"""
+
+
+# ---------------------------------------------------------------------------
+# Fill
+# ---------------------------------------------------------------------------
+
+#: The map a :func:`fill` call supplies — one value per
+#: :data:`~induscode.transcript_export.contract.ShellSlot` token. A value may
+#: be omitted, in which case its placeholder is replaced with the empty string
+#: (so a partial fill leaves no stray ``{{TOKEN}}`` in the output).
+SlotValues: TypeAlias = Mapping[str, str]
+
+
+def fill(template: str, values: SlotValues) -> str:
+    """Replace every ``{{TOKEN}}`` placeholder in a template with the value
+    supplied for that slot, returning the filled string.
+
+    Walks the known :data:`SHELL_SLOTS` (not an open scan), so only
+    sanctioned placeholders are substituted and a stray ``{{…}}`` in user
+    content is left untouched. Each token is replaced globally; a slot with no
+    supplied value collapses to the empty string. The replacement is
+    value-literal (plain ``str.replace``, no pattern language), so nothing in
+    a value is ever interpreted.
+
+    :param template: the shell carrying ``{{TOKEN}}`` markers
+    :param values: the per-slot values to splice in
+    """
+    out = template
+    for token in SHELL_SLOTS.values():
+        value = values.get(token, "")
+        out = out.replace("{{" + token + "}}", value)
+    return out

induscode/transcript_export/theme_bridge.py

@@ -0,0 +1,325 @@
+"""ThemeBridge — the color service behind the HTML transcript export.
+
+Port of TS ``src/transcript-export/theme-bridge.ts`` (verbatim logic).
+
+Everything the publisher needs to turn an :class:`ExportTheme` token bag into
+concrete page colors lives here: parsing CSS colors into :class:`Rgb`,
+measuring a color's WCAG relative luminance through a precomputed lookup
+table, deciding whether the theme reads :data:`ThemeMode` light or dark,
+deriving lighter/darker surface variants from a base, and projecting the whole
+theme to the CSS custom properties the page shell consumes.
+
+Two facts are interface-dictated and kept faithful:
+
+- The WCAG relative-luminance formula — linearize each sRGB channel with the
+  gamma piecewise curve, then weight ``0.2126 R + 0.7152 G + 0.0722 B``. The
+  per-channel linearization is precomputed once into
+  :func:`build_luminance_lut` (a :data:`LuminanceLut`) so a luminance read is
+  three table lookups plus a weighted sum, never a ``pow`` per pixel.
+- Readable foreground selection — given a background, pick the foreground
+  (from the theme's own ink choices) whose contrast against that background is
+  the larger, so text on any derived surface stays legible.
+
+Every default color the bridge falls back to is this rebuild's own
+:data:`FALLBACK_EXPORT_THEME` (a deep-slate palette), never a legacy export's
+magic constant.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from typing import Final, Mapping
+
+from .contract import (
+    FALLBACK_EXPORT_THEME,
+    ExportTheme,
+    LuminanceLut,
+    Rgb,
+    ThemeMode,
+)
+
+__all__ = [
+    "DefaultThemeBridge",
+    "build_luminance_lut",
+    "create_theme_bridge",
+    "format_color",
+    "parse_color",
+]
+
+
+# ---------------------------------------------------------------------------
+# Luminance lookup table
+# ---------------------------------------------------------------------------
+
+
+def build_luminance_lut() -> LuminanceLut:
+    """Build the 256-entry sRGB→linear lookup table the WCAG
+    relative-luminance formula needs for each channel.
+
+    For a channel value ``v`` in ``0–255``, normalize to ``s = v / 255``, then
+    apply the standard gamma-expansion: ``s / 12.92`` when ``s ≤ 0.03928``,
+    else ``((s + 0.055) / 1.055) ** 2.4``. The table holds the linearized
+    value at each integer channel so a luminance read avoids the per-call
+    ``pow``. The math is the published standard's; the table is this
+    module's.
+    """
+    lut: list[float] = []
+    for v in range(256):
+        s = v / 255
+        lut.append(s / 12.92 if s <= 0.03928 else ((s + 0.055) / 1.055) ** 2.4)
+    return tuple(lut)
+
+
+#: The shared, module-level luminance table — built once, read everywhere.
+_LUMINANCE_LUT: Final[LuminanceLut] = build_luminance_lut()
+
+#: The luminance midpoint that separates a :data:`ThemeMode` ``light`` page
+#: from a ``dark`` one. A page surface at or above this reads light; below it
+#: reads dark. The value is the perceptual midpoint of the 0–1
+#: relative-luminance range.
+_MODE_THRESHOLD: Final[float] = 0.18
+
+
+# ---------------------------------------------------------------------------
+# Color parsing & formatting
+# ---------------------------------------------------------------------------
+
+
+def _expand_short_hex(body: str) -> str:
+    """Expand a 3- or 4-digit shorthand hex body to its 6-digit form."""
+    if len(body) in (3, 4):
+        return "".join(c + c for c in body[:3])
+    return body[:6]
+
+
+#: A full six-digit lowercase hex body.
+_HEX_BODY = re.compile(r"^[0-9a-f]{6}$")
+
+#: The functional ``rgb(...)`` / ``rgba(...)`` notation.
+_RGB_FN = re.compile(r"^rgba?\(([^)]+)\)$")
+
+#: Leading decimal-number prefix of one channel field (the TS port used
+#: ``parseFloat``, which reads the numeric prefix and ignores the rest).
+_FLOAT_PREFIX = re.compile(r"^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?")
+
+
+def _parse_float_prefix(text: str) -> float | None:
+    """Read the leading decimal number of a string, or ``None`` when the
+    string carries no numeric prefix (the ``parseFloat`` NaN case)."""
+    m = _FLOAT_PREFIX.match(text)
+    return float(m.group(0)) if m is not None else None
+
+
+def parse_color(color: str) -> Rgb | None:
+    """Parse a CSS color string into its :class:`Rgb` channels. Recognizes
+    ``#rgb``, ``#rrggbb`` (and their alpha-bearing ``#rgba`` / ``#rrggbbaa``
+    forms, alpha dropped) and the functional ``rgb(r, g, b)`` /
+    ``rgba(r, g, b, a)`` notations. Any unrecognized input resolves to
+    ``None``, which the bridge treats as "fall back to the theme default"
+    rather than raising.
+
+    :param color: a CSS color string
+    """
+    text = color.strip().lower()
+
+    if text.startswith("#"):
+        body = _expand_short_hex(text[1:])
+        if _HEX_BODY.match(body) is None:
+            return None
+        return Rgb(
+            r=int(body[0:2], 16),
+            g=int(body[2:4], 16),
+            b=int(body[4:6], 16),
+        )
+
+    fn = _RGB_FN.match(text)
+    if fn is not None:
+        parts = [p for p in re.split(r"[,\s/]+", fn.group(1)) if len(p) > 0]
+        if len(parts) < 3:
+            return None
+
+        def channel(p: str) -> int:
+            n = (
+                (_parse_float_prefix(p) or 0.0) / 100 * 255
+                if p.endswith("%")
+                else _parse_float_prefix(p)
+            )
+            return 0 if n is None else _clamp_byte(n)
+
+        return Rgb(r=channel(parts[0]), g=channel(parts[1]), b=channel(parts[2]))
+
+    return None
+
+
+def _clamp_byte(value: float) -> int:
+    """Clamp and round a number into the 0–255 integer channel range.
+
+    Rounding is the half-up rule (the TS port's ``Math.round``), not Python's
+    banker's rounding — ``0.5`` fractions always step toward the brighter
+    channel.
+    """
+    if value <= 0:
+        return 0
+    if value >= 255:
+        return 255
+    return math.floor(value + 0.5)
+
+
+def format_color(rgb: Rgb) -> str:
+    """Render an :class:`Rgb` back to a ``#rrggbb`` CSS string."""
+
+    def hex_pair(v: int) -> str:
+        return format(_clamp_byte(v), "02x")
+
+    return f"#{hex_pair(rgb.r)}{hex_pair(rgb.g)}{hex_pair(rgb.b)}"
+
+
+# ---------------------------------------------------------------------------
+# Luminance & contrast
+# ---------------------------------------------------------------------------
+
+
+def _luminance_of(rgb: Rgb, lut: LuminanceLut) -> float:
+    """Compute the WCAG relative luminance (0–1) of parsed channels, reading
+    each channel's linearized value from the supplied :data:`LuminanceLut` and
+    combining them with the standard ``0.2126 / 0.7152 / 0.0722`` weights.
+    """
+    lr = lut[_clamp_byte(rgb.r)]
+    lg = lut[_clamp_byte(rgb.g)]
+    lb = lut[_clamp_byte(rgb.b)]
+    return 0.2126 * lr + 0.7152 * lg + 0.0722 * lb
+
+
+def _contrast_ratio(a: float, b: float) -> float:
+    """The WCAG contrast ratio between two luminances,
+    ``(L1 + 0.05) / (L2 + 0.05)`` with the brighter as ``L1``. Ranges from 1
+    (identical) to 21 (black vs. white).
+    """
+    hi = max(a, b)
+    lo = min(a, b)
+    return (hi + 0.05) / (lo + 0.05)
+
+
+# ---------------------------------------------------------------------------
+# Surface derivation
+# ---------------------------------------------------------------------------
+
+
+def _step_channels(rgb: Rgb, amount: float) -> Rgb:
+    """Step every channel of a base color by a signed amount, clamping to the
+    byte range. A positive amount lightens (toward white), a negative one
+    darkens (toward black). The step is linear in 0–255 space — simple and
+    predictable for deriving the small surface deltas the page uses.
+    """
+    return Rgb(
+        r=_clamp_byte(rgb.r + amount),
+        g=_clamp_byte(rgb.g + amount),
+        b=_clamp_byte(rgb.b + amount),
+    )
+
+
+# ---------------------------------------------------------------------------
+# The bridge
+# ---------------------------------------------------------------------------
+
+#: The token names of an :class:`ExportTheme`, in the order the page shell
+#: expects them as CSS custom properties. Kept as one list so
+#: :class:`DefaultThemeBridge`'s ``to_css_vars`` walks a single source.
+_THEME_TOKENS: Final[tuple[str, ...]] = (
+    "pageSurface",
+    "cardSurface",
+    "noteSurface",
+    "ink",
+    "inkMuted",
+    "accent",
+    "border",
+    "userRole",
+    "agentRole",
+    "toolRole",
+)
+
+
+class DefaultThemeBridge:
+    """The concrete :class:`~induscode.transcript_export.contract.ThemeBridge`.
+
+    Holds a resolved :class:`ExportTheme` and a :data:`LuminanceLut`, and
+    serves every color query the publisher makes against them. Pure with
+    respect to its inputs — construction resolves the theme once and the
+    methods only read.
+    """
+
+    def __init__(
+        self, theme: ExportTheme | None = None, lut: LuminanceLut | None = None
+    ) -> None:
+        """:param theme: an :class:`ExportTheme` to serve; defaults to the
+            rebuild's own :data:`FALLBACK_EXPORT_THEME`.
+        :param lut: the luminance lookup table to read; defaults to the shared
+            module-level table.
+        """
+        # The resolved export theme this bridge serves.
+        self.theme: ExportTheme = theme if theme is not None else FALLBACK_EXPORT_THEME
+        self._lut: LuminanceLut = lut if lut is not None else _LUMINANCE_LUT
+
+    def luminance(self, color: str) -> float:
+        """The WCAG relative luminance (0–1) of a CSS color; unparseable
+        input reads 0."""
+        rgb = parse_color(color)
+        return 0.0 if rgb is None else _luminance_of(rgb, self._lut)
+
+    def mode(self) -> ThemeMode:
+        """Whether the theme's page surface reads light or dark."""
+        return "light" if self.luminance(self.theme.pageSurface) >= _MODE_THRESHOLD else "dark"
+
+    def derive_surface(self, base: str, amount: float) -> str:
+        """Derive a surface variant from a base color. The ``amount`` is a
+        signed lightness delta in channel space; the sign is honored directly
+        so a caller can lighten (``+``) or darken (``−``) explicitly. When
+        ``amount`` is ``0`` the base is returned formatted but unchanged.
+        Unparseable bases fall through to the theme's card surface so a
+        derivation never yields an empty string.
+
+        :param base: the base CSS color to adjust
+        :param amount: signed lightness delta (positive lightens, negative
+            darkens)
+        """
+        rgb = parse_color(base)
+        if rgb is None:
+            return self.theme.cardSurface
+        return format_color(_step_channels(rgb, amount))
+
+    def readable_ink(self, background: str) -> str:
+        """Pick the more readable of the theme's two ink colors for a given
+        background by comparing each ink's WCAG contrast against it and
+        returning the higher. This is the bridge's own readable-foreground
+        chooser — used when text sits on a derived surface whose lightness is
+        not known ahead of time.
+
+        :param background: the surface the text will sit on
+        """
+        bg = self.luminance(background)
+        ink = self.luminance(self.theme.ink)
+        muted = self.luminance(self.theme.inkMuted)
+        return (
+            self.theme.ink
+            if _contrast_ratio(ink, bg) >= _contrast_ratio(muted, bg)
+            else self.theme.inkMuted
+        )
+
+    def to_css_vars(self) -> Mapping[str, str]:
+        """Project the theme to its CSS custom properties, keyed by token
+        name."""
+        css_vars: dict[str, str] = {}
+        for token in _THEME_TOKENS:
+            css_vars[token] = getattr(self.theme, token)
+        return css_vars
+
+
+def create_theme_bridge(theme: ExportTheme | None = None) -> DefaultThemeBridge:
+    """Build a theme bridge over an optional :class:`ExportTheme`. The
+    convenience factory the publisher calls; omitting the theme yields a
+    bridge over the rebuild's own fallback palette.
+
+    :param theme: an export palette to serve, or ``None`` for the fallback
+    """
+    return DefaultThemeBridge(theme if theme is not None else FALLBACK_EXPORT_THEME)