@tokenami/node 0.0.96--canary.bootstrap.0

package/dist/ts-plugin.cjs

@@ -0,0 +1,1299 @@
+'use strict';
+
+var ts = require('typescript/lib/tsserverlibrary.js');
+var TokenamiConfig3 = require('@tokenami/config');
+var culori2 = require('culori');
+var createJiti = require('jiti');
+var sucrase = require('sucrase');
+var pathe = require('pathe');
+var fs = require('fs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+var TokenamiConfig3__namespace = /*#__PURE__*/_interopNamespace(TokenamiConfig3);
+var culori2__namespace = /*#__PURE__*/_interopNamespace(culori2);
+var createJiti__default = /*#__PURE__*/_interopDefault(createJiti);
+var pathe__namespace = /*#__PURE__*/_interopNamespace(pathe);
+var fs__namespace = /*#__PURE__*/_interopNamespace(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');
+});
+
+// src/ts-plugin/error-codes.ts
+var INVALID_PROPERTY = 2353;
+var INVALID_VALUE = 2322;
+var EXPECT_EXTRACTABLE_COMPOSE = 2790;
+
+// src/ts-plugin/diagnostics.ts
+var TokenamiDiagnostics = class {
+  #config;
+  constructor(config, context = {}) {
+    this.#config = config;
+    context.logger?.log("Setting up diagnostics");
+  }
+  getSemanticDiagnostics(sourceFile) {
+    let diagnostics = [];
+    if (sourceFile) {
+      const processNode = this.#processNode.bind(this);
+      ts__default.default.forEachChild(sourceFile, function nextNode(node) {
+        const nodeDiagnostics = processNode(node, sourceFile);
+        if (nodeDiagnostics) diagnostics.push(...nodeDiagnostics);
+        ts__default.default.forEachChild(node, nextNode);
+      });
+    }
+    return diagnostics;
+  }
+  #processNode(node, sourceFile) {
+    const isDiagnosticPrevented = this.#shouldSuppressDiagnosticForNode(node, sourceFile);
+    if (isDiagnosticPrevented) return;
+    if (ts__default.default.isCallExpression(node) && ts__default.default.isPropertyAccessExpression(node.expression) && ts__default.default.isIdentifier(node.expression.expression) && node.expression.expression.text === "css" && node.expression.name.text === "compose" && node.arguments[0] && ts__default.default.isObjectLiteralExpression(node.arguments[0])) {
+      return this.#validateComposeConfig(node.arguments[0], sourceFile);
+    }
+    if (ts__default.default.isPropertyAssignment(node)) {
+      const nodeProperty = ts__default.default.isStringLiteral(node.name) ? node.name.text : null;
+      const property = TokenamiConfig3__namespace.TokenProperty.safeParse(nodeProperty);
+      if (!property.success) return;
+      return this.#validateTokenamiProperty(property.output, node, sourceFile);
+    }
+  }
+  #validateTokenamiProperty(property, node, sourceFile) {
+    const { variants } = TokenamiConfig3__namespace.getTokenPropertySplit(property);
+    const parts = TokenamiConfig3__namespace.getTokenPropertyParts(property, this.#config);
+    const isArbitrarySelector = variants.some(TokenamiConfig3__namespace.getArbitrarySelector);
+    if (!variants.length || parts || isArbitrarySelector) return;
+    const selector = variants.join("_");
+    const isEmptyArbSelector = variants.includes("{}");
+    const arbSuffix = isEmptyArbSelector ? ` Add an arbitrary selector or remove '${selector}'.` : "";
+    return [
+      {
+        file: sourceFile,
+        start: node.getStart(sourceFile),
+        length: node.name.getWidth(sourceFile),
+        messageText: `Selector '${selector}' does not exist in the Tokenami config.${arbSuffix}`,
+        category: ts__default.default.DiagnosticCategory.Error,
+        code: INVALID_PROPERTY
+      }
+    ];
+  }
+  #validateComposeConfig(config, sourceFile) {
+    const diagnostic = {
+      file: sourceFile,
+      messageText: `Compose styles must be statically extractable. Use 'includes' to reuse shared styles.`,
+      category: ts__default.default.DiagnosticCategory.Error,
+      code: EXPECT_EXTRACTABLE_COMPOSE
+    };
+    for (const prop of config.properties) {
+      if (ts__default.default.isSpreadAssignment(prop)) {
+        const start = prop.getStart(sourceFile);
+        const length = prop.getWidth(sourceFile);
+        return [{ ...diagnostic, start, length }];
+      }
+      if (!ts__default.default.isPropertyAssignment(prop)) continue;
+      const key = prop.name;
+      const value = prop.initializer;
+      if (ts__default.default.isComputedPropertyName(key)) {
+        const start = key.getStart(sourceFile);
+        const length = key.getWidth(sourceFile);
+        return [{ ...diagnostic, start, length }];
+      }
+      if (ts__default.default.isObjectLiteralExpression(value)) {
+        return this.#validateComposeConfig(value, sourceFile);
+      } else if (value.getText(sourceFile).length > 0 && !ts__default.default.isIdentifier(key) && !ts__default.default.isStringLiteral(value) && !ts__default.default.isNumericLiteral(value) && !(ts__default.default.isPrefixUnaryExpression(value) && value.operator === ts__default.default.SyntaxKind.MinusToken && ts__default.default.isNumericLiteral(value.operand))) {
+        const start = value.getStart(sourceFile);
+        const length = value.getWidth(sourceFile);
+        return [{ ...diagnostic, start, length }];
+      }
+    }
+  }
+  #shouldSuppressDiagnosticForNode(node, sourceFile) {
+    if (!sourceFile) return false;
+    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;
+  }
+};
+
+// 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, path, type) {
+  path = path || getConfigDefaultPath(cwd);
+  return pathe__namespace.join(cwd, path);
+}
+function getConfigAtPath(path, opts = { cache: true }) {
+  const config = (() => {
+    try {
+      if (!opts.cache) delete __require.cache[__require.resolve(path)];
+      return __require(path);
+    } catch {
+      return lazyJiti({ cache: opts.cache })(path);
+    }
+  })();
+  return mergedConfigs(config.default ?? config);
+}
+function getConfigDefaultPath(cwd, type) {
+  const existingConfig = Object.values(DEFAULT_PATHS).find((path) => {
+    return fs__namespace.existsSync(pathe__namespace.join(cwd, path));
+  });
+  return existingConfig || DEFAULT_PATHS["js"];
+}
+function getTypeDefsPath(configPath) {
+  const dirname2 = pathe__namespace.dirname(configPath);
+  return `${dirname2}/tokenami.env.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(tokenValue2, themeConfig) {
+  const theme = getThemeFromConfig(themeConfig);
+  const parts = TokenamiConfig3__namespace.getTokenValueParts(tokenValue2);
+  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__namespace.parse(configPath);
+  const typeDefStubPath = pathe__namespace.resolve(__dirname, stubPath);
+  const typeDefStub = fs__namespace.readFileSync(typeDefStubPath, "utf8");
+  return typeDefStub.replace("tokenami.config", parsed.name);
+}
+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__default.default(__filename, {
+    transform: (opts) => sucrase.transform(opts.source, { transforms: ["typescript", "imports"] }),
+    interopDefault: true,
+    requireCache: options.cache
+  });
+}
+function isColorValue(value) {
+  if (!value) return false;
+  try {
+    const isString = isNaN(Number(value));
+    return isString ? Boolean(culori2__namespace.parse(replaceCssVarsWithFallback(value))) : false;
+  } catch {
+    return false;
+  }
+}
+function isColorThemeEntry(modeValues) {
+  const firstValue = Object.values(modeValues)?.[0];
+  return isColorValue(firstValue);
+}
+function replaceCssVarsWithFallback(value) {
+  const regex = /var\([\w-_]+,\s*([\w-_]+)\)/g;
+  return value.replace(regex, (_, fallback) => fallback);
+}
+
+// src/ts-plugin/logger.ts
+var LanguageServiceLogger = class {
+  #info;
+  constructor(info) {
+    this.#info = info;
+  }
+  log(message) {
+    this.#info.project.projectService.logger.info(`Tokenami:: ${message}`);
+  }
+  error(message) {
+    this.#info.project.projectService.logger.info(`Tokenami:: ${message}`);
+  }
+};
+var TokenamiCompletions = class {
+  #ctx;
+  #config;
+  #selectorEntries;
+  #responsiveEntries;
+  #base;
+  #selectorSnippets;
+  // lazily instantiate and cache these
+  #_responsiveSelectorSnippets;
+  #_validProperties;
+  #_colorThemeKeys;
+  constructor(config, context) {
+    this.#config = config;
+    this.#ctx = { ...context, insertFormatter: context.insertFormatter ?? ((name) => name) };
+    this.#_validProperties = Array.from(getValidProperties(this.#config));
+    this.#_colorThemeKeys = this.#computeColorThemeKeys();
+    this.#selectorEntries = Object.entries(this.#config.selectors || {});
+    this.#responsiveEntries = Object.entries(this.#config.responsive || {});
+    this.#base = this.#getBaseCompletions();
+    this.#selectorSnippets = this.#getSelectorSnippetCompletions();
+  }
+  get #responsiveSelectorSnippets() {
+    if (this.#_responsiveSelectorSnippets) return this.#_responsiveSelectorSnippets;
+    const selectorConfig = this.#getSelectorConfigEntries();
+    const completions = this.#getResponsiveSelectorSnippetCompletions(selectorConfig);
+    this.#_responsiveSelectorSnippets = completions;
+    return completions;
+  }
+  propertySearch(input) {
+    const variantResults = this.variantSearch(input);
+    if (input.includes("_")) return variantResults;
+    return { ...this.#base, ...variantResults };
+  }
+  valueSearch(original) {
+    const result = {};
+    for (const [index, entry] of original.entries()) {
+      const entryName = entry.name.replace(/['"]/g, "");
+      const tokenValue2 = TokenamiConfig3__namespace.TokenValue.safeParse(entryName);
+      if (!tokenValue2.success) continue;
+      const { themeKey, token } = TokenamiConfig3__namespace.getTokenValueParts(tokenValue2.output);
+      const name = `$${token}`;
+      const isColor = this.#_colorThemeKeys.has(themeKey);
+      result[name] = {
+        name,
+        kind: ts__default.default.ScriptElementKind.string,
+        kindModifiers: isColor ? "color" : themeKey,
+        sortText: this.#createSortText(`${index}${entryName}`),
+        insertText: this.#ctx.insertFormatter(entryName, { type: "value" }),
+        labelDetails: { detail: "", description: entryName },
+        details: { themeKey, token }
+      };
+    }
+    return result;
+  }
+  variantSearch(input) {
+    const parts = TokenamiConfig3__namespace.getTokenPropertySplit(input);
+    if (!parts.variants.length) {
+      return this.#selectorSnippets;
+    }
+    if (parts.variants.length === 1) {
+      const search = this.#selectorsSearch(input, parts.alias, parts.variants);
+      return Object.assign(search, this.#responsiveSelectorSnippets);
+    }
+    return this.#responsiveSelectorsSearch(input, parts.alias, parts.variants);
+  }
+  #arbitrarySelectorRegex = /\{(.*)\}/;
+  #getArbitrarySelector(input) {
+    return input.match(this.#arbitrarySelectorRegex)?.[1];
+  }
+  #selectorsSearch(input, alias, variants) {
+    const arbSelector = this.#getArbitrarySelector(input);
+    return this.#getSelectorCompletions(alias, variants, arbSelector);
+  }
+  #responsiveSelectorsSearch(input, alias, variants) {
+    const arbSelector = this.#getArbitrarySelector(input);
+    const selectorConfig = this.#getSelectorConfigEntries(variants, arbSelector);
+    return this.#getResponsiveSelectorCompletions(alias, variants, selectorConfig);
+  }
+  #matchSearch(input, entryName) {
+    const searchEntryName = entryName.replaceAll("-", "");
+    const searchInput = input.replaceAll("-", "");
+    if (searchEntryName.startsWith(searchInput)) return true;
+    const index = searchEntryName.indexOf(searchInput);
+    return index > 0 && entryName[index] === "-";
+  }
+  #createSortText(name) {
+    const sortText = name.replace(/[0-9]+/g, (m) => m.padStart(6, "0")).replaceAll("-", "");
+    return `$${sortText}`;
+  }
+  #getBaseCompletions() {
+    const result = {};
+    for (const property of this.#_validProperties) {
+      const name = TokenamiConfig3__namespace.tokenProperty(property);
+      const entry = this.#createPropertyEntry(name, this.#createSortText(`$${name}`));
+      result[entry.name] = entry;
+    }
+    return result;
+  }
+  #getSelectorCompletions(alias, variants, arbSelector) {
+    const responsiveConfig = this.#getResponsiveConfigEntries(variants);
+    const selectorConfig = this.#getSelectorConfigEntries(variants, arbSelector);
+    const result = {};
+    for (const property of this.#_validProperties) {
+      if (!this.#matchSearch(alias, property)) continue;
+      const create = this.#createVariantPropertyEntry(property);
+      for (const [selector, value] of selectorConfig) {
+        const entry = create([selector, value]);
+        result[entry.name] = entry;
+      }
+      for (const [selector, value] of responsiveConfig) {
+        const entry = create([selector, value]);
+        result[entry.name] = entry;
+      }
+    }
+    return result;
+  }
+  #getResponsiveSelectorCompletions(alias, variants, selectorConfig) {
+    const responsiveSelectors = this.#getResponsiveSelectorConfigEntries(selectorConfig, variants);
+    const result = {};
+    for (const property of this.#_validProperties) {
+      if (!this.#matchSearch(alias, property)) continue;
+      const create = this.#createVariantPropertyEntry(property);
+      for (const [selector, value] of responsiveSelectors) {
+        const entry = create([selector, value]);
+        result[entry.name] = entry;
+      }
+    }
+    return result;
+  }
+  #getSelectorSnippetCompletions() {
+    const responsiveConfig = this.#getResponsiveConfigEntries();
+    const selectorConfig = this.#getSelectorConfigEntries();
+    const create = this.#createVariantPropertyEntry(null);
+    const result = {};
+    for (const [selector, value] of selectorConfig) {
+      const entry = create([selector, value]);
+      result[entry.name] = entry;
+    }
+    for (const [selector, value] of responsiveConfig) {
+      const entry = create([selector, value]);
+      result[entry.name] = entry;
+    }
+    return result;
+  }
+  #getResponsiveSelectorSnippetCompletions(selectorConfig) {
+    const entries = this.#getResponsiveSelectorConfigEntries(selectorConfig);
+    const create = this.#createVariantPropertyEntry(null);
+    const result = {};
+    for (const [selector, value] of entries) {
+      const entry = create([selector, value]);
+      result[entry.name] = entry;
+    }
+    return result;
+  }
+  #computeColorThemeKeys() {
+    const colorKeys = /* @__PURE__ */ new Set();
+    const theme = getThemeFromConfig(this.#config.theme);
+    const themeModes = [theme.root, ...Object.values(theme.modes)];
+    for (const theme2 of themeModes) {
+      for (const [themeKey, values] of Object.entries(theme2)) {
+        if (colorKeys.has(themeKey)) continue;
+        const firstValue = Object.values(values)[0];
+        if (typeof firstValue === "string" && isColorValue(firstValue)) {
+          colorKeys.add(themeKey);
+        }
+      }
+    }
+    return colorKeys;
+  }
+  #getSelectorConfigEntries(variants, arbSelector = "") {
+    const selectorConfig = this.#selectorEntries.concat([[`{${arbSelector}}`, ""]]);
+    if (!variants) return selectorConfig;
+    const variantSet = new Set(variants);
+    return selectorConfig.filter(([k]) => variantSet.has(k));
+  }
+  #getResponsiveConfigEntries(variants) {
+    if (!variants) return this.#responsiveEntries;
+    const variantSet = new Set(variants);
+    return this.#responsiveEntries.filter(([k]) => variantSet.has(k));
+  }
+  #getResponsiveSelectorConfigEntries(selectorConfig, variants) {
+    const responsiveConfig = this.#getResponsiveConfigEntries(variants);
+    const result = [];
+    for (const [responsiveSelector, responsiveValue] of responsiveConfig) {
+      for (const [selector, value] of selectorConfig) {
+        result.push([`${responsiveSelector}_${selector}`, [responsiveValue].concat(value)]);
+      }
+    }
+    return result;
+  }
+  #createVariantPropertyEntry(property) {
+    return ([selectorName, selector]) => {
+      const name = TokenamiConfig3__namespace.variantProperty(selectorName, property ?? "");
+      const isArbitrary = name.includes("{}");
+      const propertyEntry = isArbitrary ? this.#createAribitraryPropertyEntry(name) : this.#createPropertyEntry(name);
+      return { ...propertyEntry, details: { selector } };
+    };
+  }
+  #createAribitraryPropertyEntry(name, sortText = this.#createSortText(name)) {
+    const entry = this.#createPropertyEntry(name, sortText);
+    const insertText = entry.name.replace("{}", "{${1}}");
+    return { ...entry, insertText, isSnippet: true };
+  }
+  #createPropertyEntry(name, sortText = this.#createSortText(name)) {
+    const kind = ts__default.default.ScriptElementKind.memberVariableElement;
+    const kindModifiers = ts__default.default.ScriptElementKindModifier.optionalModifier;
+    const isSelector = name.slice(-1) === "_";
+    const filterText = isSelector ? name.slice(0, -1) : name;
+    const insertText = this.#ctx.insertFormatter(name, { type: "property" });
+    const isSnippet = insertText.includes("${");
+    return {
+      name,
+      filterText,
+      kind,
+      kindModifiers,
+      sortText,
+      insertText,
+      ...isSnippet && { isSnippet }
+    };
+  }
+};
+
+// src/ts-plugin/plugin.ts
+var createTSPlugin = (mod) => ({
+  create(info) {
+    const logger = new LanguageServiceLogger(info);
+    const cwd = info.project.getCurrentDirectory();
+    const configPath = getConfigPath(cwd, info.config.configPath);
+    const configExists = mod.typescript.sys.fileExists(configPath);
+    if (!configExists) {
+      logger.log(`Config not found at ${configPath}`);
+      return info.languageService;
+    }
+    const ctx = { ts: mod.typescript, info, logger };
+    const plugin = new TokenamiPlugin(configPath, ctx);
+    return createServiceProxy(info.languageService, plugin);
+  }
+});
+var TokenamiPlugin = class {
+  #diagnostics;
+  #config;
+  #ctx;
+  #completions;
+  #quotedCompletions;
+  #completionsForPosition = null;
+  constructor(configPath, context) {
+    this.#config = getConfigAtPath(configPath);
+    this.#diagnostics = new TokenamiDiagnostics(this.#config, context);
+    this.#completions = new TokenamiCompletions(this.#config, context);
+    this.#ctx = context;
+    this.#quotedCompletions = new TokenamiCompletions(this.#config, {
+      insertFormatter: quotedInsertFormatter,
+      logger: context.logger
+    });
+    this.#watchConfig(configPath);
+    context.logger.log(`Watching config at ${configPath}`);
+    try {
+      updateEnvFile(configPath);
+    } catch (e) {
+      context.logger.error(`Error updating typedefs: ${e}`);
+    }
+  }
+  #watchConfig(configPath) {
+    this.#ctx.ts.sys.watchFile?.(configPath, (_fileName, eventKind) => {
+      if (eventKind !== this.#ctx.ts.FileWatcherEventKind.Changed) return;
+      try {
+        const reloadedConfig = getConfigAtPath(configPath, { cache: false });
+        updateEnvFile(configPath);
+        this.#ctx.logger.log(`Config changed at ${configPath}}`);
+        this.#completions = new TokenamiCompletions(reloadedConfig, this.#ctx);
+        this.#quotedCompletions = new TokenamiCompletions(reloadedConfig, {
+          insertFormatter: quotedInsertFormatter,
+          logger: this.#ctx.logger
+        });
+        this.#diagnostics = new TokenamiDiagnostics(reloadedConfig, this.#ctx);
+        this.#ctx.info.project.refreshDiagnostics();
+        this.#config = reloadedConfig;
+      } catch (e) {
+        this.#ctx.logger.error(`Error processing config at ${configPath}: ${e}`);
+      }
+    });
+    this.#ctx.logger.log(`Watching config at ${configPath}`);
+  }
+  getSemanticDiagnostics(fileName) {
+    const original = this.#ctx.info.languageService.getSemanticDiagnostics(fileName);
+    const sourceFile = this.#ctx.info.languageService.getProgram()?.getSourceFile(fileName);
+    if (!sourceFile) return original;
+    return [...this.#diagnostics.getSemanticDiagnostics(sourceFile), ...original];
+  }
+  getCompletionsAtPosition(fileName, position, options) {
+    const languageService = this.#ctx.info.languageService;
+    const original = () => languageService.getCompletionsAtPosition(fileName, position, options);
+    const program = languageService.getProgram();
+    const sourceFile = program?.getSourceFile(fileName);
+    if (!sourceFile) return original();
+    const node = findNodeAtPosition(sourceFile, position);
+    if (!node) return original();
+    const input = this.#parseTokenamiCompletionsInput(node, fileName, position);
+    if (!input) return original();
+    const rawInput = removeQuotes(input.value);
+    const hasQuotes = input.value.startsWith('"') || input.value.startsWith("'");
+    const completions = hasQuotes ? this.#completions : this.#quotedCompletions;
+    if (input.isTokenamiProperty) {
+      const results = completions.propertySearch(rawInput);
+      this.#completionsForPosition = results;
+      return {
+        entries: Object.values(results),
+        isGlobalCompletion: false,
+        isMemberCompletion: false,
+        isNewIdentifierLocation: false,
+        optionalReplacementSpan: {
+          start: position - rawInput.length,
+          length: rawInput.length
+        }
+      };
+    } else {
+      const result = original();
+      const results = completions.valueSearch(result?.entries ?? []);
+      if (Object.keys(results).length === 0) {
+        this.#completionsForPosition = null;
+        return result;
+      }
+      this.#completionsForPosition = results;
+      return {
+        entries: Object.values(results),
+        isGlobalCompletion: false,
+        isMemberCompletion: false,
+        isNewIdentifierLocation: false,
+        optionalReplacementSpan: {
+          start: position - rawInput.length,
+          length: rawInput.length
+        }
+      };
+    }
+  }
+  getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data) {
+    const original = this.#ctx.info.languageService.getCompletionEntryDetails(
+      fileName,
+      position,
+      entryName,
+      formatOptions,
+      source,
+      preferences,
+      data
+    );
+    const entry = this.#completionsForPosition?.[entryName];
+    if (!entry) return original;
+    const selector = entry.details?.selector;
+    if (selector) return createEntryDetails(original, entry, selector);
+    const themeKey = entry.details?.themeKey;
+    const token = entry.details?.token;
+    if (!themeKey || !token) return original;
+    const tokenValue2 = TokenamiConfig3__namespace.tokenValue(themeKey, token);
+    const modeValues = getThemeValuesByThemeMode(tokenValue2, this.#config.theme);
+    const themeEntries = Object.entries(modeValues);
+    const [mode, firstValue] = themeEntries[0] || [];
+    if (!firstValue) return original;
+    if (isColorValue(firstValue)) {
+      const colorDescription = createColorTokenDescription(modeValues);
+      const rgb2 = convertToRgb(replaceCssVarsWithFallback(firstValue), mode);
+      return createEntryDetails(original, entry, `${rgb2}
+
+${colorDescription}`);
+    } else {
+      const description = createTokenDescription(modeValues);
+      return createEntryDetails(original, entry, description);
+    }
+  }
+  getQuickInfoAtPosition(fileName, position) {
+    const original = this.#ctx.info.languageService.getQuickInfoAtPosition(fileName, position);
+    const sourceFile = this.#ctx.info.languageService.getProgram()?.getSourceFile(fileName);
+    if (!original || !sourceFile) return;
+    const node = findNodeAtPosition(sourceFile, position);
+    if (!node || !node.parent || !ts__default.default.isPropertyAssignment(node.parent)) return original;
+    const property = node.parent;
+    const propertyName = property.name.getText(sourceFile);
+    const propertyValue = property.initializer.getText();
+    const tokenProperty2 = TokenamiConfig3__namespace.TokenProperty.safeParse(propertyName);
+    const tokenValue2 = TokenamiConfig3__namespace.TokenValue.safeParse(propertyValue);
+    if (!tokenProperty2.success || !tokenValue2.success) return original;
+    const { variants } = TokenamiConfig3__namespace.getTokenPropertySplit(tokenProperty2.output);
+    const propertyParts = TokenamiConfig3__namespace.getTokenPropertyParts(tokenProperty2.output, this.#config);
+    if (!propertyParts && variants.length) return;
+    const modeValues = getThemeValuesByThemeMode(tokenValue2.output, this.#config.theme);
+    const text = isColorThemeEntry(modeValues) ? createColorTokenDescription(modeValues) : createTokenDescription(modeValues);
+    return { ...original, documentation: [{ text, kind: "markdown" }] };
+  }
+  getCodeFixesAtPosition(fileName, start, end, errorCodes, formatOptions, preferences) {
+    const original = this.#ctx.info.languageService.getCodeFixesAtPosition(
+      fileName,
+      start,
+      end,
+      errorCodes,
+      formatOptions,
+      preferences
+    );
+    const sourceFile = this.#ctx.info.languageService.getProgram()?.getSourceFile(fileName);
+    if (!sourceFile || !errorCodes.includes(INVALID_VALUE)) return original;
+    const node = findNodeAtPosition(sourceFile, start);
+    if (!node?.parent || !ts__default.default.isPropertyAssignment(node.parent)) return original;
+    const assignment = node.parent;
+    const valueSpan = createTextSpanFromNode(assignment.initializer);
+    const value = ts__default.default.isStringLiteral(assignment.initializer) && assignment.initializer.text;
+    if (!value) return original;
+    const quoteMark = assignment.initializer.getText().slice(-1);
+    const arbitraryValue2 = TokenamiConfig3__namespace.arbitraryValue(value);
+    const arbitraryText = `${quoteMark}${arbitraryValue2}${quoteMark}`;
+    return [
+      {
+        description: `Use ${arbitraryText} to mark as arbitrary`,
+        fixName: "replaceWithArbitrary",
+        changes: [{ fileName, textChanges: [{ span: valueSpan, newText: arbitraryText }] }]
+      }
+    ];
+  }
+  #parseTokenamiCompletionsInput(node, fileName, position) {
+    const objLit = ts__default.default.findAncestor(node, ts__default.default.isObjectLiteralExpression);
+    if (!objLit) {
+      if (!ts__default.default.isStringLiteral(node)) return null;
+      if (!this.#isTokenValueContext(node)) return null;
+      return { isTokenamiProperty: false, value: node.getText() };
+    }
+    const prop = objLit.properties.find((p) => p.getStart() <= position && position <= p.getEnd());
+    if (!prop) return null;
+    const isTokenamiObj = this.#isTokenamiObject(objLit, fileName);
+    if (!ts__default.default.isPropertyAssignment(prop)) {
+      return isTokenamiObj ? { isTokenamiProperty: true, value: prop.getText() } : null;
+    }
+    const keyLength = prop.name.getText().length;
+    const isOnProperty = position - prop.getStart() < keyLength;
+    if (isTokenamiObj) {
+      const value = isOnProperty ? prop.name.getText() : prop.initializer.getText();
+      return { isTokenamiProperty: isOnProperty, value };
+    }
+    if (isOnProperty) return null;
+    if (!this.#isTokenValueContext(prop.initializer)) return null;
+    return { isTokenamiProperty: false, value: prop.initializer.getText() };
+  }
+  #isTokenValueContext(node) {
+    const checker = this.#ctx.info.languageService.getProgram()?.getTypeChecker();
+    const contextualType = checker?.getContextualType(node);
+    if (!contextualType) return false;
+    return this.#hasTokenValueType(contextualType);
+  }
+  #hasTokenValueType(type) {
+    if (type.isStringLiteral()) {
+      return TokenamiConfig3__namespace.TokenValue.safeParse(type.value).success;
+    }
+    if (type.isUnion()) {
+      return type.types.some((t) => this.#hasTokenValueType(t));
+    }
+    return false;
+  }
+  #isTokenamiObjectCache = TokenamiConfig3__namespace.createLRUCache();
+  #isTokenamiObject(objLit, fileName) {
+    const sourceFile = this.#ctx.info.languageService.getProgram()?.getSourceFile(fileName);
+    if (!sourceFile) return false;
+    const startPos = objLit.getStart(sourceFile);
+    const textBeforeBrace = sourceFile.text.substring(Math.max(0, startPos - 10), startPos);
+    const cacheKey = `${fileName}:${objLit.pos}:${textBeforeBrace}`;
+    if (this.#isTokenamiObjectCache.get(cacheKey)) return true;
+    const checker = this.#ctx.info.languageService.getProgram()?.getTypeChecker();
+    const contextual = checker?.getContextualType(objLit);
+    if (!contextual) return false;
+    const isTokenami = this.#hasTokenamiType(contextual);
+    if (isTokenami) this.#isTokenamiObjectCache.set(cacheKey, true);
+    return isTokenami;
+  }
+  #hasTokenamiType(type) {
+    const symbol = type.getSymbol();
+    const aliasSymbol = type.aliasSymbol;
+    const name = symbol?.getName() || aliasSymbol?.getName();
+    if (name?.startsWith("Tokenami")) return true;
+    if (type.isUnion() || type.isIntersection()) {
+      return type.types.some((t) => this.#hasTokenamiType(t));
+    }
+    return false;
+  }
+};
+function updateEnvFile(configPath) {
+  const envFilePath = getTypeDefsPath(configPath);
+  const envFileContent = ts__default.default.sys.readFile(envFilePath, "utf-8");
+  if (!envFileContent) throw new Error("Cannot read tokenami.env.d.ts file");
+  const updatedEnvFileContent = generateTypeDefs(configPath, "../stubs/tokenami.env.d.ts");
+  ts__default.default.sys.writeFile(envFilePath, updatedEnvFileContent);
+}
+function quotedInsertFormatter(name, options) {
+  if (options?.type === "value") return `"${name}"`;
+  if (name.slice(-1) === "_") return `"${name}\${1}": \${2}`;
+  return `"${name}": \${1}`;
+}
+function findNodeAtPosition(sourceFile, position) {
+  function find(node) {
+    if (position >= node.getStart(sourceFile) && position < node.getEnd()) {
+      return ts__default.default.forEachChild(node, find) || node;
+    }
+  }
+  return find(sourceFile);
+}
+function createTextSpanFromNode(node) {
+  return { start: node.getStart(), length: node.getEnd() - node.getStart() };
+}
+var createEntryDetails = (original, entryConfig, documentation) => ({
+  ...original,
+  ...entryConfig,
+  displayParts: original?.displayParts || [],
+  documentation: [{ text: documentation, kind: "markdown" }, ...original?.documentation ?? []]
+});
+function removeQuotes(name) {
+  return name.replace(/'|"/g, "");
+}
+function createColorTokenDescription(modeValues) {
+  const entries = Object.entries(modeValues);
+  const rows = entries.map(([mode, value]) => {
+    const swatch = createSquare(value, mode);
+    return `${swatch}&nbsp;&nbsp;${mode}&nbsp;&nbsp;&nbsp;&nbsp;${value}`;
+  });
+  return rows.join("\n\n");
+}
+function createTokenDescription(modeValues) {
+  const entries = Object.entries(modeValues);
+  return entries.map(([mode, value]) => `${mode}&nbsp;&nbsp;&nbsp;&nbsp;${value}`).join("\n\n");
+}
+function 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 `![](data:image/svg+xml;base64,${btoa(svg)})`;
+}
+function convertToRgb(fill, mode) {
+  try {
+    const parsed = culori2__namespace.parse(fill);
+    const color = culori2__namespace.rgb(parsed);
+    const modeColor = culori2__namespace.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 culori2__namespace.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 culori2__namespace.formatRgb(color);
+  } catch {
+    return fill;
+  }
+}
+var createServiceProxy = (service, plugin) => {
+  const proxy = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(service)) {
+    const originalMethod = service[key];
+    proxy[key] = (...args) => {
+      if (key in plugin) {
+        return plugin[key].apply(plugin, args);
+      }
+      return originalMethod.apply(service, args);
+    };
+  }
+  return proxy;
+};
+
+exports.TokenamiDiagnostics = TokenamiDiagnostics;
+exports.createTSPlugin = createTSPlugin;