tailwindcss-patch 1.2.7 → 2.0.0-alpha.0

package/dist/index.js

@@ -1,191 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var path = require('node:path');
-var fs = require('node:fs');
-var patcher = require('./patcher-a07f477f.js');
-require('semver');
-require('@babel/types');
-require('@babel/generator');
-require('@babel/traverse');
-require('@babel/parser');
-require('resolve');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var path__default = /*#__PURE__*/_interopDefaultCompat(path);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-
-function getTailwindcssEntry(basedir = process.cwd()) {
-    return patcher.requireResolve('tailwindcss');
-}
-function getContexts(basedir) {
-    const twPath = getTailwindcssEntry(basedir);
-    const distPath = path__default["default"].dirname(twPath);
-    let injectFilePath = path__default["default"].join(distPath, 'plugin.js');
-    if (!fs__default["default"].existsSync(injectFilePath)) {
-        injectFilePath = path__default["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 = 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 mkCacheDirectory(cacheDirectory) {
-    const exists = fs__default["default"].existsSync(cacheDirectory);
-    if (!exists) {
-        fs__default["default"].mkdirSync(cacheDirectory, {
-            recursive: true
-        });
-    }
-    return cacheDirectory;
-}
-function getCacheOptions$1(options = {}) {
-    var _a, _b, _c;
-    const cwd = (_a = options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
-    const dir = (_b = options.dir) !== null && _b !== void 0 ? _b : path__default["default"].resolve(cwd, 'node_modules/.cache', pkgName);
-    const file = (_c = options.file) !== null && _c !== void 0 ? _c : 'index.json';
-    const filename = path__default["default"].resolve(dir, file);
-    return {
-        cwd,
-        dir,
-        file,
-        filename,
-        strategy: 'merge'
-    };
-}
-function writeCache(data, options = {}) {
-    try {
-        const { dir, filename } = getCacheOptions$1(options);
-        mkCacheDirectory(dir);
-        fs__default["default"].writeFileSync(filename, JSON.stringify([...data], undefined, 2), 'utf8');
-        return filename;
-    }
-    catch (_a) {
-        log('write cache file fail!');
-    }
-}
-function readCache(options = {}) {
-    const { filename } = getCacheOptions$1(options);
-    try {
-        if (fs__default["default"].existsSync(filename)) {
-            const data = fs__default["default"].readFileSync(filename, 'utf8');
-            return new Set(JSON.parse(data));
-        }
-    }
-    catch (_a) {
-        log('parse cache content fail! path:' + filename);
-        try {
-            fs__default["default"].unlinkSync(filename);
-        }
-        catch (_b) {
-            log('delete cache file fail! path:' + filename);
-        }
-    }
-}
-
-function getCacheOptions(options) {
-    let cache;
-    switch (typeof options) {
-        case 'undefined': {
-            cache = {
-                enable: false
-            };
-            break;
-        }
-        case 'boolean': {
-            cache = {
-                enable: options
-            };
-            break;
-        }
-        case 'object': {
-            cache = Object.assign(Object.assign({}, options), { enable: true });
-            break;
-        }
-    }
-    return cache;
-}
-class TailwindcssPatcher {
-    constructor(options = {}) {
-        this.rawOptions = options;
-        this.cacheOptions = getCacheOptions(options.cache);
-        this.patchOptions = patcher.getPatchOptions(options.patch);
-        this.patch = patcher.createPatch(this.patchOptions);
-    }
-    getPkgEntry(basedir) {
-        return getTailwindcssEntry(basedir);
-    }
-    setCache(set) {
-        if (this.cacheOptions.enable) {
-            return writeCache(set, this.cacheOptions);
-        }
-    }
-    getCache() {
-        return readCache(this.cacheOptions);
-    }
-    getClassSet(options) {
-        var _a;
-        if (options === void 0) { options = {
-            cacheStrategy: (_a = this.cacheOptions.strategy) !== null && _a !== void 0 ? _a : '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);
-    }
-}
-
-exports.createPatch = patcher.createPatch;
-exports.ensureFileContent = patcher.ensureFileContent;
-exports.getInstalledPkgJsonPath = patcher.getInstalledPkgJsonPath;
-exports.getPatchOptions = patcher.getPatchOptions;
-exports.inspectPostcssPlugin = patcher.inspectPostcssPlugin;
-exports.inspectProcessTailwindFeaturesReturnContext = patcher.inspectProcessTailwindFeaturesReturnContext;
-exports.internalPatch = patcher.internalPatch;
-exports.monkeyPatchForExposingContext = patcher.monkeyPatchForExposingContext;
-exports.requireResolve = patcher.requireResolve;
-exports.TailwindcssPatcher = TailwindcssPatcher;
-exports.getCacheOptions = getCacheOptions;
-exports.getClassCacheSet = getClassCacheSet;
-exports.getClassCaches = getClassCaches;
-exports.getContexts = getContexts;
-exports.getTailwindcssEntry = getTailwindcssEntry;

package/dist/patcher-a07f477f.js

@@ -1,302 +0,0 @@
-'use strict';
-
-var path = require('node:path');
-var fs = require('node:fs');
-var semver = require('semver');
-var t = require('@babel/types');
-var generate = require('@babel/generator');
-var traverse = require('@babel/traverse');
-var parser = require('@babel/parser');
-var resolve = require('resolve');
-
-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;
-    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 path__default = /*#__PURE__*/_interopDefaultCompat(path);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var t__namespace = /*#__PURE__*/_interopNamespaceCompat(t);
-var generate__default = /*#__PURE__*/_interopDefaultCompat(generate);
-var traverse__default = /*#__PURE__*/_interopDefaultCompat(traverse);
-
-function ensureFileContent(filepaths) {
-    if (typeof filepaths === 'string') {
-        filepaths = [filepaths];
-    }
-    let content;
-    for (const filepath of filepaths) {
-        if (fs__default["default"].existsSync(filepath)) {
-            content = fs__default["default"].readFileSync(filepath, {
-                encoding: 'utf8'
-            });
-            break;
-        }
-    }
-    return content;
-}
-function requireResolve(id, opts) {
-    return resolve.sync(id, opts);
-}
-
-function inspectProcessTailwindFeaturesReturnContext(content) {
-    const ast = parser.parse(content);
-    let hasPatched = false;
-    traverse__default["default"](ast, {
-        FunctionDeclaration(p) {
-            var _a;
-            const n = p.node;
-            if (((_a = n.id) === null || _a === void 0 ? void 0 : _a.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 rts = t__namespace.returnStatement(t__namespace.identifier('context'));
-                        body.push(rts);
-                    }
-                }
-            }
-        }
-    });
-    return {
-        code: hasPatched ? content : generate__default["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["default"](ast, {
-        Program(p) {
-            const n = p.node;
-            const idx = n.body.findIndex((x) => {
-                var _a;
-                return (t__namespace.isExpressionStatement(x) &&
-                    t__namespace.isAssignmentExpression(x.expression) &&
-                    t__namespace.isMemberExpression(x.expression.left) &&
-                    t__namespace.isFunctionExpression(x.expression.right) &&
-                    ((_a = x.expression.right.id) === null || _a === void 0 ? void 0 : _a.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) {
-            var _a;
-            if (hasPatched) {
-                return;
-            }
-            const n = p.node;
-            if (((_a = n.id) === null || _a === void 0 ? void 0 : _a.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(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))));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    });
-    return {
-        code: hasPatched ? content : generate__default["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["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["default"].writeFileSync(processTailwindFeaturesFilePath, code, {
-                encoding: 'utf8'
-            });
-            console.log('patch tailwindcss processTailwindFeatures for return content successfully!');
-        }
-        result.processTailwindFeatures = code;
-    }
-    const pluginFilePath = path__default["default"].resolve(twDir, 'lib/plugin.js');
-    const indexFilePath = path__default["default"].resolve(twDir, 'lib/index.js');
-    const pluginContent = ensureFileContent([pluginFilePath, indexFilePath]);
-    if (pluginContent) {
-        const { code, hasPatched } = inspectPostcssPlugin(pluginContent);
-        if (!hasPatched && opt.overwrite) {
-            fs__default["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["default"].dirname(pkgJsonPath);
-        if (semver.gte(pkgJson.version, '3.0.0')) {
-            options.version = pkgJson.version;
-            const result = monkeyPatchForExposingContext(twDir, options);
-            return result;
-        }
-    }
-}
-
-exports.createPatch = createPatch;
-exports.ensureFileContent = ensureFileContent;
-exports.getInstalledPkgJsonPath = getInstalledPkgJsonPath;
-exports.getPatchOptions = getPatchOptions;
-exports.inspectPostcssPlugin = inspectPostcssPlugin;
-exports.inspectProcessTailwindFeaturesReturnContext = inspectProcessTailwindFeaturesReturnContext;
-exports.internalPatch = internalPatch;
-exports.monkeyPatchForExposingContext = monkeyPatchForExposingContext;
-exports.requireResolve = requireResolve;

package/dist/types/babel.d.ts

@@ -1,3 +0,0 @@
-export { default as generate } from '@babel/generator';
-export { default as traverse } from '@babel/traverse';
-export { parse } from '@babel/parser';

package/dist/types/cache.d.ts

@@ -1,7 +0,0 @@
-import type { CacheOptions } from './type';
-export declare function mkCacheDirectory(cacheDirectory: string): string;
-export declare function getCacheOptions(options?: CacheOptions): Required<CacheOptions> & {
-    filename: string;
-};
-export declare function writeCache(data: Set<string>, options?: CacheOptions): string | undefined;
-export declare function readCache(options?: CacheOptions): Set<string> | undefined;

package/dist/types/class.d.ts

@@ -1,17 +0,0 @@
-import type { CacheOptions, InternalCacheOptions, InternalPatchOptions, TailwindcssPatcherOptions, CacheStrategy } from './type';
-export declare function getCacheOptions(options?: CacheOptions | boolean): InternalCacheOptions;
-export declare class TailwindcssPatcher {
-    rawOptions: TailwindcssPatcherOptions;
-    cacheOptions: InternalCacheOptions;
-    patchOptions: InternalPatchOptions;
-    patch: () => void;
-    constructor(options?: TailwindcssPatcherOptions);
-    getPkgEntry(basedir?: string): string;
-    setCache(set: Set<string>): string | undefined;
-    getCache(): Set<string> | undefined;
-    getClassSet(options?: {
-        basedir?: string;
-        cacheStrategy?: CacheStrategy;
-    }): Set<string>;
-    getContexts(basedir?: string): import("./type").TailwindcssRuntimeContext[];
-}

package/dist/types/cli.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/constants.d.ts

@@ -1 +0,0 @@
-export declare const pkgName = "tailwindcss-patch";

package/dist/types/defaults.d.ts

@@ -1,2 +0,0 @@
-import type { PatchOptions } from './type';
-export declare const defaultOptions: PatchOptions;

package/dist/types/exposeContext.d.ts

@@ -1,5 +0,0 @@
-import type { TailwindcssClassCache, TailwindcssRuntimeContext } from './type';
-export declare function getTailwindcssEntry(basedir?: string): string;
-export declare function getContexts(basedir?: string): TailwindcssRuntimeContext[];
-export declare function getClassCaches(basedir?: string): TailwindcssClassCache[];
-export declare function getClassCacheSet(basedir?: string): Set<string>;

package/dist/types/index.d.ts

@@ -1,6 +0,0 @@
-export * from './class';
-export * from './exposeContext';
-export * from './inspector';
-export * from './patcher';
-export * from './utils';
-export * from './type';

package/dist/types/inspector.d.ts

@@ -1,8 +0,0 @@
-export declare function inspectProcessTailwindFeaturesReturnContext(content: string): {
-    code: string;
-    hasPatched: boolean;
-};
-export declare function inspectPostcssPlugin(content: string): {
-    code: string;
-    hasPatched: boolean;
-};

package/dist/types/logger.d.ts

@@ -1 +0,0 @@
-export declare function log(message?: any, ...optionalParams: any[]): void;

package/dist/types/patcher.d.ts

@@ -1,9 +0,0 @@
-import type { PatchOptions, InternalPatchOptions } from './type';
-export declare function getInstalledPkgJsonPath(options?: PatchOptions): string | undefined;
-export declare function getPatchOptions(options?: PatchOptions): InternalPatchOptions;
-export declare function createPatch(opt: InternalPatchOptions): () => any;
-export declare function monkeyPatchForExposingContext(twDir: string, opt: InternalPatchOptions): {
-    processTailwindFeatures?: string | undefined;
-    plugin?: string | undefined;
-} & Record<string, any>;
-export declare function internalPatch(pkgJsonPath: string | undefined, options: InternalPatchOptions): any | undefined;

package/dist/types/type.d.ts

@@ -1,72 +0,0 @@
-import type { Rule, Node } from 'postcss';
-import type { Config } from 'tailwindcss';
-export type CacheStrategy = 'merge' | 'overwrite';
-export interface CacheOptions {
-    dir?: string;
-    cwd?: string;
-    file?: string;
-    strategy?: CacheStrategy;
-}
-export type InternalCacheOptions = CacheOptions & {
-    enable?: boolean;
-};
-export interface PatchOptions {
-    overwrite?: boolean;
-    paths?: string[];
-    basedir?: string;
-    custom?: (dir: string, ctx: Record<string, any>) => void;
-}
-export interface InternalPatchOptions {
-    overwrite: boolean;
-    paths?: string[];
-    basedir?: string;
-    custom?: (dir: string, ctx: Record<string, any>) => void;
-    version?: string;
-}
-export interface TailwindcssPatcherOptions {
-    cache?: CacheOptions | boolean;
-    patch?: PatchOptions;
-}
-export type TailwindcssClassCache = Map<string, ({
-    layer: string;
-    options: Record<string, any>;
-    sort: Record<string, any>;
-} | Rule)[]>;
-export 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>;
-};

package/dist/types/utils.d.ts

@@ -1,3 +0,0 @@
-import { type SyncOpts } from 'resolve';
-export declare function ensureFileContent(filepaths: string | string[]): string | undefined;
-export declare function requireResolve(id: string, opts?: SyncOpts): string;