tailwindcss-patch 1.2.6 → 2.0.0-alpha.0

package/dist/index.cjs

@@ -0,0 +1,539 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs');
+const fs$1 = require('node:fs/promises');
+const pkg = require('resolve');
+const semver = require('semver');
+const t = require('@babel/types');
+const generate = require('@babel/generator');
+const traverse = require('@babel/traverse');
+const parser = require('@babel/parser');
+const postcss = require('postcss');
+const postcssrc = require('postcss-load-config');
+const c12 = require('c12');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
+const pkg__default = /*#__PURE__*/_interopDefaultCompat(pkg);
+const t__namespace = /*#__PURE__*/_interopNamespaceCompat(t);
+const generate__default = /*#__PURE__*/_interopDefaultCompat(generate);
+const traverse__default = /*#__PURE__*/_interopDefaultCompat(traverse);
+const postcss__default = /*#__PURE__*/_interopDefaultCompat(postcss);
+const postcssrc__default = /*#__PURE__*/_interopDefaultCompat(postcssrc);
+
+const { sync } = pkg__default;
+function ensureFileContent(filepaths) {
+  if (typeof filepaths === "string") {
+    filepaths = [filepaths];
+  }
+  let content;
+  for (const filepath of filepaths) {
+    if (fs__default.existsSync(filepath)) {
+      content = fs__default.readFileSync(filepath, {
+        encoding: "utf8"
+      });
+      break;
+    }
+  }
+  return content;
+}
+function requireResolve(id, opts) {
+  return sync(id, opts);
+}
+async function ensureDir(p) {
+  try {
+    await fs__default$1.access(p);
+  } catch {
+    await fs__default$1.mkdir(p, {
+      recursive: true
+    });
+  }
+}
+
+function getTailwindcssEntry(basedir = process.cwd()) {
+  return requireResolve("tailwindcss");
+}
+function getContexts(basedir) {
+  const twPath = getTailwindcssEntry(basedir);
+  const distPath = path__default.dirname(twPath);
+  let injectFilePath = path__default.join(distPath, "plugin.js");
+  if (!fs__default.existsSync(injectFilePath)) {
+    injectFilePath = path__default.join(distPath, "index.js");
+  }
+  const mo = require(injectFilePath);
+  if (mo.contextRef) {
+    return mo.contextRef.value;
+  }
+  return [];
+}
+function getClassCaches(basedir) {
+  const contexts = getContexts(basedir);
+  return contexts.map((x) => x.classCache);
+}
+function getClassCacheSet(basedir) {
+  const classCaches = getClassCaches(basedir);
+  const classSet = /* @__PURE__ */ new Set();
+  for (const classCacheMap of classCaches) {
+    const keys = classCacheMap.keys();
+    for (const key of keys) {
+      classSet.add(key.toString());
+    }
+  }
+  return classSet;
+}
+
+const pkgName = "tailwindcss-patch";
+
+function log(message, ...optionalParams) {
+  return console.log(`[${pkgName}]:` + message, ...optionalParams);
+}
+
+function getCacheOptions(options) {
+  let cache;
+  switch (typeof options) {
+    case "undefined": {
+      cache = {
+        enable: false
+      };
+      break;
+    }
+    case "boolean": {
+      cache = {
+        enable: options
+      };
+      break;
+    }
+    case "object": {
+      cache = { ...options, enable: true };
+      break;
+    }
+  }
+  return cache;
+}
+class CacheManager {
+  constructor(options = {}) {
+    this.options = this.getOptions(options);
+  }
+  mkdir(cacheDirectory) {
+    const exists = fs__default.existsSync(cacheDirectory);
+    if (!exists) {
+      fs__default.mkdirSync(cacheDirectory, {
+        recursive: true
+      });
+    }
+    return cacheDirectory;
+  }
+  getOptions(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const dir = options.dir ?? path__default.resolve(cwd, "node_modules/.cache", pkgName);
+    const file = options.file ?? "index.json";
+    const filename = path__default.resolve(dir, file);
+    return {
+      cwd,
+      dir,
+      file,
+      filename,
+      strategy: "merge"
+    };
+  }
+  write(data) {
+    try {
+      const { dir, filename } = this.options;
+      this.mkdir(dir);
+      fs__default.writeFileSync(filename, JSON.stringify([...data], void 0, 2), "utf8");
+      return filename;
+    } catch {
+      log("write cache file fail!");
+    }
+  }
+  read() {
+    const { filename } = this.options;
+    try {
+      if (fs__default.existsSync(filename)) {
+        const data = fs__default.readFileSync(filename, "utf8");
+        return new Set(JSON.parse(data));
+      }
+    } catch {
+      log("parse cache content fail! path:" + filename);
+      try {
+        fs__default.unlinkSync(filename);
+      } catch {
+        log("delete cache file fail! path:" + filename);
+      }
+    }
+  }
+}
+
+function inspectProcessTailwindFeaturesReturnContext(content) {
+  const ast = parser.parse(content);
+  let hasPatched = false;
+  traverse__default(ast, {
+    FunctionDeclaration(p) {
+      const n = p.node;
+      if (n.id?.name === "processTailwindFeatures" && n.body.body.length === 1 && t__namespace.isReturnStatement(n.body.body[0])) {
+        const rts = n.body.body[0];
+        if (t__namespace.isFunctionExpression(rts.argument)) {
+          const body = rts.argument.body.body;
+          const lastStatement = body.at(-1);
+          hasPatched = t__namespace.isReturnStatement(lastStatement) && t__namespace.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context";
+          if (!hasPatched) {
+            const rts2 = t__namespace.returnStatement(t__namespace.identifier("context"));
+            body.push(rts2);
+          }
+        }
+      }
+    }
+  });
+  return {
+    code: hasPatched ? content : generate__default(ast).code,
+    hasPatched
+  };
+}
+function inspectPostcssPlugin(content) {
+  const ast = parser.parse(content);
+  const exportKey = "contextRef";
+  const variableName = "contextRef";
+  const valueKey = "value";
+  let hasPatched = false;
+  traverse__default(ast, {
+    Program(p) {
+      const n = p.node;
+      const idx = n.body.findIndex((x) => {
+        return t__namespace.isExpressionStatement(x) && t__namespace.isAssignmentExpression(x.expression) && t__namespace.isMemberExpression(x.expression.left) && t__namespace.isFunctionExpression(x.expression.right) && x.expression.right.id?.name === "tailwindcss";
+      });
+      if (idx > -1) {
+        const prevStatement = n.body[idx - 1];
+        const lastStatement = n.body.at(-1);
+        const hasPatchedCondition0 = prevStatement && t__namespace.isVariableDeclaration(prevStatement) && prevStatement.declarations.length === 1 && t__namespace.isIdentifier(prevStatement.declarations[0].id) && prevStatement.declarations[0].id.name === variableName;
+        const hasPatchedCondition1 = t__namespace.isExpressionStatement(lastStatement) && t__namespace.isAssignmentExpression(lastStatement.expression) && t__namespace.isIdentifier(lastStatement.expression.right) && lastStatement.expression.right.name === variableName;
+        hasPatched = hasPatchedCondition0 || hasPatchedCondition1;
+        if (!hasPatched) {
+          const statement = t__namespace.variableDeclaration("const", [
+            t__namespace.variableDeclarator(t__namespace.identifier(variableName), t__namespace.objectExpression([t__namespace.objectProperty(t__namespace.identifier(valueKey), t__namespace.arrayExpression())]))
+          ]);
+          n.body.splice(idx, 0, statement);
+          n.body.push(
+            t__namespace.expressionStatement(
+              t__namespace.assignmentExpression(
+                "=",
+                t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier("module"), t__namespace.identifier("exports")), t__namespace.identifier(exportKey)),
+                t__namespace.identifier(variableName)
+              )
+            )
+          );
+        }
+      }
+    },
+    FunctionExpression(p) {
+      if (hasPatched) {
+        return;
+      }
+      const n = p.node;
+      if (n.id?.name === "tailwindcss" && n.body.body.length === 1 && t__namespace.isReturnStatement(n.body.body[0])) {
+        const returnStatement = n.body.body[0];
+        if (t__namespace.isObjectExpression(returnStatement.argument) && returnStatement.argument.properties.length === 2) {
+          const properties = returnStatement.argument.properties;
+          if (t__namespace.isObjectProperty(properties[0]) && t__namespace.isObjectProperty(properties[1])) {
+            const keyMatched = t__namespace.isIdentifier(properties[0].key) && properties[0].key.name === "postcssPlugin";
+            const pluginsMatched = t__namespace.isIdentifier(properties[1].key) && properties[1].key.name === "plugins";
+            if (pluginsMatched && keyMatched && t__namespace.isCallExpression(properties[1].value) && t__namespace.isMemberExpression(properties[1].value.callee) && t__namespace.isArrayExpression(properties[1].value.callee.object)) {
+              const pluginsCode = properties[1].value.callee.object.elements;
+              if (pluginsCode[1] && t__namespace.isFunctionExpression(pluginsCode[1])) {
+                const targetBlockStatement = pluginsCode[1].body;
+                const lastStatement = targetBlockStatement.body.at(-1);
+                if (t__namespace.isExpressionStatement(lastStatement)) {
+                  const newExpressionStatement = t__namespace.expressionStatement(
+                    t__namespace.callExpression(
+                      t__namespace.memberExpression(
+                        t__namespace.memberExpression(t__namespace.identifier(variableName), t__namespace.identifier("value")),
+                        t__namespace.identifier("push")
+                      ),
+                      [lastStatement.expression]
+                    )
+                  );
+                  targetBlockStatement.body[targetBlockStatement.body.length - 1] = newExpressionStatement;
+                }
+                const ifIdx = targetBlockStatement.body.findIndex((x) => t__namespace.isIfStatement(x));
+                if (ifIdx > -1) {
+                  const ifRoot = targetBlockStatement.body[ifIdx];
+                  if (t__namespace.isBlockStatement(ifRoot.consequent) && ifRoot.consequent.body[1] && t__namespace.isForOfStatement(ifRoot.consequent.body[1])) {
+                    const forOf = ifRoot.consequent.body[1];
+                    if (t__namespace.isBlockStatement(forOf.body) && forOf.body.body.length === 1 && t__namespace.isIfStatement(forOf.body.body[0])) {
+                      const if2 = forOf.body.body[0];
+                      if (t__namespace.isBlockStatement(if2.consequent) && if2.consequent.body.length === 1 && t__namespace.isExpressionStatement(if2.consequent.body[0])) {
+                        const target = if2.consequent.body[0];
+                        const newExpressionStatement = t__namespace.expressionStatement(
+                          t__namespace.callExpression(t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier(variableName), t__namespace.identifier("value")), t__namespace.identifier("push")), [target.expression])
+                        );
+                        if2.consequent.body[0] = newExpressionStatement;
+                      }
+                    }
+                  }
+                }
+                targetBlockStatement.body.unshift(
+                  // contentRef.value = []
+                  // t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(variableName), t.identifier(valueKey)), t.arrayExpression()))
+                  // contentRef.value.length = 0
+                  t__namespace.expressionStatement(
+                    t__namespace.assignmentExpression(
+                      "=",
+                      t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier(variableName), t__namespace.identifier(valueKey)), t__namespace.identifier("length")),
+                      t__namespace.numericLiteral(0)
+                    )
+                  )
+                );
+              }
+            }
+          }
+        }
+      }
+    }
+    // BlockStatement(p) {
+    //   const n = p.node
+    //   if (start && p.parent.type === 'FunctionExpression' && !p.parent.id) {
+    //     n.body.unshift(t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(variableName), t.identifier(valueKey)), t.arrayExpression())))
+    //   }
+    // }
+  });
+  return {
+    code: hasPatched ? content : generate__default(ast).code,
+    hasPatched
+  };
+}
+
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isObject(value) && isObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+const defu = createDefu();
+
+const defaultOptions = {
+  overwrite: true
+};
+
+function getInstalledPkgJsonPath(options = {}) {
+  try {
+    const tmpJsonPath = requireResolve(`tailwindcss/package.json`, {
+      paths: options.paths
+    });
+    return tmpJsonPath;
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND") {
+      console.warn("Can't find npm pkg: `tailwindcss`, Please ensure it has been installed!");
+    }
+  }
+}
+function getPatchOptions(options = {}) {
+  return defu(
+    options,
+    {
+      basedir: process.cwd()
+    },
+    defaultOptions
+  );
+}
+function createPatch(opt) {
+  return () => {
+    try {
+      const pkgJsonPath = getInstalledPkgJsonPath(opt);
+      return internalPatch(pkgJsonPath, opt);
+    } catch (error) {
+      console.warn(`patch tailwindcss failed:` + error.message);
+    }
+  };
+}
+function monkeyPatchForExposingContext(twDir, opt) {
+  const processTailwindFeaturesFilePath = path__default.resolve(twDir, "lib/processTailwindFeatures.js");
+  const processTailwindFeaturesContent = ensureFileContent(processTailwindFeaturesFilePath);
+  const result = {};
+  if (processTailwindFeaturesContent) {
+    const { code, hasPatched } = inspectProcessTailwindFeaturesReturnContext(processTailwindFeaturesContent);
+    if (!hasPatched && opt.overwrite) {
+      fs__default.writeFileSync(processTailwindFeaturesFilePath, code, {
+        encoding: "utf8"
+      });
+      console.log("patch tailwindcss processTailwindFeatures for return content successfully!");
+    }
+    result.processTailwindFeatures = code;
+  }
+  const pluginFilePath = path__default.resolve(twDir, "lib/plugin.js");
+  const indexFilePath = path__default.resolve(twDir, "lib/index.js");
+  const pluginContent = ensureFileContent([pluginFilePath, indexFilePath]);
+  if (pluginContent) {
+    const { code, hasPatched } = inspectPostcssPlugin(pluginContent);
+    if (!hasPatched && opt.overwrite) {
+      fs__default.writeFileSync(pluginFilePath, code, {
+        encoding: "utf8"
+      });
+      console.log("patch tailwindcss for expose runtime content successfully!");
+    }
+    result.plugin = code;
+  }
+  opt.custom && typeof opt.custom === "function" && opt.custom(twDir, result);
+  return result;
+}
+function internalPatch(pkgJsonPath, options) {
+  if (pkgJsonPath) {
+    const pkgJson = require(pkgJsonPath);
+    const twDir = path__default.dirname(pkgJsonPath);
+    if (semver.gte(pkgJson.version, "3.0.0")) {
+      options.version = pkgJson.version;
+      const result = monkeyPatchForExposingContext(twDir, options);
+      return result;
+    }
+  }
+}
+
+async function getCss(p) {
+  const { options, plugins } = await postcssrc__default(void 0, p);
+  const res = await postcss__default(plugins).process("@tailwind base;@tailwind components;@tailwind utilities;", {
+    from: void 0,
+    ...options
+  });
+  return res;
+}
+
+class TailwindcssPatcher {
+  constructor(options = {}) {
+    this.rawOptions = options;
+    this.cacheOptions = getCacheOptions(options.cache);
+    this.patchOptions = getPatchOptions(options.patch);
+    this.patch = createPatch(this.patchOptions);
+    this.cacheManager = new CacheManager(this.cacheOptions);
+  }
+  getPkgEntry(basedir) {
+    return getTailwindcssEntry(basedir);
+  }
+  setCache(set) {
+    if (this.cacheOptions.enable) {
+      return this.cacheManager.write(set);
+    }
+  }
+  getCache() {
+    return this.cacheManager.read();
+  }
+  /**
+   * @description 在多个 tailwindcss 上下文时，这个方法将被执行多次，所以策略上应该使用 append
+   * 详见 taro weapp-tailwindcss 独立分包
+   * @param basedir
+   * @returns
+   */
+  getClassSet(options = {
+    cacheStrategy: this.cacheOptions.strategy ?? "merge"
+  }) {
+    const { basedir, cacheStrategy } = options;
+    const set = getClassCacheSet(basedir);
+    if (cacheStrategy === "overwrite") {
+      set.size > 0 && this.setCache(set);
+    } else if (cacheStrategy === "merge") {
+      const cacheSet = this.getCache();
+      if (cacheSet) {
+        for (const x of cacheSet) {
+          set.add(x);
+        }
+      }
+      this.setCache(set);
+    }
+    return set;
+  }
+  getContexts(basedir) {
+    return getContexts(basedir);
+  }
+  async extract(options) {
+    const { configDir, filename, loose } = options;
+    await getCss(configDir);
+    const set = this.getClassSet();
+    await ensureDir(path.dirname(filename));
+    const classList = [...set];
+    await fs__default$1.writeFile(filename, JSON.stringify(classList, null, loose ? 2 : void 0), "utf8");
+    return classList;
+  }
+}
+
+function getConfig() {
+  return c12.loadConfig({
+    name: "tailwindcss-patch",
+    defaults: {
+      output: {
+        filename: ".tw-patch/tw-class-list.json"
+      },
+      postcss: {
+        configDir: process.cwd(),
+        loose: true
+      }
+    }
+  });
+}
+const defineConfig = c12.createDefineConfig();
+
+exports.CacheManager = CacheManager;
+exports.TailwindcssPatcher = TailwindcssPatcher;
+exports.createPatch = createPatch;
+exports.defineConfig = defineConfig;
+exports.ensureDir = ensureDir;
+exports.ensureFileContent = ensureFileContent;
+exports.getCacheOptions = getCacheOptions;
+exports.getClassCacheSet = getClassCacheSet;
+exports.getClassCaches = getClassCaches;
+exports.getConfig = getConfig;
+exports.getContexts = getContexts;
+exports.getInstalledPkgJsonPath = getInstalledPkgJsonPath;
+exports.getPatchOptions = getPatchOptions;
+exports.getTailwindcssEntry = getTailwindcssEntry;
+exports.inspectPostcssPlugin = inspectPostcssPlugin;
+exports.inspectProcessTailwindFeaturesReturnContext = inspectProcessTailwindFeaturesReturnContext;
+exports.internalPatch = internalPatch;
+exports.monkeyPatchForExposingContext = monkeyPatchForExposingContext;
+exports.requireResolve = requireResolve;

package/dist/index.d.ts

@@ -0,0 +1,159 @@
+import { Rule, Node } from 'postcss';
+import { Config } from 'tailwindcss';
+import * as c12 from 'c12';
+import { SyncOpts } from 'resolve';
+
+type CacheStrategy = 'merge' | 'overwrite';
+interface CacheOptions {
+    dir?: string;
+    cwd?: string;
+    file?: string;
+    strategy?: CacheStrategy;
+}
+type InternalCacheOptions = CacheOptions & {
+    enable?: boolean;
+};
+interface PatchOptions {
+    overwrite?: boolean;
+    paths?: string[];
+    basedir?: string;
+    custom?: (dir: string, ctx: Record<string, any>) => void;
+}
+interface InternalPatchOptions {
+    overwrite: boolean;
+    paths?: string[];
+    basedir?: string;
+    custom?: (dir: string, ctx: Record<string, any>) => void;
+    version?: string;
+}
+interface TailwindcssPatcherOptions {
+    cache?: CacheOptions | boolean;
+    patch?: PatchOptions;
+}
+type TailwindcssClassCache = Map<string, ({
+    layer: string;
+    options: Record<string, any>;
+    sort: Record<string, any>;
+} | Rule)[]>;
+type TailwindcssRuntimeContext = {
+    applyClassCache: Map<any, any>;
+    candidateRuleCache: Map<string | String, Set<[
+        {
+            arbitrary: any;
+            index: any;
+            layer: string;
+            options: any[];
+            parallelIndex: any;
+            parentLayer: string;
+            variants: any;
+        },
+        Node
+    ]>>;
+    candidateRuleMap: Map<string | String, [object, Node][]>;
+    changedContent: any[];
+    classCache: TailwindcssClassCache;
+    disposables: any[];
+    getClassList: Function;
+    getClassOrder: Function;
+    getVariants: Function;
+    markInvalidUtilityCandidate: Function;
+    markInvalidUtilityNode: Function;
+    notClassCache: Set<String>;
+    offsets: {
+        layerPositions: object;
+        offsets: object;
+        reservedVariantBits: any;
+        variantOffsets: Map<string, any>;
+    };
+    postCssNodeCache: Map<object, [Node]>;
+    ruleCache: Set<[object, Node]>;
+    stylesheetCache: Record<string, Set<any>>;
+    tailwindConfig: Config;
+    userConfigPath: string | null;
+    variantMap: Map<string, [[object, Function]]>;
+    variantOptions: Map<string, object>;
+};
+interface UserConfig {
+    output?: {
+        filename?: string;
+    };
+    postcss?: {
+        configDir?: string;
+        loose?: boolean;
+    };
+    tailwindcss?: {};
+}
+
+declare function getCacheOptions(options?: CacheOptions | boolean): InternalCacheOptions;
+declare class CacheManager {
+    options: Required<CacheOptions> & {
+        filename: string;
+    };
+    constructor(options?: CacheOptions);
+    mkdir(cacheDirectory: string): string;
+    getOptions(options?: CacheOptions): Required<CacheOptions> & {
+        filename: string;
+    };
+    write(data: Set<string>): string | undefined;
+    read(): Set<string> | undefined;
+}
+
+declare class TailwindcssPatcher {
+    rawOptions: TailwindcssPatcherOptions;
+    cacheOptions: InternalCacheOptions;
+    patchOptions: InternalPatchOptions;
+    patch: () => void;
+    cacheManager: CacheManager;
+    constructor(options?: TailwindcssPatcherOptions);
+    getPkgEntry(basedir?: string): string;
+    setCache(set: Set<string>): string | undefined;
+    getCache(): Set<string> | undefined;
+    /**
+     * @description 在多个 tailwindcss 上下文时，这个方法将被执行多次，所以策略上应该使用 append
+     * 详见 taro weapp-tailwindcss 独立分包
+     * @param basedir
+     * @returns
+     */
+    getClassSet(options?: {
+        basedir?: string;
+        cacheStrategy?: CacheStrategy;
+    }): Set<string>;
+    getContexts(basedir?: string): TailwindcssRuntimeContext[];
+    extract(options: {
+        configDir: string;
+        filename: string;
+        loose: boolean;
+    }): Promise<string[]>;
+}
+
+declare function getTailwindcssEntry(basedir?: string): string;
+declare function getContexts(basedir?: string): TailwindcssRuntimeContext[];
+declare function getClassCaches(basedir?: string): TailwindcssClassCache[];
+declare function getClassCacheSet(basedir?: string): Set<string>;
+
+declare function inspectProcessTailwindFeaturesReturnContext(content: string): {
+    code: string;
+    hasPatched: boolean;
+};
+declare function inspectPostcssPlugin(content: string): {
+    code: string;
+    hasPatched: boolean;
+};
+
+declare function getInstalledPkgJsonPath(options?: PatchOptions): string | undefined;
+declare function getPatchOptions(options?: PatchOptions): InternalPatchOptions;
+declare function createPatch(opt: InternalPatchOptions): () => any;
+declare function monkeyPatchForExposingContext(twDir: string, opt: InternalPatchOptions): {
+    processTailwindFeatures?: string | undefined;
+    plugin?: string | undefined;
+} & Record<string, any>;
+declare function internalPatch(pkgJsonPath: string | undefined, options: InternalPatchOptions): any | undefined;
+
+declare function getConfig(): Promise<c12.ResolvedConfig<UserConfig, c12.ConfigLayerMeta>>;
+declare const defineConfig: c12.DefineConfig<UserConfig, c12.ConfigLayerMeta>;
+
+declare function ensureFileContent(filepaths: string | string[]): string | undefined;
+declare function requireResolve(id: string, opts?: SyncOpts): string;
+declare function ensureDir(p: string): Promise<void>;
+
+export { CacheManager, CacheOptions, CacheStrategy, InternalCacheOptions, InternalPatchOptions, PatchOptions, TailwindcssClassCache, TailwindcssPatcher, TailwindcssPatcherOptions, TailwindcssRuntimeContext, UserConfig, createPatch, defineConfig, ensureDir, ensureFileContent, getCacheOptions, getClassCacheSet, getClassCaches, getConfig, getContexts, getInstalledPkgJsonPath, getPatchOptions, getTailwindcssEntry, inspectPostcssPlugin, inspectProcessTailwindFeaturesReturnContext, internalPatch, monkeyPatchForExposingContext, requireResolve };