bestax-migrate 2.10.0 → 2.12.0

package/dist/sources/bulma-classes/class-map.d.ts

@@ -29,6 +29,12 @@ export interface Modifier {
     readonly writes: readonly PropWrite[];
     /** The raw tags the writes are exact on (Title's size picks its heading). */
     readonly tagIn?: readonly string[];
+    /**
+     * The prop renders the class for `true` alone, not for any truthy value
+     * (`Field`'s `grouped`), so a condition a joiner adds it under can't be
+     * handed to the prop as it is.
+     */
+    readonly onlyTrue?: boolean;
 }
 /**
  * - `mapped`: converts to `target`.
@@ -131,6 +137,17 @@ export interface RootEntry {
     readonly folds?: readonly PropWrite[];
     /** The target renders the element's only child itself. */
     readonly absorbs?: Absorbs;
+    /** Props the target needs to render this class at all (`variant="lines"`). */
+    readonly writes?: readonly PropWrite[];
+    /**
+     * The target renders the element's children itself, `prop` of them, each
+     * a bare, empty `<tag>`. The element converts only when its children are
+     * just that, and they go (`.skeleton-lines`' `<div>`s, as `lines`).
+     */
+    readonly countsChildren?: {
+        readonly tag: string;
+        readonly prop: string;
+    };
     /** The target takes no helper props, so every helper class stays a class. */
     readonly noHelpers?: boolean;
     /**

package/dist/sources/bulma-classes/class-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"class-map.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/class-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,MAAM,MAAM,GAChB;IAAE,QAAQ,CAAC,EAAE,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAE9E,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAE9D;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,uBAAuB;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IACxD;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CACzB,MAAM,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CACjE,CAAC;CACH;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,+CAA+C;IAC/C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,KAAK,CAAC;IACxC,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IACxD,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,CAAC,EAAE,WAAW,GAAG,OAAO,GAAG,IAAI,CAAC;IAClD,mFAAmF;IACnF,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,iBAAiB,GAAG,IAAI,CAAC;IACxD,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACrD;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,iDAAiD;IACjD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE;QACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;QACnC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;QAC7B,+EAA+E;QAC/E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF;;;;OAIG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACnD;AAID,eAAO,MAAM,MAAM,+NAoBT,CAAC;AACX,eAAO,MAAM,KAAK,sDAAuD,CAAC;AAC1E,eAAO,MAAM,UAAU,8CAA+C,CAAC;AACvE,eAAO,MAAM,UAAU,qDAAsD,CAAC;AAC9E,eAAO,MAAM,eAAe,8DAKlB,CAAC;AACX,eAAO,MAAM,YAAY,4DAMf,CAAC;AACX,eAAO,MAAM,aAAa,sEAMhB,CAAC;AACX,eAAO,MAAM,QAAQ,6EAOX,CAAC;AACX,eAAO,MAAM,eAAe,6DAKlB,CAAC;AACX,eAAO,MAAM,UAAU,6CAA8C,CAAC;AACtE,eAAO,MAAM,gBAAgB,iIAWnB,CAAC;AACX,eAAO,MAAM,cAAc,2GAQjB,CAAC;AACX,eAAO,MAAM,WAAW,sFAQd,CAAC;AACX,eAAO,MAAM,WAAW,8EAOd,CAAC;AACX,eAAO,MAAM,gBAAgB,yCAA0C,CAAC;AACxE,eAAO,MAAM,SAAS,6HAUZ,CAAC;AAuDX,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKvD;AAyED,eAAO,MAAM,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CA8nCrD,CAAC;AAcF;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,SAAS,MAAM,EAwDvC,CAAC;AAEF,yDAAyD;AACzD,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EASzC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYrD,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAYzE,CAAC;AAEF,6DAA6D;AAC7D,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEtD,CAAC;AAIF;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB,YAAY,GACZ,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,gBAAgB,GAChB,WAAW,GACX,OAAO,CAAC;AAEZ,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;CAC3B;AA6DD,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAsGzD,CAAC;AAEH,iEAAiE;AACjE,eAAO,MAAM,YAAY,EAAE,WAAW,CAAC,MAAM,CAS3C,CAAC;AAIH;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CA0CA,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEnE;AAiBD,qCAAqC;AACrC,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE5D;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAGlE;AAED,qCAAqC;AACrC,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,GACZ,QAAQ,GAAG,SAAS,CAEtB;AAED,kDAAkD;AAClD,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE5D;AAED,0CAA0C;AAC1C,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE1D"}
+{"version":3,"file":"class-map.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/class-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,MAAM,MAAM,GAChB;IAAE,QAAQ,CAAC,EAAE,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAE9E,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAE9D;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,uBAAuB;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IACxD;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CACzB,MAAM,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CACjE,CAAC;CACH;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,+CAA+C;IAC/C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,KAAK,CAAC;IACxC,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IACxD,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,CAAC,EAAE,WAAW,GAAG,OAAO,GAAG,IAAI,CAAC;IAClD,mFAAmF;IACnF,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,iBAAiB,GAAG,IAAI,CAAC;IACxD,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACrD;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,iDAAiD;IACjD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE;QACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;QACnC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;QAC7B,+EAA+E;QAC/E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF;;;;OAIG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACvC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1E,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACnD;AAID,eAAO,MAAM,MAAM,+NAoBT,CAAC;AACX,eAAO,MAAM,KAAK,sDAAuD,CAAC;AAC1E,eAAO,MAAM,UAAU,8CAA+C,CAAC;AACvE,eAAO,MAAM,UAAU,qDAAsD,CAAC;AAC9E,eAAO,MAAM,eAAe,8DAKlB,CAAC;AACX,eAAO,MAAM,YAAY,4DAMf,CAAC;AACX,eAAO,MAAM,aAAa,sEAMhB,CAAC;AACX,eAAO,MAAM,QAAQ,6EAOX,CAAC;AACX,eAAO,MAAM,eAAe,6DAKlB,CAAC;AACX,eAAO,MAAM,UAAU,6CAA8C,CAAC;AACtE,eAAO,MAAM,gBAAgB,iIAWnB,CAAC;AACX,eAAO,MAAM,cAAc,2GAQjB,CAAC;AACX,eAAO,MAAM,WAAW,sFAQd,CAAC;AACX,eAAO,MAAM,WAAW,8EAOd,CAAC;AACX,eAAO,MAAM,gBAAgB,yCAA0C,CAAC;AACxE,eAAO,MAAM,SAAS,6HAUZ,CAAC;AAuDX,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKvD;AAyED,eAAO,MAAM,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAgpCrD,CAAC;AAcF;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,SAAS,MAAM,EAwDvC,CAAC;AAEF,yDAAyD;AACzD,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EASzC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYrD,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAYzE,CAAC;AAEF,6DAA6D;AAC7D,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEtD,CAAC;AAIF;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB,YAAY,GACZ,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,gBAAgB,GAChB,WAAW,GACX,OAAO,CAAC;AAEZ,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;CAC3B;AA6DD,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAsGzD,CAAC;AAEH,iEAAiE;AACjE,eAAO,MAAM,YAAY,EAAE,WAAW,CAAC,MAAM,CAS3C,CAAC;AAIH;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CA0CA,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEnE;AAiBD,qCAAqC;AACrC,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE5D;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAGlE;AAED,qCAAqC;AACrC,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,GACZ,QAAQ,GAAG,SAAS,CAEtB;AAED,kDAAkD;AAClD,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE5D;AAED,0CAA0C;AAC1C,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE1D"}

package/dist/sources/bulma-classes/class-map.js

@@ -621,12 +621,16 @@ export const ROOTS = {
         tag: 'div',
         // `has-addons-centered`, `is-grouped-right` and the like stay classes:
         // the prop values that render them render `has-addons` too.
-        modifiers: flags({
-            'is-horizontal': 'horizontal',
-            'is-grouped': 'grouped',
-            'has-addons': 'hasAddons',
-            'is-narrow': 'narrow',
-        }),
+        modifiers: {
+            ...flags({
+                'is-horizontal': 'horizontal',
+                'has-addons': 'hasAddons',
+                'is-narrow': 'narrow',
+            }),
+            // `grouped` renders `is-grouped` for `true` and its three layouts, and
+            // for nothing else truthy.
+            'is-grouped': { writes: [{ prop: 'grouped' }], onlyTrue: true },
+        },
         wrapsChildren: {
             in: 'field-body',
             unless: ['Field.Label', 'Field.Body'],
@@ -1155,6 +1159,28 @@ export const ROOTS = {
         absorbs: { tag: 'ul', attributesOn: 'element' },
         ownProps: ['alignment', 'separator', 'size'],
     },
+    // `Skeleton` takes no helper props: what it isn't given as its own reaches
+    // the DOM as an attribute, so every helper class stays a class.
+    'skeleton-block': {
+        status: 'mapped',
+        target: 'Skeleton',
+        tag: 'div',
+        textColor: null,
+        bgColor: null,
+        noHelpers: true,
+        ownProps: ['variant', 'lines'],
+    },
+    'skeleton-lines': {
+        status: 'mapped',
+        target: 'Skeleton',
+        tag: 'div',
+        textColor: null,
+        bgColor: null,
+        noHelpers: true,
+        writes: [{ prop: 'variant', value: 'lines' }],
+        countsChildren: { tag: 'div', prop: 'lines' },
+        ownProps: ['variant', 'lines'],
+    },
     // ---- Families bestax has but that do not map element by element yet ------
     checkbox: todo('Checkbox', "bestax `Checkbox` renders its own styled markup, not Bulma's"),
     checkboxes: todo('Checkboxes', 'bestax `Checkboxes` renders its own `.field` and `.control` wrappers'),
@@ -1205,8 +1231,6 @@ export const ROOTS = {
     'panel-icon': part(),
     'panel-list': part(),
     tabs: todo('Tabs', "bestax `Tabs` renders each tab's `<li>` and `<a>` together, with tab roles"),
-    'skeleton-block': todo('Skeleton', 'bestax `Skeleton` renders its own markup'),
-    'skeleton-lines': todo('Skeleton', 'bestax `Skeleton` renders its own markup'),
     // ---- Wrappers a component renders from a prop ---------------------------------
     // Each renders the wrapper with its own class and nothing else, so the
     // element folds only when it carries no attribute and no other class.

package/dist/sources/bulma-classes/plan.d.ts

@@ -13,6 +13,19 @@ export interface ElementFacts {
     tag: string;
     /** The static className, split on whitespace, in order. */
     tokens: readonly string[];
+    /**
+     * For a `className` a class joiner builds (`clsx('button', busy &&
+     * 'is-loading')`), the classes each condition adds, one list per condition;
+     * `tokens` then holds the ones it always adds. Set only when the codemod
+     * can read every argument.
+     */
+    conditional?: readonly (readonly string[])[];
+    /**
+     * Indexes into `conditional` of conditions that may have side effects (a
+     * call, an assignment). A condition that becomes a prop is evaluated before
+     * the ones left in the call, so it passes them only when neither is one.
+     */
+    impure?: readonly number[];
     /**
      * The element's other attributes: a string value, `true` for a bare
      * attribute, or null for an expression.
@@ -38,6 +51,12 @@ export interface ElementFacts {
      * entry that `absorbs` it reads.
      */
     soleChild?: ChildFacts;
+    /**
+     * The element's children, when every one React renders is a plain HTML
+     * element; left out when one is anything else (text, an expression, a
+     * component). What an entry that `countsChildren` reads.
+     */
+    childElements?: readonly ChildFacts[];
     /** The bestax components already in the file inside this element. */
     bestaxInside?: readonly string[];
     /** The bestax components already in the file around this element. */
@@ -67,6 +86,11 @@ export interface ChildFacts {
      */
     attributes: ReadonlyMap<string, string | number | true | null>;
     hasSpread: boolean;
+    /**
+     * Nothing inside it but whitespace React drops. A comment is something:
+     * an element that goes would take it with it.
+     */
+    isEmpty: boolean;
 }
 export interface Todo {
     rule: string;
@@ -99,6 +123,16 @@ export interface Conversion {
         /** Child attributes a prop above renders instead. */
         drop: string[];
     };
+    /**
+     * The target renders the element's children itself, from a prop above:
+     * they go, and the element closes itself.
+     */
+    rendersChildren?: true;
+    /**
+     * Conditional classes (`ElementFacts.conditional`) that become a boolean
+     * prop set to their condition, each once. The rest stay in the joiner call.
+     */
+    conditional?: Array<[prop: string, token: string]>;
 }
 export interface Plan {
     conversion: Conversion | null;

package/dist/sources/bulma-classes/plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAiBH,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,2DAA2D;IAC3D,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B;;;OAGG;IACH,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC;IACtD,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,4EAA4E;IAC5E,WAAW,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,qEAAqE;IACrE,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,qEAAqE;IACrE,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAClC;;;OAGG;IACH,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC;IAC/D,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IACnD,4DAA4D;IAC5D,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,mEAAmE;IACnE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;OAGG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE;QACR,oEAAoE;QACpE,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;QACnD,4DAA4D;QAC5D,OAAO,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;QAC3C,qDAAqD;QACrD,IAAI,EAAE,MAAM,EAAE,CAAC;KAChB,CAAC;CACH;AAED,MAAM,WAAW,IAAI;IACnB,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B;;;OAGG;IACH,IAAI,CAAC,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;QACnD,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;IACF,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AA+BD,wBAAgB,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CA0S9C"}
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/plan.ts"],"names":[],"mappings":"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"}

package/dist/sources/bulma-classes/plan.js

@@ -42,7 +42,13 @@ function tagsItReaches(entry) {
 export function plan(facts) {
     const todos = [];
     const { tag, tokens } = facts;
-    for (const token of tokens) {
+    // Every class the element may carry: its fixed ones, and any a condition
+    // adds, which the element has to be right with as well as without.
+    const carried = [
+        ...new Set([...tokens, ...(facts.conditional ?? []).flat()]),
+    ];
+    const mayCarry = (token) => carried.includes(token);
+    for (const token of carried) {
         const hint = legacyHint(token);
         if (hint)
             todos.push({ rule: ruleId('legacy', token), message: hint });
@@ -50,7 +56,7 @@ export function plan(facts) {
     // A family this source leaves as markup keeps its element as markup, even
     // beside a class it would convert (`navbar box`): the family's parts carry no
     // TODO of their own, so its outermost class is the one place it is flagged.
-    const family = tokens.find(token => {
+    const family = carried.find(token => {
         const found = rootFor(token);
         return found?.status === 'todo' && !found.part;
     });
@@ -74,7 +80,7 @@ export function plan(facts) {
     else {
         // A root the table does not convert keeps the element as markup, so a
         // later pass (or a person) still finds it as the class it is.
-        if (tokens.some(token => rootFor(token))) {
+        if (carried.some(token => rootFor(token))) {
             return { conversion: null, todos };
         }
         entry = wrapperEntry(tag);
@@ -110,6 +116,11 @@ export function plan(facts) {
     if (attributes.has('dangerouslySetInnerHTML')) {
         return refuse('attr', 'dangerouslySetInnerHTML', `\`dangerouslySetInnerHTML\` sets the element's content directly, and some bestax components render content of their own beside \`children\`, which React rejects; keep this element as markup`);
     }
+    // Every fact about the element's children comes from the JSX inside it, so
+    // children passed as an attribute are content none of them sees.
+    if (attributes.has('children')) {
+        return refuse('attr', 'children', `this element sets \`children\` as an attribute, and the codemod reads an element's children from the JSX inside it, so it can't tell what bestax \`${target}\` would render from these; move them inside the element, then re-run`);
+    }
     for (const name of attributes.keys()) {
         if (renamed.has(name))
             continue;
@@ -158,11 +169,20 @@ export function plan(facts) {
     }
     const wraps = entry.wrapsChildren;
     if (wraps &&
-        (!wraps.when || tokens.includes(wraps.when)) &&
+        (!wraps.when || mayCarry(wraps.when)) &&
         (facts.hasChildren || wraps.whenEmpty) &&
         !facts.childTargets?.some(child => wraps.unless.includes(child))) {
         return refuse('children', target, `bestax \`${target}\` renders its children inside a \`.${wraps.in}\` of its own unless one of them is a ${orList(wraps.unless)}, so this element stays markup`);
     }
+    const counts = entry.countsChildren;
+    const counted = facts.childElements?.every(child => child.tag === counts?.tag &&
+        child.tokens === undefined &&
+        child.attributes.size === 0 &&
+        !child.hasSpread &&
+        child.isEmpty);
+    if (counts && !counted) {
+        return refuse('children', target, `bestax \`${target}\` renders this element's children itself, \`${counts.prop}\` bare, empty <${counts.tag}>s, so it converts only when its children are just that; keep it as markup`);
+    }
     if (missing.length > 0) {
         const list = missing.map(([name, value]) => `\`${name}="${value}"\``);
         return refuse('defaults', target, `bestax \`${target}\` renders ${list.join(' and ')} when the element does not set ${missing.length === 1 ? 'it' : 'them'}; add ${missing.length === 1 ? 'it' : 'them'} here if that is what you want, then re-run`);
@@ -178,7 +198,8 @@ export function plan(facts) {
         }
     }
     // ---- Tokens → props ---------------------------------------------------------
-    const writes = new Map();
+    // What the root itself needs comes first, so no class can take its prop.
+    const writes = new Map((entry.writes ?? []).map(write => [write.prop, write.value ?? true]));
     /** The tokens each written prop came from, so a group rule can undo it. */
     const sourceOf = new Map();
     const groupOf = new Map();
@@ -254,8 +275,49 @@ export function plan(facts) {
     if (as)
         props.push(['as', as]);
     props.push(...writes);
+    if (counts) {
+        props.push([counts.prop, String(facts.childElements.length)]);
+        numbers.push(counts.prop);
+    }
+    // A class a condition adds becomes the boolean prop that renders it, set to
+    // that condition, when it is one of the root's flags on its own: the
+    // component renders it exactly when the condition is truthy, as the joiner
+    // does. Anything else a condition adds stays in the joiner call.
+    const parts = facts.conditional ?? [];
+    const conditional = [];
+    let conditionalStays = false;
+    const places = (token) => parts.filter(part => part.includes(token)).length +
+        (tokens.includes(token) ? 1 : 0);
+    const paired = new Set(Object.values(entry.absorbs?.pairs ?? {}));
+    const impure = new Set(facts.impure ?? []);
+    let impureStays = false;
+    parts.forEach((part, index) => {
+        const [token] = part;
+        const modifier = part.length === 1 && places(token) === 1 && !paired.has(token)
+            ? modifierFor(entry, token)
+            : undefined;
+        const [write, ...more] = modifier?.writes ?? [];
+        const flag = write !== undefined &&
+            more.length === 0 &&
+            write.value === undefined &&
+            !modifier.onlyTrue &&
+            (!modifier.tagIn || modifier.tagIn.includes(tag)) &&
+            !writes.has(write.prop) &&
+            !conditional.some(([prop]) => prop === write.prop);
+        // Written as a prop, the condition is evaluated before any left in the
+        // call ahead of it, which is safe only when neither can have side effects.
+        const reorders = conditionalStays && (impureStays || impure.has(index));
+        if (flag && !reorders) {
+            conditional.push([write.prop, token]);
+        }
+        else {
+            conditionalStays = true;
+            if (impure.has(index))
+                impureStays = true;
+        }
+    });
     const rest = tokens.filter(token => !converted.has(token));
-    if (entry.ownClassOnly && rest.length > 0) {
+    if (entry.ownClassOnly && (rest.length > 0 || conditionalStays)) {
         return refuse('attr', 'className', `bestax \`${target}\` drops its own class when it is given a \`className\`, so this element's other classes would take the place of \`.${root}\`; keep it as markup`);
     }
     return {
@@ -266,6 +328,8 @@ export function plan(facts) {
             drop,
             numbers,
             ...(absorbed ? { absorbs: absorbed } : {}),
+            ...(counts ? { rendersChildren: true } : {}),
+            ...(conditional.length > 0 ? { conditional } : {}),
         },
         todos,
     };
@@ -294,7 +358,7 @@ function absorb(facts, root, entry, target, refuse) {
         return refuse('spread', target, `the <${spec.tag}> inside spreads props, which bestax \`${target}\` may read differently than the <${spec.tag}> did; convert the two to \`${target}\` by hand`);
     }
     if (child.tokens === null) {
-        return refuse('dynamic-class', target, `the <${spec.tag}> inside has a computed \`className\`, and the codemod converts static class strings only; convert the two to bestax \`${target}\` by hand, turning each condition into its prop`);
+        return refuse('dynamic-class', target, `the <${spec.tag}> inside has a computed \`className\`, which the codemod does not read there; convert the two to bestax \`${target}\` by hand, turning each condition into its prop`);
     }
     if (child.tokens?.length === 0) {
         return refuse('attr', 'className', `the <${spec.tag}> inside has an empty \`className\`, which renders \`class=""\`, and bestax \`${target}\` renders it with no class attribute; drop the empty \`className\`, then re-run`);

package/dist/sources/bulma-classes/rules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAUH,eAAO,MAAM,KAAK,EAAE,WAAW,CAAC,MAAM,CAapC,CAAC;AAyBH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK1D"}
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAUH,eAAO,MAAM,KAAK,EAAE,WAAW,CAAC,MAAM,CAapC,CAAC;AA0BH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK1D"}

package/dist/sources/bulma-classes/rules.js

@@ -40,8 +40,9 @@ const VOCABULARY = new Set([
     ...Object.values(WRAPPERS),
     ...Object.values(WRAPPER_OWN_PROPS).flat(),
     ...HELPER_PROPS,
-    // Refused on every target, so no entry lists it.
+    // Refused on every target, so no entry lists them.
     'dangerouslySetInnerHTML',
+    'children',
     // Refused where the target drops its own class for one it is given.
     'className',
     // Refused on the child a target renders itself.

package/dist/sources/bulma-classes/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAW,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA8YvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CAwZpB"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAW,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAmtBvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,gBAAqB,GAC7B,MAAM,GAAG,SAAS,CAygBpB"}

package/dist/sources/bulma-classes/transform.js

@@ -21,8 +21,9 @@ import { addTodo, findAttr, forgetJsxParens, jsxNameParts, literalValueOf, makeA
 import { collectBoundNames, makeReserve, prefersTabs, resolvesToBinding, } from '../_shared/imports.js';
 import { rewriteStylesheetImports } from '../_shared/css-imports.js';
 import { BESTAX, buildBestaxImport, placeBestaxImport, seedBestaxImport, } from '../_shared/bestax-import.js';
-import { plan } from './plan.js';
+import { plan, } from './plan.js';
 import { REACT_RUNTIMES, } from './project.js';
+import { rootFor } from './class-map.js';
 import { ruleId } from './rules.js';
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
@@ -48,48 +49,293 @@ const HEADER_PRAGMA = /^[\s*]*(?:@ts-(?:no)?check|@flow|@noflow|eslint-disable(?
 /** Directives that act on the line after them, so must stay above it. */
 const NEXT_LINE_DIRECTIVE = /^[\s*]*(?:eslint-disable-next-line|@ts-expect-error|@ts-ignore|prettier-ignore)\b/;
 /**
- * A comment moved to sit after a JSX tag name. It has to be a block comment
- * there: recast prints a line comment as `<// …`, which TypeScript reads as a
- * closing tag.
+ * A comment moved into a JSX tag, before or after a node there. It has to be
+ * a block comment: after a tag name recast prints a line comment as `<// …`,
+ * which TypeScript reads as a closing tag, and before an attribute it would
+ * run on into it.
  */
-function afterTagName(comment) {
-    if (comment.type !== 'CommentLine') {
-        return { ...comment, leading: false, trailing: true };
-    }
+function asBlock(comment, trailing) {
+    const placed = { leading: !trailing, trailing };
+    if (comment.type !== 'CommentLine')
+        return { ...comment, ...placed };
     return {
         type: 'CommentBlock',
         value: ` ${comment.value.trim().replace(/\*\//g, '*\\/')} `,
-        leading: false,
-        trailing: true,
+        ...placed,
     };
 }
+/** A comment moved to sit after a JSX tag name. */
+function afterTagName(comment) {
+    return asBlock(comment, true);
+}
 /**
- * Put `props`, then what stays in `className`, where an element's
- * `className` was. A comment on the className goes with whatever takes its
- * place: the first new attribute, else the next one along, else the tag name.
+ * Put `replacement` where an element's `className` was. A comment on the
+ * className, and any `carried` from inside it, goes with whatever takes its
+ * place: the first new attribute, else the next one along, else the tag
+ * name. A className kept in `replacement` keeps its own.
  */
-function writeClassName(j, element, props, className) {
+function spliceClassName(element, replacement, carried = []) {
     const attrs = element.openingElement.attributes;
     const classAttr = findAttr(element, 'className');
-    const replacement = props.map(([name, value]) => makeAttr(j, name, value === true ? undefined : value));
-    if (className)
-        replacement.push(makeAttr(j, 'className', className));
-    if (classAttr.comments?.length) {
+    const kept = replacement.includes(classAttr);
+    const moving = [...(kept ? [] : (classAttr.comments ?? [])), ...carried];
+    if (moving.length > 0) {
         const name = element.openingElement.name;
         const carrier = replacement[0] ?? attrs.find((attr) => attr !== classAttr) ?? name;
         carrier.comments = [
             ...(carrier.comments ?? []),
-            ...classAttr.comments.map((comment) => carrier === name ? afterTagName(comment) : comment),
+            ...moving.map((comment) => carrier === name ? afterTagName(comment) : comment),
         ];
     }
     attrs.splice(attrs.indexOf(classAttr), 1, ...replacement);
 }
+/** Put `props`, then what stays in `className`, where `className` was. */
+function writeClassName(j, element, props, className) {
+    const replacement = props.map(([name, value]) => makeAttr(j, name, value === true ? undefined : value));
+    if (className)
+        replacement.push(makeAttr(j, 'className', className));
+    spliceClassName(element, replacement);
+}
+/**
+ * The same, for a `className` a joiner builds: the classes a prop now
+ * renders leave the call, each condition that became a prop moves onto it,
+ * and what is left stays in the call (a plain string when nothing in it is
+ * conditional, no `className` when nothing is left). Returns whether the
+ * call is gone.
+ */
+function writeJoined(j, element, conversion, joined) {
+    const { call, statics, parts } = joined;
+    const kept = new Set(conversion.className?.split(' ') ?? []);
+    const carried = [];
+    const remove = (list, node) => list.splice(list.indexOf(node), 1);
+    for (const node of statics) {
+        const classes = classesIn(staticText(node));
+        const remaining = classes.filter(token => kept.has(token));
+        if (remaining.length === classes.length)
+            continue;
+        if (remaining.length === 0) {
+            carried.push(...commentsWithin(node));
+            remove(call.arguments, node);
+            continue;
+        }
+        const literal = j.stringLiteral(remaining.join(' '));
+        literal.comments = node.comments;
+        call.arguments[call.arguments.indexOf(node)] = literal;
+    }
+    const conditions = (conversion.conditional ?? []).map(([prop, token]) => {
+        const part = parts.find(found => found.tokens.length === 1 && found.tokens[0] === token);
+        carried.push(...commentsWithin(part.node, part.condition));
+        if (part.object) {
+            remove(part.object.properties, part.node);
+            if (part.object.properties.length === 0) {
+                carried.push(...commentsWithin(part.object));
+                remove(call.arguments, part.object);
+            }
+        }
+        else {
+            remove(call.arguments, part.node);
+        }
+        const value = part.negate
+            ? j.unaryExpression('!', part.condition)
+            : part.condition;
+        return j.jsxAttribute(j.jsxIdentifier(prop), j.jsxExpressionContainer(value));
+    });
+    const classAttr = findAttr(element, 'className');
+    let rest = [classAttr];
+    const gone = call.arguments.every((arg) => staticText(arg) !== null);
+    if (gone) {
+        carried.push(...commentsWithin(classAttr.value));
+        const classes = call.arguments.flatMap((arg) => classesIn(staticText(arg)));
+        rest =
+            classes.length > 0 ? [makeAttr(j, 'className', classes.join(' '))] : [];
+    }
+    spliceClassName(element, [
+        ...conversion.props.map(([name, value]) => makeAttr(j, name, value === true ? undefined : value)),
+        ...conditions,
+        ...rest,
+    ], carried.map(comment => asBlock(comment, false)));
+    return gone;
+}
 /** A lowercase intrinsic tag: not a component, not a custom element. */
 const INTRINSIC = /^[a-z][a-z0-9]*$/;
 /** Subtrees whose tags are not HTML. */
 const FOREIGN_ROOTS = new Set(['svg', 'math']);
 /** Parents that render their only child as it is. */
 const PASS_THROUGH_PARENTS = new Set(['Fragment', 'React.Fragment']);
+/**
+ * Class joiners whose arguments the codemod can read exactly, by package and
+ * export: a string adds its classes, and an object key, `a && 'x'` or
+ * `a ? 'x' : ''` adds them when the condition is truthy. Not `clsx/lite`,
+ * which ignores objects, `classnames/dedupe`, where a later key can take a
+ * class back, or `classnames/bind`, which looks names up in a CSS module.
+ */
+const JOINERS = {
+    clsx: ['default', 'clsx'],
+    classnames: ['default'],
+};
+/** A string literal's or an expression-free template's text, else null. */
+function staticText(node) {
+    if (node?.type === 'StringLiteral')
+        return node.value;
+    if (node?.type === 'TemplateLiteral' && node.expressions.length === 0) {
+        return node.quasis[0].value.cooked ?? null;
+    }
+    return null;
+}
+function classesIn(text) {
+    return text.split(/\s+/).filter(Boolean);
+}
+/** A joiner argument that adds nothing: `''`, `null`, `undefined`, `false`. */
+function addsNothing(node) {
+    if (staticText(node)?.trim() === '')
+        return true;
+    if (node.type === 'NullLiteral')
+        return true;
+    if (node.type === 'BooleanLiteral')
+        return node.value === false;
+    return node.type === 'Identifier' && node.name === 'undefined';
+}
+/**
+ * Whether evaluating an expression can't change anything: names, literals,
+ * property reads, and operators over those. A call, an assignment, `new` or
+ * `delete` can. (So can a getter; a property read is taken as a read.)
+ */
+function sideEffectFree(node) {
+    switch (node?.type) {
+        case 'Identifier':
+        case 'StringLiteral':
+        case 'NumericLiteral':
+        case 'BooleanLiteral':
+        case 'NullLiteral':
+        case 'BigIntLiteral':
+        case 'ThisExpression':
+            return true;
+        case 'TemplateLiteral':
+            return node.expressions.every(sideEffectFree);
+        case 'MemberExpression':
+        case 'OptionalMemberExpression':
+            return (sideEffectFree(node.object) &&
+                (!node.computed || sideEffectFree(node.property)));
+        case 'UnaryExpression':
+            return node.operator !== 'delete' && sideEffectFree(node.argument);
+        case 'BinaryExpression':
+        case 'LogicalExpression':
+            return sideEffectFree(node.left) && sideEffectFree(node.right);
+        case 'ConditionalExpression':
+            return [node.test, node.consequent, node.alternate].every(sideEffectFree);
+        case 'TSAsExpression':
+        case 'TSSatisfiesExpression':
+        case 'TSNonNullExpression':
+        case 'TSTypeAssertion':
+        case 'ParenthesizedExpression':
+            return sideEffectFree(node.expression);
+        default:
+            return false;
+    }
+}
+/**
+ * A `className={joiner(…)}` whose every argument the codemod can read, or
+ * undefined: an argument it can't (a variable, a call, a spread, an array)
+ * could add any class.
+ */
+function readJoiner(value, isJoiner) {
+    const call = value?.type === 'JSXExpressionContainer' ? value.expression : null;
+    if (call?.type !== 'CallExpression' || !isJoiner(call.callee)) {
+        return undefined;
+    }
+    const statics = [];
+    const parts = [];
+    for (const arg of call.arguments) {
+        if (staticText(arg) !== null) {
+            statics.push(arg);
+        }
+        else if (arg.type === 'ObjectExpression') {
+            for (const property of arg.properties) {
+                const plain = (property.type === 'ObjectProperty' ||
+                    property.type === 'Property') &&
+                    !property.computed &&
+                    !property.method &&
+                    (property.kind === undefined || property.kind === 'init');
+                const key = !plain
+                    ? undefined
+                    : property.key.type === 'Identifier'
+                        ? property.key.name
+                        : staticText(property.key);
+                if (key == null)
+                    return undefined;
+                parts.push({
+                    tokens: classesIn(key),
+                    condition: property.value,
+                    negate: false,
+                    node: property,
+                    object: arg,
+                });
+            }
+        }
+        else if (arg.type === 'LogicalExpression' &&
+            arg.operator === '&&' &&
+            staticText(arg.right) !== null) {
+            parts.push({
+                tokens: classesIn(staticText(arg.right)),
+                condition: arg.left,
+                negate: false,
+                node: arg,
+            });
+        }
+        else if (arg.type === 'ConditionalExpression' &&
+            staticText(arg.consequent) !== null &&
+            addsNothing(arg.alternate)) {
+            parts.push({
+                tokens: classesIn(staticText(arg.consequent)),
+                condition: arg.test,
+                negate: false,
+                node: arg,
+            });
+        }
+        else if (arg.type === 'ConditionalExpression' &&
+            staticText(arg.alternate) !== null &&
+            addsNothing(arg.consequent)) {
+            parts.push({
+                tokens: classesIn(staticText(arg.alternate)),
+                condition: arg.test,
+                negate: true,
+                node: arg,
+            });
+        }
+        else {
+            return undefined;
+        }
+    }
+    const tokens = [
+        ...new Set(statics.flatMap(node => classesIn(staticText(node)))),
+    ];
+    return { call, tokens, statics, parts };
+}
+/**
+ * Every comment on a node and inside it, except inside `keep` (a condition
+ * that moves, taking its comments with it).
+ */
+function commentsWithin(node, keep) {
+    const found = [];
+    const visit = (current) => {
+        if (!current || typeof current !== 'object' || current === keep)
+            return;
+        if (Array.isArray(current)) {
+            current.forEach(visit);
+            return;
+        }
+        if (typeof current.type !== 'string')
+            return;
+        found.push(...(current.comments ?? []));
+        for (const [key, child] of Object.entries(current)) {
+            if (key !== 'comments' && key !== 'loc' && key !== 'original') {
+                visit(child);
+            }
+        }
+    };
+    visit(node);
+    return found;
+}
 /**
  * The static text of a `className`, or null when it is computed. A string
  * literal, `{'…'}`, and a template literal with no expressions are static.
@@ -294,6 +540,10 @@ function reachesReact(child) {
         return isContent(child);
     return /[^ \t\r\n]/.test(child.value) || !/[\r\n]/.test(child.value);
 }
+/** Whitespace React drops, which nothing is lost with. A comment is kept. */
+function dropped(child) {
+    return child.type === 'JSXText' && !reachesReact(child);
+}
 /** A plain HTML child as the planner reads it; nothing for a component. */
 function childFacts(child) {
     const name = child.openingElement.name;
@@ -311,8 +561,25 @@ function childFacts(child) {
         }),
         attributes: attributesBesides(child, classAttr, childAttributeValue),
         hasSpread: hasSpread(child),
+        isEmpty: (child.children ?? []).every(dropped),
     };
 }
+/**
+ * An element's children as plain HTML elements, when that is every one
+ * React renders; undefined when one is anything else.
+ */
+function childElementsOf(element) {
+    const children = [];
+    for (const child of element.children ?? []) {
+        if (dropped(child))
+            continue;
+        const found = child.type === 'JSXElement' ? childFacts(child) : undefined;
+        if (!found)
+            return undefined;
+        children.push(found);
+    }
+    return children;
+}
 function insideForeignContent(elementPath) {
     let current = elementPath.parent;
     while (current) {
@@ -392,6 +659,33 @@ export default function transform(fileInfo, api, options = {}) {
     // a child that is one of its parts.
     const planned = new Map();
     const programScope = root.find(j.Program).paths()[0]?.scope;
+    // The joiners the file imports, by local name, and the elements whose
+    // joiner call converts.
+    const joinerLocals = new Set();
+    root.find(j.ImportDeclaration).forEach((importPath) => {
+        const node = importPath.node;
+        const exported = Object.hasOwn(JOINERS, node.source.value)
+            ? JOINERS[node.source.value]
+            : undefined;
+        if (!exported || node.importKind === 'type')
+            return;
+        for (const spec of node.specifiers ?? []) {
+            const name = spec.type === 'ImportDefaultSpecifier'
+                ? 'default'
+                : spec.type === 'ImportSpecifier' && spec.importKind !== 'type'
+                    ? (spec.imported.name ?? spec.imported.value)
+                    : undefined;
+            if (name && exported.includes(name))
+                joinerLocals.add(spec.local.name);
+        }
+    });
+    /** Whether a callee is one of those joiners where it is called. */
+    const isJoiner = (callee, scopePath) => callee?.type === 'Identifier' &&
+        joinerLocals.has(callee.name) &&
+        resolvesToBinding(scopePath, callee.name, programScope);
+    const joins = new Map();
+    /** Joiners a rewritten className no longer calls. */
+    const unjoined = new Set();
     /**
      * The bestax component an element already is, when its name is the bestax
      * import and not a local that shadows it; `scopePath` is where the name is
@@ -419,7 +713,7 @@ export default function transform(fileInfo, api, options = {}) {
      * React renders, and no comment, which folding the element would drop.
      */
     const soleChild = (element) => {
-        const content = (element.children ?? []).filter((child) => child.type !== 'JSXText' || reachesReact(child));
+        const content = (element.children ?? []).filter((child) => !dropped(child));
         return content.length === 1 && content[0].type === 'JSXElement'
             ? content[0]
             : undefined;
@@ -492,26 +786,52 @@ export default function transform(fileInfo, api, options = {}) {
             childTargets: childTargets(elementPath),
             soleChildTarget: planned.get(sole)?.conversion?.target,
             soleChild: sole && childFacts(sole),
+            childElements: childElementsOf(element),
             bestaxInside: bestaxInside.get(element) ?? [],
             bestaxAround: surrounding.bestax,
             componentsAround: surrounding.other,
             onlyChildOf: onlyChildOf(elementPath, bestaxLocals),
         };
-        let result = plan(facts);
+        // A joiner call the codemod can read converts exactly: its fixed classes
+        // as for a static className, and each condition on a flag as its prop.
+        const joined = className === null
+            ? readJoiner(classAttr.value, callee => isJoiner(callee, elementPath))
+            : undefined;
+        let exact;
+        if (joined) {
+            exact = plan({
+                ...facts,
+                tokens: joined.tokens,
+                conditional: joined.parts.map(part => part.tokens),
+                impure: joined.parts.flatMap((part, index) => sideEffectFree(part.condition) ? [] : [index]),
+            });
+            if (exact.conversion)
+                joins.set(element, joined);
+            else
+                exact = undefined;
+        }
+        let result = exact ?? plan(facts);
         const converts = result.conversion !== null || result.fold !== undefined;
         const becomes = result.conversion?.target ?? result.fold?.target;
-        if (className === null && becomes) {
-            // The same element with a static className would convert; with a
-            // computed one, only a person can turn each condition into its prop.
+        if (className === null && !exact && becomes) {
+            // The same element with a static className would convert; with one
+            // computed any other way, only a person can turn each condition into
+            // its prop.
             const target = becomes;
+            // A call it could read says what stopped it instead.
+            const conditionalRoot = joined?.parts
+                .flatMap(part => part.tokens)
+                .find(token => rootFor(token)?.target === target);
+            const message = !joined
+                ? `this \`className\` is computed, and the codemod reads only a \`clsx\` or \`classnames\` call of class strings and conditional classes; convert this element to bestax \`${target}\` by hand, turning each condition into its prop`
+                : conditionalRoot
+                    ? `this \`className\` adds \`.${conditionalRoot}\` only under a condition, so whether this element is a bestax \`${target}\` at all depends on it; convert it by hand if it always is, turning each condition into its prop`
+                    : `this \`className\` is computed, and the codemod can't write every class it adds onto bestax \`${target}\` as it is; convert this element by hand, turning each condition into its prop`;
             result = {
                 conversion: null,
                 todos: [
                     ...result.todos,
-                    {
-                        rule: ruleId('dynamic-class', target),
-                        message: `this \`className\` is computed, and the codemod converts static class strings only; convert this element to bestax \`${target}\` by hand, turning each condition into its prop`,
-                    },
+                    { rule: ruleId('dynamic-class', target), message },
                 ],
             };
         }
@@ -631,13 +951,42 @@ export default function transform(fileInfo, api, options = {}) {
                 findAttr(child, from).name = j.jsxIdentifier(to);
             }
         }
+        // A target that renders the element's children itself takes their place:
+        // they go, and so does the closing tag, their comments and its own moving
+        // to the name that stays.
+        const gone = conversion.rendersChildren
+            ? [
+                ...(element.children ?? [])
+                    .filter((node) => node.type === 'JSXElement')
+                    .flatMap((node) => [
+                    ...(node.comments ?? []),
+                    ...tagComments(node),
+                ]),
+                ...[element.closingElement, element.closingElement?.name].flatMap((node) => node?.comments ?? []),
+            ]
+            : [];
         const [head, ...rest] = conversion.target.split('.');
         renameElement(j, element, [ctx.reserve(head), ...rest].join('.'));
         for (const name of conversion.drop) {
             const holder = findAttr(element, name) ? element : child;
             removeAttr(holder, findAttr(holder, name));
         }
-        writeClassName(j, element, conversion.props, conversion.className);
+        const joined = joins.get(element);
+        if (!joined) {
+            writeClassName(j, element, conversion.props, conversion.className);
+        }
+        else if (writeJoined(j, element, conversion, joined)) {
+            unjoined.add(joined.call.callee.name);
+        }
+        if (conversion.rendersChildren) {
+            element.children = [];
+            element.openingElement.selfClosing = true;
+            element.closingElement = null;
+            if (gone.length) {
+                const name = element.openingElement.name;
+                name.comments = [...(name.comments ?? []), ...gone.map(afterTagName)];
+            }
+        }
         let written = element;
         if (child) {
             child.openingElement.name = element.openingElement.name;
@@ -670,6 +1019,34 @@ export default function transform(fileInfo, api, options = {}) {
         }
         ctx.dirty = true;
     }
+    // A joiner import only these rewrites stopped using goes too, so the file
+    // gains no unused import; one the file already left unused stays.
+    for (const name of unjoined) {
+        const referenced = root
+            .find(j.Identifier, { name })
+            .filter((identifierPath) => identifierPath.parent.node.type !== 'ImportSpecifier' &&
+            identifierPath.parent.node.type !== 'ImportDefaultSpecifier');
+        if (referenced.size() > 0)
+            continue;
+        root.find(j.ImportDeclaration).forEach((importPath) => {
+            const node = importPath.node;
+            const specifiers = node.specifiers ?? [];
+            const spec = specifiers.find((found) => found.local?.name === name);
+            if (!spec)
+                return;
+            specifiers.splice(specifiers.indexOf(spec), 1);
+            if (specifiers.length > 0)
+                return;
+            // The declaration goes with its last name; its comments (a file
+            // header, a directive) stay, on the statement beside it.
+            const index = program.body.indexOf(node);
+            const neighbour = program.body[index + 1] ?? program.body[index - 1];
+            if (node.comments?.length && neighbour) {
+                neighbour.comments = [...node.comments, ...(neighbour.comments ?? [])];
+            }
+            program.body.splice(index, 1);
+        });
+    }
     // ---- 5. The bestax import ---------------------------------------------------
     const body = program.body;
     placeBestaxImport(bestaxImportState, buildBestaxImport(ctx, bestaxImportState), {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bestax-migrate",
-  "version": "2.10.0",
+  "version": "2.12.0",
   "description": "Codemods for migrating existing React apps from other Bulma libraries to @allxsmith/bestax-bulma",
   "type": "module",
   "bin": {
@@ -38,7 +38,7 @@
     "chalk": "^6.0.0",
     "commander": "^15.0.0",
     "jscodeshift": "^17.3.0",
-    "@allxsmith/bestax-bulma": "^5.16.9"
+    "@allxsmith/bestax-bulma": "^5.16.10"
   },
   "devDependencies": {
     "@jest/globals": "^30.0.0",
@@ -47,6 +47,8 @@
     "@types/node": "^26.3.0",
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.5",
+    "classnames": "^2.5.1",
+    "clsx": "^2.1.1",
     "jest": "^30.2.0",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",