tokenami 0.0.77--canary.400.e4d091f.0

package/dist/index.js

@@ -0,0 +1,1149 @@
+import { fileURLToPath } from 'url';
+import path from 'path';
+import TrieSearch from 'trie-search';
+import * as culori from 'culori';
+import * as TokenamiConfig from '@tokenami/config';
+import createJiti from 'jiti';
+import { transform } from 'sucrase';
+import * as pathe from 'pathe';
+import * as fs from 'fs';
+
+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 supportedProperties = new Set(Object.keys(supported));
+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 fs.existsSync(pathe.join(cwd, path2));
+  });
+  return existingConfig || DEFAULT_PATHS[type || "js"];
+}
+function getTypeDefsPath(configPath) {
+  const dirname2 = pathe.dirname(configPath);
+  return `${dirname2}/tokenami.env.d.ts`;
+}
+function getCiTypeDefsPath(configPath) {
+  const dirname2 = pathe.dirname(configPath);
+  return `${dirname2}/tokenami.env.ci.d.ts`;
+}
+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 = TokenamiConfig.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 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 = fs.readFileSync(typeDefStubPath, "utf8");
+  return typeDefStub.replace("tokenami.config", parsed.name);
+}
+function generateCiTypeDefs(configPath) {
+  return generateTypeDefs(configPath, "../stubs/tokenami.env.ci.d.ts");
+}
+function getValidProperties(config) {
+  return /* @__PURE__ */ new Set([
+    ...supportedProperties,
+    ...Object.keys(config.properties || {}),
+    ...Object.keys(config.customProperties || {}),
+    ...Object.keys(config.aliases || {})
+  ]);
+}
+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
+  });
+}
+
+// src/ts-plugin.ts
+var INVALID_PROPERTY_ERROR_CODE = 2353;
+var INVALID_VALUE_ERROR_CODE = 2322;
+function createTSPlugin(modules) {
+  const ts = modules.typescript;
+  let entryConfigMap = /* @__PURE__ */ new Map();
+  function getAllProperties(config) {
+    return Array.from(getValidProperties(config));
+  }
+  function getSelectorEntries(config) {
+    const configSelectorEntries = Object.entries(config.selectors || {});
+    return configSelectorEntries.concat([["{}", ""]]);
+  }
+  function getResponsiveEntries(config) {
+    return Object.entries(config.responsive || {});
+  }
+  function getResponsiveSelectorEntries(config) {
+    const selectorEntries = getSelectorEntries(config);
+    const responsiveEntries = getResponsiveEntries(config);
+    const responsiveSelectorEntries = responsiveEntries.flatMap(
+      ([responsiveSelector, responsiveValue]) => {
+        return selectorEntries.map(([selector, value]) => {
+          const combinedSelector = `${responsiveSelector}_${selector}`;
+          const combinedValue = [responsiveValue].concat(value);
+          return [combinedSelector, combinedValue];
+        });
+      }
+    );
+    return responsiveSelectorEntries;
+  }
+  function getSelectorCompletions(config, quote) {
+    const entries = getSelectorEntries(config).concat(getResponsiveEntries(config));
+    const properties = getAllProperties(config);
+    return properties.flatMap((property) => {
+      const create2 = createVariantPropertyEntry(property, quote);
+      return entries.map(create2);
+    });
+  }
+  function getResponsiveSelectorCompletions(config, quote) {
+    const entries = getResponsiveSelectorEntries(config);
+    const properties = getAllProperties(config);
+    return properties.flatMap((property) => {
+      const create2 = createVariantPropertyEntry(property, quote);
+      return entries.map(create2);
+    });
+  }
+  function getSelectorSnippetCompletions(config, quote) {
+    const entries = getSelectorEntries(config).concat(getResponsiveEntries(config));
+    const create2 = createVariantPropertyEntry("", quote);
+    return entries.map(create2);
+  }
+  function getResponsiveSelectorSnippetCompletions(config, quote) {
+    const entries = getResponsiveSelectorEntries(config);
+    const create2 = createVariantPropertyEntry("", quote);
+    return entries.map(create2);
+  }
+  const createSelectorSnippetTrie = (config) => {
+    const completions = getSelectorSnippetCompletions(config);
+    const quotedCompletions = getSelectorSnippetCompletions(config, '"');
+    return {
+      unquoted: createCompletionEntriesTrie(completions),
+      quoted: createCompletionEntriesTrie(quotedCompletions)
+    };
+  };
+  const createResponsiveSelectorSnippetTrie = (config) => {
+    const completions = getResponsiveSelectorSnippetCompletions(config);
+    const quotedCompletions = getResponsiveSelectorSnippetCompletions(config, '"');
+    return {
+      unquoted: createCompletionEntriesTrie(completions),
+      quoted: createCompletionEntriesTrie(quotedCompletions)
+    };
+  };
+  const createSelectorTrie = (config) => {
+    const completions = getSelectorCompletions(config);
+    const quotedCompletions = getSelectorCompletions(config, '"');
+    return {
+      unquoted: createCompletionEntriesTrie(completions),
+      quoted: createCompletionEntriesTrie(quotedCompletions)
+    };
+  };
+  const createResponsiveSelectorTrie = (config) => {
+    const completions = getResponsiveSelectorCompletions(config);
+    const quotedCompletions = getResponsiveSelectorCompletions(config, '"');
+    return {
+      unquoted: createCompletionEntriesTrie(completions),
+      quoted: createCompletionEntriesTrie(quotedCompletions)
+    };
+  };
+  const createCompletionEntriesTrie = (items) => {
+    const trie = new TrieSearch("sortText", {
+      splitOnRegEx: /\$/g,
+      expandRegexes: []
+    });
+    trie.addAll(items);
+    return trie;
+  };
+  const createVariantPropertyEntry = (property, quote = "") => {
+    return ([selector, value]) => {
+      const tokenProperty2 = TokenamiConfig.variantProperty(selector, property);
+      const name = `${quote}${tokenProperty2}${quote}`;
+      const isSnippet = name.includes("{}");
+      const entry = isSnippet ? createPropertySnippetEntry(name) : createPropertyEntry(name);
+      updateEntryDetailsConfig({ ...entry, value });
+      return entry;
+    };
+  };
+  const createPropertyEntry = (name, sortText = getSortText(name)) => {
+    const kind = ts.ScriptElementKind.memberVariableElement;
+    const kindModifiers = ts.ScriptElementKindModifier.optionalModifier;
+    return { name, kind, kindModifiers, sortText, insertText: name };
+  };
+  const createPropertySnippetEntry = (name, sortText = getSortText(name)) => {
+    const entry = createPropertyEntry(name, sortText);
+    const insertText = entry.name.replace("{}", "{${1}}");
+    return { ...entry, insertText, isSnippet: true };
+  };
+  const getSortText = (name) => {
+    const regex = new RegExp(`['"-]|${TokenamiConfig.tokenProperty("")}`, "g");
+    name = name.replace(regex, "").replace(/[0-9]+/g, (m) => m.padStart(6, "0"));
+    return `$${name}`;
+  };
+  function updateEntryDetailsConfig(params) {
+    const { name, ...config } = params;
+    entryConfigMap.set(params.name, config);
+  }
+  function getEntryDetailsConfig(name) {
+    return entryConfigMap.get(name);
+  }
+  function getBaseResults(entries, search) {
+    const baseTrie = createCompletionEntriesTrie(entries);
+    return baseTrie.search(search);
+  }
+  function isQuoted(node) {
+    return ts.isStringLiteral(node);
+  }
+  function findNodeAtPosition(sourceFile, position) {
+    function find(node) {
+      if (position >= node.getStart(sourceFile) && position < node.getEnd()) {
+        return ts.forEachChild(node, find) || node;
+      }
+    }
+    return find(sourceFile);
+  }
+  const getInputAtPosition = (node, position) => {
+    let input = node.getText();
+    if (ts.isObjectLiteralExpression(node)) {
+      for (const property of node.properties) {
+        const start = property.getStart();
+        const end = property.getEnd();
+        if (start <= position && position <= end) {
+          input = property.getText();
+        }
+      }
+    }
+    return input.replace(/'|"/g, "");
+  };
+  function createTextSpanFromNode(node) {
+    return { start: node.getStart(), length: node.getEnd() - node.getStart() };
+  }
+  function shouldSuppressDiagnosticForNode(node, sourceFile) {
+    const lineStarts = sourceFile.getLineStarts();
+    const nodeStartPos = node.getStart(sourceFile);
+    const nodeStartLine = sourceFile.getLineAndCharacterOfPosition(nodeStartPos).line;
+    if (nodeStartLine > 0) {
+      const previousLineStartPos = lineStarts[nodeStartLine - 1] || 0;
+      const previousLineEndPos = lineStarts[nodeStartLine] || 0;
+      const previousLineText = sourceFile.text.substring(previousLineStartPos, previousLineEndPos);
+      return /\/\/ @ts-ignore/.test(previousLineText);
+    }
+    return false;
+  }
+  function transformBasePropertyEntry(entry) {
+    const property = TokenamiConfig.TokenProperty.safeParse(entry.name);
+    if (!property.success)
+      return null;
+    const sortText = `$${getSortText(entry.name)}`;
+    return { ...entry, sortText, insertText: entry.name };
+  }
+  function transformTokenValueEntry(entry, config) {
+    const entryName = entry.name;
+    const property = TokenamiConfig.TokenValue.safeParse(entryName);
+    if (!property.success)
+      return entry;
+    const parts = TokenamiConfig.getTokenValueParts(property.output);
+    const modeValues = getThemeValuesByThemeMode(property.output, config.theme);
+    if (!Object.entries(modeValues).length)
+      return entry;
+    const name = `$${parts.token}`;
+    const kindModifiers = isColorThemeEntry(modeValues) ? "color" : parts.themeKey;
+    const tokenIndex = getTokenValueIndexFromTheme(property.output, config.theme);
+    const sortText = getSortText(`${tokenIndex}${entryName}`);
+    const labelDetails = { detail: "", description: entryName };
+    const insertText = entryName;
+    const nextEntry = { ...entry, name, sortText, kindModifiers, insertText, labelDetails };
+    updateEntryDetailsConfig({ ...nextEntry, themeKey: parts.themeKey, modeValues });
+    return nextEntry;
+  }
+  function getTokenValueIndexFromTheme(tokenValue, themeConfig) {
+    const theme = getThemeFromConfig(themeConfig);
+    const parts = TokenamiConfig.getTokenValueParts(tokenValue);
+    const modeKey = Object.keys(theme.modes)[0];
+    const modeTheme = modeKey && theme.modes[modeKey];
+    const flattenedTheme = { ...theme.root, ...modeTheme };
+    const tokenNames = Object.keys(flattenedTheme[parts.themeKey]);
+    return tokenNames.indexOf(parts.token);
+  }
+  function updateEnvFile(configPath, config) {
+    const envFilePath = getTypeDefsPath(configPath);
+    const ciEnvFilePath = getCiTypeDefsPath(configPath);
+    const envFileContent = ts.sys.readFile(envFilePath, "utf-8");
+    if (!envFileContent)
+      throw new Error("Cannot read tokenami.env.d.ts file");
+    const properties = Object.keys(config.properties || {});
+    const customProperties = Object.keys(config.customProperties || {});
+    const experimentalProperties = properties.flatMap((property) => {
+      if (supportedProperties.has(property))
+        return [];
+      return [property];
+    });
+    const customPropertyTypes = [...experimentalProperties, ...customProperties].map((property) => {
+      return [`TokenProperties<'${property}'>`];
+    });
+    const updatedEnvFileContent = !customProperties.length ? generateTypeDefs(configPath, "../stubs/tokenami.env.d.ts") : generateTypeDefs(configPath, "../stubs/tokenami.env-custom.d.ts").replace(
+      "interface TokenamiProperties {",
+      `interface TokenamiProperties extends ${customPropertyTypes.join(", ")} {`
+    );
+    ts.sys.writeFile(envFilePath, updatedEnvFileContent);
+    if (ts.sys.readFile(ciEnvFilePath, "utf-8")) {
+      ts.sys.writeFile(ciEnvFilePath, generateCiTypeDefs(configPath));
+    }
+  }
+  function create(info) {
+    const proxy = /* @__PURE__ */ Object.create(null);
+    for (let k of Object.keys(info.languageService)) {
+      const x = info.languageService[k];
+      proxy[k] = (...args) => x.apply(info.languageService, args);
+    }
+    const logger = info.project.projectService.logger;
+    const cwd = info.project.getCurrentDirectory();
+    const configPath = getConfigPath(cwd, info.config.configPath);
+    const configExists = ts.sys.fileExists(configPath);
+    if (!configExists) {
+      logger.info(`Tokenami:: Cannot find config at ${configPath}`);
+      return proxy;
+    }
+    let config = getConfigAtPath(configPath);
+    let selectorCompletions = createSelectorTrie(config);
+    let selectorSnippetCompletions = createSelectorSnippetTrie(config);
+    let responsiveSelectorCompletions = createResponsiveSelectorTrie(config);
+    let responsiveSelectorSnippetCompletions = createResponsiveSelectorSnippetTrie(config);
+    try {
+      updateEnvFile(configPath, config);
+    } catch (e) {
+      logger.info(`Tokenami:: Skipped typedefs update with ${e}`);
+    }
+    logger.info(`Tokenami:: Watching config at ${configPath}`);
+    ts.sys.watchFile?.(configPath, (_, eventKind) => {
+      if (eventKind === modules.typescript.FileWatcherEventKind.Changed) {
+        logger.info(`Tokenami:: Config changed at ${configPath}`);
+        try {
+          config = getReloadedConfigAtPath(configPath);
+          info.project.refreshDiagnostics();
+          selectorCompletions = createSelectorTrie(config);
+          selectorSnippetCompletions = createSelectorSnippetTrie(config);
+          responsiveSelectorCompletions = createResponsiveSelectorTrie(config);
+          responsiveSelectorSnippetCompletions = createResponsiveSelectorSnippetTrie(config);
+          updateEnvFile(configPath, config);
+        } catch (e) {
+          logger.info(`Tokenami:: Skipped change to ${configPath} with ${e}`);
+        }
+      }
+    });
+    const getVariantResults = (input, search, node) => {
+      const parts = TokenamiConfig.getTokenPropertySplit(input);
+      const type = isQuoted(node) ? "unquoted" : "quoted";
+      if (parts.variants.length) {
+        if (parts.variants.length > 1) {
+          return responsiveSelectorCompletions[type].search(search);
+        }
+        const selectors = selectorCompletions[type].search(search);
+        const snippets = responsiveSelectorSnippetCompletions[type].search(search);
+        return [...selectors, ...snippets];
+      }
+      return selectorSnippetCompletions[type].search(search);
+    };
+    proxy.getSemanticDiagnostics = (fileName) => {
+      const diagnostics = info.languageService.getSemanticDiagnostics(fileName);
+      const program = info.languageService.getProgram();
+      const sourceFile = program?.getSourceFile(fileName);
+      const findDiagnosticIndex = (code, node) => {
+        return diagnostics.findIndex((diagnostic) => {
+          const isCodeMatch = diagnostic.code === code;
+          const isCurrentNode = diagnostic.start === node.getStart();
+          return isCodeMatch && isCurrentNode;
+        });
+      };
+      const updateDiagnosticMessage = (index, messageText) => {
+        if (index === -1)
+          return;
+        diagnostics[index] = { ...diagnostics[index], messageText };
+      };
+      const processNode = (node) => {
+        const isDiagnosticPrevented = shouldSuppressDiagnosticForNode(node, sourceFile);
+        if (isDiagnosticPrevented || !ts.isPropertyAssignment(node))
+          return;
+        const nodeProperty = ts.isStringLiteral(node.name) ? node.name.text : null;
+        const property = TokenamiConfig.TokenProperty.safeParse(nodeProperty);
+        if (!property.success)
+          return;
+        const { variants } = TokenamiConfig.getTokenPropertySplit(property.output);
+        const parts = TokenamiConfig.getTokenPropertyParts(property.output, config);
+        const invalidValueIndex = findDiagnosticIndex(INVALID_VALUE_ERROR_CODE, node);
+        const isArbitrarySelector = variants.some(TokenamiConfig.getArbitrarySelector);
+        if (variants.length && !parts && !isArbitrarySelector) {
+          const selector = variants.join("_");
+          const isEmptyArbitrarySelector = variants.includes("{}");
+          const message = `Tokenami properties may only specify known selectors, and '${selector}' does not exist.${isEmptyArbitrarySelector ? ` Add an arbitrary selector or remove '${selector}'.` : ""}`;
+          diagnostics.push({
+            file: sourceFile,
+            start: node.getStart(),
+            length: node.name.getWidth(),
+            messageText: message,
+            category: ts.DiagnosticCategory.Error,
+            code: INVALID_PROPERTY_ERROR_CODE
+          });
+        }
+        if (invalidValueIndex > -1 && ts.isStringLiteral(node.initializer)) {
+          const value = node.initializer.text;
+          const arbitraryValue2 = TokenamiConfig.arbitraryValue(value);
+          const message = `Value '${value}' is not assignable to Tokenami property '${property.output}'. Use value from theme or mark arbitrary with '${arbitraryValue2}'.`;
+          updateDiagnosticMessage(invalidValueIndex, message);
+        }
+        if (invalidValueIndex > -1 && ts.isNumericLiteral(node.initializer)) {
+          const message = `Tokenami grid values are not assignable to '${property.output}'.`;
+          updateDiagnosticMessage(invalidValueIndex, message);
+        }
+      };
+      if (sourceFile) {
+        ts.forEachChild(sourceFile, function nextNode(node) {
+          processNode(node);
+          ts.forEachChild(node, nextNode);
+        });
+      }
+      return diagnostics;
+    };
+    proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences) => {
+      const original = info.languageService.getCodeFixesAtPosition(
+        fileName,
+        start,
+        end,
+        errorCodes,
+        formatOptions,
+        preferences
+      );
+      if (!errorCodes.includes(INVALID_VALUE_ERROR_CODE))
+        return original;
+      const program = info.languageService.getProgram();
+      const sourceFile = program?.getSourceFile(fileName);
+      if (!sourceFile)
+        return original;
+      const node = findNodeAtPosition(sourceFile, start);
+      if (!node?.parent || !ts.isPropertyAssignment(node.parent))
+        return original;
+      const assignment = node.parent;
+      const valueSpan = createTextSpanFromNode(assignment.initializer);
+      const value = ts.isStringLiteral(assignment.initializer) && assignment.initializer.text;
+      if (!value)
+        return original;
+      const quoteMark = assignment.initializer.getText().slice(-1);
+      const arbitraryValue2 = TokenamiConfig.arbitraryValue(value);
+      const arbitraryText = `${quoteMark}${arbitraryValue2}${quoteMark}`;
+      return [
+        {
+          description: `Use ${arbitraryText} to mark as arbitrary`,
+          fixName: "replaceWithArbitrary",
+          changes: [
+            {
+              fileName,
+              textChanges: [{ span: valueSpan, newText: arbitraryText }]
+            }
+          ]
+        }
+      ];
+    };
+    proxy.getCompletionsAtPosition = (fileName, position, options) => {
+      const original = info.languageService.getCompletionsAtPosition(fileName, position, options);
+      const program = info.languageService.getProgram();
+      const sourceFile = program?.getSourceFile(fileName);
+      if (!original || !sourceFile)
+        return;
+      const isTokenPropertyEntries = original.entries.some(
+        (entry) => TokenamiConfig.TokenProperty.safeParse(entry.name).success
+      );
+      const isTokenValueEntries = original.entries.some(
+        (entry) => TokenamiConfig.TokenValue.safeParse(entry.name).success
+      );
+      if (isTokenValueEntries) {
+        original.entries = original.entries.map((entry) => transformTokenValueEntry(entry, config));
+      } else if (isTokenPropertyEntries) {
+        const node = findNodeAtPosition(sourceFile, position);
+        if (!node)
+          return;
+        const input = getInputAtPosition(node, position);
+        const search = getSortText(input).replace("$", "");
+        const entries = original.entries.flatMap((entry) => {
+          const transformedEntry = transformBasePropertyEntry(entry);
+          return transformedEntry ? [transformedEntry] : [];
+        });
+        if (search) {
+          const baseResults = getBaseResults(entries, search);
+          const variantResults = getVariantResults(input, search, node);
+          original.entries = [...baseResults, ...variantResults];
+        } else {
+          const snippetEntries = isQuoted(node) ? getSelectorSnippetCompletions(config) : getSelectorSnippetCompletions(config, '"');
+          original.entries = [...entries, ...snippetEntries];
+        }
+        return { ...original, isIncomplete: true };
+      }
+      return original;
+    };
+    proxy.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, data) => {
+      const entryConfig = getEntryDetailsConfig(entryName);
+      const original = info.languageService.getCompletionEntryDetails(
+        fileName,
+        position,
+        entryName,
+        formatOptions,
+        source,
+        preferences,
+        data
+      );
+      if (!entryConfig)
+        return original;
+      const common = {
+        ...original,
+        name: entryName,
+        kind: entryConfig.kind,
+        kindModifiers: entryConfig.kindModifiers,
+        displayParts: original?.displayParts || []
+      };
+      const originalDocumentation = original?.documentation || [];
+      if (entryConfig.modeValues) {
+        const entries = Object.entries(entryConfig.modeValues);
+        const [mode, firstValue] = entries[0] || [];
+        if (isColorThemeEntry(entryConfig.modeValues)) {
+          const description = createColorTokenDescription(entryConfig.modeValues);
+          const rgb2 = firstValue ? convertToRgb(replaceCssVarsWithFallback(firstValue), mode) : firstValue;
+          const docs = { text: `${rgb2}
+
+${description}`, kind: "markdown" };
+          return { ...common, documentation: [docs, ...originalDocumentation] };
+        } else {
+          const description = createTokenDescription(entryConfig.modeValues);
+          const docs = { text: `${firstValue}
+
+${description}`, kind: "markdown" };
+          return { ...common, documentation: [docs, ...originalDocumentation] };
+        }
+      }
+      if (entryConfig.value) {
+        const docs = { kind: "markdown", text: String(entryConfig.value) };
+        const documentation = [docs, ...originalDocumentation];
+        return { ...common, documentation };
+      }
+      return common;
+    };
+    proxy.getQuickInfoAtPosition = (fileName, position) => {
+      const original = info.languageService.getQuickInfoAtPosition(fileName, position);
+      const sourceFile = info.languageService.getProgram()?.getSourceFile(fileName);
+      if (!original || !sourceFile)
+        return original;
+      const node = findNodeAtPosition(sourceFile, position);
+      if (!node || !node.parent || !ts.isPropertyAssignment(node.parent))
+        return original;
+      const property = node.parent;
+      const propertyName = property.name.getText(sourceFile);
+      const propertyValue = property.initializer.getText();
+      const tokenProperty2 = TokenamiConfig.TokenProperty.safeParse(propertyName);
+      const tokenValue = TokenamiConfig.TokenValue.safeParse(propertyValue);
+      if (!tokenProperty2.success || !tokenValue.success)
+        return original;
+      const { variants } = TokenamiConfig.getTokenPropertySplit(tokenProperty2.output);
+      const propertyParts = TokenamiConfig.getTokenPropertyParts(tokenProperty2.output, config);
+      if (!propertyParts && variants.length)
+        return;
+      const modeValues = getThemeValuesByThemeMode(tokenValue.output, config.theme);
+      const text = isColorThemeEntry(modeValues) ? createColorTokenDescription(modeValues) : createTokenDescription(modeValues);
+      return { ...original, documentation: [{ text, kind: "markdown" }] };
+    };
+    return proxy;
+  }
+  return { create };
+}
+function convertToRgb(fill, mode) {
+  try {
+    const parsed = culori.parse(fill);
+    const color = culori.rgb(parsed);
+    const modeColor = culori.rgb(mode == "dark" ? "#000" : "#fff");
+    const bgColor = fill === "transparent" ? void 0 : modeColor;
+    if (!color)
+      return fill;
+    if (!bgColor || parsed?.alpha === void 0 || parsed.alpha === 1) {
+      return culori.formatRgb(color);
+    }
+    const alpha = parsed.alpha;
+    color.r = color.r * alpha + bgColor.r * (1 - alpha);
+    color.g = color.g * alpha + bgColor.g * (1 - alpha);
+    color.b = color.b * alpha + bgColor.b * (1 - alpha);
+    color.alpha = 1;
+    return culori.formatRgb(color);
+  } catch {
+    return fill;
+  }
+}
+function createColorTokenDescription(modeValues) {
+  return createDescription(modeValues, (mode, value) => [createSquare(value, mode), mode, value]);
+}
+function createTokenDescription(modeValues) {
+  return createDescription(modeValues, (mode, value) => [mode, value]);
+}
+function createDescription(modeValues, builder) {
+  const entries = Object.entries(modeValues);
+  const rows = entries.map(([mode, value]) => createRow(builder(mode, value)));
+  return rows.join(`
+
+`);
+}
+function createRow(row) {
+  return row.join(createSquare("transparent") + createSquare("transparent"));
+}
+var createSquare = (color, mode) => {
+  const fill = convertToRgb(replaceCssVarsWithFallback(color), mode);
+  const svg = `<svg width="10" height="10" xmlns="http://www.w3.org/2000/svg"><rect width="10" height="10" x="0" y="0" fill="${fill}" /></svg>`;
+  return `![Image](data:image/svg+xml;base64,${btoa(svg)})`;
+};
+function replaceCssVarsWithFallback(value) {
+  const regex = /var\([\w-_]+,\s*([\w-_]+)\)/g;
+  return value.replace(regex, (_, fallback) => fallback);
+}
+function isColorThemeEntry(modeValues) {
+  try {
+    const firstValue = Object.values(modeValues || {})?.[0];
+    const isString = isNaN(Number(firstValue));
+    return isString ? Boolean(culori.parse(replaceCssVarsWithFallback(firstValue || ""))) : false;
+  } catch {
+    return false;
+  }
+}
+
+export { createTSPlugin as default };