Skip to content

Commit b93829a

Browse files
fix(css): keep the calc() around a steps() count jump-none rejects bare (#22168)
* fix(css): keep the calc() around a steps() count jump-none rejects bare The math fold wrote `steps(calc(1), jump-none)` back as `steps(1,jump-none)`, which is not the same function: CSS Easing 2 §2.2 says the count must be at least 2 under `jump-none` and at least 1 under every other step position, so the literal is rejected where the `calc()` around it is clamped. WebKit honours the source and drops the printed form; Blink rejects both, which is why only the WebKit equivalence row reported it. This is the `CLAMPED_VALUE_RANGES` trade one argument in, so it is answered the same way: the generator carries the minimum per `<step-position>` — spec prose no dataset states, since the grammar says only `<integer>` — and the printer declines the bare form below it. A position the table has not met reads as the largest minimum, so an unknown spelling keeps its `calc()` rather than being guessed at. `steps(calc(2), jump-none)` still folds, as does every other position's `calc(1)`, and an omitted position is `end`, which takes one. * fix(css): decline the steps() fold under a position it cannot read The guard read the first identifier among `steps()`'s children, so a position written as a substitution left it at the minimum every position but `jump-none` takes: `steps(calc(1), var(--pos))` folded to `steps(1,var(--pos))`, which `--pos` resolving to `jump-none` makes invalid. The comma now parts the count from the position, and anything standing there that is not a keyword this knows reads as the largest minimum, so the fold declines rather than guess what it resolves to. `steps(calc(2), var(--pos))` still folds, since no position rejects two. * test: assert the folded step count without a substitution WebKit reported the new `steps(calc(2), var(--pos))` case as a difference: a declaration carrying a substitution is not parsed until the substitution resolves, so the engine echoes its text as written and the folded `2` reads apart from the source's `calc(2)`, where Blink folds both alike. The printed form is valid either way — two satisfies every step position — so this is what the engine serializes rather than what the printer wrote. Filing it would exempt the whole fixture from the WebKit row, which is the file this change is about. An unknown keyword makes the same point: the position is one the table cannot read, so the minimum is two and the count folds, with nothing for a substitution to defer. * test(css): drive the steps() count guard in-process The config cases prove the behaviour but cannot report it: the minifier runs where the coverage run does not count it, so the whole math-fold region reads as unexecuted under the integration flag. `codecov/patch` is scoped to `unit` and `integration`, which is why the patch stayed at 46.66% while the comment, counting `syntax-equivalence` too, read 100%. These drive the same assertions through `SourceProcessor` directly, which runs in-process: every line and branch of the guard, each `<step-position>` the generated table names, the omitted position, a spelling it cannot read, a substitution standing where the keyword goes, and a comment between the arguments.
1 parent 6b889c8 commit b93829a

9 files changed

Lines changed: 171 additions & 7 deletions

File tree

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
---
2+
"webpack": patch
3+
---
4+
5+
Keep the `calc()` around a `steps()` count `jump-none` would reject bare.

‎lib/css/data.js‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3597,6 +3597,19 @@ const CALC_REJECTING_PROPERTIES = new Set(["overflow-clip-margin"]);
35973597
/** @type {Map<string, [string, number, number]>} */
35983598
const CLAMPED_VALUE_RANGES = new Map([["font-style", ["deg", -90, 90]]]);
35993599

3600+
// The smallest count `steps()` takes as a literal, keyed by its
3601+
// `<step-position>`. A position missing here is one the table has not met, so
3602+
// it reads as the largest and the fold declines rather than guesses.
3603+
/** @type {Map<string, number>} */
3604+
const STEP_POSITION_MINIMUM_COUNTS = new Map([
3605+
["jump-start", 1],
3606+
["jump-end", 1],
3607+
["jump-both", 1],
3608+
["jump-none", 2],
3609+
["start", 1],
3610+
["end", 1]
3611+
]);
3612+
36003613
// At-rules whose empty block is inert, so dropping it changes nothing.
36013614
const DROPPABLE_WHEN_EMPTY_AT_RULES = new Set([
36023615
"media",
@@ -7954,6 +7967,7 @@ module.exports.SLASH_BOX_SHORTHANDS = SLASH_BOX_SHORTHANDS;
79547967
module.exports.SLASH_LONGHANDS = SLASH_LONGHANDS;
79557968
module.exports.SRGB_SPACE = SRGB_SPACE;
79567969
module.exports.STEPPED_FUNCTIONS = STEPPED_FUNCTIONS;
7970+
module.exports.STEP_POSITION_MINIMUM_COUNTS = STEP_POSITION_MINIMUM_COUNTS;
79577971
module.exports.SUBSTITUTION_FUNCTIONS = SUBSTITUTION_FUNCTIONS;
79587972
module.exports.SUPPORTED_FROM = SUPPORTED_FROM;
79597973
module.exports.SUPPORT_BROWSERS = SUPPORT_BROWSERS;

‎lib/css/syntax.js‎

Lines changed: 58 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -127,6 +127,7 @@ const {
127127
SLASH_LONGHANDS,
128128
SRGB_SPACE,
129129
STEPPED_FUNCTIONS,
130+
STEP_POSITION_MINIMUM_COUNTS,
130131
SUBSTITUTION_FUNCTIONS,
131132
SUPPORTED_FROM,
132133
SUPPORT_BROWSERS,
@@ -7494,6 +7495,61 @@ const _foldLosesClamp = (term) => {
74947495
return match === null || _losesClamp(property, match[1], match[2]);
74957496
};
74967497

7498+
// A folded term that is a plain count, which is the only shape a step count
7499+
// takes — anything else is not the argument this guard judges.
7500+
const _INTEGER_TERM_RE = /^\d+$/;
7501+
7502+
/**
7503+
* Whether writing a folded term bare would take `steps()` under the count its
7504+
* `<step-position>` needs. CSS Easing 2 puts that at two under `jump-none` and
7505+
* one under every other position, and a count below it rejects the function
7506+
* where the `calc()` around the same value is clamped instead.
7507+
* @param {string} term the folded term
7508+
* @param {CssPath} path the accessor positioned on the math function
7509+
* @returns {boolean} true when the `calc()` has to stay
7510+
*/
7511+
const _foldBelowStepCount = (term, path) => {
7512+
// WHY: Folding `steps(calc(1), jump-none)` to `steps(1,jump-none)` printed a
7513+
// function the source did not name. Measured over three engines: WebKit reads
7514+
// the source and drops the printed form, while Blink rejects both — which is
7515+
// why one engine alone could not see it.
7516+
const parent = path.parent;
7517+
if (
7518+
parent === null ||
7519+
path.type(parent) !== T_FUNCTION ||
7520+
!_INTEGER_TERM_RE.test(term) ||
7521+
asciiLowerCaseName(path.name(parent)) !== "steps"
7522+
) {
7523+
return false;
7524+
}
7525+
// An omitted position is `end`, which takes one. A position this cannot read
7526+
// — an unknown spelling, or a substitution where the keyword goes — reads as
7527+
// the largest, so the fold declines rather than guess what it resolves to.
7528+
let minimum = 1;
7529+
let afterComma = false;
7530+
const count = path.childCount(parent);
7531+
for (let at = 0; at < count; at++) {
7532+
const child = path.childAt(parent, at);
7533+
const type = path.type(child);
7534+
if (type === T_COMMA) {
7535+
afterComma = true;
7536+
continue;
7537+
}
7538+
// Before the comma stands the count itself, and either side may carry
7539+
// whitespace or a comment between the arguments.
7540+
if (!afterComma || type === T_WHITESPACE || type === T_COMMENT) continue;
7541+
const named =
7542+
type === T_IDENT
7543+
? STEP_POSITION_MINIMUM_COUNTS.get(
7544+
asciiLowerCaseName(path.value(child))
7545+
)
7546+
: undefined;
7547+
minimum = named === undefined ? 2 : named;
7548+
break;
7549+
}
7550+
return Number(term) < minimum;
7551+
};
7552+
74977553
/**
74987554
* Put back the fraction that keeps a number a `<number>` token, in the spelling
74997555
* the rest of the printer uses — one fractional digit, and no leading zero.
@@ -17219,7 +17275,8 @@ const printer = (path, writer) => {
1721917275
const folded =
1722017276
shape.test(term) &&
1722117277
!_inCalcRejectingProperty() &&
17222-
!_foldLosesClamp(term)
17278+
!_foldLosesClamp(term) &&
17279+
!_foldBelowStepCount(term, path)
1722317280
? term
1722417281
: `calc(${term})`;
1722517282
// A division can land on a value needing every digit of a double, which

‎test/configCases/css/minimize-timing-functions/__snapshots__/ConfigCacheTest.snap‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -43,5 +43,12 @@ Array [
4343
"/*! webpack: a custom property's easing function is opaque, bar its spacing */.t39{--easing:cubic-bezier(0.25,0.1,0.25,1)}",
4444
"/*! webpack: a signed argument still resolves to the keyword */.t40{animation-timing-function:ease-in-out}",
4545
"/*! webpack: a non-integer step count keeps the function */.t41{animation-timing-function:steps(1.5,end)}",
46+
"/*! webpack: jump-none takes two intervals, so a calc() holding one has to stay */.t42{animation-timing-function:steps(calc(1),jump-none)}",
47+
"/*! webpack: the same count is folded where jump-none can hold it */.t43{animation-timing-function:steps(2,jump-none)}",
48+
"/*! webpack: every other position takes one, so its calc() folds */.t44{animation-timing-function:steps(1,jump-both)}",
49+
"/*! webpack: an omitted position is end, which takes one */.t45{animation-timing-function:steps(1)}",
50+
"/*! webpack: a position no grammar here states keeps its calc() */.t46{animation-timing-function:steps(calc(1),jump-sideways)}",
51+
"/*! webpack: a substitution could name jump-none, so its calc() has to stay */.t47{animation-timing-function:steps(calc(1),var(--pos))}",
52+
"/*! webpack: the same count is folded where no position could reject it */.t48{animation-timing-function:steps(2,jump-sideways)}",
4653
]
4754
`;

‎test/configCases/css/minimize-timing-functions/__snapshots__/ConfigTest.snap‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -43,5 +43,12 @@ Array [
4343
"/*! webpack: a custom property's easing function is opaque, bar its spacing */.t39{--easing:cubic-bezier(0.25,0.1,0.25,1)}",
4444
"/*! webpack: a signed argument still resolves to the keyword */.t40{animation-timing-function:ease-in-out}",
4545
"/*! webpack: a non-integer step count keeps the function */.t41{animation-timing-function:steps(1.5,end)}",
46+
"/*! webpack: jump-none takes two intervals, so a calc() holding one has to stay */.t42{animation-timing-function:steps(calc(1),jump-none)}",
47+
"/*! webpack: the same count is folded where jump-none can hold it */.t43{animation-timing-function:steps(2,jump-none)}",
48+
"/*! webpack: every other position takes one, so its calc() folds */.t44{animation-timing-function:steps(1,jump-both)}",
49+
"/*! webpack: an omitted position is end, which takes one */.t45{animation-timing-function:steps(1)}",
50+
"/*! webpack: a position no grammar here states keeps its calc() */.t46{animation-timing-function:steps(calc(1),jump-sideways)}",
51+
"/*! webpack: a substitution could name jump-none, so its calc() has to stay */.t47{animation-timing-function:steps(calc(1),var(--pos))}",
52+
"/*! webpack: the same count is folded where no position could reject it */.t48{animation-timing-function:steps(2,jump-sideways)}",
4653
]
4754
`;

‎test/configCases/css/minimize-timing-functions/style.css‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -86,3 +86,18 @@
8686
.t40 { animation-timing-function: cubic-bezier(+0.42, -0, 0.58, 1) }
8787
/*! webpack: a non-integer step count keeps the function */
8888
.t41 { animation-timing-function: steps(1.5, end) }
89+
90+
/*! webpack: jump-none takes two intervals, so a calc() holding one has to stay */
91+
.t42 { animation-timing-function: steps(calc(1), jump-none) }
92+
/*! webpack: the same count is folded where jump-none can hold it */
93+
.t43 { animation-timing-function: steps(calc(2), jump-none) }
94+
/*! webpack: every other position takes one, so its calc() folds */
95+
.t44 { animation-timing-function: steps(calc(1), jump-both) }
96+
/*! webpack: an omitted position is end, which takes one */
97+
.t45 { animation-timing-function: steps(calc(1)) }
98+
/*! webpack: a position no grammar here states keeps its calc() */
99+
.t46 { animation-timing-function: steps(calc(1), jump-sideways) }
100+
/*! webpack: a substitution could name jump-none, so its calc() has to stay */
101+
.t47 { animation-timing-function: steps(calc(1), var(--pos)) }
102+
/*! webpack: the same count is folded where no position could reject it */
103+
.t48 { animation-timing-function: steps(calc(2), jump-sideways) }

‎test/specCases/syntaxEquivalence.spectest.js‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -255,10 +255,6 @@ const FILED_WPT_VALUE_DEFECTS = new Map([
255255
"background-image:paint(mypaint ",
256256
"webkit only: the unimplemented `paint()` again \u2014 see `paint( mypaint`"
257257
],
258-
[
259-
"animation-timing-function:steps(calc(1), jump-none)",
260-
"webkit only: a printer defect, not yet decided \u2014 WebKit reads the step count through a `calc()` where the printed form drops it. Measured in the first WebKit run"
261-
],
262258
[
263259
"font-family:\"New Century Schoolbook\", serif",
264260
"firefox only: not a printer defect — Gecko carries the source's quoting into the computed family where Blink drops it, so unquoting a name neither engine reads differently still reads as a difference there"

‎test/unitCases/CssSyntax.unittest.js‎

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6888,6 +6888,48 @@ describe("CssSyntax minify — the value transforms' rejection paths", () => {
68886888
expect(minify("a{width:calc(5px - 5px)}")).toBe("a{width:0}");
68896889
});
68906890

6891+
it("keeps them on a `steps()` count its position would reject", () => {
6892+
// CSS Easing 2 puts the minimum at two under `jump-none` and one under
6893+
// every other position, and the bare literal is rejected where the
6894+
// `calc()` around the same value is clamped instead.
6895+
expect(value("steps(calc(1),jump-none)")).toBe("steps(calc(1),jump-none)");
6896+
expect(value("steps(calc(2),jump-none)")).toBe("steps(2,jump-none)");
6897+
expect(value("steps(calc(1),jump-both)")).toBe("steps(1,jump-both)");
6898+
// An omitted position is `end`, which takes one.
6899+
expect(value("steps(calc(1))")).toBe("steps(1)");
6900+
// Both names are read case-insensitively, so the guard still reads the
6901+
// position a source spelled in capitals.
6902+
expect(value("STEPS(calc(1),JUMP-NONE)")).toBe("steps(calc(1),JUMP-NONE)");
6903+
});
6904+
6905+
it("reads a `steps()` position it cannot name as the largest", () => {
6906+
// An unknown spelling, and a substitution standing where the keyword
6907+
// goes, could both resolve to `jump-none`, so the fold declines below
6908+
// two rather than guess.
6909+
expect(value("steps(calc(1),jump-sideways)")).toBe(
6910+
"steps(calc(1),jump-sideways)"
6911+
);
6912+
expect(value("steps(calc(2),jump-sideways)")).toBe(
6913+
"steps(2,jump-sideways)"
6914+
);
6915+
expect(value("steps(calc(1),var(--pos))")).toBe(
6916+
"steps(calc(1),var(--pos))"
6917+
);
6918+
// A comment between the arguments is not the position.
6919+
expect(value("steps(calc(1),/*c*/jump-none)")).toBe(
6920+
"steps(calc(1),jump-none)"
6921+
);
6922+
});
6923+
6924+
it("drives every `<step-position>` the table names", () => {
6925+
// `steps(1, …)` has a keyword of its own at each end, which is what the
6926+
// positions taking one count print as.
6927+
expect(value("steps(calc(1),jump-start)")).toBe("step-start");
6928+
expect(value("steps(calc(1),start)")).toBe("step-start");
6929+
expect(value("steps(calc(1),jump-end)")).toBe("step-end");
6930+
expect(value("steps(calc(1),end)")).toBe("step-end");
6931+
});
6932+
68916933
it("does not run inside a `@supports` condition or a custom property", () => {
68926934
const supports = "@supports (width:calc(1px + 2px)){a{color:red}}";
68936935
expect(minify(supports)).toBe(supports);

‎tooling/generate-css-data.js‎

Lines changed: 23 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3777,7 +3777,7 @@ const eighthTurnEntries = (values) => {
37773777
// Spec prose no dataset states: an equivalence between two spellings, or a
37783778
// judgement about what a construct still does. Each carries the reason it has to
37793779
// be written out rather than derived.
3780-
/** @type {{ cssWideKeywords: string[], cubicBezierKeywords: [string, string][], flexKeywords: [string, string][], fontWeightNumbers: [string, string][], fontStretchPercentages: [string, string][], filterFunctionOmitted: [string, string][], positionKeywordPercentages: [string, string][], legacyPseudoElements: string[], compoundContinuations: string[], featurelessPseudoClasses: string[], initialValueKeywords: [string, string][], initialKeywordsAnEngineReadsApart: string[], unmergeableSlotKeywords: [string, string][], zeroUnitKeepingProperties: string[], calcRejectingProperties: string[], clampedValueRanges: [string, string, number, number][], autoSecondValueProperties: string[], defaultGradientDirections: string[], xAxisTransforms: [string, string][], negativeAcceptingProperties: string[], placeShorthands: string[], oneValuePairShorthands: string[], familyShorthands: string[], orderedShorthands: string[], omittableInitialKeywords: string[], pairLonghandOverrides: [string, string[]][], droppableWhenEmptyAtRules: string[], replacedByNameAtRules: string[], classSpellings: [string, string[]][], absoluteUnitScale: [string, string, number][], unitConversionTargets: string[], angleUnits: string[], colorSpacePrimitives: [string, string][], oklabMatrices: number[][], systemUiStack: string[], colorTransfers: [string, string][], predefinedColorSpaces: [string, string, string, string][], colorPrimaries: [string, number[]][], colorWhitePoints: [string, number[]][], enginesDisagreeOnTransfer: string[], calcConstantValues: [string, string][], quarterTurnAngle: [string, number][], eighthTurnSine: (number | null)[], eighthTurnTangent: (number | null)[], mathFunctionFold: [string, string, string, string, string | null, boolean][], mathPrimitives: [string, string][], predefinedCounterStyles: string[], predefinedCounterNames: string[], cssModulesKeywordSupplement: [string, string, number][] }} */
3780+
/** @type {{ cssWideKeywords: string[], cubicBezierKeywords: [string, string][], flexKeywords: [string, string][], fontWeightNumbers: [string, string][], fontStretchPercentages: [string, string][], filterFunctionOmitted: [string, string][], positionKeywordPercentages: [string, string][], legacyPseudoElements: string[], compoundContinuations: string[], featurelessPseudoClasses: string[], initialValueKeywords: [string, string][], initialKeywordsAnEngineReadsApart: string[], unmergeableSlotKeywords: [string, string][], zeroUnitKeepingProperties: string[], calcRejectingProperties: string[], clampedValueRanges: [string, string, number, number][], stepPositionMinimumCounts: [string, number][], autoSecondValueProperties: string[], defaultGradientDirections: string[], xAxisTransforms: [string, string][], negativeAcceptingProperties: string[], placeShorthands: string[], oneValuePairShorthands: string[], familyShorthands: string[], orderedShorthands: string[], omittableInitialKeywords: string[], pairLonghandOverrides: [string, string[]][], droppableWhenEmptyAtRules: string[], replacedByNameAtRules: string[], classSpellings: [string, string[]][], absoluteUnitScale: [string, string, number][], unitConversionTargets: string[], angleUnits: string[], colorSpacePrimitives: [string, string][], oklabMatrices: number[][], systemUiStack: string[], colorTransfers: [string, string][], predefinedColorSpaces: [string, string, string, string][], colorPrimaries: [string, number[]][], colorWhitePoints: [string, number[]][], enginesDisagreeOnTransfer: string[], calcConstantValues: [string, string][], quarterTurnAngle: [string, number][], eighthTurnSine: (number | null)[], eighthTurnTangent: (number | null)[], mathFunctionFold: [string, string, string, string, string | null, boolean][], mathPrimitives: [string, string][], predefinedCounterStyles: string[], predefinedCounterNames: string[], cssModulesKeywordSupplement: [string, string, number][] }} */
37813781

37823782
const SUPPLEMENT = {
37833783
// CSS Values 4's list. `mdn-data` has no `css-wide-keyword` production.
@@ -3908,6 +3908,19 @@ const SUPPLEMENT = {
39083908
// declaration off. CSS Fonts 4 §2.3 bounds `oblique` at ±90deg; `mdn-data`
39093909
// states `oblique <angle>` with no range, and no dataset carries the clamp.
39103910
clampedValueRanges: [["font-style", "deg", -90, 90]],
3911+
// WHY: The same trade one argument in: `steps()` clamps a count below its
3912+
// minimum inside a `calc()` and rejects the bare literal, so folding one to
3913+
// the value it equals switches the easing off. CSS Easing 2 §2.2 states the
3914+
// minimum as prose — `jump-none` holds neither end, so it takes two intervals
3915+
// to have any — and the grammar `mdn-data` carries says only `<integer>`.
3916+
stepPositionMinimumCounts: [
3917+
["jump-start", 1],
3918+
["jump-end", 1],
3919+
["jump-both", 1],
3920+
["jump-none", 2],
3921+
["start", 1],
3922+
["end", 1]
3923+
],
39113924
// CSS Backgrounds 3 §3.9 / CSS Masking 1 §4.5: these spell an omitted second
39123925
// value `auto`, not the first repeated. Their shared grammar cannot say so.
39133926
autoSecondValueProperties: ["background-size", "mask-size"],
@@ -7233,6 +7246,14 @@ const CLAMPED_VALUE_RANGES = new Map([${SUPPLEMENT.clampedValueRanges
72337246
.map(([name, unit, min, max]) => `["${name}", ["${unit}", ${min}, ${max}]]`)
72347247
.join(", ")}]);
72357248
7249+
// The smallest count \`steps()\` takes as a literal, keyed by its
7250+
// \`<step-position>\`. A position missing here is one the table has not met, so
7251+
// it reads as the largest and the fold declines rather than guesses.
7252+
/** @type {Map<string, number>} */
7253+
const STEP_POSITION_MINIMUM_COUNTS = new Map([${SUPPLEMENT.stepPositionMinimumCounts
7254+
.map(([name, min]) => `["${name}", ${min}]`)
7255+
.join(", ")}]);
7256+
72367257
// At-rules whose empty block is inert, so dropping it changes nothing.
72377258
const DROPPABLE_WHEN_EMPTY_AT_RULES = ${setLiteral(
72387259
SUPPLEMENT.droppableWhenEmptyAtRules
@@ -7608,7 +7629,7 @@ module.exports.PREFIX_WINDOWS = PREFIX_WINDOWS;\nmodule.exports.PREFIX_WINDOW_ST
76087629
module.exports.QUARTER_TURN_ANGLE = QUARTER_TURN_ANGLE;
76097630
module.exports.RATIO_PROPERTIES = RATIO_PROPERTIES;\nmodule.exports.REPEAT_STYLE_KEYWORDS = REPEAT_STYLE_KEYWORDS;\nmodule.exports.REPEAT_STYLE_PROPERTIES = REPEAT_STYLE_PROPERTIES;\nmodule.exports.RGB_TO_NAME = RGB_TO_NAME;
76107631
module.exports.SELECTOR_FUNCTIONS = SELECTOR_FUNCTIONS;\nmodule.exports.SELECTOR_SUPPORTED_FROM = SELECTOR_SUPPORTED_FROM;\nmodule.exports.SHADOW_PROPERTIES = SHADOW_PROPERTIES;\nmodule.exports.SHORTHAND_INITIAL_KEYWORDS = SHORTHAND_INITIAL_KEYWORDS;\nmodule.exports.SHORTHAND_LONGHANDS = SHORTHAND_LONGHANDS;\nmodule.exports.SLASH_BOX_SHORTHANDS = SLASH_BOX_SHORTHANDS;\nmodule.exports.SLASH_LONGHANDS = SLASH_LONGHANDS;\nmodule.exports.SRGB_SPACE = SRGB_SPACE;
7611-
module.exports.STEPPED_FUNCTIONS = STEPPED_FUNCTIONS;
7632+
module.exports.STEPPED_FUNCTIONS = STEPPED_FUNCTIONS;\nmodule.exports.STEP_POSITION_MINIMUM_COUNTS = STEP_POSITION_MINIMUM_COUNTS;
76127633
module.exports.SUBSTITUTION_FUNCTIONS = SUBSTITUTION_FUNCTIONS;\nmodule.exports.SUPPORTED_FROM = SUPPORTED_FROM;\nmodule.exports.SUPPORT_BROWSERS = SUPPORT_BROWSERS;\nmodule.exports.SUPPORT_PROFILES = SUPPORT_PROFILES;\nmodule.exports.SYSTEM_UI_STACK = SYSTEM_UI_STACK;\nmodule.exports.THROUGH_MATRIX = THROUGH_MATRIX;\nmodule.exports.THROUGH_TRANSFER = THROUGH_TRANSFER;\nmodule.exports.TRANSITION_BEHAVIORS = TRANSITION_BEHAVIORS;
76137634
module.exports.UNIT_CONVERSION_TARGETS = UNIT_CONVERSION_TARGETS;
76147635
module.exports.UNIT_GROUP_BASE = UNIT_GROUP_BASE;\nmodule.exports.UNSHARED_LONGHAND_KEYWORDS = UNSHARED_LONGHAND_KEYWORDS;\nmodule.exports.VALUE_SUPPORT_PACKED = VALUE_SUPPORT_PACKED;\nmodule.exports.X_AXIS_TRANSFORMS = X_AXIS_TRANSFORMS;

0 commit comments

Comments
 (0)