@skbkontur/react-ui 6.4.1 → 6.4.2-static-css.0

package/lib/theming/themeToCssVars.js

@@ -0,0 +1,861 @@
+import { ThemeFactory } from './ThemeFactory.js';
+import { REACT_UI_THEME_MARKERS, findPropertyDescriptor } from './ThemeHelpers.js';
+/**
+ * Префикс всех CSS-переменных темы.
+ * Без префикса потребитель не отличит переменные react-ui от своих.
+ */
+export var THEME_CSS_VAR_PREFIX = '--kontur-';
+/**
+ * Имя CSS-переменной для переменной темы.
+ * Имя переменной темы не переименовывается в kebab-case, чтобы его можно было
+ * один в один сопоставить с документацией темы: `btnBgDefault` -> `--kontur-btnBgDefault`.
+ */
+export function getThemeCssVarName(themeKey) {
+    return "".concat(THEME_CSS_VAR_PREFIX).concat(themeKey);
+}
+/** Служебные ключи-маркеры темы, которые не являются переменными. */
+var MARKER_KEYS = Object.values(REACT_UI_THEME_MARKERS).map(function (marker) { return marker.key; });
+/** Имя переменной темы, пригодное для использования в качестве имени CSS-переменной. */
+var VALID_THEME_KEY = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+/** Геттер-проброска: `return this.bgDefault;` */
+var PASSTHROUGH_GETTER = /^return\s+this\.([A-Za-z_$][A-Za-z0-9_$]*)\s*;?$/;
+/**
+ * Геттер-шаблон: ``return `${this.a} solid ${this.b}`;``
+ *
+ * Пробел после `return` необязателен: перед кавычкой он не нужен, и минификатор
+ * его убирает — ``return`${this.a} solid ${this.b}` ``.
+ */
+var TEMPLATE_GETTER = /^return\s*`([^`]*)`\s*;?$/;
+/** Начало es5-вида шаблонного геттера: `return "" ...` или `return "литерал" ...` */
+var CONCAT_HEAD = /^\s*return\s*"((?:[^"\\]|\\.)*)"/;
+/** Интерполяция-ссылка на другую переменную темы: `this.linkFocusOutlineWidth` */
+var THIS_REFERENCE = /^this\.([A-Za-z_$][A-Za-z0-9_$]*)$/;
+var isRef = function (part) { return 'ref' in part; };
+/**
+ * Точка с запятой завершает объявление и не может быть частью значения CSS-переменной.
+ * Хвостовые `;` в значениях темы (например, `selectBorderColorTransition`) отбрасываются,
+ * значения с `;` в середине объявить нельзя — такие переменные пропускаются.
+ */
+function sanitizeValue(value) {
+    return value.replace(/[\s;]+$/, '');
+}
+/** Тело геттера в одну строку: `get x() { return this.y; }` -> `return this.y;` */
+function getGetterBody(theme, themeKey) {
+    var descriptor = findPropertyDescriptor(theme, themeKey);
+    if (typeof descriptor.get !== 'function') {
+        return null;
+    }
+    var source = descriptor.get.toString();
+    var bodyStart = source.indexOf('{');
+    var bodyEnd = source.lastIndexOf('}');
+    if (bodyStart === -1 || bodyEnd <= bodyStart) {
+        return null;
+    }
+    // Комментарии снимаются ДО схлопывания пробелов, и это не косметика.
+    // Переносы строк схлопываются в пробел, и однострочный комментарий перед
+    // `return` съедал бы весь остаток тела — геттер разбирался бы как литерал, а
+    // его ссылки на другие токены теряли бы производность. В исходниках этого не
+    // видно: комментарии до `Function.prototype.toString()` там не доживают.
+    return stripComments(source.slice(bodyStart + 1, bodyEnd))
+        .trim()
+        .replace(/\s+/g, ' ');
+}
+/**
+ * Убирает комментарии из тела функции, не трогая строковые литералы.
+ *
+ * Регулярка тут не годится: `//` встречается внутри значений (протокол-
+ * относительный `url(//…)`), и вырезать её как комментарий значило бы испортить
+ * значение.
+ */
+function stripComments(body) {
+    var _a;
+    var result = '';
+    var index = 0;
+    var quote = null;
+    while (index < body.length) {
+        var char = body[index];
+        if (quote) {
+            if (char === '\\') {
+                result += char + ((_a = body[index + 1]) !== null && _a !== void 0 ? _a : '');
+                index += 2;
+                continue;
+            }
+            if (char === quote) {
+                quote = null;
+            }
+            result += char;
+            index += 1;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            quote = char;
+            result += char;
+            index += 1;
+            continue;
+        }
+        if (char === '/' && body[index + 1] === '/') {
+            var lineEnd = body.indexOf('\n', index);
+            index = lineEnd === -1 ? body.length : lineEnd;
+            // Перенос строки остаётся: без него `return` слипся бы с предыдущей строкой.
+            continue;
+        }
+        if (char === '/' && body[index + 1] === '*') {
+            var commentEnd = body.indexOf('*/', index + 2);
+            index = commentEnd === -1 ? body.length : commentEnd + 2;
+            result += ' ';
+            continue;
+        }
+        result += char;
+        index += 1;
+    }
+    return result;
+}
+/**
+ * Разбирает исходник шаблонного литерала на литералы и ссылки.
+ * Возвращает null, если хотя бы одна интерполяция — не простая ссылка `this.<переменная>`
+ * (например, `${parseInt(this.menuOffsetY) - 1}`) или в литерале есть эскейп-последовательность.
+ */
+function parseTemplateParts(template) {
+    var parts = [];
+    var literal = '';
+    var index = 0;
+    while (index < template.length) {
+        if (template[index] === '\\') {
+            // Эскейпы (`\n`, `\${`) не переносятся в CSS как есть — отдаём значение литералом.
+            return null;
+        }
+        if (template[index] !== '$' || template[index + 1] !== '{') {
+            literal += template[index];
+            index += 1;
+            continue;
+        }
+        var depth = 1;
+        var expression = '';
+        index += 2;
+        while (index < template.length && depth > 0) {
+            if (template[index] === '{') {
+                depth += 1;
+            }
+            else if (template[index] === '}') {
+                depth -= 1;
+                if (depth === 0) {
+                    break;
+                }
+            }
+            expression += template[index];
+            index += 1;
+        }
+        if (depth !== 0) {
+            return null;
+        }
+        index += 1;
+        var reference = expression.trim().match(THIS_REFERENCE);
+        if (!reference) {
+            return null;
+        }
+        parts.push({ literal: literal });
+        parts.push({ ref: reference[1] });
+        literal = '';
+    }
+    parts.push({ literal: literal });
+    return parts;
+}
+/**
+ * Раскладывает значение переменной темы на куски.
+ * Проброски и шаблоны из ссылок становятся ссылками, всё остальное — литералом
+ * с уже вычисленным значением.
+ */
+function getValueParts(theme, themeKey, value) {
+    var literalOnly = [{ literal: value }];
+    var body = getGetterBody(theme, themeKey);
+    if (body === null) {
+        return literalOnly;
+    }
+    var passthrough = body.match(PASSTHROUGH_GETTER);
+    if (passthrough) {
+        return [{ ref: passthrough[1] }];
+    }
+    var template = body.match(TEMPLATE_GETTER);
+    if (template) {
+        return parseTemplateParts(template[1]) || literalOnly;
+    }
+    return parseConcatParts(body) || literalOnly;
+}
+/**
+ * Тот же шаблон, но после компиляции в es5.
+ *
+ * Пакет собирается с `target: "es5"` (см. корневой tsconfig), а
+ * `Function.prototype.toString()` отдаёт то, что реально выполняется. Шаблонный
+ * литерал к этому моменту уже превращён в цепочку `concat`:
+ *
+ *     return "".concat(this.a, " solid ").concat(this.b);
+ *
+ * Без разбора этой формы 14 ссылок деградировали бы в литералы именно в
+ * опубликованном пакете — то есть в исходниках производность есть, а у
+ * потребителя нет.
+ */
+function parseConcatParts(body) {
+    var head = body.match(CONCAT_HEAD);
+    if (!head) {
+        return null;
+    }
+    var parts = [];
+    if (head[1]) {
+        parts.push({ literal: head[1] });
+    }
+    var index = head[0].length;
+    while (index < body.length) {
+        if (body.startsWith(';', index) || body[index] === undefined || /^\s*$/.test(body.slice(index))) {
+            break;
+        }
+        if (!body.startsWith('.concat(', index)) {
+            return null;
+        }
+        index += '.concat('.length;
+        // Скобки и кавычки считаем честно: в значениях темы встречаются и
+        // `cubic-bezier(0.5, 1, 0.89, 1)`, и `rgba(0, 0, 0, .16)` — регулярка на
+        // `[^)]*` обрывалась бы на первой внутренней скобке.
+        var argsStart = index;
+        var depth = 1;
+        var quote = null;
+        while (index < body.length && depth > 0) {
+            var char = body[index];
+            if (quote) {
+                if (char === '\\') {
+                    index += 1;
+                }
+                else if (char === quote) {
+                    quote = null;
+                }
+            }
+            else if (char === '"' || char === "'") {
+                quote = char;
+            }
+            else if (char === '(') {
+                depth += 1;
+            }
+            else if (char === ')') {
+                depth -= 1;
+                if (depth === 0) {
+                    break;
+                }
+            }
+            index += 1;
+        }
+        if (depth !== 0) {
+            return null;
+        }
+        var args = splitConcatArgs(body.slice(argsStart, index));
+        index += 1;
+        if (!args) {
+            return null;
+        }
+        for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {
+            var arg = args_1[_i];
+            var reference = arg.match(THIS_REFERENCE);
+            if (reference) {
+                parts.push({ ref: reference[1] });
+                continue;
+            }
+            var quoted = arg.match(/^(["'])((?:[^\\]|\\.)*?)\1$/);
+            if (!quoted || quoted[2].includes('\\')) {
+                // Не строковый литерал или эскейп — в CSS переносить нельзя.
+                return null;
+            }
+            parts.push({ literal: quoted[2] });
+        }
+    }
+    return parts.length ? parts : null;
+}
+/** Делит аргументы `concat` по запятым верхнего уровня, не ломая строки с запятой внутри. */
+function splitConcatArgs(source) {
+    var _a;
+    var args = [];
+    var current = '';
+    var quote = null;
+    for (var index = 0; index < source.length; index++) {
+        var char = source[index];
+        if (quote) {
+            current += char;
+            if (char === '\\') {
+                current += (_a = source[++index]) !== null && _a !== void 0 ? _a : '';
+            }
+            else if (char === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+            continue;
+        }
+        if (char === ',') {
+            args.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    args.push(current.trim());
+    if (quote) {
+        return null;
+    }
+    return args.filter(Boolean);
+}
+/**
+ * Начало объявления локальных переменных арифметического геттера.
+ * `var` — тот же `const` после сборки в es5.
+ */
+var CALC_LOCAL_KEYWORD = /^(?:const|var)\s+/;
+/** Один декларатор объявления: `borderWidth = parseInt(this.btnBorderWidth, 10) || 0`. */
+var CALC_LOCAL_DECLARATOR = /^\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*/;
+/** ``return `${...}px`;`` и ``return `-${...}px`;`` — минус перед интерполяцией даёт отрицательный отступ. */
+var CALC_RETURN_STATEMENT = /^return\s*`(-?)\$\{(.+)\}px`\s*;?$/;
+/**
+ * Тот же `return` после сборки в es5: `Function.prototype.toString()` отдаёт
+ * то, что реально выполняется, а при `target: es5` TypeScript превращает
+ * шаблонный литерал в `"".concat(...)`.
+ */
+var CALC_RETURN_STATEMENT_ES5 = /^return\s*"(-?)"\.concat\((.+),\s*"px"\)\s*;?$/;
+/** Значение переменной, которое `parseInt` читает без потерь: целое число пикселей. */
+var INTEGER_PX_VALUE = /^-?\d+px$/;
+/** Значение, с которым сравнивается результат вычисления выражения. */
+var PX_VALUE = /^-?\d+(?:\.\d+)?px$/;
+/**
+ * Число, идентификатор, `||` или одиночный знак; последняя альтернатива ловит
+ * всё непонятное по одному символу, чтобы такое выражение отсеялось целиком.
+ */
+var CALC_TOKEN = /\d+(?:\.\d+)?|[A-Za-z_$][A-Za-z0-9_$]*|\|\||[()+\-*/,.]|\S/g;
+/** Токен из числа поддержанных. */
+var CALC_VALID_TOKEN = /^(?:\d+(?:\.\d+)?|[A-Za-z_$][A-Za-z0-9_$]*|\|\||[()+\-*/,.])$/;
+var CALC_PRECEDENCE = { '+': 1, '-': 1, '*': 2, '/': 2 };
+/** Приоритет атома выше любого оператора: атом никогда не берётся в скобки. */
+var CALC_ATOM_PRECEDENCE = 3;
+function tokenizeCalc(source) {
+    var tokens = source.match(CALC_TOKEN);
+    if (tokens === null) {
+        return null;
+    }
+    return tokens.every(function (token) { return CALC_VALID_TOKEN.test(token); }) ? tokens : null;
+}
+/**
+ * Разбирает арифметическое выражение из исходника геттера.
+ *
+ * Локальные `const` подставляются в место использования: в CSS переменных для них нет,
+ * а выражение всё равно уходит в одну строку.
+ *
+ * @param source Исходник выражения
+ * @param locals Уже разобранные локальные переменные геттера
+ * @returns Дерево выражения или null, если встретилось что-то неподдержанное
+ */
+function parseCalcExpression(source, locals) {
+    var tokens = tokenizeCalc(source.trim());
+    if (tokens === null) {
+        return null;
+    }
+    var position = 0;
+    var peek = function () { return tokens[position]; };
+    var eat = function (expected) {
+        if (tokens[position] !== expected) {
+            return false;
+        }
+        position += 1;
+        return true;
+    };
+    /** `parseInt(this.X)` и `parseInt(this.X, 10)` — единственная форма чтения переменной темы. */
+    var parseParseIntCall = function () {
+        if (!eat('(') || !eat('this') || !eat('.')) {
+            return null;
+        }
+        var themeKey = peek();
+        if (themeKey === undefined || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(themeKey)) {
+            return null;
+        }
+        position += 1;
+        if (eat(',') && !eat('10')) {
+            // Другое основание системы счисления меняет смысл: не переносим.
+            return null;
+        }
+        if (!eat(')')) {
+            return null;
+        }
+        return { kind: 'ref', themeKey: themeKey };
+    };
+    var parseAtom = function () {
+        var _a;
+        var token = peek();
+        if (token === undefined) {
+            return null;
+        }
+        if (token === '(') {
+            position += 1;
+            var inner = parseOr();
+            if (inner === null || !eat(')')) {
+                return null;
+            }
+            return inner;
+        }
+        if (/^\d/.test(token)) {
+            position += 1;
+            return { kind: 'number', value: Number(token) };
+        }
+        if (!/^[A-Za-z_$]/.test(token)) {
+            return null;
+        }
+        position += 1;
+        if (token === 'parseInt') {
+            return parseParseIntCall();
+        }
+        // Всё, что не `parseInt` и не локальная переменная (`Math`, импорт модуля), не переносится.
+        return (_a = locals.get(token)) !== null && _a !== void 0 ? _a : null;
+    };
+    var parseUnary = function () {
+        if (!eat('-')) {
+            return parseAtom();
+        }
+        var operand = parseUnary();
+        if (operand === null) {
+            return null;
+        }
+        if (operand.kind === 'number') {
+            return { kind: 'number', value: -operand.value };
+        }
+        // В `calc()` унарного минуса нет, умножение на -1 — его законный эквивалент.
+        return { kind: 'binary', operator: '*', left: { kind: 'number', value: -1 }, right: operand };
+    };
+    var parseProduct = function () {
+        var left = parseUnary();
+        if (left === null) {
+            return null;
+        }
+        while (peek() === '*' || peek() === '/') {
+            var operator = tokens[position];
+            position += 1;
+            var right = parseUnary();
+            if (right === null) {
+                return null;
+            }
+            left = { kind: 'binary', operator: operator, left: left, right: right };
+        }
+        return left;
+    };
+    // Стрелка, а не объявление функции: в объявлении TypeScript теряет сужение
+    // `tokens` до непустого массива.
+    var parseSum = function () {
+        var left = parseProduct();
+        if (left === null) {
+            return null;
+        }
+        while (peek() === '+' || peek() === '-') {
+            var operator = tokens[position];
+            position += 1;
+            var right = parseProduct();
+            if (right === null) {
+                return null;
+            }
+            left = { kind: 'binary', operator: operator, left: left, right: right };
+        }
+        return left;
+    };
+    /**
+     * `parseInt(this.X, 10) || 0` — страховка от NaN. В CSS её нет; на числах,
+     * которые реально лежат в теме, она не срабатывает, и это подтверждает
+     * сверка с JS-значением ниже.
+     *
+     * Уровень ниже суммы, а не только на самом верху выражения: минификатор,
+     * подставляющий локальную переменную в место использования, уносит страховку
+     * внутрь скобок — `2 * (parseInt(this.x, 10) || 0)`.
+     */
+    var parseOr = function () {
+        var value = parseSum();
+        if (value === null) {
+            return null;
+        }
+        while (eat('||')) {
+            var fallback = parseSum();
+            if (fallback === null || fallback.kind !== 'number' || fallback.value !== 0) {
+                return null;
+            }
+        }
+        return value;
+    };
+    var parsed = parseOr();
+    return parsed !== null && position === tokens.length ? parsed : null;
+}
+/**
+ * Находит конец инициализатора локальной переменной: ближайшие `,` или `;` вне скобок.
+ *
+ * Запятую верхнего уровня пропускать нельзя: минификатор склеивает объявления в
+ * список (`var a=1,b=2;`). Запятую внутри `parseInt(this.x, 10)` — наоборот,
+ * учитывать нельзя. Кавычка любого вида означает, что объявления закончились и
+ * началась строка `return`, — такое выражение не наше.
+ *
+ * @returns Индекс разделителя или null
+ */
+function findCalcInitializerEnd(source, start) {
+    var depth = 0;
+    for (var index = start; index < source.length; index++) {
+        var char = source[index];
+        if (char === '`' || char === '"' || char === "'") {
+            return null;
+        }
+        if (char === '(') {
+            depth += 1;
+        }
+        else if (char === ')') {
+            depth -= 1;
+            if (depth < 0) {
+                return null;
+            }
+        }
+        else if (depth === 0 && (char === ',' || char === ';')) {
+            return index;
+        }
+    }
+    return null;
+}
+/**
+ * Считывает объявления локальных переменных в начале тела геттера.
+ *
+ * Одно объявление может объявлять несколько переменных: `const a = 1, b = 2;` в
+ * исходниках так не написано, но минификатор сводит к этому виду цепочку `const`.
+ *
+ * @param body Тело геттера
+ * @param locals Карта, в которую складываются разобранные переменные
+ * @returns Остаток тела после объявлений или null, если объявление не разобрано
+ */
+function readCalcLocals(body, locals) {
+    var rest = body;
+    var keyword = rest.match(CALC_LOCAL_KEYWORD);
+    while (keyword) {
+        var cursor = keyword[0].length;
+        for (;;) {
+            var declarator = rest.slice(cursor).match(CALC_LOCAL_DECLARATOR);
+            if (!declarator) {
+                return null;
+            }
+            cursor += declarator[0].length;
+            var end = findCalcInitializerEnd(rest, cursor);
+            if (end === null) {
+                return null;
+            }
+            var value = parseCalcExpression(rest.slice(cursor, end), locals);
+            if (value === null) {
+                return null;
+            }
+            locals.set(declarator[1], value);
+            var isLastDeclarator = rest[end] === ';';
+            cursor = end + 1;
+            if (isLastDeclarator) {
+                break;
+            }
+        }
+        rest = rest.slice(cursor).replace(/^\s+/, '');
+        keyword = rest.match(CALC_LOCAL_KEYWORD);
+    }
+    return rest;
+}
+/**
+ * Разбирает тело арифметического геттера: объявления локальных переменных и завершающий `return`.
+ * @returns Дерево выражения (с уже подставленными локальными переменными) или null
+ */
+function parseCalcGetterBody(body) {
+    var _a;
+    var locals = new Map();
+    var rest = readCalcLocals(body, locals);
+    if (rest === null) {
+        return null;
+    }
+    var returned = (_a = rest.match(CALC_RETURN_STATEMENT)) !== null && _a !== void 0 ? _a : rest.match(CALC_RETURN_STATEMENT_ES5);
+    if (!returned) {
+        return null;
+    }
+    var expression = parseCalcExpression(returned[2], locals);
+    if (expression === null) {
+        return null;
+    }
+    if (returned[1] !== '-') {
+        return expression;
+    }
+    return { kind: 'binary', operator: '*', left: { kind: 'number', value: -1 }, right: expression };
+}
+/**
+ * Тип выражения по правилам `calc()`.
+ * @returns 'length', 'number' или null, если такое выражение в `calc()` незаконно
+ */
+function getCalcType(node) {
+    if (node.kind === 'number') {
+        return 'number';
+    }
+    if (node.kind === 'ref') {
+        return 'length';
+    }
+    var left = getCalcType(node.left);
+    var right = getCalcType(node.right);
+    if (left === null || right === null) {
+        return null;
+    }
+    switch (node.operator) {
+        case '+':
+        case '-':
+            // Число рядом с длиной — это пиксели, `px` допишется при печати.
+            return left === 'length' || right === 'length' ? 'length' : 'number';
+        case '*':
+            // В умножении хотя бы один операнд обязан быть числом.
+            if (left === 'length' && right === 'length') {
+                return null;
+            }
+            return left === 'number' ? right : left;
+        case '/':
+            // Делить можно только на число.
+            return right === 'number' ? left : null;
+    }
+}
+/** Есть ли в выражении хоть одна ссылка на переменную темы. */
+function hasCalcRef(node) {
+    if (node.kind === 'ref') {
+        return true;
+    }
+    return node.kind === 'binary' && (hasCalcRef(node.left) || hasCalcRef(node.right));
+}
+/**
+ * Вычисляет выражение так же, как это делает JS-геттер.
+ * Ссылка берётся только из целого числа пикселей: на дробном или безразмерном значении
+ * `parseInt` и CSS разошлись бы.
+ */
+function evaluateCalc(node, values) {
+    if (node.kind === 'number') {
+        return node.value;
+    }
+    if (node.kind === 'ref') {
+        var value = values.get(node.themeKey);
+        if (value === undefined || !INTEGER_PX_VALUE.test(value)) {
+            return null;
+        }
+        return parseInt(value, 10);
+    }
+    var left = evaluateCalc(node.left, values);
+    var right = evaluateCalc(node.right, values);
+    if (left === null || right === null) {
+        return null;
+    }
+    switch (node.operator) {
+        case '+':
+            return left + right;
+        case '-':
+            return left - right;
+        case '*':
+            return left * right;
+        case '/':
+            return right === 0 ? null : left / right;
+    }
+}
+function getCalcPrecedence(node) {
+    return node.kind === 'binary' ? CALC_PRECEDENCE[node.operator] : CALC_ATOM_PRECEDENCE;
+}
+/**
+ * Печатает выражение, расставляя скобки только там, где они меняют результат.
+ * Правый операнд `-` и `/` скобок требует чаще: эти операторы не ассоциативны.
+ *
+ * @param node Узел выражения
+ * @param context Чем должен оказаться узел в `calc()`: длиной или числом
+ */
+function printCalc(node, context) {
+    if (node.kind === 'number') {
+        return context === 'length' ? "".concat(node.value, "px") : String(node.value);
+    }
+    if (node.kind === 'ref') {
+        return "var(".concat(getThemeCssVarName(node.themeKey), ")");
+    }
+    var operandPrecedence = CALC_PRECEDENCE[node.operator];
+    var rightPrecedence = getCalcRightPrecedence(node.operator);
+    var _a = getCalcOperandContexts(node, context), leftContext = _a[0], rightContext = _a[1];
+    return "".concat(printCalcOperand(node.left, leftContext, operandPrecedence), " ").concat(node.operator, " ").concat(printCalcOperand(node.right, rightContext, rightPrecedence));
+}
+/**
+ * Приоритет, ниже которого правый операнд надо взять в скобки.
+ * `-` и `/` не ассоциативны: `a - (b + c)` и `a / (b * c)` без скобок меняют смысл.
+ */
+function getCalcRightPrecedence(operator) {
+    if (operator === '-') {
+        return CALC_PRECEDENCE['*'];
+    }
+    if (operator === '/') {
+        return CALC_ATOM_PRECEDENCE;
+    }
+    return CALC_PRECEDENCE[operator];
+}
+/**
+ * Контексты операндов: в сумме оба операнда того же типа, что и результат,
+ * в делении делитель всегда число, в умножении длину несёт ровно один операнд.
+ */
+function getCalcOperandContexts(node, context) {
+    if (node.operator === '+' || node.operator === '-') {
+        return [context, context];
+    }
+    if (node.operator === '/') {
+        return [context, 'number'];
+    }
+    if (context === 'number') {
+        return ['number', 'number'];
+    }
+    // Длину несёт тот операнд, который ею уже является; если оба числовые —
+    // единицы дописываются правому, результат тот же.
+    return getCalcType(node.left) === 'length' ? ['length', 'number'] : ['number', 'length'];
+}
+function printCalcOperand(node, context, minPrecedence) {
+    var printed = printCalc(node, context);
+    return getCalcPrecedence(node) < minPrecedence ? "(".concat(printed, ")") : printed;
+}
+/**
+ * Переводит арифметический геттер в `calc()`.
+ *
+ * Значение отдаётся, только если выражение разобрано целиком, законно в `calc()`
+ * и вычисляется ровно в то же число, что вернул JS-геттер. Единицы в `calc()`
+ * приходят из самих переменных, поэтому `px` из шаблона не переносится.
+ *
+ * @param theme Объект темы
+ * @param themeKey Ключ переменной
+ * @param value Значение, которое вернул геттер
+ * @param values Объявленные значения переменных темы
+ * @returns Строка `calc(...)` или null
+ */
+function getCalcValue(theme, themeKey, value, values) {
+    if (!PX_VALUE.test(value)) {
+        return null;
+    }
+    var body = getGetterBody(theme, themeKey);
+    if (body === null) {
+        return null;
+    }
+    var expression = parseCalcGetterBody(body);
+    // Выражение без ссылок производности не добавляет — такому место в литерале.
+    if (expression === null || getCalcType(expression) !== 'length' || !hasCalcRef(expression)) {
+        return null;
+    }
+    var evaluated = evaluateCalc(expression, values);
+    if (evaluated === null || !Number.isFinite(evaluated) || evaluated !== parseFloat(value)) {
+        return null;
+    }
+    return "calc(".concat(printCalc(expression, 'length'), ")");
+}
+//#endregion
+/**
+ * Значение CSS-переменной для одного ключа темы.
+ *
+ * Порядок разбора: сначала ссылки (проброски и шаблоны), затем арифметика в `calc()`,
+ * иначе — готовое значение литералом.
+ */
+function getCssVarValue(theme, themeKey, value, values) {
+    var _a;
+    var parts = getValueParts(theme, themeKey, value);
+    // Ссылка допустима, только если переменная-источник объявлена и подстановка её
+    // объявленного значения даёт ровно то же, что отдаёт тема. Иначе — литерал.
+    var isResolvable = parts.some(isRef) &&
+        parts.every(function (part) { return !isRef(part) || values.has(part.ref); }) &&
+        parts.map(function (part) { return (isRef(part) ? values.get(part.ref) : part.literal); }).join('') === value;
+    if (isResolvable) {
+        return parts.map(function (part) { return (isRef(part) ? "var(".concat(getThemeCssVarName(part.ref), ")") : part.literal); }).join('');
+    }
+    return (_a = getCalcValue(theme, themeKey, value, values)) !== null && _a !== void 0 ? _a : value;
+}
+/**
+ * Собирает пары «имя CSS-переменной — значение» для всех переменных темы.
+ *
+ * Проброски и шаблоны превращаются в ссылки `var(--kontur-<источник>)`, а арифметические
+ * геттеры — в `calc()` из тех же ссылок, чтобы переопределение одной переменной
+ * автоматически меняло все производные от неё. Остальные значения эмитируются литералом.
+ *
+ * @param theme Объект темы
+ * @returns Объект вида `{ '--kontur-bgSecondary': 'var(--kontur-bgDefault)' }`
+ */
+export function themeToCssVarsMap(theme) {
+    var themeKeys = ThemeFactory.getKeys(theme)
+        .map(String)
+        .filter(function (themeKey) { return VALID_THEME_KEY.test(themeKey) && !MARKER_KEYS.includes(themeKey); });
+    var CSS_WIDE_KEYWORD = /^(inherit|initial|unset|revert|revert-layer)$/i;
+    /**
+     * CSS-wide keyword custom property нести не может: в объявлении
+     * `--x: inherit` ключевое слово применяется К САМОЙ ПЕРЕМЕННОЙ — она наследует
+     * значение родителя, а на верхнем уровне это ничто. Ссылка `var(--x)` тогда
+     * вычисляется в пустоту, то есть даёт `unset`, а не подставляет `inherit`.
+     *
+     * Поэтому такой токен не объявляется вовсе — как и пустой. Результат тот же:
+     * `var()` без объявления даёт `unset`, а для наследуемых свойств `unset`
+     * и есть `inherit`, то есть ровно то, что токен и означал.
+     */
+    // Значения читаются один раз: геттеры темы вычисляемые.
+    var values = new Map();
+    themeKeys.forEach(function (themeKey) {
+        var value = theme[themeKey];
+        if (typeof value !== 'string') {
+            return;
+        }
+        var sanitized = sanitizeValue(value);
+        if (sanitized === '' || sanitized.includes(';') || CSS_WIDE_KEYWORD.test(sanitized)) {
+            return;
+        }
+        values.set(themeKey, sanitized);
+    });
+    var cssVars = {};
+    values.forEach(function (value, themeKey) {
+        cssVars[getThemeCssVarName(themeKey)] = getCssVarValue(theme, themeKey, value, values);
+    });
+    return cssVars;
+}
+/**
+ * Подпись темы: её значения, а не сгенерированный из них CSS.
+ *
+ * Из подписи считается имя класса-носителя, и потому она обязана быть
+ * устойчивой к сборке приложения. Текст блока таким свойством не обладает:
+ * `calc()` собирается из исходного текста геттера, и минификатор потребителя
+ * сворачивает в нём константы — `* (8 - 1)` превращается в `* 7`. Значение то
+ * же, текст другой, хеш другой, и совпасть с извлечённым на сборке файлом ему
+ * уже нечем. Сами же значения темы минификатор не меняет.
+ *
+ * @param theme Объект темы
+ * @returns Строка вида `bgDefault:#fff;btnBgDefault:…`
+ */
+export function themeValuesSignature(theme) {
+    return ThemeFactory.getKeys(theme)
+        .map(String)
+        .filter(function (themeKey) { return VALID_THEME_KEY.test(themeKey) && !MARKER_KEYS.includes(themeKey); })
+        .map(function (themeKey) {
+        var value = theme[themeKey];
+        return typeof value === 'string' ? "".concat(themeKey, ":").concat(value) : '';
+    })
+        .join(';');
+}
+/**
+ * Превращает тему в блок объявлений CSS-переменных.
+ *
+ * Блок не обёрнут в селектор — это делает вызывающий код,
+ * например `:root { ... }` или `.my-scope { ... }`.
+ *
+ * @param theme Объект темы
+ * @returns Строка объявлений, по одному на строку
+ */
+export function themeToCssVars(theme) {
+    var cached = cssVarsCache.get(theme);
+    if (cached !== undefined) {
+        return cached;
+    }
+    var cssVars = themeToCssVarsMap(theme);
+    var result = Object.keys(cssVars)
+        .map(function (name) { return "".concat(name, ": ").concat(cssVars[name], ";"); })
+        .join('\n');
+    cssVarsCache.set(theme, result);
+    return result;
+}
+/**
+ * Блок один и тот же для одной темы, а собирается он недёшево: разбор исходников
+ * 540 геттеров плюс склейка полутора тысяч объявлений — около 4 мс.
+ *
+ * Кеш общий, не привязанный к инстансу Emotion: на сервере инстанс свой на каждый
+ * запрос, и без этого генерация повторялась бы на каждом. Ключ — объект темы,
+ * поэтому `WeakMap`: темы создаются динамически через `ThemeFactory.create`, и
+ * держать их вечно нельзя.
+ */
+var cssVarsCache = new WeakMap();
+//# sourceMappingURL=themeToCssVars.js.map