postcss-calc 11.1.1 → 11.2.0

package/src/lib/print.js

@@ -0,0 +1,75 @@
+import { serializeResult } from './serialize.js';
+
+/** @typedef {import('../reduce.js').ResolvedReduceCalcOptions} ResolvedReduceCalcOptions */
+/** @typedef {import('../reduce.js').Replacement} Replacement */
+/** @typedef {import('./serialize.js').SerializeOptions} SerializeOptions */
+
+/**
+ * @param {string} value
+ * @param {Replacement} replacement
+ * @param {ResolvedReduceCalcOptions} options
+ * @param {SerializeOptions} serializeOptions
+ * @return {string}
+ */
+function serializeReplacement(value, replacement, options, serializeOptions) {
+  let text;
+  try {
+    text = serializeResult(replacement.result, serializeOptions);
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error('Error');
+    const original =
+      replacement.result.original ??
+      value.slice(replacement.start, replacement.end);
+    options.onParseError?.(err, original);
+    text = original;
+  }
+  if (
+    options.warnWhenCannotResolve &&
+    replacement.result.status === 'unresolved'
+  ) {
+    options.onWarn?.('Could not reduce expression: ' + value);
+  }
+  return text;
+}
+
+/**
+ * Serialize compiled candidates and splice the resulting text into the
+ * original source. Replacements are already non-overlapping because the
+ * finder treats a supported outer function as one range.
+ *
+ * @param {string} value
+ * @param {Replacement[]} replacements
+ * @param {ResolvedReduceCalcOptions} options
+ * @param {SerializeOptions} serializeOptions
+ * @return {string}
+ */
+function applyReplacements(value, replacements, options, serializeOptions) {
+  if (replacements.length === 1) {
+    const replacement = replacements[0];
+    const text = serializeReplacement(
+      value,
+      replacement,
+      options,
+      serializeOptions
+    );
+    return (
+      value.slice(0, replacement.start) + text + value.slice(replacement.end)
+    );
+  }
+
+  let output = '';
+  let lastIndex = 0;
+  for (const replacement of replacements) {
+    const text = serializeReplacement(
+      value,
+      replacement,
+      options,
+      serializeOptions
+    );
+    output += value.slice(lastIndex, replacement.start) + text;
+    lastIndex = replacement.end;
+  }
+  return output + value.slice(lastIndex);
+}
+
+export { applyReplacements };

package/src/lib/regex.js

@@ -0,0 +1,4 @@
+// CSS numeric token prefix, including an optional sign and exponent.
+const CSS_NUMBER_PREFIX = /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?/;
+
+export { CSS_NUMBER_PREFIX };

package/src/lib/scan.js

@@ -0,0 +1,61 @@
+import { TokenType as CssType } from '@csstools/css-tokenizer';
+import { lookupMathFunction } from './functions.js';
+
+/**
+ * @typedef {object} Candidate
+ * @property {string} name
+ * @property {string} normalizedName
+ * @property {number} start
+ * @property {number} end
+ * @property {string} rootSpelling
+ * @property {boolean} calculation
+ * @property {number} sliceStart
+ * @property {number} sliceEnd
+ * @property {boolean} closed
+ */
+
+/**
+ * Find complete supported math-function ranges. A supported function is
+ * treated as one candidate even when parsing it later fails, so nested
+ * calculations cannot produce partial output for an invalid outer function.
+ *
+ * @param {string} value
+ * @param {import('@csstools/css-tokenizer').CSSToken[]} tokens
+ * @param {ReturnType<typeof import('./block-index.js').indexBlocks>} index
+ * @return {Candidate[]}
+ */
+function findCalculations(value, tokens, index) {
+  /** @type {Candidate[]} */
+  const candidates = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token[0] !== CssType.Function) continue;
+
+    const name = token[4].value;
+    const lookup = lookupMathFunction(name);
+    if (!lookup) continue;
+    const isCalc = lookup.definition.calculation === true;
+
+    const close = index.closeOf(i, tokens.length);
+    const closed = close !== -1;
+    const end = closed ? tokens[close][3] + 1 : value.length;
+    const sliceStart = isCalc ? i + 1 : i;
+    const sliceEnd = closed ? close + (isCalc ? 0 : 1) : tokens.length - 1;
+    candidates.push({
+      name,
+      normalizedName: lookup.normalizedName,
+      start: token[2],
+      end,
+      rootSpelling: value.slice(token[2], token[3]),
+      calculation: isCalc,
+      sliceStart,
+      sliceEnd,
+      closed,
+    });
+    if (!closed) break;
+    i = close;
+  }
+  return candidates;
+}
+
+export { findCalculations };