@kimdw-rtk/ui 0.0.8 → 0.0.9

package/dist/node_modules/.pnpm/@vanilla-extract_css@1.17.4_babel-plugin-macros@3.1.0/node_modules/@vanilla-extract/css/dist/vanilla-extract-css.esm.js

@@ -0,0 +1,390 @@
+import { injectStyles } from '../injectStyles/dist/vanilla-extract-css-injectStyles.esm.js';
+import { _ as _objectSpread2, d as dudupeAndJoinClassList, t as transformCss } from './transformCss-0dba36bf.esm.js';
+import { setAdapterIfNotSet, appendCss, registerClassName, registerComposition, markCompositionUsed, getIdentOption } from '../adapter/dist/vanilla-extract-css-adapter.esm.js';
+import murmur2 from '../../../../../@emotion_hash@0.9.2/node_modules/@emotion/hash/dist/emotion-hash.esm.js';
+import { getFileScope, getAndIncrementRefCounter, hasFileScope } from '../fileScope/dist/vanilla-extract-css-fileScope.esm.js';
+import { LRUCache } from '../../../../../lru-cache@10.4.3/node_modules/lru-cache/dist/esm/index.js';
+import { walkObject, get } from '../../../../../@vanilla-extract_private@1.0.9/node_modules/@vanilla-extract/private/dist/vanilla-extract-private.esm.js';
+import cssescExports from '../../../../../../../_virtual/cssesc.js';
+import diff from '../../../../../deep-object-diff@1.1.9/node_modules/deep-object-diff/mjs/diff.js';
+import picocolorsExports from '../../../../../../../_virtual/picocolors.js';
+import '../../../../../dedent@1.6.0_babel-plugin-macros@3.1.0/node_modules/dedent/dist/dedent.js';
+import cjsExports from '../../../../../../../_virtual/cjs.js';
+
+var localClassNames = new Set();
+var composedClassLists = [];
+var bufferedCSSObjs = [];
+var browserRuntimeAdapter = {
+  appendCss: cssObj => {
+    bufferedCSSObjs.push(cssObj);
+  },
+  registerClassName: className => {
+    localClassNames.add(className);
+  },
+  registerComposition: composition => {
+    composedClassLists.push(composition);
+  },
+  markCompositionUsed: () => {},
+  onEndFileScope: fileScope => {
+    var css = transformCss({
+      localClassNames: Array.from(localClassNames),
+      composedClassLists,
+      cssObjs: bufferedCSSObjs
+    }).join('\n');
+    injectStyles({
+      fileScope,
+      css
+    });
+    bufferedCSSObjs = [];
+  },
+  getIdentOption: () => process.env.NODE_ENV === 'production' ? 'short' : 'debug'
+};
+if (typeof window !== 'undefined') {
+  setAdapterIfNotSet(browserRuntimeAdapter);
+}
+
+var getLastSlashBeforeIndex = (path, index) => {
+  var pathIndex = index - 1;
+  while (pathIndex >= 0) {
+    if (path[pathIndex] === '/') {
+      return pathIndex;
+    }
+    pathIndex--;
+  }
+  return -1;
+};
+
+/**
+ * Assumptions:
+ * - The path is always normalized to use posix file separators (/) (see `addFileScope`)
+ * - The path is always relative to the project root, i.e. there will never be a leading slash (see `addFileScope`)
+ * - As long as `.css` is there, we have a valid `.css.*` file path, because otherwise there wouldn't
+ *   be a file scope to begin with
+ *
+ * The LRU cache we use can't cache undefined/null values, so we opt to return an empty string,
+ * rather than using a custom Symbol or something similar.
+ */
+var _getDebugFileName = path => {
+  var file;
+  var lastIndexOfDotCss = path.lastIndexOf('.css');
+  if (lastIndexOfDotCss === -1) {
+    return '';
+  }
+  var lastSlashIndex = getLastSlashBeforeIndex(path, lastIndexOfDotCss);
+  file = path.slice(lastSlashIndex + 1, lastIndexOfDotCss);
+
+  // There are no slashes, therefore theres no directory to extract
+  if (lastSlashIndex === -1) {
+    return file;
+  }
+  var secondLastSlashIndex = getLastSlashBeforeIndex(path, lastSlashIndex - 1);
+  // If secondLastSlashIndex is -1, it means that the path looks like `directory/file.css.ts`,
+  // in which case dir will still be sliced starting at 0, which is what we want
+  var dir = path.slice(secondLastSlashIndex + 1, lastSlashIndex);
+  var debugFileName = file !== 'index' ? file : dir;
+  return debugFileName;
+};
+var memoizedGetDebugFileName = () => {
+  var cache = new LRUCache({
+    max: 500
+  });
+  return path => {
+    var cachedResult = cache.get(path);
+    if (cachedResult) {
+      return cachedResult;
+    }
+    var result = _getDebugFileName(path);
+    cache.set(path, result);
+    return result;
+  };
+};
+var getDebugFileName = memoizedGetDebugFileName();
+
+function getDevPrefix(_ref) {
+  var {
+    debugId,
+    debugFileName
+  } = _ref;
+  var parts = debugId ? [debugId.replace(/\s/g, '_')] : [];
+  if (debugFileName) {
+    var {
+      filePath
+    } = getFileScope();
+    var _debugFileName = getDebugFileName(filePath);
+
+    // debugFileName could be an empty string
+    if (_debugFileName) {
+      parts.unshift(_debugFileName);
+    }
+  }
+  return parts.join('_');
+}
+function normalizeIdentifier(identifier) {
+  return identifier.match(/^[0-9]/) ? "_".concat(identifier) : identifier;
+}
+function generateIdentifier(arg) {
+  var identOption = getIdentOption();
+  var {
+    debugId,
+    debugFileName = true
+  } = _objectSpread2(_objectSpread2({}, typeof arg === 'string' ? {
+    debugId: arg
+  } : null), typeof arg === 'object' ? arg : null);
+
+  // Convert ref count to base 36 for optimal hash lengths
+  var refCount = getAndIncrementRefCounter().toString(36);
+  var {
+    filePath,
+    packageName
+  } = getFileScope();
+  var fileScopeHash = murmur2(packageName ? "".concat(packageName).concat(filePath) : filePath);
+  var identifier = "".concat(fileScopeHash).concat(refCount);
+  if (identOption === 'debug') {
+    var devPrefix = getDevPrefix({
+      debugId,
+      debugFileName
+    });
+    if (devPrefix) {
+      identifier = "".concat(devPrefix, "__").concat(identifier);
+    }
+    return normalizeIdentifier(identifier);
+  }
+  if (typeof identOption === 'function') {
+    identifier = identOption({
+      hash: identifier,
+      debugId,
+      filePath,
+      packageName
+    });
+    if (!identifier.match(/^[A-Z_][0-9A-Z_-]+$/i)) {
+      throw new Error("Identifier function returned invalid indentifier: \"".concat(identifier, "\""));
+    }
+    return identifier;
+  }
+  return normalizeIdentifier(identifier);
+}
+
+var normaliseObject = obj => walkObject(obj, () => '');
+function validateContract(contract, tokens) {
+  var theDiff = diff(normaliseObject(contract), normaliseObject(tokens));
+  var valid = Object.keys(theDiff).length === 0;
+  return {
+    valid,
+    diffString: valid ? '' : renderDiff(contract, theDiff)
+  };
+}
+function diffLine(value, nesting, type) {
+  var whitespace = [...Array(nesting).keys()].map(() => '  ').join('');
+  var line = "".concat(type ? type : ' ').concat(whitespace).concat(value);
+  if (process.env.NODE_ENV !== 'test') {
+    if (type === '-') {
+      return picocolorsExports.red(line);
+    }
+    if (type === '+') {
+      return picocolorsExports.green(line);
+    }
+  }
+  return line;
+}
+function renderDiff(orig, diff) {
+  var nesting = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var lines = [];
+  if (nesting === 0) {
+    lines.push(diffLine('{', 0));
+  }
+  var innerNesting = nesting + 1;
+  var keys = Object.keys(diff).sort();
+  for (var key of keys) {
+    var value = diff[key];
+    if (!(key in orig)) {
+      lines.push(diffLine("".concat(key, ": ...,"), innerNesting, '+'));
+    } else if (typeof value === 'object') {
+      lines.push(diffLine("".concat(key, ": {"), innerNesting));
+      lines.push(renderDiff(orig[key], diff[key], innerNesting));
+      lines.push(diffLine('}', innerNesting));
+    } else {
+      lines.push(diffLine("".concat(key, ": ...,"), innerNesting, '-'));
+    }
+  }
+  if (nesting === 0) {
+    lines.push(diffLine('}', 0));
+  }
+  return lines.join('\n');
+}
+
+var buildPropertyRule = _ref => {
+  var {
+    syntax,
+    inherits,
+    initialValue
+  } = _ref;
+  return _objectSpread2({
+    syntax: "\"".concat(Array.isArray(syntax) ? syntax.join(' | ') : syntax, "\""),
+    inherits: inherits ? 'true' : 'false'
+  }, initialValue != null ? {
+    initialValue
+  } : {});
+};
+function createVar(debugIdOrDeclaration, debugId) {
+  var cssVarName = cssescExports(generateIdentifier({
+    debugId: typeof debugIdOrDeclaration === 'string' ? debugIdOrDeclaration : debugId,
+    debugFileName: false
+  }), {
+    isIdentifier: true
+  });
+  if (debugIdOrDeclaration && typeof debugIdOrDeclaration === 'object') {
+    appendCss({
+      type: 'property',
+      name: "--".concat(cssVarName),
+      rule: buildPropertyRule(debugIdOrDeclaration)
+    }, getFileScope());
+  }
+  return "var(--".concat(cssVarName, ")");
+}
+function assignVars(varContract, tokens) {
+  var varSetters = {};
+  var {
+    valid,
+    diffString
+  } = validateContract(varContract, tokens);
+  if (!valid) {
+    throw new Error("Tokens don't match contract.\n".concat(diffString));
+  }
+  walkObject(tokens, (value, path) => {
+    varSetters[get(varContract, path)] = String(value);
+  });
+  return varSetters;
+}
+function createThemeContract(tokens) {
+  return walkObject(tokens, (_value, path) => {
+    return createVar(path.join('-'));
+  });
+}
+function composedStyle(rules, debugId) {
+  var className = generateIdentifier(debugId);
+  registerClassName(className, getFileScope());
+  var classList = [];
+  var styleRules = [];
+  for (var rule of rules) {
+    if (typeof rule === 'string') {
+      classList.push(rule);
+    } else {
+      styleRules.push(rule);
+    }
+  }
+  var result = className;
+  if (classList.length > 0) {
+    result = "".concat(className, " ").concat(dudupeAndJoinClassList(classList));
+    registerComposition({
+      identifier: className,
+      classList: result
+    }, getFileScope());
+    if (styleRules.length > 0) {
+      // If there are styles attached to this composition then it is
+      // always used and should never be removed
+      markCompositionUsed(className);
+    }
+  }
+  if (styleRules.length > 0) {
+    var _rule = cjsExports.all(styleRules, {
+      // Replace arrays rather than merging
+      arrayMerge: (_, sourceArray) => sourceArray
+    });
+    appendCss({
+      type: 'local',
+      selector: className,
+      rule: _rule
+    }, getFileScope());
+  }
+  return result;
+}
+function style(rule, debugId) {
+  if (Array.isArray(rule)) {
+    return composedStyle(rule, debugId);
+  }
+  var className = generateIdentifier(debugId);
+  registerClassName(className, getFileScope());
+  appendCss({
+    type: 'local',
+    selector: className,
+    rule
+  }, getFileScope());
+  return className;
+}
+
+/**
+ * @deprecated The same functionality is now provided by the 'style' function when you pass it an array
+ */
+function composeStyles() {
+  var compose = hasFileScope() ? composedStyle : dudupeAndJoinClassList;
+  for (var _len = arguments.length, classNames = new Array(_len), _key = 0; _key < _len; _key++) {
+    classNames[_key] = arguments[_key];
+  }
+  return compose(classNames);
+}
+function globalStyle(selector, rule) {
+  appendCss({
+    type: 'global',
+    selector,
+    rule
+  }, getFileScope());
+}
+function keyframes(rule, debugId) {
+  var name = cssescExports(generateIdentifier(debugId), {
+    isIdentifier: true
+  });
+  appendCss({
+    type: 'keyframes',
+    name,
+    rule
+  }, getFileScope());
+  return name;
+}
+function styleVariants() {
+  if (typeof (arguments.length <= 1 ? undefined : arguments[1]) === 'function') {
+    var _data = arguments.length <= 0 ? undefined : arguments[0];
+    var _mapData = arguments.length <= 1 ? undefined : arguments[1];
+    var _debugId = arguments.length <= 2 ? undefined : arguments[2];
+    var _classMap = {};
+    for (var _key2 in _data) {
+      _classMap[_key2] = style(_mapData(_data[_key2], _key2), _debugId ? "".concat(_debugId, "_").concat(_key2) : _key2);
+    }
+    return _classMap;
+  }
+  var styleMap = arguments.length <= 0 ? undefined : arguments[0];
+  var debugId = arguments.length <= 1 ? undefined : arguments[1];
+  var classMap = {};
+  for (var _key3 in styleMap) {
+    classMap[_key3] = style(styleMap[_key3], debugId ? "".concat(debugId, "_").concat(_key3) : _key3);
+  }
+  return classMap;
+}
+
+// createContainer is used for local scoping of CSS containers
+// For now it is mostly just an alias of generateIdentifier
+var createContainer = debugId => generateIdentifier(debugId);
+
+var defaultLayerOptions = {};
+var merge = (obj1, obj2) => _objectSpread2(_objectSpread2({}, obj1), obj2);
+var getLayerArgs = function getLayerArgs() {
+  var options = defaultLayerOptions;
+  var debugId = arguments.length <= 0 ? undefined : arguments[0];
+  if (typeof (arguments.length <= 0 ? undefined : arguments[0]) === 'object') {
+    options = merge(defaultLayerOptions, arguments.length <= 0 ? undefined : arguments[0]);
+    debugId = arguments.length <= 1 ? undefined : arguments[1];
+  }
+  return [options, debugId];
+};
+function globalLayer() {
+  var [options, name] = getLayerArgs(...arguments);
+  if (options.parent) {
+    name = "".concat(options.parent, ".").concat(name);
+  }
+  appendCss({
+    type: 'layer',
+    name
+  }, getFileScope());
+  return name;
+}
+
+export { assignVars, composeStyles, createContainer, createThemeContract, createVar, generateIdentifier, globalLayer, globalStyle, keyframes, style, styleVariants };

package/dist/node_modules/.pnpm/@vanilla-extract_css@1.17.4_babel-plugin-macros@3.1.0/node_modules/@vanilla-extract/css/fileScope/dist/vanilla-extract-css-fileScope.esm.js

@@ -0,0 +1,20 @@
+import { _ as _taggedTemplateLiteral } from '../../dist/taggedTemplateLiteral-10998315.esm.js';
+import dedent from '../../../../../../dedent@1.6.0_babel-plugin-macros@3.1.0/node_modules/dedent/dist/dedent.js';
+
+var _templateObject;
+var refCounter = 0;
+var fileScopes = [];
+function hasFileScope() {
+  return fileScopes.length > 0;
+}
+function getFileScope() {
+  if (fileScopes.length === 0) {
+    throw new Error(dedent(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n        Styles were unable to be assigned to a file. This is generally caused by one of the following:\n\n        - You may have created styles outside of a '.css.ts' context\n        - You may have incorrect configuration. See https://vanilla-extract.style/documentation/getting-started\n      "]))));
+  }
+  return fileScopes[0];
+}
+function getAndIncrementRefCounter() {
+  return refCounter++;
+}
+
+export { getAndIncrementRefCounter, getFileScope, hasFileScope };

package/dist/node_modules/.pnpm/@vanilla-extract_css@1.17.4_babel-plugin-macros@3.1.0/node_modules/@vanilla-extract/css/functionSerializer/dist/vanilla-extract-css-functionSerializer.esm.js

@@ -0,0 +1,11 @@
+function addFunctionSerializer(target, recipe) {
+  // TODO: Update to "__function_serializer__" in future.
+  // __recipe__ is the backwards compatible name
+  Object.defineProperty(target, '__recipe__', {
+    value: recipe,
+    writable: false
+  });
+  return target;
+}
+
+export { addFunctionSerializer };

package/dist/node_modules/.pnpm/@vanilla-extract_css@1.17.4_babel-plugin-macros@3.1.0/node_modules/@vanilla-extract/css/injectStyles/dist/vanilla-extract-css-injectStyles.esm.js

@@ -0,0 +1,22 @@
+var stylesheets = {};
+var injectStyles = _ref => {
+  var {
+    fileScope,
+    css
+  } = _ref;
+  var fileScopeId = fileScope.packageName ? [fileScope.packageName, fileScope.filePath].join('/') : fileScope.filePath;
+  var stylesheet = stylesheets[fileScopeId];
+  if (!stylesheet) {
+    var styleEl = document.createElement('style');
+    if (fileScope.packageName) {
+      styleEl.setAttribute('data-package', fileScope.packageName);
+    }
+    styleEl.setAttribute('data-file', fileScope.filePath);
+    styleEl.setAttribute('type', 'text/css');
+    stylesheet = stylesheets[fileScopeId] = styleEl;
+    document.head.appendChild(styleEl);
+  }
+  stylesheet.innerHTML = css;
+};
+
+export { injectStyles };

package/dist/node_modules/.pnpm/@vanilla-extract_private@1.0.9/node_modules/@vanilla-extract/private/dist/vanilla-extract-private.esm.js

@@ -0,0 +1,37 @@
+function getVarName(variable) {
+  var matches = variable.match(/^var\((.*)\)$/);
+  if (matches) {
+    return matches[1];
+  }
+  return variable;
+}
+
+function get(obj, path) {
+  var result = obj;
+  for (var key of path) {
+    if (!(key in result)) {
+      throw new Error("Path ".concat(path.join(' -> '), " does not exist in object"));
+    }
+    result = result[key];
+  }
+  return result;
+}
+
+function walkObject(obj, fn) {
+  var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var clone = {};
+  for (var key in obj) {
+    var _value = obj[key];
+    var currentPath = [...path, key];
+    if (typeof _value === 'string' || typeof _value === 'number' || _value == null) {
+      clone[key] = fn(_value, currentPath);
+    } else if (typeof _value === 'object' && !Array.isArray(_value)) {
+      clone[key] = walkObject(_value, fn, currentPath);
+    } else {
+      console.warn("Skipping invalid key \"".concat(currentPath.join('.'), "\". Should be a string, number, null or object. Received: \"").concat(Array.isArray(_value) ? 'Array' : typeof _value, "\""));
+    }
+  }
+  return clone;
+}
+
+export { get, getVarName, walkObject };

package/dist/node_modules/.pnpm/@vanilla-extract_recipes@0.5.7_@vanilla-extract_css@1.17.4_babel-plugin-macros@3.1.0_/node_modules/@vanilla-extract/recipes/dist/createRuntimeFn-62c9670f.esm.js

@@ -0,0 +1,111 @@
+function toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : String(i);
+}
+
+function _defineProperty(obj, key, value) {
+  key = toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+
+function mapValues(input, fn) {
+  var result = {};
+  for (var _key in input) {
+    result[_key] = fn(input[_key], _key);
+  }
+  return result;
+}
+
+var shouldApplyCompound = (compoundCheck, selections, defaultVariants) => {
+  for (var key of Object.keys(compoundCheck)) {
+    var _selections$key;
+    if (compoundCheck[key] !== ((_selections$key = selections[key]) !== null && _selections$key !== void 0 ? _selections$key : defaultVariants[key])) {
+      return false;
+    }
+  }
+  return true;
+};
+var createRuntimeFn = config => {
+  var runtimeFn = options => {
+    var className = config.defaultClassName;
+    var selections = _objectSpread2(_objectSpread2({}, config.defaultVariants), options);
+    for (var variantName in selections) {
+      var _selections$variantNa;
+      var variantSelection = (_selections$variantNa = selections[variantName]) !== null && _selections$variantNa !== void 0 ? _selections$variantNa : config.defaultVariants[variantName];
+      if (variantSelection != null) {
+        var selection = variantSelection;
+        if (typeof selection === 'boolean') {
+          // @ts-expect-error
+          selection = selection === true ? 'true' : 'false';
+        }
+        var selectionClassName =
+        // @ts-expect-error
+        config.variantClassNames[variantName][selection];
+        if (selectionClassName) {
+          className += ' ' + selectionClassName;
+        }
+      }
+    }
+    for (var [compoundCheck, compoundClassName] of config.compoundVariants) {
+      if (shouldApplyCompound(compoundCheck, selections, config.defaultVariants)) {
+        className += ' ' + compoundClassName;
+      }
+    }
+    return className;
+  };
+  runtimeFn.variants = () => Object.keys(config.variantClassNames);
+  runtimeFn.classNames = {
+    get base() {
+      return config.defaultClassName.split(' ')[0];
+    },
+    get variants() {
+      return mapValues(config.variantClassNames, classNames => mapValues(classNames, className => className.split(' ')[0]));
+    }
+  };
+  return runtimeFn;
+};
+
+export { createRuntimeFn as c, mapValues as m };

package/dist/node_modules/.pnpm/@vanilla-extract_recipes@0.5.7_@vanilla-extract_css@1.17.4_babel-plugin-macros@3.1.0_/node_modules/@vanilla-extract/recipes/dist/vanilla-extract-recipes.esm.js

@@ -0,0 +1,43 @@
+import { addFunctionSerializer } from '../../../../../@vanilla-extract_css@1.17.4_babel-plugin-macros@3.1.0/node_modules/@vanilla-extract/css/functionSerializer/dist/vanilla-extract-css-functionSerializer.esm.js';
+import { style, styleVariants } from '../../../../../@vanilla-extract_css@1.17.4_babel-plugin-macros@3.1.0/node_modules/@vanilla-extract/css/dist/vanilla-extract-css.esm.js';
+import { m as mapValues, c as createRuntimeFn } from './createRuntimeFn-62c9670f.esm.js';
+
+function recipe(options, debugId) {
+  var {
+    variants = {},
+    defaultVariants = {},
+    compoundVariants = [],
+    base
+  } = options;
+  var defaultClassName;
+  if (!base || typeof base === 'string') {
+    var baseClassName = style({});
+    defaultClassName = base ? "".concat(baseClassName, " ").concat(base) : baseClassName;
+  } else {
+    defaultClassName = style(base, debugId);
+  }
+
+  // @ts-expect-error
+  var variantClassNames = mapValues(variants, (variantGroup, variantGroupName) => styleVariants(variantGroup, styleRule => typeof styleRule === 'string' ? [styleRule] : styleRule, variantGroupName));
+  var compounds = [];
+  for (var {
+    style: theStyle,
+    variants: _variants
+  } of compoundVariants) {
+    compounds.push([_variants, typeof theStyle === 'string' ? theStyle : style(theStyle, "".concat(debugId, "_compound_").concat(compounds.length))]);
+  }
+  var config = {
+    defaultClassName,
+    variantClassNames,
+    defaultVariants,
+    compoundVariants: compounds
+  };
+  return addFunctionSerializer(createRuntimeFn(config), {
+    importPath: '@vanilla-extract/recipes/createRuntimeFn',
+    importName: 'createRuntimeFn',
+    // @ts-expect-error
+    args: [config]
+  });
+}
+
+export { recipe };