tokenami 0.0.77--canary.400.e4d091f.0

package/dist/cli.js

@@ -0,0 +1,1227 @@
+import { fileURLToPath } from 'url';
+import path from 'path';
+import * as Tokenami2 from '@tokenami/config';
+import browserslist from 'browserslist';
+import * as lightning from 'lightningcss';
+import { browserslistToTargets } from 'lightningcss';
+import cac from 'cac';
+import glob from 'fast-glob';
+import inquirer from 'inquirer';
+import * as fs2 from 'fs';
+import * as chokidar from 'chokidar';
+import * as pathe from 'pathe';
+import { stringify } from '@stitches/stringify';
+import createJiti from 'jiti';
+import { transform } from 'sucrase';
+import chalk from 'chalk';
+import * as acorn from 'acorn';
+import * as acornWalk from 'acorn-walk';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+var __filename = /* @__PURE__ */ getFilename();
+
+// src/supports.ts
+var supportedLogical = {
+  "block-overflow": 1,
+  "block-size": 1,
+  "border-block": 1,
+  "border-block-end": 1,
+  "border-block-start": 1,
+  "border-block-color": 1,
+  "border-block-end-color": 1,
+  "border-block-end-style": 1,
+  "border-block-end-width": 1,
+  "border-block-start-color": 1,
+  "border-block-start-style": 1,
+  "border-block-start-width": 1,
+  "border-block-style": 1,
+  "border-block-width": 1,
+  "border-inline": 1,
+  "border-inline-end": 1,
+  "border-inline-start": 1,
+  "border-inline-color": 1,
+  "border-inline-end-color": 1,
+  "border-inline-end-style": 1,
+  "border-inline-end-width": 1,
+  "border-inline-start-color": 1,
+  "border-inline-start-style": 1,
+  "border-inline-start-width": 1,
+  "border-inline-style": 1,
+  "border-inline-width": 1,
+  "contain-intrinsic-block-size": 1,
+  "contain-intrinsic-inline-size": 1,
+  "inline-size": 1,
+  "inset-block": 1,
+  "inset-block-end": 1,
+  "inset-block-start": 1,
+  "inset-inline": 1,
+  "inset-inline-end": 1,
+  "inset-inline-start": 1,
+  "margin-block": 1,
+  "margin-block-end": 1,
+  "margin-block-start": 1,
+  "margin-inline": 1,
+  "margin-inline-end": 1,
+  "margin-inline-start": 1,
+  "max-block-size": 1,
+  "max-inline-size": 1,
+  "min-block-size": 1,
+  "min-inline-size": 1,
+  "overflow-block": 1,
+  "overflow-inline": 1,
+  "overscroll-behavior-block": 1,
+  "overscroll-behavior-inline": 1,
+  "padding-block": 1,
+  "padding-block-end": 1,
+  "padding-block-start": 1,
+  "padding-inline": 1,
+  "padding-inline-end": 1,
+  "padding-inline-start": 1,
+  "scroll-margin-block": 1,
+  "scroll-margin-block-end": 1,
+  "scroll-margin-block-start": 1,
+  "scroll-margin-inline": 1,
+  "scroll-margin-inline-end": 1,
+  "scroll-margin-inline-start": 1,
+  "scroll-padding-block": 1,
+  "scroll-padding-block-end": 1,
+  "scroll-padding-block-start": 1,
+  "scroll-padding-inline": 1,
+  "scroll-padding-inline-end": 1,
+  "scroll-padding-inline-start": 1
+};
+var supported = {
+  all: 1,
+  animation: 1,
+  "animation-range": 1,
+  background: 1,
+  "background-position": 1,
+  border: 1,
+  "border-bottom": 1,
+  "border-color": 1,
+  "border-image": 1,
+  "border-left": 1,
+  "border-radius": 1,
+  "border-right": 1,
+  "border-style": 1,
+  "border-top": 1,
+  "border-width": 1,
+  caret: 1,
+  "column-rule": 1,
+  columns: 1,
+  "contain-intrinsic-size": 1,
+  container: 1,
+  flex: 1,
+  "flex-flow": 1,
+  font: 1,
+  gap: 1,
+  grid: 1,
+  "grid-area": 1,
+  "grid-column": 1,
+  "grid-row": 1,
+  "grid-template": 1,
+  inset: 1,
+  "line-clamp": 1,
+  "list-style": 1,
+  margin: 1,
+  mask: 1,
+  "mask-border": 1,
+  motion: 1,
+  offset: 1,
+  outline: 1,
+  overflow: 1,
+  "overscroll-behavior": 1,
+  padding: 1,
+  "place-content": 1,
+  "place-items": 1,
+  "place-self": 1,
+  "scroll-margin": 1,
+  "scroll-padding": 1,
+  "scroll-snap-margin": 1,
+  "scroll-timeline": 1,
+  "text-decoration": 1,
+  "text-emphasis": 1,
+  transition: 1,
+  "view-timeline": 1,
+  "accent-color": 1,
+  "align-content": 1,
+  "align-items": 1,
+  "align-self": 1,
+  "align-tracks": 1,
+  "animation-composition": 1,
+  "animation-delay": 1,
+  "animation-direction": 1,
+  "animation-duration": 1,
+  "animation-fill-mode": 1,
+  "animation-iteration-count": 1,
+  "animation-name": 1,
+  "animation-play-state": 1,
+  "animation-range-end": 1,
+  "animation-range-start": 1,
+  "animation-timeline": 1,
+  "animation-timing-function": 1,
+  appearance: 1,
+  "aspect-ratio": 1,
+  "backdrop-filter": 1,
+  "backface-visibility": 1,
+  "background-attachment": 1,
+  "background-blend-mode": 1,
+  "background-clip": 1,
+  "background-color": 1,
+  "background-image": 1,
+  "background-origin": 1,
+  "background-position-x": 1,
+  "background-position-y": 1,
+  "background-repeat": 1,
+  "background-size": 1,
+  "border-bottom-color": 1,
+  "border-bottom-left-radius": 1,
+  "border-bottom-right-radius": 1,
+  "border-bottom-style": 1,
+  "border-bottom-width": 1,
+  "border-collapse": 1,
+  "border-end-end-radius": 1,
+  "border-end-start-radius": 1,
+  "border-image-outset": 1,
+  "border-image-repeat": 1,
+  "border-image-slice": 1,
+  "border-image-source": 1,
+  "border-image-width": 1,
+  "border-left-color": 1,
+  "border-left-style": 1,
+  "border-left-width": 1,
+  "border-right-color": 1,
+  "border-right-style": 1,
+  "border-right-width": 1,
+  "border-spacing": 1,
+  "border-start-end-radius": 1,
+  "border-start-start-radius": 1,
+  "border-top-color": 1,
+  "border-top-left-radius": 1,
+  "border-top-right-radius": 1,
+  "border-top-style": 1,
+  "border-top-width": 1,
+  bottom: 1,
+  "box-decoration-break": 1,
+  "box-shadow": 1,
+  "box-sizing": 1,
+  "break-after": 1,
+  "break-before": 1,
+  "break-inside": 1,
+  "caption-side": 1,
+  "caret-color": 1,
+  "caret-shape": 1,
+  clear: 1,
+  "clip-path": 1,
+  color: 1,
+  "color-adjust": 1,
+  "color-scheme": 1,
+  "column-count": 1,
+  "column-fill": 1,
+  "column-gap": 1,
+  "column-rule-color": 1,
+  "column-rule-style": 1,
+  "column-rule-width": 1,
+  "column-span": 1,
+  "column-width": 1,
+  contain: 1,
+  "contain-intrinsic-height": 1,
+  "contain-intrinsic-width": 1,
+  "container-name": 1,
+  "container-type": 1,
+  content: 1,
+  "content-visibility": 1,
+  "counter-increment": 1,
+  "counter-reset": 1,
+  "counter-set": 1,
+  cursor: 1,
+  direction: 1,
+  display: 1,
+  "empty-cells": 1,
+  filter: 1,
+  "flex-basis": 1,
+  "flex-direction": 1,
+  "flex-grow": 1,
+  "flex-shrink": 1,
+  "flex-wrap": 1,
+  float: 1,
+  "font-family": 1,
+  "font-feature-settings": 1,
+  "font-kerning": 1,
+  "font-language-override": 1,
+  "font-optical-sizing": 1,
+  "font-palette": 1,
+  "font-size": 1,
+  "font-size-adjust": 1,
+  "font-smooth": 1,
+  "font-stretch": 1,
+  "font-style": 1,
+  "font-synthesis": 1,
+  "font-synthesis-position": 1,
+  "font-synthesis-small-caps": 1,
+  "font-synthesis-style": 1,
+  "font-synthesis-weight": 1,
+  "font-variant": 1,
+  "font-variant-alternates": 1,
+  "font-variant-caps": 1,
+  "font-variant-east-asian": 1,
+  "font-variant-emoji": 1,
+  "font-variant-ligatures": 1,
+  "font-variant-numeric": 1,
+  "font-variant-position": 1,
+  "font-variation-settings": 1,
+  "font-weight": 1,
+  "forced-color-adjust": 1,
+  "grid-auto-columns": 1,
+  "grid-auto-flow": 1,
+  "grid-auto-rows": 1,
+  "grid-column-end": 1,
+  "grid-column-start": 1,
+  "grid-row-end": 1,
+  "grid-row-start": 1,
+  "grid-template-areas": 1,
+  "grid-template-columns": 1,
+  "grid-template-rows": 1,
+  "hanging-punctuation": 1,
+  height: 1,
+  "hyphenate-character": 1,
+  "hyphenate-limit-chars": 1,
+  hyphens: 1,
+  "image-orientation": 1,
+  "image-rendering": 1,
+  "image-resolution": 1,
+  "initial-letter": 1,
+  "input-security": 1,
+  isolation: 1,
+  "justify-content": 1,
+  "justify-items": 1,
+  "justify-self": 1,
+  "justify-tracks": 1,
+  left: 1,
+  "letter-spacing": 1,
+  "line-break": 1,
+  "line-height": 1,
+  "line-height-step": 1,
+  "list-style-image": 1,
+  "list-style-position": 1,
+  "list-style-type": 1,
+  "margin-bottom": 1,
+  "margin-left": 1,
+  "margin-right": 1,
+  "margin-top": 1,
+  "margin-trim": 1,
+  "mask-border-mode": 1,
+  "mask-border-outset": 1,
+  "mask-border-repeat": 1,
+  "mask-border-slice": 1,
+  "mask-border-source": 1,
+  "mask-border-width": 1,
+  "mask-clip": 1,
+  "mask-composite": 1,
+  "mask-image": 1,
+  "mask-mode": 1,
+  "mask-origin": 1,
+  "mask-position": 1,
+  "mask-repeat": 1,
+  "mask-size": 1,
+  "mask-type": 1,
+  "masonry-auto-flow": 1,
+  "math-depth": 1,
+  "math-shift": 1,
+  "math-style": 1,
+  "max-height": 1,
+  "max-lines": 1,
+  "max-width": 1,
+  "min-height": 1,
+  "min-width": 1,
+  "mix-blend-mode": 1,
+  "motion-distance": 1,
+  "motion-path": 1,
+  "motion-rotation": 1,
+  "object-fit": 1,
+  "object-position": 1,
+  "offset-anchor": 1,
+  "offset-distance": 1,
+  "offset-path": 1,
+  "offset-position": 1,
+  "offset-rotate": 1,
+  "offset-rotation": 1,
+  opacity: 1,
+  order: 1,
+  orphans: 1,
+  "outline-color": 1,
+  "outline-offset": 1,
+  "outline-style": 1,
+  "outline-width": 1,
+  "overflow-anchor": 1,
+  "overflow-clip-box": 1,
+  "overflow-clip-margin": 1,
+  "overflow-wrap": 1,
+  "overflow-x": 1,
+  "overflow-y": 1,
+  overlay: 1,
+  "overscroll-behavior-x": 1,
+  "overscroll-behavior-y": 1,
+  "padding-bottom": 1,
+  "padding-left": 1,
+  "padding-right": 1,
+  "padding-top": 1,
+  page: 1,
+  "page-break-after": 1,
+  "page-break-before": 1,
+  "page-break-inside": 1,
+  "paint-order": 1,
+  perspective: 1,
+  "perspective-origin": 1,
+  "pointer-events": 1,
+  position: 1,
+  "print-color-adjust": 1,
+  quotes: 1,
+  resize: 1,
+  right: 1,
+  rotate: 1,
+  "row-gap": 1,
+  "ruby-align": 1,
+  "ruby-merge": 1,
+  "ruby-position": 1,
+  scale: 1,
+  "scroll-behavior": 1,
+  "scroll-margin-bottom": 1,
+  "scroll-margin-left": 1,
+  "scroll-margin-right": 1,
+  "scroll-margin-top": 1,
+  "scroll-padding-bottom": 1,
+  "scroll-padding-left": 1,
+  "scroll-padding-right": 1,
+  "scroll-padding-top": 1,
+  "scroll-snap-align": 1,
+  "scroll-snap-margin-bottom": 1,
+  "scroll-snap-margin-left": 1,
+  "scroll-snap-margin-right": 1,
+  "scroll-snap-margin-top": 1,
+  "scroll-snap-stop": 1,
+  "scroll-snap-type": 1,
+  "scroll-timeline-axis": 1,
+  "scroll-timeline-name": 1,
+  "scrollbar-color": 1,
+  "scrollbar-gutter": 1,
+  "scrollbar-width": 1,
+  "shape-image-threshold": 1,
+  "shape-margin": 1,
+  "shape-outside": 1,
+  "tab-size": 1,
+  "table-layout": 1,
+  "text-align": 1,
+  "text-align-last": 1,
+  "text-combine-upright": 1,
+  "text-decoration-color": 1,
+  "text-decoration-line": 1,
+  "text-decoration-skip": 1,
+  "text-decoration-skip-ink": 1,
+  "text-decoration-style": 1,
+  "text-decoration-thickness": 1,
+  "text-emphasis-color": 1,
+  "text-emphasis-position": 1,
+  "text-emphasis-style": 1,
+  "text-indent": 1,
+  "text-justify": 1,
+  "text-orientation": 1,
+  "text-overflow": 1,
+  "text-rendering": 1,
+  "text-shadow": 1,
+  "text-size-adjust": 1,
+  "text-transform": 1,
+  "text-underline-offset": 1,
+  "text-underline-position": 1,
+  "text-wrap": 1,
+  "timeline-scope": 1,
+  top: 1,
+  "touch-action": 1,
+  transform: 1,
+  "transform-box": 1,
+  "transform-origin": 1,
+  "transform-style": 1,
+  "transition-behavior": 1,
+  "transition-delay": 1,
+  "transition-duration": 1,
+  "transition-property": 1,
+  "transition-timing-function": 1,
+  translate: 1,
+  "unicode-bidi": 1,
+  "user-select": 1,
+  "vertical-align": 1,
+  "view-timeline-axis": 1,
+  "view-timeline-inset": 1,
+  "view-timeline-name": 1,
+  "view-transition-name": 1,
+  visibility: 1,
+  "white-space": 1,
+  "white-space-collapse": 1,
+  "white-space-trim": 1,
+  widows: 1,
+  width: 1,
+  "will-change": 1,
+  "word-break": 1,
+  "word-spacing": 1,
+  "word-wrap": 1,
+  "writing-mode": 1,
+  "z-index": 1,
+  zoom: 1,
+  "alignment-baseline": 1,
+  "baseline-shift": 1,
+  clip: 1,
+  "clip-rule": 1,
+  "color-interpolation": 1,
+  "color-rendering": 1,
+  "dominant-baseline": 1,
+  fill: 1,
+  "fill-opacity": 1,
+  "fill-rule": 1,
+  "flood-color": 1,
+  "flood-opacity": 1,
+  "glyph-orientation-vertical": 1,
+  "lighting-color": 1,
+  marker: 1,
+  "marker-end": 1,
+  "marker-mid": 1,
+  "marker-start": 1,
+  "shape-rendering": 1,
+  "stop-color": 1,
+  "stop-opacity": 1,
+  stroke: 1,
+  "stroke-dasharray": 1,
+  "stroke-dashoffset": 1,
+  "stroke-linecap": 1,
+  "stroke-linejoin": 1,
+  "stroke-miterlimit": 1,
+  "stroke-opacity": 1,
+  "stroke-width": 1,
+  "text-anchor": 1,
+  "vector-effect": 1,
+  ...supportedLogical
+};
+var inheritedProperties = /* @__PURE__ */ new Set([
+  "azimuth",
+  "border-collapse",
+  "border-spacing",
+  "caption-side",
+  "color",
+  "cursor",
+  "direction",
+  "empty-cells",
+  "font-family",
+  "font-size",
+  "font-style",
+  "font-variant",
+  "font-weight",
+  "font-stretch",
+  "font",
+  "letter-spacing",
+  "line-height",
+  "list-style-image",
+  "list-style-position",
+  "list-style-type",
+  "list-style",
+  "orphans",
+  "quotes",
+  "text-align",
+  "text-indent",
+  "text-transform",
+  "visibility",
+  "white-space",
+  "widows",
+  "word-spacing"
+]);
+var supportedProperties = new Set(Object.keys(supported));
+var supportedLogicalProperties = new Set(Object.keys(supportedLogical));
+
+// src/utils.ts
+var DEFAULT_PATHS = {
+  js: "./.tokenami/tokenami.config.js",
+  ts: "./.tokenami/tokenami.config.ts",
+  cjs: "./.tokenami/tokenami.config.cjs",
+  mjs: "./.tokenami/tokenami.config.mjs"
+};
+function getConfigPath(cwd, path2, type) {
+  path2 = path2 || getConfigDefaultPath(cwd, type);
+  return pathe.join(cwd, path2);
+}
+function getConfigAtPath(path2) {
+  const config = function() {
+    try {
+      return __require(path2);
+    } catch {
+      return lazyJiti()(path2);
+    }
+  }();
+  return mergedConfigs(config.default ?? config);
+}
+function getReloadedConfigAtPath(path2) {
+  const config = function() {
+    try {
+      delete __require.cache[__require.resolve(path2)];
+      return __require(path2);
+    } catch {
+      return lazyJiti({ cache: false })(path2);
+    }
+  }();
+  return mergedConfigs(config.default ?? config);
+}
+function getConfigDefaultPath(cwd, type) {
+  const existingConfig = Object.values(DEFAULT_PATHS).find((path2) => {
+    return fs2.existsSync(pathe.join(cwd, path2));
+  });
+  return existingConfig || DEFAULT_PATHS[type || "js"];
+}
+function getTypeDefsPath(configPath) {
+  const dirname3 = pathe.dirname(configPath);
+  return `${dirname3}/tokenami.env.d.ts`;
+}
+function getCiTypeDefsPath(configPath) {
+  const dirname3 = pathe.dirname(configPath);
+  return `${dirname3}/tokenami.env.ci.d.ts`;
+}
+function getThemeValuesByTokenValues(tokenValues, theme) {
+  const entries = getThemeValueByTokenValueEntries(tokenValues, theme);
+  return Object.fromEntries(entries);
+}
+function getThemeValueByTokenValueEntries(tokenValues, theme) {
+  const sorted = [...tokenValues].sort();
+  return sorted.flatMap((tokenValue) => {
+    const parts = Tokenami2.getTokenValueParts(tokenValue);
+    const value = theme[parts.themeKey]?.[parts.token];
+    if (value == null)
+      return [];
+    const valueString = String(value);
+    const tokenValues2 = findTokenValuesInThemeValue(valueString);
+    const themeValuesEntries = getThemeValueByTokenValueEntries(tokenValues2, theme);
+    return [[parts.property, valueString], ...themeValuesEntries];
+  });
+}
+function findTokenValuesInThemeValue(themeValue) {
+  const cssVariables = themeValue.match(/var\([\w-_]+\)/g) || [];
+  const tokenValues = cssVariables.filter((v) => Tokenami2.TokenValue.safeParse(v).success);
+  return tokenValues;
+}
+function getThemeFromConfig(themeConfig) {
+  const { modes = {}, root, ...base } = themeConfig;
+  if ("modes" in themeConfig) {
+    const config = themeConfig;
+    return { modes: config.modes, root: config.root };
+  }
+  return { modes: {}, root: base };
+}
+function getThemeValuesByThemeMode(tokenValue, themeConfig) {
+  const theme = getThemeFromConfig(themeConfig);
+  const parts = Tokenami2.getTokenValueParts(tokenValue);
+  const modeThemeEntries = Object.entries(theme.modes);
+  const modeValues = modeThemeEntries.concat([["root", theme.root]]).flatMap(([mode, theme2]) => {
+    const value = theme2[parts.themeKey]?.[parts.token];
+    return value == null ? [] : [[mode, String(value)]];
+  });
+  return Object.fromEntries(modeValues);
+}
+function generateConfig(include, configPath) {
+  const filename = pathe.basename(configPath);
+  const configStubPath = pathe.resolve(__dirname, `../stubs/${filename}`);
+  const configStub = fs2.readFileSync(configStubPath, "utf8");
+  return configStub.replace("include: []", `include: [${include}]`);
+}
+function mergedConfigs(theirs) {
+  return theirs;
+}
+function generateTypeDefs(configPath, stubPath = "../stubs/tokenami.env.d.ts") {
+  const parsed = pathe.parse(configPath);
+  const typeDefStubPath = pathe.resolve(__dirname, stubPath);
+  const typeDefStub = fs2.readFileSync(typeDefStubPath, "utf8");
+  return typeDefStub.replace("tokenami.config", parsed.name);
+}
+function generateCiTypeDefs(configPath) {
+  return generateTypeDefs(configPath, "../stubs/tokenami.env.ci.d.ts");
+}
+function getResponsivePropertyVariants(tokenProperty2, responsive) {
+  return Object.keys(responsive || {}).map((query) => {
+    const name = Tokenami2.getTokenPropertyName(tokenProperty2);
+    return Tokenami2.variantProperty(query, name);
+  });
+}
+function getValidProperties(config) {
+  return /* @__PURE__ */ new Set([
+    ...supportedProperties,
+    ...Object.keys(config.properties || {}),
+    ...Object.keys(config.customProperties || {}),
+    ...Object.keys(config.aliases || {})
+  ]);
+}
+function unique(items) {
+  return Array.from(new Set(items));
+}
+var jitiCache = {};
+function lazyJiti(options = {}) {
+  const cacheId = JSON.stringify(options);
+  return jitiCache[cacheId] ??= createJiti(__filename, {
+    transform: (opts) => transform(opts.source, { transforms: ["typescript", "imports"] }),
+    interopDefault: true,
+    requireCache: options.cache
+  });
+}
+function error(str) {
+  console.error(`${chalk.bgRed(" tokenami ")} ${chalk.red(str)}`);
+  process.exit(1);
+}
+function debug(str) {
+  console.debug(`${chalk.bgYellow(" tokenami ")} ${chalk.yellow(str)}`);
+}
+
+// src/sheet.ts
+var UNUSED_LAYERS_REGEX = /[\n\s]*@layer[^;{]+;/g;
+var DEFAULT_SELECTOR = "[style]";
+var CUSTOM_PROP_PREFIX = "--_";
+var LAYERS = {
+  BASE: "tk",
+  LOGICAL: "tkl",
+  SELECTORS: "tks",
+  SELECTORS_LOGICAL: "tksl"
+};
+function generate(params) {
+  try {
+    const sheet = createSheet(params);
+    const transformed = lightning.transform({
+      code: Buffer.from(sheet),
+      filename: params.output,
+      minify: params.minify,
+      targets: params.targets
+    });
+    return transformed.code.toString().replace(UNUSED_LAYERS_REGEX, "");
+  } catch (e) {
+    const message = e instanceof Error ? e.message : "Unknown error";
+    const escapedMessage = message.replace(/(['"])/g, "\\$1");
+    debug(`Error generating stylesheet: ${message}`);
+    return `body::after { content: 'Error generating stylesheet: ${escapedMessage}'; position: fixed; inset: 0; background: #ec6142; color: white; padding: 20px; font-family: sans-serif; z-index: 9999; }`;
+  }
+}
+function createSheet(params) {
+  if (!params.tokens.properties.length)
+    return "";
+  const tokenProperties = params.tokens.properties;
+  const tokenValues = params.tokens.values;
+  const propertyConfigsByCSSProperty = getPropertyConfigs(tokenProperties, params.config);
+  const allPropertyConfigs = Array.from(propertyConfigsByCSSProperty.values()).flat();
+  const elemSelectors = unique(
+    allPropertyConfigs.map((config) => {
+      const selectors = getSelectorsFromConfig(config.selector, params.config);
+      return selectors.find(isElementSelector) || DEFAULT_SELECTOR;
+    })
+  );
+  const styles = {
+    reset: /* @__PURE__ */ new Set(),
+    atomic: /* @__PURE__ */ new Set(),
+    selectors: /* @__PURE__ */ new Set(),
+    toggles: {}
+  };
+  propertyConfigsByCSSProperty.forEach((configs, cssProperty) => {
+    const isLogical = supportedLogicalProperties.has(cssProperty);
+    const isInheritable = inheritedProperties.has(cssProperty);
+    const sortedConfigs = [...configs].sort((a, b) => a.order - b.order);
+    const variants = sortedConfigs.flatMap((config) => config.variant ? [config.variant] : []);
+    const variantValue = unique(variants).reduce((fallback, variant) => {
+      const hashedProperty = hashVariantProperty(variant, cssProperty);
+      return `var(${hashedProperty}, ${fallback})`;
+    }, "revert-layer");
+    configs.forEach((config) => {
+      const layerIndex = getAtomicLayerIndex(cssProperty, params.config);
+      const toggleKey = config.responsive || config.selector;
+      const propertyPrefix = config.isCustom ? CUSTOM_PROP_PREFIX : "";
+      if (layerIndex === -1)
+        return;
+      if (config.variant && toggleKey) {
+        const responsive = getResponsiveSelectorFromConfig(config.responsive, params.config);
+        const selectors = getSelectorsFromConfig(config.selector, params.config);
+        const hasCombinator = selectors.some(isCombinatorSelector);
+        const responsiveSelectors = [responsive, ...selectors].filter(Boolean);
+        const hashedProperty = hashVariantProperty(config.variant, cssProperty);
+        const variantProperty2 = Tokenami2.parsedVariantProperty(config.variant, cssProperty);
+        const basePropertyValue = getBasePropertyValue(variantProperty2, config, false);
+        const toggleProperty = Tokenami2.parsedTokenProperty(config.variant);
+        const toggleDeclaration = `${hashedProperty}: var(${toggleProperty}) ${basePropertyValue};`;
+        const layer = `${isLogical ? LAYERS.SELECTORS_LOGICAL : LAYERS.SELECTORS}${layerIndex}`;
+        const customPropertyFallback = `var(${Tokenami2.tokenProperty(cssProperty)})`;
+        const customPropertyValue = variantValue.replace("revert-layer", customPropertyFallback);
+        const declaration = `${propertyPrefix}${cssProperty}: ${config.isCustom ? customPropertyValue : variantValue};`;
+        const toggle = responsiveSelectors.reduceRight(
+          (declaration2, selector) => `${selector} { ${declaration2} }`,
+          `${toggleProperty}: ;`
+        );
+        styles.reset.add(`${toggleProperty}: initial;`);
+        if (!isInheritable && !hasCombinator)
+          styles.reset.add(`${variantProperty2}: initial;`);
+        styles.selectors.add(`@layer ${layer} { ${elemSelectors} { ${declaration} } }`);
+        styles.selectors.add(`@layer ${layer} { ${elemSelectors} { ${toggleDeclaration} } }`);
+        styles.toggles[toggleKey] ??= /* @__PURE__ */ new Set();
+        styles.toggles[toggleKey].add(toggle);
+        if (config.isGrid) {
+          const gridToggle = getGridPropertyToggle(variantProperty2);
+          styles.selectors.add(`@layer ${layer} { ${elemSelectors} { ${gridToggle} } }`);
+        }
+      } else {
+        const propertyValue = getBasePropertyValue(config.tokenProperty, config);
+        const declaration = `${DEFAULT_SELECTOR} { ${propertyPrefix}${cssProperty}: ${propertyValue}; }`;
+        const layer = `${isLogical ? LAYERS.LOGICAL : LAYERS.BASE}${layerIndex}`;
+        if (!isInheritable)
+          styles.reset.add(`${config.tokenProperty}: initial;`);
+        styles.atomic.add(`@layer ${layer} { ${declaration} }`);
+        if (config.isGrid) {
+          const gridToggle = getGridPropertyToggle(config.tokenProperty);
+          styles.atomic.add(`@layer ${layer} { ${DEFAULT_SELECTOR} { ${gridToggle} } }`);
+        }
+      }
+    });
+  });
+  return `
+    @layer global {
+      ${params.config.globalStyles ? stringify(params.config.globalStyles) : ""}
+    }
+
+    @layer tokenami {
+      ${generateKeyframeRules(tokenValues, params.config)}
+      ${generateThemeTokens(tokenValues, params.config)}
+
+      * { ${Array.from(styles.reset).join(" ")} }
+
+      ${generatePlaceholderLayers(LAYERS.BASE)}
+      ${generatePlaceholderLayers(LAYERS.LOGICAL)}
+      ${generatePlaceholderLayers(LAYERS.SELECTORS)}
+      ${generatePlaceholderLayers(LAYERS.SELECTORS_LOGICAL)}
+
+      ${Array.from(styles.atomic).join(" ")}
+      ${Array.from(styles.selectors).join(" ")}
+
+      ${Object.values(styles.toggles).flatMap((set) => Array.from(set)).join(" ")}
+    }
+  `;
+}
+function getGridPropertyToggle(property) {
+  const hashGridProperty = hashVariantProperty("grid", property);
+  const gridProperty3 = Tokenami2.gridProperty();
+  return `${hashGridProperty}: var(${property}__calc) calc(var(${property}) * var(${gridProperty3}));`;
+}
+function getBasePropertyValue(property, config, revert = true) {
+  const hashGridProperty = hashVariantProperty("grid", property);
+  const baseProperty = `var(${property}${revert ? ", revert-layer" : ""})`;
+  return config.isGrid ? `var(${hashGridProperty}, ${baseProperty})` : baseProperty;
+}
+function generatePlaceholderLayers(prefix) {
+  return `@layer ${Array.from({ length: 20 }).map((_, layer) => `${prefix}${layer}`).join(", ")};`;
+}
+function getPropertyConfigs(tokenProperties, config) {
+  let propertyConfigs = /* @__PURE__ */ new Map();
+  const customProperties = Object.keys(config.customProperties || {});
+  tokenProperties.forEach((tokenProperty2) => {
+    const parts = Tokenami2.getTokenPropertyParts(tokenProperty2, config);
+    if (!parts)
+      return;
+    const properties = Tokenami2.getCSSPropertiesForAlias(parts.alias, config.aliases);
+    const responsiveOrder = parts.responsive ? 1 : 0;
+    const selectorOrder = parts.selector ? 2 : 0;
+    const order = responsiveOrder + selectorOrder;
+    properties.forEach((cssProperty) => {
+      const tokenProperty3 = Tokenami2.parsedTokenProperty(cssProperty);
+      const currentConfigs = propertyConfigs.get(cssProperty) || [];
+      const isCustom = customProperties.includes(cssProperty);
+      const isGrid = config.properties?.[cssProperty]?.includes("grid") ?? false;
+      const nextConfig = { ...parts, tokenProperty: tokenProperty3, order, isCustom, isGrid };
+      propertyConfigs.set(cssProperty, [...currentConfigs, nextConfig]);
+    });
+  });
+  return propertyConfigs;
+}
+var SHORTHAND_TO_LONGHAND_ENTRIES = [...Tokenami2.mapShorthandToLonghands.entries()];
+function getAtomicLayerIndex(cssProperty, config) {
+  const validProperties = getValidProperties(config);
+  const isSupported = validProperties.has(cssProperty);
+  const initialDepth = isSupported ? 1 : -1;
+  if (cssProperty === "all")
+    return 0;
+  return SHORTHAND_TO_LONGHAND_ENTRIES.reduce((depth, [shorthand, longhands]) => {
+    const isLonghand = longhands.includes(cssProperty);
+    return isLonghand ? depth + getAtomicLayerIndex(shorthand, config) : depth;
+  }, initialDepth);
+}
+function generateKeyframeRules(tokenValues, config) {
+  const themeValues = tokenValues.flatMap((tokenValue) => {
+    return Object.values(getThemeValuesByThemeMode(tokenValue, config.theme));
+  });
+  const rules = Object.entries(config.keyframes || {}).flatMap(([name, styles]) => {
+    const nameRegex = new RegExp(`\\b${name}\\b`);
+    const isUsingKeyframeName = themeValues.some((value) => nameRegex.test(value));
+    if (!isUsingKeyframeName)
+      return [];
+    return [[`@keyframes ${name} { ${stringify(styles)} }`]];
+  });
+  return rules.join(" ");
+}
+function generateThemeTokens(tokenValues, config) {
+  const theme = getThemeFromConfig(config.theme);
+  const rootSelector = ":root";
+  const gridStyles = `${rootSelector} { ${Tokenami2.gridProperty()}: ${config.grid}; }`;
+  const rootStyles = getThemeStyles(rootSelector, tokenValues, theme.root, config);
+  const themeToModes = {};
+  const modeEntries = Object.entries(theme.modes || {});
+  for (const [mode, theme2] of modeEntries) {
+    const themeKey = JSON.stringify(theme2);
+    if (themeKey in themeToModes)
+      themeToModes[themeKey].push(mode);
+    else
+      themeToModes[themeKey] = [mode];
+  }
+  const modeStyles = Object.entries(themeToModes).map(([theme2, modes]) => {
+    const selector = modes.map(config.themeSelector).join(", ");
+    return getThemeStyles(selector, tokenValues, JSON.parse(theme2), config);
+  });
+  const themeTokens = [gridStyles, rootStyles, modeStyles.join(" ")];
+  return themeTokens.join(" ");
+}
+var getThemeStyles = (selector, tokenValues, theme, config) => {
+  const themeValues = getThemeValuesByTokenValues(tokenValues, theme);
+  const customPropertyThemeValues = getCustomPropertyThemeValues(themeValues, config);
+  const selectors = Array.isArray(selector) ? selector : [selector];
+  for (const customKey of Object.keys(customPropertyThemeValues)) {
+    delete themeValues[customKey];
+  }
+  const themeStyles = selectors.reduceRight(
+    (declaration, selector2) => `${selector2} { ${declaration} }`,
+    stringify(themeValues)
+  );
+  const elementSelector = selectors.at(-1);
+  const elementThemeStyles = getElementThemeStyles(elementSelector, customPropertyThemeValues);
+  const customPropertyThemeStyles = selectors.slice(0, -1).reduceRight((declaration, selector2) => {
+    return `${selector2} { ${declaration} }`;
+  }, elementThemeStyles);
+  return themeStyles + " " + customPropertyThemeStyles;
+};
+var getElementThemeStyles = (selector, themeValues) => {
+  const splitChained = selector.split(",");
+  return splitChained.map((selector2) => `${selector2}, ${selector2} ${DEFAULT_SELECTOR} { ${stringify(themeValues)} }`).join(" ");
+};
+function getCustomPropertyThemeValues(themeValues, config) {
+  const entries = Object.entries(themeValues).flatMap(([key, value]) => {
+    const valueWithCustomPrefixes = getPrefixedCustomPropertyValues(value, config.customProperties);
+    return valueWithCustomPrefixes ? [[key, valueWithCustomPrefixes]] : [];
+  });
+  return Object.fromEntries(entries);
+}
+var CUSTOM_PROP_REGEX = /\(--[^-][\w-]+/g;
+var getPrefixedCustomPropertyValues = (themeValue, customProperties) => {
+  const variables = themeValue.match(CUSTOM_PROP_REGEX);
+  if (!variables)
+    return null;
+  return themeValue.replace(CUSTOM_PROP_REGEX, (m) => {
+    const match = m.replace("(", "");
+    const tokenProperty2 = Tokenami2.TokenProperty.safeParse(match);
+    if (!tokenProperty2.success)
+      return m;
+    const parts = Tokenami2.getTokenPropertySplit(tokenProperty2.output);
+    const isCustom = Boolean(customProperties?.[parts.alias]);
+    if (!isCustom)
+      return m;
+    const tokenPrefix = Tokenami2.tokenProperty("");
+    const customPrefixTokenValue = tokenProperty2.output.replace(tokenPrefix, CUSTOM_PROP_PREFIX);
+    return "(" + customPrefixTokenValue;
+  });
+};
+function hash(str) {
+  let hash2 = 0;
+  for (let i = 0, len = str.length; i < len; i++) {
+    let chr = str.charCodeAt(i);
+    hash2 = (hash2 << 5) - hash2 + chr;
+    hash2 |= 0;
+  }
+  return Math.abs(hash2).toString(32);
+}
+function hashVariantProperty(variant, property) {
+  return `--_${hash(variant + property)}`;
+}
+var PSEUDO_REGEX = /::/;
+function isElementSelector(selector = "") {
+  return isCombinatorSelector(selector) || PSEUDO_REGEX.test(selector);
+}
+var COMBINATOR_REGEX = /(.+)\s\[style|style\]\s(.+)/;
+function isCombinatorSelector(selector = "") {
+  return COMBINATOR_REGEX.test(selector);
+}
+function getResponsiveSelectorFromConfig(responsiveSelector, tokenamiConfig) {
+  return responsiveSelector && tokenamiConfig.responsive?.[responsiveSelector];
+}
+function getSelectorsFromConfig(propertySelector, tokenamiConfig) {
+  const arbitrarySelector = Tokenami2.getArbitrarySelector(propertySelector);
+  const configSelector = propertySelector && tokenamiConfig.selectors?.[propertySelector];
+  const selector = arbitrarySelector?.replace(/_/g, " ") || configSelector;
+  const selectors = selector ? Array.isArray(selector) ? selector : [selector] : ["&"];
+  const isSelectionVariant = selectors.includes("&::selection");
+  if (selectors.toString().indexOf("&") === -1) {
+    throw new Error(`Selector '${selector}' must include '&'`);
+  }
+  return selectors.map((selector2) => {
+    const tkSelector = isSelectionVariant ? `[style*="${propertySelector}_"]` : DEFAULT_SELECTOR;
+    return selector2.replace(/&/g, tkSelector);
+  });
+}
+
+// package.json
+var package_default = {
+  name: "tokenami",
+  version: "0.0.76",
+  license: "MIT",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  repository: "https://github.com/tokenami/tokenami",
+  publishConfig: {
+    access: "public"
+  },
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      }
+    }
+  },
+  bin: {
+    tokenami: "bin.js"
+  },
+  files: [
+    "dist",
+    "stubs",
+    "bin.js"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    typecheck: "tsc --noEmit"
+  },
+  devDependencies: {
+    "@types/culori": "^2.1.0",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.3.1",
+    tsup: "^7.0.0",
+    typescript: "^5.1.3"
+  },
+  dependencies: {
+    "@stitches/stringify": "^1.2.8",
+    "@tokenami/config": "workspace:*",
+    "@tokenami/ds": "workspace:*",
+    acorn: "^8.11.3",
+    "acorn-walk": "^8.3.2",
+    browserslist: "^4.22.2",
+    cac: "^6.7.14",
+    chalk: "^5.2.0",
+    chokidar: "^3.5.3",
+    csstype: "^3.1.2",
+    culori: "^4.0.1",
+    "fast-glob": "^3.2.12",
+    inquirer: "^9.2.12",
+    jiti: "^1.21.0",
+    lightningcss: "1.23.0",
+    pathe: "^1.1.1",
+    sucrase: "^3.34.0",
+    "trie-search": "^2.0.0"
+  },
+  peerDependencies: {
+    typescript: ">= 5"
+  }
+};
+
+// src/cli.ts
+var questions = [
+  {
+    type: "list",
+    name: "type",
+    message: "TypeScript or JavaScript?",
+    choices: [
+      { name: "TypeScript", value: "ts" },
+      { name: "JavaScript", value: "js" }
+    ]
+  },
+  {
+    type: "input",
+    name: "folder",
+    message: "What folder should Tokenami watch for token properties?",
+    default: "./app"
+  }
+];
+var run = () => {
+  const cli = cac("tokenami");
+  const cwd = process.cwd();
+  cli.command("init").option("-c, --config [path]", "Path to a custom config file").action(async (_, flags) => {
+    const tsconfigPath = pathe.join(cwd, "tsconfig.json");
+    const jsconfigPath = pathe.join(cwd, "jsconfig.json");
+    const hasTsConfig = fs2.existsSync(tsconfigPath);
+    const hasJsConfig = fs2.existsSync(jsconfigPath);
+    const hasProjectConfig = hasTsConfig || hasJsConfig;
+    if (hasProjectConfig)
+      questions.shift();
+    const answers = await inquirer.prompt(questions);
+    const type = hasTsConfig ? "ts" : hasJsConfig ? "js" : answers.type;
+    const extensions = type === "ts" ? "ts,tsx" : "js,jsx";
+    const include = `'${answers.folder}/**/*.{${extensions}}'`;
+    const configPath = getConfigPath(cwd, flags?.config, type);
+    const outDir = pathe.dirname(configPath);
+    const initialConfig = generateConfig(include, configPath);
+    const ciTypeDefs = generateCiTypeDefs(configPath);
+    const typeDefs = generateTypeDefs(configPath);
+    fs2.mkdirSync(outDir, { recursive: true });
+    fs2.writeFileSync(configPath, initialConfig, { flag: "w" });
+    fs2.writeFileSync(getTypeDefsPath(configPath), typeDefs, { flag: "w" });
+    fs2.writeFileSync(getCiTypeDefsPath(configPath), ciTypeDefs, { flag: "w" });
+    debug(`Project successfully configured in './tokenami'`);
+  });
+  cli.command("[files]", "Include file glob").option("-c, --config [path]", "Path to a custom config file").option("-o, --output [path]", "Output file", { default: "public/tokenami.css" }).option("-w, --watch", "Watch for changes and rebuild as needed").option("--minify", "Minify CSS output").action(async (_, flags) => {
+    const startTime = startTimer();
+    const minify = flags.minify;
+    const configPath = getConfigPath(cwd, flags.config);
+    const browsers = browserslist(null, { env: process.env.NODE_ENV || "development" });
+    const targets = browserslistToTargets(browsers);
+    let config = getConfigAtPath(configPath);
+    config.include = flags.files || config.include;
+    if (!config.include.length)
+      error("Provide a glob pattern to include files");
+    async function regenerateStylesheet(file, config2) {
+      const generateTime = startTimer();
+      const tokens2 = await findUsedTokens(cwd, config2);
+      generateStyles({ tokens: tokens2, cwd, out: flags.output, config: config2, minify, targets });
+      debug(`Generated styles from ${file} in ${generateTime()}ms.`);
+    }
+    if (flags.watch) {
+      const configWatcher = watch2(cwd, [configPath]);
+      const tokenWatcher = watch2(cwd, config.include, config.exclude);
+      debug(`Watching for changes to ${config.include}.`);
+      tokenWatcher.on("all", (_2, file) => regenerateStylesheet(file, config));
+      configWatcher.on("all", async (_2, file) => {
+        try {
+          config = getReloadedConfigAtPath(configPath);
+          config.include = flags.files || config.include;
+          regenerateStylesheet(file, config);
+        } catch (e) {
+          debug(`Skipped change to ${file} with ${e}`);
+        }
+      });
+      process.once("SIGINT", async () => {
+        await tokenWatcher.close();
+        await configWatcher.close();
+      });
+    }
+    const tokens = await findUsedTokens(cwd, config);
+    generateStyles({ tokens, cwd, out: flags.output, config, minify, targets });
+    debug(`Ready in ${startTime()}ms.`);
+  });
+  cli.help();
+  cli.version(package_default.version);
+  cli.parse();
+};
+function generateStyles(params) {
+  const { cwd, out, ...generateParams } = params;
+  const outDir = pathe.join(cwd, pathe.dirname(out));
+  const outPath = pathe.join(cwd, out);
+  const output = generate({ ...generateParams, output: outPath });
+  fs2.mkdirSync(outDir, { recursive: true });
+  fs2.writeFileSync(outPath, output, { flag: "w" });
+}
+function watch2(cwd, include, exclude) {
+  return chokidar.watch(include, {
+    cwd,
+    persistent: true,
+    ignoreInitial: true,
+    ignorePermissionErrors: true,
+    ignored: exclude
+  });
+}
+async function findUsedTokens(cwd, config) {
+  const include = config.include;
+  const exclude = config.exclude;
+  const entries = await glob(include, { cwd, onlyFiles: true, stats: false, ignore: exclude });
+  let tokenProperties = [];
+  let tokenValues = [];
+  entries.forEach((entry) => {
+    const fileContent = fs2.readFileSync(entry, "utf8");
+    const tokens = matchTokens(fileContent, config.theme);
+    const responsiveProperties = matchResponsiveComposeVariants(fileContent, config);
+    tokenProperties = [...tokenProperties, ...tokens.properties, ...responsiveProperties];
+    tokenValues = [...tokenValues, ...tokens.values];
+  });
+  return { properties: tokenProperties, values: tokenValues };
+}
+var CSS_VARIABLE_REGEX = /--(?:[\w-]+|\{[^\{\}]*\})+/g;
+function matchTokens(content, theme) {
+  const matches = content.match(CSS_VARIABLE_REGEX) || [];
+  const stringMatches = Array.from(matches).map(Tokenami2.stringifyProperty);
+  const uniqueMatches = unique(stringMatches);
+  const variableMatches = uniqueMatches.filter((match) => match !== Tokenami2.gridProperty());
+  const values = variableMatches.flatMap((match) => {
+    const valueProperty = Tokenami2.TokenValue.safeParse(`var(${match})`);
+    if (!valueProperty.success)
+      return [];
+    const themeValues = getThemeValuesByThemeMode(valueProperty.output, theme);
+    return Object.entries(themeValues).length ? [valueProperty.output] : [];
+  });
+  const properties = variableMatches.flatMap((match) => {
+    const tokenProperty2 = Tokenami2.TokenProperty.safeParse(match);
+    const isValue = values.includes(`var(${match})`);
+    if (isValue || !tokenProperty2.success)
+      return [];
+    return tokenProperty2.output;
+  });
+  return { properties, values };
+}
+var COMPOSE_BLOCKS_REGEX = /^.*css\.compose\(\{[\s\S]*?\}\);/gm;
+function matchResponsiveComposeVariants(fileContent, config) {
+  const composeBlocks = fileContent.match(COMPOSE_BLOCKS_REGEX);
+  if (!composeBlocks)
+    return [];
+  const responsiveBlocks = composeBlocks.filter((block) => block.match("responsiveVariants"));
+  return responsiveBlocks.flatMap((block) => {
+    const ast = acorn.parse(block, { ecmaVersion: 2020 });
+    const responsiveVariants = findResponsiveVariants(ast);
+    const tokens = matchTokens(JSON.stringify(responsiveVariants), config.theme);
+    return tokens.properties.flatMap((tokenProperty2) => {
+      return getResponsivePropertyVariants(tokenProperty2, config.responsive);
+    });
+  });
+}
+function findResponsiveVariants(node) {
+  let responsiveVariantsNode = null;
+  acornWalk.simple(node, {
+    Property(node2) {
+      if (node2.key.type === "Identifier" && node2.key.name === "responsiveVariants") {
+        responsiveVariantsNode = node2;
+      }
+    }
+  });
+  return responsiveVariantsNode;
+}
+function startTimer() {
+  const start = performance.now();
+  return () => {
+    const stop = performance.now();
+    return Math.round(stop - start);
+  };
+}
+try {
+  run();
+} catch (e) {
+  error(e instanceof Error ? e.message : "Unknown error occurred.");
+}