@salty-css/core 0.0.1-alpha.30 → 0.0.1-alpha.301

package/define-templates-Deq1aCbN.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class TemplateFactory {
+  constructor(params) {
+    __publicField(this, "_path");
+    this.params = params;
+  }
+  get _current() {
+    return this.params.template;
+  }
+  get isDefineTemplate() {
+    return true;
+  }
+  _setPath(path) {
+    this._path = path;
+    return this;
+  }
+}
+class TemplatesFactory {
+  constructor(params) {
+    __publicField(this, "_path");
+    __publicField(this, "templates", []);
+    this.params = params;
+    Object.entries(params).forEach(([name, template]) => {
+      this.templates.push(
+        new TemplateFactory({
+          name,
+          template
+        })
+      );
+    });
+  }
+  get _current() {
+    return this.params;
+  }
+  get _children() {
+    return Object.fromEntries(
+      this.templates.map((template) => {
+        return [template.params.name, template];
+      })
+    );
+  }
+  get isDefineTemplates() {
+    return true;
+  }
+  _setPath(path) {
+    this._path = path;
+    this.templates.forEach((template) => template._setPath(path));
+    return this;
+  }
+}
+const defineTemplates = (templates) => {
+  return new TemplatesFactory(templates);
+};
+exports.TemplateFactory = TemplateFactory;
+exports.TemplatesFactory = TemplatesFactory;
+exports.defineTemplates = defineTemplates;

package/factories/define-global-styles.d.ts

@@ -0,0 +1,7 @@
+import { GlobalStyles } from '../types/config-types';
+export declare class GlobalStylesFactory {
+    _current: GlobalStyles;
+    constructor(_current: GlobalStyles);
+    get isGlobalDefine(): boolean;
+}
+export declare const defineGlobalStyles: (styles: GlobalStyles) => GlobalStylesFactory;

package/factories/define-media-query.d.ts

@@ -0,0 +1,8 @@
+import { MediaQueryFactory } from '../css/media';
+type MediaDefinitionCallback = (media: MediaQueryFactory) => ReturnType<MediaQueryFactory['next']>;
+export declare const defineMediaQuery: (mediaFactory: MediaDefinitionCallback) => string & {
+    isMedia: boolean;
+    and: MediaQueryFactory;
+    or: MediaQueryFactory;
+};
+export {};

package/factories/define-templates.d.ts

@@ -0,0 +1,27 @@
+import { CssTemplateFunction, CssTemplateObject, CssTemplates } from '../types/config-types';
+export interface TemplateFactoryParams {
+    name: string;
+    template: CssTemplateObject | CssTemplateFunction;
+}
+export declare class TemplateFactory {
+    params: TemplateFactoryParams;
+    _path?: string;
+    constructor(params: TemplateFactoryParams);
+    get _current(): CssTemplateObject | CssTemplateFunction;
+    get isDefineTemplate(): boolean;
+    _setPath(path: string): this;
+}
+export type TemplatesFactoryParams = CssTemplates;
+export declare class TemplatesFactory {
+    params: TemplatesFactoryParams;
+    _path?: string;
+    private templates;
+    constructor(params: TemplatesFactoryParams);
+    get _current(): CssTemplates;
+    get _children(): {
+        [k: string]: TemplateFactory;
+    };
+    get isDefineTemplates(): boolean;
+    _setPath(path: string): this;
+}
+export declare const defineTemplates: (templates: TemplatesFactoryParams) => TemplatesFactory;

package/factories/define-variables.d.ts

@@ -0,0 +1,12 @@
+import { SaltyVariables } from '../types/config-types';
+export declare class VariablesFactory {
+    _current: SaltyVariables;
+    constructor(_current: SaltyVariables);
+    get isDefineVariables(): boolean;
+}
+/**
+   * Base level variables that can be used in all styles as they are applied globally to :root.
+   @param responsive Variables that are defined for different media queries.
+   @param conditional Variables that are defined for different parent selectors (classes or data attributes).
+   */
+export declare const defineVariables: (variables: SaltyVariables) => VariablesFactory;

package/factories/index.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const css_media = require("../css/media.cjs");
+const defineTemplates = require("../define-templates-Deq1aCbN.cjs");
+class GlobalStylesFactory {
+  constructor(_current) {
+    this._current = _current;
+  }
+  get isGlobalDefine() {
+    return true;
+  }
+}
+const defineGlobalStyles = (styles) => {
+  return new GlobalStylesFactory(styles);
+};
+const defineMediaQuery = (mediaFactory) => {
+  return mediaFactory(css_media.media);
+};
+class VariablesFactory {
+  constructor(_current) {
+    this._current = _current;
+  }
+  get isDefineVariables() {
+    return true;
+  }
+}
+const defineVariables = (variables) => {
+  return new VariablesFactory(variables);
+};
+exports.TemplateFactory = defineTemplates.TemplateFactory;
+exports.TemplatesFactory = defineTemplates.TemplatesFactory;
+exports.defineTemplates = defineTemplates.defineTemplates;
+exports.GlobalStylesFactory = GlobalStylesFactory;
+exports.VariablesFactory = VariablesFactory;
+exports.defineGlobalStyles = defineGlobalStyles;
+exports.defineMediaQuery = defineMediaQuery;
+exports.defineVariables = defineVariables;

package/factories/index.d.ts

@@ -0,0 +1,4 @@
+export * from './define-global-styles';
+export * from './define-media-query';
+export * from './define-variables';
+export * from './define-templates';

package/factories/index.js

@@ -0,0 +1,37 @@
+import { media } from "../css/media.js";
+import { T, a, d } from "../define-templates-CVhhgPnd.js";
+class GlobalStylesFactory {
+  constructor(_current) {
+    this._current = _current;
+  }
+  get isGlobalDefine() {
+    return true;
+  }
+}
+const defineGlobalStyles = (styles) => {
+  return new GlobalStylesFactory(styles);
+};
+const defineMediaQuery = (mediaFactory) => {
+  return mediaFactory(media);
+};
+class VariablesFactory {
+  constructor(_current) {
+    this._current = _current;
+  }
+  get isDefineVariables() {
+    return true;
+  }
+}
+const defineVariables = (variables) => {
+  return new VariablesFactory(variables);
+};
+export {
+  GlobalStylesFactory,
+  T as TemplateFactory,
+  a as TemplatesFactory,
+  VariablesFactory,
+  defineGlobalStyles,
+  defineMediaQuery,
+  d as defineTemplates,
+  defineVariables
+};

package/generators/class-name-generator.d.ts

@@ -0,0 +1,6 @@
+import { StylesGenerator } from './styles-generator';
+import { StyledParams } from '../types';
+export declare class ClassNameGenerator<const STYLE_PARAMS extends StyledParams = StyledParams> extends StylesGenerator<STYLE_PARAMS> {
+    _params: STYLE_PARAMS;
+    constructor(_params: STYLE_PARAMS);
+}

package/generators/index.cjs

@@ -0,0 +1,121 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const parseStyles = require("../parse-styles-D-p_guRO.cjs");
+const dashCase = require("../dash-case-Cz8wwE9a.cjs");
+class StylesGenerator {
+  constructor(params) {
+    __publicField(this, "buildContext", {});
+    this.params = params;
+  }
+  get priority() {
+    return 0;
+  }
+  get isRoot() {
+    return this.priority === 0;
+  }
+  get hash() {
+    const { base, variants, compoundVariants, anyOfVariants } = this.params;
+    return dashCase.toHash({ base, variants, compoundVariants, anyOfVariants });
+  }
+  get cssClassName() {
+    return this.hash;
+  }
+  get classNames() {
+    const classNames = /* @__PURE__ */ new Set([this.cssClassName]);
+    const { className } = this.params;
+    if (typeof className == "string") classNames.add(className);
+    if (typeof className == "object") className.forEach((c) => classNames.add(c));
+    this.getTemplateClasses().forEach((c) => classNames.add(c));
+    if (this.buildContext.classNames) this.buildContext.classNames.forEach((c) => classNames.add(c));
+    return [...classNames].join(" ");
+  }
+  get cssFileName() {
+    const { callerName } = this.buildContext;
+    if (callerName) {
+      const dasherized = dashCase.dashCase(callerName);
+      return `cl_${dasherized}-${this.hash}.css`;
+    }
+    return `${this.hash}.css`;
+  }
+  get css() {
+    const { base = {}, variants = {}, compoundVariants = [], anyOfVariants = [] } = this.params;
+    const { config } = this.buildContext;
+    const combinedStyles = { ...base, variants, compoundVariants, anyOfVariants };
+    const css = parseStyles.parseAndJoinStyles(combinedStyles, `.${this.cssClassName}`, config, this.isRoot);
+    return css;
+  }
+  getTemplateClasses(config = this.buildContext.config) {
+    if (!(config == null ? void 0 : config.templates) || !this.params.base || this.priority > 0) return [];
+    const templateKeys = Object.keys(config.templates);
+    return Object.entries(this.params.base).reduce((acc, [key, value]) => {
+      if (templateKeys.includes(key)) acc.push("t_" + dashCase.toHash(dashCase.dashCase(`${key}-${value}`), 4));
+      return acc;
+    }, []);
+  }
+  _withBuildContext(context) {
+    this.buildContext = context;
+    return this;
+  }
+}
+class ClassNameGenerator extends StylesGenerator {
+  constructor(_params) {
+    super(_params);
+    this._params = _params;
+  }
+}
+class StyledGenerator extends StylesGenerator {
+  constructor(tagName, _params) {
+    super(_params);
+    this.tagName = tagName;
+    this._params = _params;
+  }
+  get priority() {
+    var _a;
+    if (this.params.priority) return this.params.priority;
+    if (typeof this.tagName === "function" || typeof this.tagName === "object") {
+      const prev = ((_a = this.tagName.generator) == null ? void 0 : _a.priority) || 0;
+      return prev + 1;
+    }
+    return 0;
+  }
+  get clientProps() {
+    const { element, variants = {}, compoundVariants = [], anyOfVariants = [], defaultVariants = {}, defaultProps = {}, passProps } = this.params;
+    const { callerName, isProduction } = this.buildContext;
+    const variantKeys = /* @__PURE__ */ new Set([]);
+    const addVariantKey = (name) => {
+      const defaultVariant = defaultVariants[name];
+      if (defaultVariant !== void 0) variantKeys.add(`${name}=${String(defaultVariant)}`);
+      else variantKeys.add(name);
+    };
+    Object.keys(variants).forEach(addVariantKey);
+    compoundVariants.map((cv) => Object.keys(cv).forEach(addVariantKey));
+    anyOfVariants.map((cv) => Object.keys(cv).forEach(addVariantKey));
+    const propValueKeys = /* @__PURE__ */ new Set([]);
+    if (this.params.base) {
+      const matches = JSON.stringify(this.params.base).match(/\{-?props\.([^}]+)\}/gi);
+      if (matches) {
+        matches.forEach((match) => {
+          const value = match.replace(/\{(?:-)?props\.([^}]+)\}/gi, "$1");
+          const dashed = dashCase.dashCase(value);
+          if (value) propValueKeys.add(dashed);
+        });
+      }
+    }
+    return {
+      element,
+      hash: this.hash,
+      variantKeys: [...variantKeys],
+      propValueKeys: [...propValueKeys],
+      passProps,
+      defaultProps,
+      attr: {
+        "data-component-name": !isProduction ? callerName : void 0
+      }
+    };
+  }
+}
+exports.ClassNameGenerator = ClassNameGenerator;
+exports.StyledGenerator = StyledGenerator;

package/generators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './class-name-generator';
+export * from './styled-generator';

package/generators/index.js

@@ -0,0 +1,121 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { p as parseAndJoinStyles } from "../parse-styles-CqBQc3eQ.js";
+import { t as toHash, d as dashCase } from "../dash-case-NMk0mXyT.js";
+class StylesGenerator {
+  constructor(params) {
+    __publicField(this, "buildContext", {});
+    this.params = params;
+  }
+  get priority() {
+    return 0;
+  }
+  get isRoot() {
+    return this.priority === 0;
+  }
+  get hash() {
+    const { base, variants, compoundVariants, anyOfVariants } = this.params;
+    return toHash({ base, variants, compoundVariants, anyOfVariants });
+  }
+  get cssClassName() {
+    return this.hash;
+  }
+  get classNames() {
+    const classNames = /* @__PURE__ */ new Set([this.cssClassName]);
+    const { className } = this.params;
+    if (typeof className == "string") classNames.add(className);
+    if (typeof className == "object") className.forEach((c) => classNames.add(c));
+    this.getTemplateClasses().forEach((c) => classNames.add(c));
+    if (this.buildContext.classNames) this.buildContext.classNames.forEach((c) => classNames.add(c));
+    return [...classNames].join(" ");
+  }
+  get cssFileName() {
+    const { callerName } = this.buildContext;
+    if (callerName) {
+      const dasherized = dashCase(callerName);
+      return `cl_${dasherized}-${this.hash}.css`;
+    }
+    return `${this.hash}.css`;
+  }
+  get css() {
+    const { base = {}, variants = {}, compoundVariants = [], anyOfVariants = [] } = this.params;
+    const { config } = this.buildContext;
+    const combinedStyles = { ...base, variants, compoundVariants, anyOfVariants };
+    const css = parseAndJoinStyles(combinedStyles, `.${this.cssClassName}`, config, this.isRoot);
+    return css;
+  }
+  getTemplateClasses(config = this.buildContext.config) {
+    if (!(config == null ? void 0 : config.templates) || !this.params.base || this.priority > 0) return [];
+    const templateKeys = Object.keys(config.templates);
+    return Object.entries(this.params.base).reduce((acc, [key, value]) => {
+      if (templateKeys.includes(key)) acc.push("t_" + toHash(dashCase(`${key}-${value}`), 4));
+      return acc;
+    }, []);
+  }
+  _withBuildContext(context) {
+    this.buildContext = context;
+    return this;
+  }
+}
+class ClassNameGenerator extends StylesGenerator {
+  constructor(_params) {
+    super(_params);
+    this._params = _params;
+  }
+}
+class StyledGenerator extends StylesGenerator {
+  constructor(tagName, _params) {
+    super(_params);
+    this.tagName = tagName;
+    this._params = _params;
+  }
+  get priority() {
+    var _a;
+    if (this.params.priority) return this.params.priority;
+    if (typeof this.tagName === "function" || typeof this.tagName === "object") {
+      const prev = ((_a = this.tagName.generator) == null ? void 0 : _a.priority) || 0;
+      return prev + 1;
+    }
+    return 0;
+  }
+  get clientProps() {
+    const { element, variants = {}, compoundVariants = [], anyOfVariants = [], defaultVariants = {}, defaultProps = {}, passProps } = this.params;
+    const { callerName, isProduction } = this.buildContext;
+    const variantKeys = /* @__PURE__ */ new Set([]);
+    const addVariantKey = (name) => {
+      const defaultVariant = defaultVariants[name];
+      if (defaultVariant !== void 0) variantKeys.add(`${name}=${String(defaultVariant)}`);
+      else variantKeys.add(name);
+    };
+    Object.keys(variants).forEach(addVariantKey);
+    compoundVariants.map((cv) => Object.keys(cv).forEach(addVariantKey));
+    anyOfVariants.map((cv) => Object.keys(cv).forEach(addVariantKey));
+    const propValueKeys = /* @__PURE__ */ new Set([]);
+    if (this.params.base) {
+      const matches = JSON.stringify(this.params.base).match(/\{-?props\.([^}]+)\}/gi);
+      if (matches) {
+        matches.forEach((match) => {
+          const value = match.replace(/\{(?:-)?props\.([^}]+)\}/gi, "$1");
+          const dashed = dashCase(value);
+          if (value) propValueKeys.add(dashed);
+        });
+      }
+    }
+    return {
+      element,
+      hash: this.hash,
+      variantKeys: [...variantKeys],
+      propValueKeys: [...propValueKeys],
+      passProps,
+      defaultProps,
+      attr: {
+        "data-component-name": !isProduction ? callerName : void 0
+      }
+    };
+  }
+}
+export {
+  ClassNameGenerator,
+  StyledGenerator
+};

package/generators/styled-generator.d.ts

@@ -0,0 +1,20 @@
+import { StylesGenerator } from './styles-generator';
+import { StyledParams, Tag } from '../types';
+export interface StyledGeneratorClientProps {
+    element?: string;
+    hash?: string;
+    variantKeys?: string[];
+    propValueKeys?: string[];
+    passProps?: boolean | string | string[];
+    defaultProps?: Record<PropertyKey, unknown>;
+    attr?: {
+        [key: string]: any;
+    };
+}
+export declare class StyledGenerator<const STYLE_PARAMS extends StyledParams = StyledParams> extends StylesGenerator<STYLE_PARAMS> {
+    tagName: Tag<any>;
+    _params: STYLE_PARAMS;
+    constructor(tagName: Tag<any>, _params: STYLE_PARAMS);
+    get priority(): number;
+    get clientProps(): StyledGeneratorClientProps;
+}

package/generators/styles-generator.d.ts

@@ -0,0 +1,22 @@
+import { StyledParams } from '../types';
+import { CachedConfig, SaltyConfig } from '../types/config-types';
+export interface StylesGeneratorBuildTimeProps {
+    callerName?: string;
+    isProduction?: boolean;
+    config?: SaltyConfig & CachedConfig;
+    classNames?: string[];
+}
+export declare class StylesGenerator<const STYLE_PARAMS extends StyledParams = StyledParams> {
+    params: STYLE_PARAMS;
+    buildContext: StylesGeneratorBuildTimeProps;
+    constructor(params: STYLE_PARAMS);
+    get priority(): number;
+    get isRoot(): boolean;
+    get hash(): string;
+    get cssClassName(): string;
+    get classNames(): string;
+    get cssFileName(): string;
+    get css(): Promise<string>;
+    getTemplateClasses(config?: (SaltyConfig & CachedConfig) | undefined): string[];
+    _withBuildContext(context: StylesGeneratorBuildTimeProps): this;
+}

package/helpers/color.d.ts

@@ -0,0 +1,18 @@
+import { CachedConfig } from '../config';
+import { ColorInstance, ColorLike } from 'color';
+declare global {
+    const saltyConfig: CachedConfig;
+}
+type BaseColor = Omit<ColorLike, string> | PropertyValueToken;
+declare class Color {
+    base: BaseColor;
+    isColor: boolean;
+    currentColor: ColorInstance;
+    constructor(base: BaseColor);
+    private _createProxy;
+    private _resolveBaseColor;
+    _handleColorMethod(method: keyof ColorInstance): any;
+    toString(): string;
+}
+export declare const color: (value: BaseColor) => Color & ColorInstance;
+export {};

package/helpers/index.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const colorFunction = require("color");
+const viewportClamp = require("../viewport-clamp-CEmzmcSj.cjs");
+class Color {
+  constructor(base) {
+    __publicField(this, "isColor", true);
+    __publicField(this, "currentColor");
+    this.base = base;
+    const colorValue = this._resolveBaseColor(base);
+    this.currentColor = colorFunction(colorValue);
+    return this._createProxy();
+  }
+  _createProxy() {
+    return new Proxy(this, {
+      get(target, prop) {
+        if (prop in target) return target[prop];
+        if (prop in target.currentColor) return target._handleColorMethod(prop);
+        return target[prop];
+      }
+    });
+  }
+  _resolveBaseColor(base) {
+    if (typeof base !== "string") return base;
+    const isToken = /\{[^{}]+\}/g.test(base);
+    if (!isToken) return base;
+    if (typeof saltyConfig === "undefined") return "transparent";
+    const { staticVariables } = saltyConfig;
+    if (!staticVariables) return "transparent";
+    const tokenPath = base.replace(/^\{|\}$/g, "").split(".");
+    const value = tokenPath.reduce((acc, key) => acc[key], staticVariables);
+    return value;
+  }
+  _handleColorMethod(method) {
+    const color2 = this.currentColor;
+    if (typeof color2[method] !== "function") return color2[method];
+    return (...args) => {
+      this.currentColor = color2[method](...args);
+      return this._createProxy();
+    };
+  }
+  toString() {
+    return this.currentColor.toString();
+  }
+}
+const color = (value) => {
+  return new Color(value);
+};
+exports.defineViewportClamp = viewportClamp.defineViewportClamp;
+exports.color = color;

package/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './color';
+export * from './viewport-clamp';

package/helpers/index.js

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import colorFunction from "color";
+import { d } from "../viewport-clamp-K553uXu3.js";
+class Color {
+  constructor(base) {
+    __publicField(this, "isColor", true);
+    __publicField(this, "currentColor");
+    this.base = base;
+    const colorValue = this._resolveBaseColor(base);
+    this.currentColor = colorFunction(colorValue);
+    return this._createProxy();
+  }
+  _createProxy() {
+    return new Proxy(this, {
+      get(target, prop) {
+        if (prop in target) return target[prop];
+        if (prop in target.currentColor) return target._handleColorMethod(prop);
+        return target[prop];
+      }
+    });
+  }
+  _resolveBaseColor(base) {
+    if (typeof base !== "string") return base;
+    const isToken = /\{[^{}]+\}/g.test(base);
+    if (!isToken) return base;
+    if (typeof saltyConfig === "undefined") return "transparent";
+    const { staticVariables } = saltyConfig;
+    if (!staticVariables) return "transparent";
+    const tokenPath = base.replace(/^\{|\}$/g, "").split(".");
+    const value = tokenPath.reduce((acc, key) => acc[key], staticVariables);
+    return value;
+  }
+  _handleColorMethod(method) {
+    const color2 = this.currentColor;
+    if (typeof color2[method] !== "function") return color2[method];
+    return (...args) => {
+      this.currentColor = color2[method](...args);
+      return this._createProxy();
+    };
+  }
+  toString() {
+    return this.currentColor.toString();
+  }
+}
+const color = (value) => {
+  return new Color(value);
+};
+export {
+  color,
+  d as defineViewportClamp
+};

package/helpers/viewport-clamp.d.ts

@@ -0,0 +1,9 @@
+interface ViewportClampConfig {
+    screenSize: number;
+    axis?: 'vertical' | 'horizontal';
+    minMultiplier?: number;
+    maxMultiplier?: number;
+    minMaxUnit?: string;
+}
+export declare const defineViewportClamp: (config: ViewportClampConfig) => (value: number, min?: number | undefined, max?: number | undefined) => string;
+export {};

package/helpers-DM2fbDDz.js

@@ -0,0 +1,18 @@
+import { join } from "path";
+const getCorePackageRoot = () => {
+  let { pathname } = new URL(import.meta.url);
+  while (/core\/?(src\/)?$/.test(pathname) === false) {
+    pathname = join(pathname, "../");
+  }
+  return pathname;
+};
+const resolveExportValue = async (value, maxLevel = 10, _level = 0) => {
+  if (_level >= maxLevel) return value;
+  if (value instanceof Promise) return await resolveExportValue(await value, _level + 1, maxLevel);
+  if (typeof value === "function" && "_shouldResolve" in value) return await resolveExportValue(await value(), _level + 1, maxLevel);
+  return value;
+};
+export {
+  getCorePackageRoot as g,
+  resolveExportValue as r
+};