@homebound/truss 1.137.4 → 2.0.0-next.1

package/build/index.js

@@ -1,32 +1,1419 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.newSetCssVariablesMethod = exports.newParamMethod = exports.newIncrementMethods = exports.newCoreIncrementMethods = exports.newMethodsForProp = exports.newPxMethod = exports.newMethod = exports.newAliasesMethods = exports.generate = exports.defaultSections = void 0;
-__exportStar(require("./config"), exports);
-var tachyons_1 = require("./sections/tachyons");
-Object.defineProperty(exports, "defaultSections", { enumerable: true, get: function () { return tachyons_1.defaultSections; } });
-var generate_1 = require("./generate");
-Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generate_1.generate; } });
-var methods_1 = require("./methods");
-Object.defineProperty(exports, "newAliasesMethods", { enumerable: true, get: function () { return methods_1.newAliasesMethods; } });
-Object.defineProperty(exports, "newMethod", { enumerable: true, get: function () { return methods_1.newMethod; } });
-Object.defineProperty(exports, "newPxMethod", { enumerable: true, get: function () { return methods_1.newPxMethod; } });
-Object.defineProperty(exports, "newMethodsForProp", { enumerable: true, get: function () { return methods_1.newMethodsForProp; } });
-Object.defineProperty(exports, "newCoreIncrementMethods", { enumerable: true, get: function () { return methods_1.newCoreIncrementMethods; } });
-Object.defineProperty(exports, "newIncrementMethods", { enumerable: true, get: function () { return methods_1.newIncrementMethods; } });
-Object.defineProperty(exports, "newParamMethod", { enumerable: true, get: function () { return methods_1.newParamMethod; } });
-Object.defineProperty(exports, "newSetCssVariablesMethod", { enumerable: true, get: function () { return methods_1.newSetCssVariablesMethod; } });
+// src/config.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/methods.ts
+var _stylexCollector = null;
+function startStylexCollection() {
+  _stylexCollector = [];
+}
+function stopStylexCollection() {
+  const result = _stylexCollector;
+  _stylexCollector = null;
+  return result;
+}
+function collect(entry) {
+  if (_stylexCollector) _stylexCollector.push(entry);
+}
+function newMethod(abbr, defs) {
+  collect({ kind: "static", abbr, defs: { ...defs } });
+  return `${comment(defs)} get ${abbr}() { return this${Object.entries(defs).map(([prop, value]) => `.add("${prop}", ${maybeWrap(value)})`).join("")}; }`;
+}
+function newParamMethod(abbr, prop, extraProperties = {}) {
+  collect({
+    kind: "param",
+    abbr,
+    props: [prop],
+    extraDefs: Object.keys(extraProperties).length > 0 ? { ...extraProperties } : void 0
+  });
+  const additionalDefs2 = Object.entries(extraProperties).map(([prop2, value]) => `.add("${prop2}", ${maybeWrap(value)})`).join("");
+  return `${comment({
+    [prop]: "value"
+  })} ${abbr}(value: Properties["${prop}"]) { return this.add("${prop}", value)${additionalDefs2}; }`;
+}
+function newMethodsForProp(prop, defs, baseName = prop, includePx = false, valueMethodExtraProperties) {
+  return [
+    ...Object.entries(defs).map(
+      ([abbr, value]) => newMethod(
+        abbr,
+        // If the value is an object, use it as the full defs, otherwise, use it as the prop value
+        typeof value === "object" ? value : { [prop]: value }
+      )
+    ),
+    // Conditionally add a method that directly accepts a value for prop
+    ...baseName !== null ? [newParamMethod(baseName, prop, valueMethodExtraProperties)] : [],
+    ...baseName !== null && includePx ? [newPxMethod(baseName, prop)] : []
+  ];
+}
+function newAliasesMethods(aliases) {
+  return Object.entries(aliases).map(([abbr, values]) => {
+    collect({ kind: "alias", abbr, aliasTargets: values });
+    return `get ${abbr}() { return this${values.map((v) => `.${v}`).join("")}; }`;
+  });
+}
+function newSetCssVariablesMethod(abbr, defs) {
+  collect({ kind: "cssvar", abbr, defs: { ...defs } });
+  return `get ${abbr}() { return this${Object.entries(defs).map(([prop, value]) => `.add("${prop}" as any, "${value}")`).join("")}; }`;
+}
+function newIncrementMethods(config, abbr, prop, opts = {}) {
+  const props = typeof prop === "string" ? [prop] : prop;
+  const delegateMethods = newCoreIncrementMethods(config, abbr, props);
+  const autoComment = comment(Object.fromEntries(props.map((p) => [p, "auto"])));
+  const valueComment = comment(Object.fromEntries(props.map((p) => [p, "v"])));
+  const pxComment = comment(Object.fromEntries(props.map((p) => [p, "px"])));
+  if (opts.auto) {
+    collect({ kind: "static", abbr: `${abbr}a`, defs: Object.fromEntries(props.map((p) => [p, "auto"])) });
+  }
+  collect({ kind: "increment-param", abbr, props, usesMaybeInc: true });
+  collect({ kind: "px-delegate", abbr: `${abbr}Px`, props });
+  return [
+    ...delegateMethods,
+    ...opts.auto ? [`${autoComment} get ${abbr}a() { return this.${props.map((p) => `add("${p}", "auto")`).join(".")}; }`] : [],
+    `${valueComment} ${abbr}(v: number | string) { return this.${props.map((p) => `add("${p}", maybeInc(v))`).join(".")}; }`,
+    `${pxComment} ${abbr}Px(px: number) { return this.${props.map((p) => `add("${p}", \`\${px}px\`)`).join(".")}; }`
+  ];
+}
+function newCoreIncrementMethods(config, abbr, props) {
+  return zeroTo(config.numberOfIncrements).map((i) => {
+    const px = `${i * config.increment}px`;
+    const defs = Object.fromEntries(props.map((p) => [p, px]));
+    collect({ kind: "static", abbr: `${abbr}${i}`, defs });
+    const sets = props.map((p) => `add("${p}", "${px}")`).join(".");
+    return `${comment(defs)} get ${abbr}${i}() { return this.${sets}; }`;
+  });
+}
+function newPxMethod(abbr, prop) {
+  collect({ kind: "px-delegate", abbr: `${abbr}Px`, props: [prop] });
+  return `${comment({ [prop]: "px" })} ${abbr}Px(px: number) { return this.${abbr}(\`\${px}px\`); }`;
+}
+var zeroTo = (n) => [...Array(n + 1).keys()];
+function maybeWrap(value) {
+  return typeof value === "number" ? String(value) : `"${value}"`;
+}
+function comment(defs) {
+  const paramNames = ["value", "px", "inc"];
+  const values = Object.entries(defs).map(([prop, value]) => `${prop}: ${paramNames.includes(value) ? value : maybeWrap(value)}`).join("; ");
+  return `/** Sets \`${values}\`. */
+`;
+}
+
+// src/sections/tachyons/border.ts
+var borderDefs = [
+  ["ba", ["borderStyle", "borderWidth"]],
+  ["bt", ["borderTopStyle", "borderTopWidth"]],
+  ["br", ["borderRightStyle", "borderRightWidth"]],
+  ["bb", ["borderBottomStyle", "borderBottomWidth"]],
+  ["bl", ["borderLeftStyle", "borderLeftWidth"]]
+];
+var border = () => [
+  ...borderDefs.map(([abbr, [style, width2]]) => {
+    return newMethod(abbr, { [style]: "solid", [width2]: "1px" });
+  }),
+  newMethod("bn", { borderStyle: "none", borderWidth: "0" })
+];
+
+// src/sections/tachyons/borderColors.ts
+var borderColor = ({ palette }) => {
+  const defs = Object.fromEntries(Object.entries(palette).map(([key, value]) => [`bc${key}`, value]));
+  return newMethodsForProp("borderColor", defs, "bc");
+};
+
+// src/sections/tachyons/borderRadius.ts
+var borderRadius = () => newMethodsForProp("borderRadius", {
+  br0: "0",
+  br1: ".125rem",
+  br2: ".25rem",
+  br3: ".5rem",
+  br4: "1rem",
+  br100: "100%",
+  brPill: "9999px"
+});
+
+// src/sections/tachyons/borderStyles.ts
+var borderStyle = () => newMethodsForProp(
+  "borderStyle",
+  {
+    bsDashed: "dashed",
+    bsDotted: "dotted",
+    bsn: "none",
+    bss: "solid"
+  },
+  "bs"
+);
+
+// src/sections/tachyons/borderWidths.ts
+var borderWidth = () => newMethodsForProp(
+  "borderWidth",
+  {
+    bw1: "1px",
+    bw2: "2px"
+  },
+  "bw"
+);
+
+// src/sections/tachyons/boxShadow.ts
+var boxShadow = () => [
+  // bsn is taken by `borderStyle: none`.
+  newMethod("shadowNone", { boxShadow: "none" })
+];
+
+// src/sections/tachyons/coordinates.ts
+var directions = ["top", "right", "bottom", "left"];
+var coordinates = (config) => directions.flatMap((d) => {
+  return newIncrementMethods(config, d, d);
+});
+
+// src/sections/tachyons/cursor.ts
+var cursor = () => [
+  ...newMethodsForProp("cursor", {
+    cursorPointer: "pointer",
+    cursorNotAllowed: "not-allowed"
+  })
+];
+
+// src/sections/tachyons/display.ts
+var display = () => newMethodsForProp("display", {
+  dn: "none",
+  db: "block",
+  dib: "inline-block",
+  dit: "inline-table",
+  dt: "table",
+  dtc: "table-cell",
+  dtRow: "table-row",
+  dtColumn: "table-column",
+  dtColumnGroup: "table-column-group",
+  // added
+  dg: "grid",
+  dig: "inline-grid",
+  df: "flex",
+  dif: "inline-flex"
+});
+
+// src/sections/tachyons/flexbox.ts
+var flexbox = () => [
+  ...newMethodsForProp(
+    "flex",
+    {
+      fi: "initial",
+      fa: "auto",
+      fn: "none",
+      f1: "1",
+      f2: "2",
+      f3: "3",
+      f4: "4",
+      f5: "5"
+    },
+    "f"
+  ),
+  ...newMethodsForProp(
+    "justifyContent",
+    {
+      jcfs: "flex-start",
+      jcfe: "flex-end",
+      jcc: "center",
+      jcsb: "space-between",
+      jcsa: "space-around",
+      jcse: "space-evenly"
+    },
+    "jc"
+  ),
+  ...newMethodsForProp(
+    "justifySelf",
+    {
+      jsa: "auto",
+      jsc: "center",
+      jss: "start",
+      jse: "end"
+    },
+    "js"
+  ),
+  ...newMethodsForProp(
+    "justifyItems",
+    {
+      jifs: "flex-start",
+      jife: "flex-end",
+      jic: "center",
+      jisb: "space-between",
+      jisa: "space-around",
+      jise: "space-evenly"
+    },
+    "ji"
+  ),
+  ...newMethodsForProp(
+    "alignSelf",
+    {
+      asfs: "flex-start",
+      asfe: "flex-end",
+      asc: "center",
+      asb: "baseline",
+      asStretch: "stretch"
+    },
+    "as"
+  ),
+  ...newMethodsForProp(
+    "alignItems",
+    {
+      aifs: "flex-start",
+      aife: "flex-end",
+      ais: "start",
+      aie: "end",
+      aic: "center",
+      aib: "baseline",
+      aiStretch: "stretch"
+    },
+    "ai"
+  ),
+  ...newMethodsForProp(
+    "placeSelf",
+    {
+      psa: "auto",
+      psc: "center",
+      pss: "start",
+      pse: "end",
+      psfs: "flex-start",
+      psfe: "flex-end",
+      psStretch: "stretch"
+    },
+    "ps"
+  ),
+  ...newMethodsForProp(
+    "placeContent",
+    {
+      pcc: "center",
+      pcs: "start",
+      pce: "end",
+      pcsb: "space-between",
+      pcsa: "space-around",
+      pcse: "space-evenly",
+      pcb: "baseline",
+      pcStretch: "stretch"
+    },
+    "pc"
+  ),
+  ...newMethodsForProp(
+    "placeItems",
+    {
+      pic: "center",
+      pis: "start",
+      pie: "end",
+      pisb: "space-between",
+      pisa: "space-around",
+      pise: "space-evenly",
+      pib: "baseline",
+      piStretch: "stretch"
+    },
+    "pi"
+  ),
+  ...newMethodsForProp(
+    "flexBasis",
+    // https://github.com/tack-hammer/tailwind-plugin-flex-basis#usage
+    {
+      fb1: "100%",
+      fb2: "50%",
+      fb3: "33.333333%",
+      fb4: "25%",
+      fb5: "20%",
+      fb6: "16.666666%",
+      fb7: "14.285714%",
+      fb0: "12.5%"
+    },
+    "fb"
+  ),
+  ...newMethodsForProp("flexGrow", { fg0: 0, fg1: 1 }),
+  ...newMethodsForProp("flexShrink", { fs0: 0, fs1: 1 }),
+  ...newMethodsForProp(
+    "flexDirection",
+    {
+      fdr: "row",
+      fdrr: "row-reverse",
+      fdc: "column",
+      fdcr: "column-reverse"
+    },
+    "fd"
+  ),
+  ...newMethodsForProp(
+    "flexWrap",
+    {
+      fww: "wrap",
+      fwr: "wrap-reverse",
+      fwnw: "nowrap"
+    },
+    "flexWrap"
+  ),
+  newParamMethod("order", "order")
+];
+
+// src/sections/tachyons/floats.ts
+var float = () => newMethodsForProp(
+  "float",
+  {
+    fl: "left",
+    fr: "right"
+  },
+  "float"
+);
+
+// src/sections/tachyons/fontWeight.ts
+var fontWeight = () => newMethodsForProp(
+  "fontWeight",
+  {
+    fwn: "normal",
+    fwb: "bold",
+    fw1: 100,
+    fw2: 200,
+    fw3: 300,
+    fw4: 400,
+    fw5: 500,
+    fw6: 600,
+    fw7: 700,
+    fw8: 800,
+    fw9: 900
+  },
+  "fw"
+);
+
+// src/sections/tachyons/grid.ts
+var grid = (config) => [
+  newParamMethod("gtc", "gridTemplateColumns"),
+  newParamMethod("gtr", "gridTemplateRows"),
+  newParamMethod("gr", "gridRow"),
+  newParamMethod("gc", "gridColumn"),
+  newParamMethod("gar", "gridAutoRows"),
+  newParamMethod("gac", "gridAutoColumns"),
+  ...newIncrementMethods(config, "gap", "gap"),
+  ...newIncrementMethods(config, "rg", "rowGap"),
+  ...newIncrementMethods(config, "cg", "columnGap")
+];
+
+// src/sections/tachyons/heights.ts
+var height = (config) => [
+  // https://github.com/tachyons-css/tachyons/blob/master/src/_heights.css
+  // Technically h1 in tachyons is 1em and ours is 1 inc
+  ...newIncrementMethods(config, "h", "height", { auto: true }),
+  ...newMethodsForProp(
+    "height",
+    {
+      h25: "25%",
+      h50: "50%",
+      h75: "75%",
+      h100: "100%",
+      vh25: "25vh",
+      vh50: "50vh",
+      vh75: "75vh",
+      vh100: "100vh",
+      hfc: "fit-content",
+      hmaxc: "max-content",
+      hminc: "min-content"
+    },
+    // Skip `h` here b/c it's created by newIncrementMethods below
+    null
+  ),
+  ...newMethodsForProp(
+    "minHeight",
+    {
+      mh0: 0,
+      mh25: "25%",
+      mh50: "50%",
+      mh75: "75%",
+      mh100: "100%",
+      mvh100: "100vh"
+    },
+    "mh",
+    true
+  ),
+  ...newMethodsForProp(
+    "maxHeight",
+    {
+      maxh0: "0",
+      maxh25: "25%",
+      maxh50: "50%",
+      maxh75: "75%",
+      maxh100: "100%"
+    },
+    "maxh",
+    true
+  ),
+  // Sneak this into heights.ts even though it's for width & height
+  `${comment({ height: "px", width: "px" })}
+  sqPx(px: number) { return this.add("height", \`\${px}px\`).add("width", \`\${px}px\`); }`
+];
+
+// src/sections/tachyons/lineClamp.ts
+var additionalDefs = {
+  overflow: "hidden",
+  display: "-webkit-box",
+  // As of 11/28/2022, this is deprecated but still necessary for lineClamp to work:
+  // https://github.com/tailwindlabs/tailwindcss-line-clamp/blob/master/src/index.js
+  WebkitBoxOrient: "vertical",
+  // tailwinds doesn't add this by default, but it seems like a good default for us.
+  textOverflow: "ellipsis"
+};
+var lineClamp = () => newMethodsForProp(
+  "WebkitLineClamp",
+  {
+    lineClamp1: { ...additionalDefs, WebkitLineClamp: 1 },
+    lineClamp2: { ...additionalDefs, WebkitLineClamp: 2 },
+    lineClamp3: { ...additionalDefs, WebkitLineClamp: 3 },
+    lineClamp4: { ...additionalDefs, WebkitLineClamp: 4 },
+    lineClamp5: { ...additionalDefs, WebkitLineClamp: 5 },
+    lineClamp6: { ...additionalDefs, WebkitLineClamp: 6 },
+    lineClampNone: { WebkitLineClamp: "unset" }
+  },
+  "lineClamp",
+  false,
+  additionalDefs
+);
+
+// src/sections/tachyons/objectFit.ts
+var objectFit = () => newMethodsForProp("objectFit", {
+  objectContain: "contain",
+  objectCover: "cover",
+  objectFill: "fill",
+  objectNone: "none",
+  objectScaleDown: "scale-down"
+});
+
+// src/sections/tachyons/outlines.ts
+var outline = () => newMethodsForProp("outline", {
+  outline1: "1px solid",
+  outlineTransparent: "1px solid transparent",
+  outline0: "0"
+});
+
+// src/sections/tachyons/overflow.ts
+var overflow = () => {
+  return [
+    ...newMethodsForProp("overflow", {
+      ov: "visible",
+      oh: "hidden",
+      os: "scroll",
+      oa: "auto"
+    }),
+    ...newMethodsForProp("overflowY", {
+      oyv: "visible",
+      oyh: "hidden",
+      oys: "scroll",
+      oya: "auto"
+    }),
+    ...newMethodsForProp("overflowX", {
+      oxv: "visible",
+      oxh: "hidden",
+      oxs: "scroll",
+      oxa: "auto"
+    })
+  ];
+};
+
+// src/sections/tachyons/position.ts
+var position = () => newMethodsForProp("position", {
+  absolute: "absolute",
+  fixed: "fixed",
+  static: "static",
+  relative: "relative",
+  // added
+  sticky: "sticky"
+});
+
+// src/utils.ts
+function lowerCaseFirst(s) {
+  return s.charAt(0).toLowerCase() + s.substr(1);
+}
+function quote(s) {
+  return `"${s}"`;
+}
+
+// src/sections/tachyons/skins.ts
+var skins = (config) => {
+  const { palette } = config;
+  const colors = newMethodsForProp(
+    "color",
+    Object.fromEntries(
+      Object.entries(palette).map(([key, value]) => [
+        lowerCaseFirst(key),
+        value
+      ])
+    )
+  );
+  const backgroundColors = newMethodsForProp(
+    "backgroundColor",
+    Object.fromEntries(
+      Object.entries(palette).map(([key, value]) => [`bg${key}`, value])
+    ),
+    "bgColor"
+  );
+  const fillColors = newMethodsForProp(
+    "fill",
+    Object.fromEntries(
+      Object.entries(palette).map(([key, value]) => [`f${key}`, value])
+    )
+  );
+  return [...colors, ...backgroundColors, ...fillColors];
+};
+
+// src/sections/tachyons/spacing.ts
+var spacing = (config) => {
+  const marginDefs = [
+    ["mt", "marginTop"],
+    ["mr", "marginRight"],
+    ["mb", "marginBottom"],
+    ["ml", "marginLeft"],
+    ["mx", ["marginLeft", "marginRight"]],
+    ["my", ["marginTop", "marginBottom"]],
+    ["m", ["marginTop", "marginBottom", "marginRight", "marginLeft"]]
+  ];
+  const margins = [...marginDefs.map(([abbr, conf]) => newIncrementMethods(config, abbr, conf, { auto: true })).flat()];
+  const paddingDefs = [
+    ["pt", "paddingTop"],
+    ["pr", "paddingRight"],
+    ["pb", "paddingBottom"],
+    ["pl", "paddingLeft"],
+    ["px", ["paddingLeft", "paddingRight"]],
+    ["py", ["paddingTop", "paddingBottom"]],
+    ["p", ["paddingTop", "paddingBottom", "paddingRight", "paddingLeft"]]
+  ];
+  const paddings = paddingDefs.map(([abbr, conf]) => newIncrementMethods(config, abbr, conf)).flat();
+  return [...margins, ...paddings];
+};
+
+// src/sections/tachyons/textAlign.ts
+var textAlign = () => newMethodsForProp(
+  "textAlign",
+  {
+    tal: "left",
+    tac: "center",
+    tar: "right",
+    taj: "justify"
+  },
+  "ta"
+);
+
+// src/sections/tachyons/textDecoration.ts
+var textDecoration = () => newMethodsForProp("textDecoration", {
+  tdn: "none",
+  tdlt: "line-through",
+  tdu: "underline"
+});
+
+// src/sections/tachyons/textTransform.ts
+var textTransform = () => newMethodsForProp(
+  "textTransform",
+  {
+    ttc: "capitalize",
+    ttl: "lowercase",
+    ttu: "uppercase",
+    ttn: "none"
+  },
+  "tt"
+);
+
+// src/sections/tachyons/typeScale.ts
+var typeScale = ({ fonts }) => [
+  ...Object.entries(fonts).map(([abbr, defs]) => {
+    if (typeof defs === "string") {
+      return newMethod(abbr, { fontSize: defs });
+    }
+    return newMethod(abbr, defs);
+  })
+];
+
+// src/sections/tachyons/typography.ts
+var typography = () => [
+  newMethod("measure", { maxWidth: "30em" }),
+  newMethod("measureWide", { maxWidth: "34em" }),
+  newMethod("measureNarrow", { maxWidth: "20em" }),
+  newMethod("indent", {
+    textIndent: "1em",
+    marginTop: 0,
+    marginBottom: 0
+  }),
+  newMethod("smallCaps", { fontVariant: "small-caps" }),
+  newMethod("truncate", {
+    whiteSpace: "nowrap",
+    overflow: "hidden",
+    textOverflow: "ellipsis"
+  }),
+  // Include `fs(...)` & `fsPx(...)` for one-off font-sizes. We technically also have
+  // `fs0` and `fs1` for `flexShrink`, but this seems fine.
+  ...newMethodsForProp("fontSize", {}, "fs", true),
+  ...newMethodsForProp("lineHeight", {}, "lh", true)
+];
+
+// src/sections/tachyons/userSelect.ts
+var userSelect = () => newMethodsForProp(
+  "userSelect",
+  {
+    usn: "none",
+    ust: "text",
+    usAll: "all",
+    usAuto: "auto"
+  },
+  "select"
+);
+
+// src/sections/tachyons/verticalAlign.ts
+var verticalAlign = () => newMethodsForProp(
+  "verticalAlign",
+  {
+    vaBaseline: "baseline",
+    vam: "middle",
+    vat: "top",
+    vaBottom: "bottom"
+  },
+  "va"
+);
+
+// src/sections/tachyons/visibility.ts
+var visibility = () => newMethodsForProp("visibility", {
+  vv: "visible",
+  vh: "hidden"
+});
+
+// src/sections/tachyons/whitespace.ts
+var whitespace = () => newMethodsForProp("whiteSpace", {
+  wsp: "pre",
+  wsn: "normal",
+  wsnw: "nowrap",
+  wsbs: "break-spaces",
+  wspw: "pre-wrap",
+  wspl: "pre-line"
+});
+
+// src/sections/tachyons/widths.ts
+var width = (config) => [
+  ...newMethodsForProp(
+    "width",
+    {
+      w25: "25%",
+      w50: "50%",
+      w75: "75%",
+      w100: "100%",
+      wfc: "fit-content",
+      wmaxc: "max-content",
+      wminc: "min-content"
+    },
+    // Skip `w` here b/c it's created by newIncrementMethods below
+    null
+  ),
+  ...newMethodsForProp(
+    "minWidth",
+    {
+      mw0: 0,
+      mw25: "25%",
+      mw50: "50%",
+      mw75: "75%",
+      mw100: "100%",
+      mwfc: "fit-content",
+      mwminc: "min-content",
+      mwmaxc: "max-content"
+    },
+    "mw",
+    true
+  ),
+  ...newMethodsForProp(
+    "maxWidth",
+    {
+      maxw0: "0",
+      maxw25: "25%",
+      maxw50: "50%",
+      maxw75: "75%",
+      maxw100: "100%",
+      maxwfc: "fit-content",
+      maxwminc: "min-content",
+      maxwmaxc: "max-content"
+    },
+    "maxw",
+    true
+  ),
+  ...newIncrementMethods(config, "w", "width", { auto: true })
+];
+
+// src/sections/tachyons/wordBreak.ts
+var wordBreak = () => newMethodsForProp("wordBreak", {
+  wbn: "normal",
+  wbba: "break-all",
+  wbka: "keep-all",
+  wbbw: "break-word"
+});
+
+// src/sections/tachyons/zIndex.ts
+var zIndex = (config) => [
+  // Even though we define const z0/z1/etc indexes to follow Tachyons, ideally applications
+  // should define their own application-specific indexes, i.e.:
+  //
+  // export const zIndexes = {
+  //  ourModals: 10,
+  //  ourLabels: 12,
+  // }
+  //
+  // And then use `Css.z(zIndexes.ourModals).$` to get better documentation and maintainability
+  // then just using the zN abbreviations.
+  ...newMethodsForProp(
+    "zIndex",
+    {
+      z0: 0,
+      z1: 1,
+      z2: 2,
+      z3: 3,
+      z4: 4,
+      z5: 5,
+      z999: 999,
+      z9999: 9999,
+      zInherit: "inherit",
+      zInitial: "initial",
+      zUnset: "unset"
+    },
+    "z"
+  )
+];
+
+// src/sections/tachyons/container.ts
+var container = () => [
+  ...newMethodsForProp(
+    "containerType",
+    {
+      cts: "size",
+      ctis: "inline-size",
+      ctn: "normal"
+    },
+    "ct"
+  ),
+  ...newMethodsForProp("containerName", {}, "cn")
+];
+
+// src/sections/tachyons/opacity.ts
+var opacity = () => [
+  ...newMethodsForProp(
+    "opacity",
+    {
+      o0: "0",
+      o25: "0.25",
+      o50: "0.5",
+      o75: "0.75",
+      o100: "1"
+    },
+    "o"
+  )
+];
+
+// src/sections/tachyons/index.ts
+var defaultSections = {
+  border,
+  borderColor,
+  borderRadius,
+  borderStyle,
+  borderWidth,
+  boxShadow,
+  container,
+  coordinates,
+  cursor,
+  display,
+  flexbox,
+  float,
+  fontWeight,
+  grid,
+  height,
+  lineClamp,
+  objectFit,
+  opacity,
+  outline,
+  overflow,
+  position,
+  skins,
+  spacing,
+  textAlign,
+  textDecoration,
+  textTransform,
+  typeScale,
+  typography,
+  userSelect,
+  verticalAlign,
+  visibility,
+  whitespace,
+  width,
+  wordBreak,
+  zIndex
+};
+
+// src/generate.ts
+import { promises as fs } from "fs";
+import { code, def, imp } from "ts-poet";
+
+// src/breakpoints.ts
+function makeBreakpoints(breakpoints) {
+  const r = {
+    print: "@media print"
+  };
+  const bps = Object.keys(breakpoints);
+  Object.entries(breakpoints).forEach(([bp, px], i) => {
+    const isFirst = i === 0;
+    const isLast = i === bps.length - 1;
+    const min = !isFirst ? `${px}px` : "0";
+    const max = !isLast ? `${breakpoints[bps[i + 1]] - 1}px` : "0";
+    if (isFirst) {
+      r[bp] = `@media (max-width: ${max})`;
+    } else if (isLast) {
+      r[bp] = `@media (min-width: ${min})`;
+    } else {
+      r[bp] = `@media (min-width: ${min}) and (max-width: ${max})`;
+    }
+    if (!isFirst) {
+      const isSecond = i === 1;
+      const prevBp = bps[i - 1];
+      const name = `${prevBp}Or${capitalize(bp)}`;
+      const parts = [];
+      if (!isSecond) {
+        const prevMin = breakpoints[bps[i - 1]];
+        parts.push(`(min-width: ${prevMin}px)`);
+      }
+      if (!isLast) {
+        parts.push(`(max-width: ${max})`);
+      }
+      r[name] = `@media ${parts.join(" and ")}`;
+    }
+    if (!isFirst && !isLast) {
+      r[`${bp}AndUp`] = `@media (min-width: ${min})`;
+      r[`${bp}AndDown`] = `@media (max-width: ${max})`;
+    }
+  });
+  return r;
+}
+function capitalize(s) {
+  return `${s[0].toUpperCase()}${s.substring(1)}`;
+}
+
+// src/generate.ts
+import { pascalCase } from "change-case";
+
+// src/sections/tachyons-rn/spacing.ts
+var spacing2 = (config) => {
+  const marginDefs = [
+    ["mt", "marginTop"],
+    ["mr", "marginRight"],
+    ["mb", "marginBottom"],
+    ["ml", "marginLeft"],
+    ["mx", ["marginLeft", "marginRight"]],
+    ["my", ["marginTop", "marginBottom"]],
+    ["m", ["marginTop", "marginBottom", "marginRight", "marginLeft"]]
+  ];
+  const margins = [...marginDefs.map(([abbr, conf]) => newIncrementMethods(config, abbr, conf, { auto: true })).flat()];
+  const paddingDefs = [
+    ["pt", "paddingTop"],
+    ["pr", "paddingRight"],
+    ["pb", "paddingBottom"],
+    ["pl", "paddingLeft"],
+    ["px", ["paddingLeft", "paddingRight"]],
+    ["py", ["paddingTop", "paddingBottom"]],
+    ["p", ["paddingTop", "paddingBottom", "paddingRight", "paddingLeft"]]
+  ];
+  const paddings = paddingDefs.map(([abbr, conf]) => newIncrementMethods(config, abbr, conf)).flat();
+  return [...margins, ...paddings];
+};
+
+// src/sections/tachyons-rn/index.ts
+var reactNativeSections = {
+  spacing: spacing2
+};
+
+// src/generate.ts
+var CssProperties = imp("Properties@csstype");
+var defaultTypeAliases = {
+  Margin: ["margin", "marginTop", "marginRight", "marginBottom", "marginLeft"],
+  Padding: ["padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft"]
+};
+async function generate(config) {
+  const { outputPath } = config;
+  const target = config.target ?? "stylex";
+  if (target === "stylex") {
+    const { sections, entries } = collectStylexGenerationData(config);
+    const cssOutput = generateStylexCssBuilder(config, sections).toString();
+    await fs.writeFile(outputPath, cssOutput);
+    const mappingPath = config.mappingOutputPath || outputPath.replace(/\.ts$/, ".json");
+    const mapping = generateTrussMapping(config, entries);
+    await fs.writeFile(mappingPath, condensedJson(mapping) + "\n");
+    return;
+  }
+  if (target === "react-native") {
+    const output = generateCssBuilder(config).toString();
+    await fs.writeFile(outputPath, output);
+    return;
+  }
+  throw new Error(`Unsupported truss target "${target}". Use "stylex" (default) or "react-native".`);
+}
+function generateCssBuilder(config) {
+  const { fonts, increment, extras, typeAliases, breakpoints = {}, palette } = config;
+  const sections = generateSections(config);
+  const lines = Object.entries(sections).map(([name, value]) => [`// ${name}`, ...value, ""]).flat();
+  const typeAliasCode = Object.entries({
+    ...defaultTypeAliases,
+    ...typeAliases
+  }).map(([name, props]) => {
+    return `export type ${name} = ${props.map(quote).join(" | ")};
+
+`;
+  });
+  const typographyType = code`
+    export type ${def("Typography")} = ${Object.keys(fonts).map(quote).join(" | ")};
+  `;
+  const genBreakpoints = makeBreakpoints(breakpoints);
+  const breakpointCode = [
+    `export type Breakpoint = ${Object.keys(genBreakpoints).map(quote).join(" | ")};`,
+    `export enum Breakpoints {
+       ${Object.entries(genBreakpoints).map(([name, value]) => `${name} = "${value}"`)}
+    };`
+  ];
+  const breakpointIfs = Object.entries(genBreakpoints).map(([name, value]) => {
+    return code`
+      get if${pascalCase(name)}() {
+        return this.newCss({ selector: ${quote(value)} });
+      }`;
+  });
+  const containerQueriesCode = code`
+    /**
+     * Utility to help write \`@container\` queries
+     *
+     * @param name - The name of the container.
+     * @param lt - The maximum width of the container inclusive.
+     * @param gt - The minimum width of the container exclusive.
+     */
+    type ContainerProps = { name?: string } & ({ lt: number } | { gt: number } | { lt: number; gt: number });
+    export function Container(props: ContainerProps) {
+      const { name = "" } = props;
+      const lt = "lt" in props ? props.lt : undefined;
+      const gt = "gt" in props ? props.gt : undefined;
+
+      const ltQuery = lt !== undefined ? \`(max-width: \${lt}px)\` : "";
+      const gtQuery = gt !== undefined ? \`(min-width: \${gt + 1}px)\` : "";
+      const query = [ltQuery, gtQuery].filter(Boolean).join(" and ");
+
+      return \`@container \${name} \${query}\`;
+    }`;
+  return code`
+// This file is auto-generated by truss: https://github.com/homebound-team/truss.
+// See your project's \`truss-config.ts\` to make configuration changes (fonts, increments, etc).
+
+/** Given a type X, and the user's proposed type T, only allow keys in X and nothing else. */
+export type Only<X, T> = X & Record<Exclude<keyof T, keyof X>, never>;
+
+export type ${def("Properties")} = ${CssProperties}<string | 0, string>;
+
+${typographyType}
+
+type Opts<T> = {
+  rules: T,
+  enabled: boolean,
+  important: boolean,
+  selector: string | undefined
+};
+
+class CssBuilder<T extends Properties> {
+  constructor(private opts: Opts<T>) {}
+
+  private get rules(): T { return this.opts.rules };
+  private get enabled(): boolean { return this.opts.enabled };
+  private get selector(): string | undefined { return this.opts.selector };
+  private newCss(opts: Partial<Opts<T>>): CssBuilder<T> {
+    return new CssBuilder({ ...this.opts, ...opts });
+  }
+
+  ${lines.join("\n  ").replace(/ +\n/g, "\n")}
+    
+  get $(): T { return maybeImportant(sortObject(this.rules), this.opts.important); }
+
+  if(bp: Breakpoint): CssBuilder<T>;
+  if(cond: boolean): CssBuilder<T>;
+  if(attr: string, value: boolean | string): CssBuilder<T>;
+  if(arg: boolean | Breakpoint | string, value?: boolean | string): CssBuilder<T> {
+    if (value !== undefined) {
+      return this.newCss({ selector: \`[\${arg}='\${value}']\` });
+    } else if (typeof arg === "boolean") {
+      return this.newCss({ enabled: arg });
+    } else {
+      return this.newCss({ selector: Breakpoints[arg as Breakpoint] });
+    }
+  }
+
+  get onHover() {
+    return this.newCss({ selector: ":hover" });
+  }
+  
+  ifContainer(props: ContainerProps) {
+    return this.newCss({ selector: Container(props) });
+  }
+  
+  ${breakpointIfs}
+
+  get else() {
+    if (this.selector !== undefined) {
+      if (this.selector.includes("not")) {
+        throw new Error("else was already called");
+      } else {
+        return this.newCss({ selector: this.selector.replace("@media", "@media not") });
+      }
+    }
+    return this.newCss({ enabled: !this.enabled });
+  }
+
+  get important() { return this.newCss({ important: true }); }
+
+  /** Adds new properties, either a specific key/value or a Properties object, to the current css. */
+  add<P extends Properties>(props: P): CssBuilder<T & P>;
+  add<K extends keyof Properties>(prop: K, value: Properties[K]): CssBuilder<T & { [U in K]: Properties[K] }>;
+  add<K extends keyof Properties>(propOrProperties: K | Properties, value?: Properties[K]): CssBuilder<any> {
+    if (!this.enabled) return this;
+    const newRules = typeof propOrProperties === "string" ?  { [propOrProperties]: value } : propOrProperties;
+    const rules = this.selector
+      ? { ...this.rules, [this.selector]: { ...(this.rules as any)[this.selector], ...newRules } }
+      : { ...this.rules, ...newRules };
+    return this.newCss({ rules: rules as any });
+  }
+
+  /** Adds new properties, either a specific key/value or a Properties object, to a nested selector. */
+  addIn<P extends Properties>(selector: string, props: P | undefined): CssBuilder<T & P>;
+  addIn<K extends keyof Properties>(selector: string, prop: K, value: Properties[K]): CssBuilder<T & { [U in K]: Properties[K] }>;
+  addIn<K extends keyof Properties>(selector: string, propOrProperties: K | Properties, value?: Properties[K]): CssBuilder<any> {
+    const newRules = typeof propOrProperties === "string" ?  { [propOrProperties]: value } : propOrProperties;
+    if (!this.enabled) return this;
+    if (newRules === undefined) {
+      return this;
+    }
+    const rules = { ...this.rules, [selector]: { ...(this.rules as any)[selector], ...newRules } };
+    return this.newCss({ rules: rules as any });
+  }
+}
+
+/** Sort keys so equivalent rule objects have deterministic shape. */
+function sortObject<T extends object>(obj: T): T {
+  return Object.keys(obj)
+    .sort()
+    .reduce((acc, key) => {
+      acc[key as keyof T] = obj[key as keyof T];
+      return acc;
+    }, ({} as any) as T) as T;
+}
+
+/** Conditionally adds \`important!\` to everything. */
+function maybeImportant<T extends object>(obj: T, important: boolean): T {
+  if (important) {
+    Object.keys(obj).forEach(key => {
+      (obj as any)[key] = \`\${(obj as any)[key]} !important\`;
+    });
+  }
+  return obj;
+}
+
+/** Converts \`inc\` into pixels value with a \`px\` suffix. */
+export function maybeInc(inc: number | string): string {
+  return typeof inc === "string" ? inc : \`\${increment(inc)}px\`;
+}
+
+/** Converts \`inc\` into pixels. */
+export function increment(inc: number): number {
+  return inc * ${increment};
+}
+
+/** Convert \`pixels\` to a \`px\` units string so it's not ambiguous. */
+export function px(pixels: number): string {
+  return \`\${pixels}px\`;
+}
+
+export enum Palette {
+  ${Object.entries(palette).map(([name, value]) => {
+    return `${name} = "${value}",`;
+  })}
+}
+
+/** A shortcut for defining Xss types. */
+export type Xss<P extends keyof Properties> = Pick<Properties, P>;
+
+/** An entry point for Css expressions. CssBuilder is immutable so this is safe to share. */
+export const Css = new CssBuilder({ rules: {}, enabled: true, important: false, selector: undefined });
+
+${typeAliasCode}
+
+${breakpointCode}
+
+${containerQueriesCode}
+
+${extras || ""}
+  `;
+}
+function generateMethods(config, methodFns) {
+  return Object.fromEntries(Object.entries(methodFns).map(([name, fn]) => [name, fn(config)]));
+}
+function generateSections(config) {
+  const { aliases, defaultMethods = "tachyons", sections: customSections } = config;
+  return {
+    ...defaultMethods === "tachyons" ? generateMethods(config, defaultSections) : defaultMethods === "tachyons-rn" ? generateMethods(config, reactNativeSections) : {},
+    ...customSections ? generateMethods(config, customSections) : {},
+    ...aliases && { aliases: newAliasesMethods(aliases) }
+  };
+}
+function collectStylexGenerationData(config) {
+  startStylexCollection();
+  try {
+    const sections = generateSections(config);
+    const entries = stopStylexCollection();
+    return { sections, entries };
+  } catch (error) {
+    stopStylexCollection();
+    throw error;
+  }
+}
+function generateStylexCssBuilder(config, sections) {
+  const { fonts, increment, extras, palette, breakpoints = {} } = config;
+  const lines = Object.entries(sections).map(([name, value]) => [`// ${name}`, ...value, ""]).flat();
+  const genBreakpointsMap = makeBreakpoints(breakpoints);
+  const breakpointIfs = Object.entries(genBreakpointsMap).map(([name, value]) => {
+    return code`
+      get if${pascalCase(name)}() {
+        return this.newCss({ selector: ${quote(value)} });
+      }`;
+  });
+  const breakpointCode = [
+    `export type Breakpoint = ${Object.keys(genBreakpointsMap).map(quote).join(" | ")};`,
+    `export enum Breakpoints {`,
+    ...Object.entries(genBreakpointsMap).map(([name, value]) => `  ${name} = "${value}",`),
+    `}`
+  ];
+  const typographyType = code`
+    export type ${def("Typography")} = ${Object.keys(fonts).map(quote).join(" | ")};
+  `;
+  return code`
+// This file is auto-generated by truss: https://github.com/homebound-team/truss.
+// See your project's \`truss-config.ts\` to make configuration changes (fonts, increments, etc).
+// Target: stylex (build-time plugin)
+
+import * as stylex from "@stylexjs/stylex";
+
+export type ${def("Properties")} = ${CssProperties}<string | 0, string>;
+
+/** A marker returned by \`stylex.defineMarker()\`, used with \`when\`/\`markerOf\` etc. */
+export type Marker = ReturnType<typeof stylex.defineMarker>;
+
+${typographyType}
+
+/** The type accepted by the \`css\` JSX prop. Opaque - the build-time plugin resolves this. */
+export type CssProp = any[];
+
+// Augment React types so JSX elements accept the \`css\` prop
+declare module "react" {
+  interface HTMLAttributes<T> {
+    css?: CssProp;
+  }
+  interface SVGAttributes<T> {
+    css?: CssProp;
+  }
+}
+
+type Opts<T> = {
+  rules: T;
+  enabled: boolean;
+  selector: string | undefined;
+};
+
+class CssBuilder<T extends Properties> {
+  constructor(private opts: Opts<T>) {}
+
+  ${lines.join("\n  ").replace(/ +\n/g, "\n")}
+
+  get $(): CssProp {
+    return this.rules as any;
+  }
+
+  get onHover() {
+    return this.newCss({ selector: ":hover" });
+  }
+  get onFocus() {
+    return this.newCss({ selector: ":focus" });
+  }
+  get onFocusVisible() {
+    return this.newCss({ selector: ":focus-visible" });
+  }
+  get onActive() {
+    return this.newCss({ selector: ":active" });
+  }
+  get onDisabled() {
+    return this.newCss({ selector: ":disabled" });
+  }
+
+  /** Marks this element as a default hover marker (for ancestor pseudo selectors). */
+  get marker(): CssBuilder<T> {
+    return this;
+  }
+
+  /** Marks this element with a user-defined marker (return value of stylex.defineMarker()). */
+  markerOf(_marker: Marker): CssBuilder<T> {
+    return this;
+  }
+
+  /**
+    * Styles after this \`when\` are applied based on a relationship + pseudo selector.
+    *
+    * \`when("ancestor", ":hover")\` — react to ancestor hover
+    * \`when("descendant", ":focus")\` — react to descendant focus
+    * \`when("siblingAfter", ":hover")\` — react to a following sibling's hover
+    */
+  when(relationship: "ancestor" | "descendant" | "anySibling" | "siblingBefore" | "siblingAfter", pseudo: string): CssBuilder<T>;
+  /**
+    * Styles after this \`when\` are applied based on a relationship-to-marker + pseudo selector.
+    *
+    * \`when("ancestor", marker, ":hover")\` — react to a specific ancestor's hover
+    */
+  when(relationship: "ancestor" | "descendant" | "anySibling" | "siblingBefore" | "siblingAfter", marker: Marker, pseudo: string): CssBuilder<T>;
+  when(_relationship: string, _pseudoOrMarker: string | Marker, _pseudo?: string): CssBuilder<T> {
+    return this;
+  }
+
+  ifContainer(_props: { name?: string; lt?: number; gt?: number }) {
+    return this;
+  }
+
+  /** Apply styles within a pseudo-element (e.g. \`"::placeholder"\`, \`"::selection"\`). */
+  element(_pseudoElement: string): CssBuilder<T> {
+    return this;
+  }
+
+  ${breakpointIfs}
+
+  /** Conditionally apply styles when \`cond\` is true. */
+  if(cond: boolean): CssBuilder<T>;
+  /** Apply styles within a media query (e.g. \`Breakpoints.sm\` or a raw \`@media\` string). */
+  if(mediaQuery: string): CssBuilder<T>;
+  if(condOrMediaQuery: boolean | string): CssBuilder<T> {
+    if (typeof condOrMediaQuery === "boolean") {
+      return new CssBuilder({ ...this.opts, enabled: condOrMediaQuery });
+    }
+    return this.newCss({ selector: condOrMediaQuery });
+  }
+
+  get else(): CssBuilder<T> {
+    return new CssBuilder({ ...this.opts, enabled: !this.enabled });
+  }
+
+  add<K extends keyof Properties>(prop: K, value: Properties[K]): CssBuilder<T & { [U in K]: Properties[K] }> {
+    if (!this.enabled) return this;
+    const newRules = { [prop]: value };
+    const rules = this.selector
+      ? { ...this.rules, [this.selector]: { ...(this.rules as any)[this.selector], ...newRules } }
+      : { ...this.rules, ...newRules };
+    return this.newCss({ rules });
+  }
+
+  private get rules(): T {
+    return this.opts.rules;
+  }
+  private get enabled(): boolean {
+    return this.opts.enabled;
+  }
+  private get selector(): string | undefined {
+    return this.opts.selector;
+  }
+  private newCss(opts: Partial<Opts<T>>): CssBuilder<T> {
+    return new CssBuilder({ ...this.opts, ...opts });
+  }
+}
+
+/** Converts \`inc\` into pixels value with a \`px\` suffix. */
+export function maybeInc(inc: number | string): string {
+  return typeof inc === "string" ? inc : \`\${inc * ${increment}}px\`;
+}
+
+export enum Palette {
+  ${Object.entries(palette).map(([name, value]) => {
+    return `${name} = "${value}",`;
+  })}
+}
+
+/** An entry point for Css expressions. CssBuilder is immutable so this is safe to share. */
+export const Css = new CssBuilder({ rules: {}, enabled: true, selector: undefined });
+
+${breakpointCode}
+
+${extras || ""}
+  `;
+}
+function generateTrussMapping(config, entries) {
+  const { breakpoints = {} } = config;
+  const abbreviations = {};
+  for (const entry of entries) {
+    switch (entry.kind) {
+      case "static":
+      case "cssvar":
+        abbreviations[entry.abbr] = { kind: "static", defs: entry.defs || {} };
+        break;
+      case "param":
+        abbreviations[entry.abbr] = {
+          kind: "dynamic",
+          props: entry.props || [],
+          incremented: false,
+          extraDefs: entry.extraDefs
+        };
+        break;
+      case "increment-param":
+        abbreviations[entry.abbr] = {
+          kind: "dynamic",
+          props: entry.props || [],
+          incremented: true,
+          extraDefs: entry.extraDefs
+        };
+        break;
+      case "px-delegate":
+        abbreviations[entry.abbr] = {
+          kind: "delegate",
+          target: entry.abbr.replace(/Px$/, "")
+        };
+        break;
+      case "alias":
+        abbreviations[entry.abbr] = {
+          kind: "alias",
+          chain: entry.aliasTargets || []
+        };
+        break;
+    }
+  }
+  const genBreakpointsMap = makeBreakpoints(breakpoints);
+  const breakpointEntries = {};
+  for (const [name, mediaQuery] of Object.entries(genBreakpointsMap)) {
+    breakpointEntries[`if${pascalCase(name)}`] = mediaQuery;
+  }
+  return {
+    increment: config.increment,
+    ...Object.keys(breakpointEntries).length > 0 ? { breakpoints: breakpointEntries } : {},
+    abbreviations
+  };
+}
+function condensedJson(mapping) {
+  const lines = [];
+  lines.push("{");
+  lines.push(`  "increment": ${mapping.increment},`);
+  if (mapping.breakpoints && Object.keys(mapping.breakpoints).length > 0) {
+    lines.push(`  "breakpoints": ${JSON.stringify(mapping.breakpoints)},`);
+  }
+  lines.push(`  "abbreviations": {`);
+  const entries = Object.entries(mapping.abbreviations);
+  for (let i = 0; i < entries.length; i++) {
+    const [key, value] = entries[i];
+    const comma = i < entries.length - 1 ? "," : "";
+    lines.push(`    ${JSON.stringify(key)}: ${JSON.stringify(value)}${comma}`);
+  }
+  lines.push("  }");
+  lines.push("}");
+  return lines.join("\n");
+}
+export {
+  defaultSections,
+  defineConfig,
+  generate,
+  newAliasesMethods,
+  newCoreIncrementMethods,
+  newIncrementMethods,
+  newMethod,
+  newMethodsForProp,
+  newParamMethod,
+  newPxMethod,
+  newSetCssVariablesMethod,
+  startStylexCollection,
+  stopStylexCollection
+};
 //# sourceMappingURL=index.js.map