postcss-calc 11.1.0 → 11.1.2

package/types/lib/parser.d.ts

@@ -1,51 +1,55 @@
-export type Token = import('./tokenizer.js').Token;
-export type TokenType = import('./tokenizer.js').TokenType;
+export type CSSToken = import('@csstools/css-tokenizer').CSSToken;
 export type Node = import('./node.js').Node;
+export type Component = string | Node | Component[];
+export type Token = {
+    type: 'number' | 'dimension' | 'ident' | 'function' | 'punct' | 'eof';
+    value: string | number;
+    raw: string;
+    unit?: string;
+    rawUnit?: string;
+    signCharacter?: '+' | '-';
+    pos: number;
+    ws: boolean;
+};
 export type PrefixParselet = (p: Parser, token: Token) => Node;
+/** Bounded cursor that skips trivia but records whether it preceded a token. */
 declare class Parser {
-    /** @private */
-    i;
-    /** @private @readonly */
-    tokens;
+    #private;
     /**
-     * @param {Token[]} tokens
+     * @param {CSSToken[]} tokens
+     * @param {number} start
+     * @param {number} end
+     * @param {Map<number, number>} [ends]
      */
-    constructor(tokens: Token[]);
+    constructor(tokens: CSSToken[], start: number, end: number, ends?: Map<number, number>);
+    /** @return {Map<number, number>} */
+    get ends(): Map<number, number>;
+    /** @return {number} */
+    eofPosition(): number;
+    /** @return {Token} */
+    read(): Token;
     /** @return {Token} */
     peek(): Token;
     /** @return {Token} */
     next(): Token;
-    /**
-     * @param {TokenType} type
-     * @param {string} [value]
-     * @return {Token}
-     */
-    expect(type: TokenType, value?: string): Token;
-    /**
-     * @param {string} value
-     * @param {string} [value2]
-     * @return {boolean}
-     */
+    /** @return {{start: number, close: number, tokens: CSSToken[], ends: Map<number, number>}} */
+    functionRange(): {
+        start: number;
+        close: number;
+        tokens: CSSToken[];
+        ends: Map<number, number>;
+    };
+    /** @param {number} index */
+    consumeThrough(index: number): void;
+    /** @param {string} value @param {string} [value2] @return {boolean} */
     isPunct(value: string, value2?: string): boolean;
-    /**
-     * @param {string} value
-     * @return {boolean}
-     */
+    /** @param {string} value @return {boolean} */
     matchPunct(value: string): boolean;
-    /**
-     * @param {string} value
-     * @return {Token}
-     */
+    /** @param {string} value @return {Token} */
     expectPunct(value: string): Token;
-    /**
-     * @param {number} [minBp]
-     * @return {Node}
-     */
+    /** @param {number} [minBp] @return {Node} */
     parseExpr(minBp?: number): Node;
 }
-/**
- * @param {Token[]} tokens
- * @return {Node}
- */
-declare function parse(tokens: Token[]): Node;
+/** @param {CSSToken[]} tokens @param {number} [start] @param {number} [end] @return {Node} */
+declare function parse(tokens: CSSToken[], start?: number, end?: number): Node;
 export { parse };

package/types/lib/serialize.d.ts

@@ -11,6 +11,10 @@ export type SerializeOptions = {
      * Wrapper name to use when `calc()` is needed. Default `'calc'`.
      */
     calcName?: string;
+    /**
+     * Serialize finite negative scalars without a wrapper. Internal selector-only mode.
+     */
+    unwrapSingleNegativeNumber?: boolean;
 };
 /**
  * @param {Node} node

package/types/lib/simplify/bucket.d.ts

@@ -1,20 +1,20 @@
 export type UnitBucket = {
     unit: string;
+    rawUnit?: string;
     total: number;
     /**
      * largest |term| accumulated into `total`, for noise detection
      */
     scale: number;
     base: import('../convertUnits.js').BaseType | null;
-    order: number;
 };
 /**
  * @typedef {object} UnitBucket
  * @property {string} unit
+ * @property {string} [rawUnit]
  * @property {number} total
  * @property {number} scale largest |term| accumulated into `total`, for noise detection
  * @property {import('../convertUnits.js').BaseType | null} base
- * @property {number} order
  */
 /** Mutates `buckets` in place — totals of survivor buckets accumulate the
  *  converted values of merged neighbors. Caller must not reuse the input.

package/types/lib/tokenizer.d.ts

@@ -1,32 +1,3 @@
-export type TokenType = 'number' | 'dimension' | 'ident' | 'punct' | 'eof';
-export type Token = {
-    type: TokenType;
-    value: string;
-    /**
-     * Present on `dimension` tokens; `%` for percentages.
-     */
-    unit?: string;
-    pos: number;
-    /**
-     * Whitespace immediately before — drives the §10.1 `+`/`-` rule.
-     */
-    ws: boolean;
-};
-/**
- * @param {string} input
- * @return {Token[]}
- */
-declare function tokenize(input: string): Token[];
-/**
- * Convert a slice of an existing CSS token stream into the token subset used
- * by the calculation parser. Token positions remain relative to the original
- * source text, which keeps parse errors useful to adapter callers.
- *
- * @param {import('@csstools/css-tokenizer').CSSToken[]} cssTokens
- * @param {number} eofPosition
- * @param {number} [start]
- * @param {number} [end]
- * @return {Token[]}
- */
-declare function tokenizeTokens(cssTokens: import('@csstools/css-tokenizer').CSSToken[], eofPosition: number, start?: number, end?: number): Token[];
-export { tokenize, tokenizeTokens };
+/** @param {string} input @return {import('@csstools/css-tokenizer').CSSToken[]} */
+declare function tokenize(input: string): import('@csstools/css-tokenizer').CSSToken[];
+export { tokenize };

package/types/reduce.d.ts

@@ -2,6 +2,10 @@ import { hasPotentialMathFunction, QUICK_MATH_TEST } from './lib/simplify/call.j
 export type ReduceCalcOptions = {
     precision?: number | false;
     warnWhenCannotResolve?: boolean;
+    /**
+     * Serialize finite negative results without a `calc()` wrapper. Defaults to `false`.
+     */
+    unwrapSingleNegativeNumber?: boolean;
     /**
      * Invoked when parse/simplify throws.
      */
@@ -23,7 +27,6 @@ export type Replacement = {
     end: number;
     node: import('./lib/node.js').Node;
     calcName: string;
-    matchedName: string;
 };
 /**
  * Simplify every supported CSS math function in a component-value string.