@unocss/postcss 0.50.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-PRESENT Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,242 @@
+# @unocss/postcss
+
+## Experimental
+This package is in an experimental state right now. It doesn't follow semver, and may introduce breaking changes in patch versions.
+
+<!-- @unocss-ignore -->
+
+PostCSS plugin for UnoCSS. Supports `@apply`、`@screen` and `theme()` directives.
+
+## Install
+
+```bash
+npm i -D @unocss/postcss
+```
+
+```ts
+// postcss.config.cjs
+module.exports = {
+  plugins: {
+    '@unocss/postcss': {
+      // Optional
+      content: ['**/*.{html,js,ts,jsx,tsx,vue,svelte,astro}'],
+    },
+  },
+}
+```
+
+```ts
+// uno.config.js
+import { defineConfig, presetUno } from 'unocss'
+
+export default defineConfig({
+  presets: [
+    presetUno(),
+  ],
+})
+```
+
+```css
+/* style.css */
+@unocss;
+```
+
+## Usage
+
+### `@unocss`
+
+`@unocss` at-rule is a placeholder. It will be replaced by the generated CSS. 
+
+You can also inject each layer individually:
+
+```css
+/* style.css */
+@unocss preflights;
+@unocss default;
+
+/*
+  Fallback layer. It's always recommended to include.
+  Only unused layers will be injected here.
+*/
+@unocss; 
+```
+
+If you want to include all layers no matter whether they are previously included or not, you can use `@unocss all`. This is useful if you want to include generated CSS in multiple files.
+
+```css
+@unocss all; 
+```
+
+### `@apply`
+
+```css
+.custom-div {
+  @apply text-center my-0 font-medium;
+}
+```
+
+Will be transformed to:
+
+```css
+.custom-div {
+  margin-top: 0rem;
+  margin-bottom: 0rem;
+  text-align: center;
+  font-weight: 500;
+}
+```
+
+### `@screen`
+
+The `@screen` directive allows you to create media queries that reference your breakpoints by name comes from [`theme.breakpoints`](https://github.com/unocss/unocss/blob/main/README.md#extend-theme).
+
+```css
+.grid {
+  --uno: grid grid-cols-2;
+}
+@screen xs {
+  .grid {
+    --uno: grid-cols-1;
+  }
+}
+@screen sm {
+  .grid {
+    --uno: grid-cols-3;
+  }
+}
+/* ... */
+...
+```
+
+Will be transformed to:
+
+```css
+.grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+@media (min-width: 320px) {
+  .grid {
+    grid-template-columns: repeat(1, minmax(0, 1fr));
+  }
+}
+@media (min-width: 640px) {
+  .grid {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+}
+/* ... */
+```
+
+#### Breakpoint Variant Support
+`@screen` also supports `lt`、`at` variants
+
+##### `@screen lt`
+
+```css
+.grid {
+  --uno: grid grid-cols-2;
+}
+@screen lt-xs {
+  .grid {
+    --uno: grid-cols-1;
+  }
+}
+@screen lt-sm {
+  .grid {
+    --uno: grid-cols-3;
+  }
+}
+/* ... */
+```
+
+Will be transformed to:
+
+```css
+.grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+@media (max-width: 319.9px) {
+  .grid {
+    grid-template-columns: repeat(1, minmax(0, 1fr));
+  }
+}
+@media (max-width: 639.9px) {
+  .grid {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+}
+/* ... */
+```
+
+##### `@screen at`
+
+```css
+.grid {
+  --uno: grid grid-cols-2;
+}
+@screen at-xs {
+  .grid {
+    --uno: grid-cols-1;
+  }
+}
+@screen at-xl {
+  .grid {
+    --uno: grid-cols-3;
+  }
+}
+@screen at-xxl {
+  .grid {
+    --uno: grid-cols-4;
+  }
+}
+/* ... */
+```
+
+Will be transformed to:
+
+```css
+.grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+@media (min-width: 320px) and (max-width: 639.9px) {
+  .grid {
+    grid-template-columns: repeat(1, minmax(0, 1fr));
+  }
+}
+@media (min-width: 1280px) and (max-width: 1535.9px) {
+  .grid {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+}
+@media (min-width: 1536px) {
+  .grid {
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+  }
+}
+/* ... */
+```
+
+### `theme()`
+
+Use the `theme()` function to access your theme config values using dot notation.
+
+```css
+.btn-blue {
+  background-color: theme('colors.blue.500');
+}
+```
+
+Will be compiled to:
+
+```css
+.btn-blue {
+  background-color: #3b82f6;
+}
+```
+
+## License
+
+MIT License &copy; 2022-PRESENT [hannoeru](https://github.com/hannoeru) [sibbng](https://github.com/sibbng)

package/dist/index.cjs

@@ -0,0 +1,266 @@
+'use strict';
+
+const promises = require('fs/promises');
+const fg = require('fast-glob');
+const postcss = require('postcss');
+const core = require('@unocss/core');
+const config = require('@unocss/config');
+const cssTree = require('css-tree');
+const MagicString = require('magic-string');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
+const fg__default = /*#__PURE__*/_interopDefaultLegacy(fg);
+const postcss__default = /*#__PURE__*/_interopDefaultLegacy(postcss);
+const MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
+
+const defaultIncludeGlobs = ["**/*.{html,js,ts,jsx,tsx,vue,svelte,astro,elm,php,phtml,mdx,md}"];
+
+function parseApply(root, uno, directiveName) {
+  root.walkAtRules(directiveName, async (rule) => {
+    if (!rule.parent)
+      return;
+    const source = rule.source;
+    const classNames = core.expandVariantGroup(rule.params).split(/\s+/g).map((className) => className.trim().replace(/\\/, ""));
+    const utils = (await Promise.all(
+      classNames.map((i) => uno.parseToken(i, "-"))
+    )).filter(core.notNull).flat().sort((a, b) => a[0] - b[0]).sort((a, b) => (a[3] ? uno.parentOrders.get(a[3]) ?? 0 : 0) - (b[3] ? uno.parentOrders.get(b[3]) ?? 0 : 0)).reduce((acc, item) => {
+      const target = acc.find((i) => i[1] === item[1] && i[3] === item[3]);
+      if (target)
+        target[2] += item[2];
+      else
+        acc.push([...item]);
+      return acc;
+    }, []);
+    if (!utils.length)
+      return;
+    for (const i of utils) {
+      const [, _selector, body, parent] = i;
+      const selector = _selector?.replace(core.regexScopePlaceholder, " ") || _selector;
+      if (parent || selector && selector !== ".\\-") {
+        const node = cssTree.parse(rule.parent.toString(), {
+          context: "rule"
+        });
+        let newSelector = cssTree.generate(node.prelude);
+        if (selector && selector !== ".\\-") {
+          const selectorAST = cssTree.parse(selector, {
+            context: "selector"
+          });
+          const prelude = cssTree.clone(node.prelude);
+          prelude.children.forEach((child) => {
+            const parentSelectorAst = cssTree.clone(selectorAST);
+            parentSelectorAst.children.forEach((i2) => {
+              if (i2.type === "ClassSelector" && i2.name === "\\-")
+                Object.assign(i2, cssTree.clone(child));
+            });
+            Object.assign(child, parentSelectorAst);
+          });
+          newSelector = cssTree.generate(prelude);
+        }
+        let css = `${newSelector}{${body}}`;
+        if (parent)
+          css = `${parent}{${css}}`;
+        const css_parsed = postcss__default.parse(css);
+        css_parsed.walkDecls((declaration) => {
+          declaration.source = source;
+        });
+        rule.parent.after(css_parsed);
+      } else {
+        const css = postcss__default.parse(body);
+        css.walkDecls((declaration) => {
+          declaration.source = source;
+        });
+        rule.parent.append(css);
+      }
+    }
+    rule.remove();
+  });
+}
+
+function parseTheme(root, uno, directiveName) {
+  const themeFnRE = new RegExp(`${directiveName}\\((.*?)\\)`, "g");
+  root.walkDecls((decl) => {
+    const matches = Array.from(decl.value.matchAll(themeFnRE));
+    if (!matches.length)
+      return;
+    for (const match of matches) {
+      const rawArg = match[1].trim();
+      if (!rawArg)
+        throw new Error(`${directiveName}() expect exact one argument, but got 0`);
+      let value = uno.config.theme;
+      const keys = rawArg.slice(1, -1).split(".");
+      keys.every((key) => {
+        if (value[key] != null)
+          value = value[key];
+        else if (value[+key] != null)
+          value = value[+key];
+        else
+          return false;
+        return true;
+      });
+      if (typeof value === "string") {
+        const code = new MagicString__default(decl.value);
+        code.overwrite(
+          match.index,
+          match.index + match[0].length,
+          value
+        );
+        decl.value = code.toString();
+      }
+    }
+  });
+}
+
+function parseScreen(root, uno, directiveName) {
+  root.walkAtRules(directiveName, async (rule) => {
+    let breakpointName = "";
+    let prefix = "";
+    if (rule.params)
+      breakpointName = rule.params.trim();
+    if (!breakpointName)
+      return;
+    const match = breakpointName.match(/^(?:(lt|at)-)?(\w+)$/);
+    if (match) {
+      prefix = match[1];
+      breakpointName = match[2];
+    }
+    const resolveBreakpoints = () => {
+      let breakpoints;
+      if (uno.userConfig && uno.userConfig.theme)
+        breakpoints = uno.userConfig.theme.breakpoints;
+      if (!breakpoints)
+        breakpoints = uno.config.theme.breakpoints;
+      return breakpoints;
+    };
+    const variantEntries = Object.entries(resolveBreakpoints() ?? {}).map(([point, size], idx) => [point, size, idx]);
+    const generateMediaQuery = (breakpointName2, prefix2) => {
+      const [, size, idx] = variantEntries.find((i) => i[0] === breakpointName2);
+      if (prefix2) {
+        if (prefix2 === "lt")
+          return `(max-width: ${calcMaxWidthBySize(size)})`;
+        else if (prefix2 === "at")
+          return `(min-width: ${size})${variantEntries[idx + 1] ? ` and (max-width: ${calcMaxWidthBySize(variantEntries[idx + 1][1])})` : ""}`;
+        else
+          throw new Error(`breakpoint variant not supported: ${prefix2}`);
+      }
+      return `(min-width: ${size})`;
+    };
+    if (!variantEntries.find((i) => i[0] === breakpointName))
+      throw new Error(`breakpoint ${breakpointName} not found`);
+    rule.name = "media";
+    rule.params = `${generateMediaQuery(breakpointName, prefix)}`;
+  });
+}
+function calcMaxWidthBySize(size) {
+  const value = size.match(/^-?[0-9]+\.?[0-9]*/)?.[0] || "";
+  const unit = size.slice(value.length);
+  const maxWidth = parseFloat(value) - 0.1;
+  return Number.isNaN(maxWidth) ? size : `${maxWidth}${unit}`;
+}
+
+function unocss({ content, directiveMap, cwd, configOrPath } = {
+  cwd: process.cwd()
+}) {
+  const fileMap = /* @__PURE__ */ new Map();
+  const fileClassMap = /* @__PURE__ */ new Map();
+  const classes = /* @__PURE__ */ new Set();
+  const config$1 = config.loadConfig(cwd, configOrPath);
+  let uno;
+  core.warnOnce(
+    "`@unocss/postcss` package is in an experimental state right now. It doesn't follow semver, and may introduce breaking changes in patch versions."
+  );
+  return {
+    postcssPlugin: "unocss",
+    plugins: [
+      async function(root, result) {
+        const cfg = await config$1;
+        if (!Object.keys(!cfg.config))
+          throw new Error("UnoCSS config file not found.");
+        if (!uno)
+          uno = core.createGenerator(cfg.config);
+        parseApply(root, uno, directiveMap?.apply || "apply");
+        parseTheme(root, uno, directiveMap?.theme || "theme");
+        parseScreen(root, uno, directiveMap?.screen || "screen");
+        const globs = content?.filter((v) => typeof v === "string") ?? defaultIncludeGlobs;
+        const rawContent = content?.filter((v) => typeof v === "object") ?? [];
+        const entries = await fg__default(globs, {
+          cwd,
+          dot: true,
+          absolute: true,
+          ignore: ["**/{.git,node_modules}/**"]
+        });
+        if (result.opts.from?.split("?")[0].endsWith(".css")) {
+          result.messages.push({
+            type: "dependency",
+            plugin: "unocss",
+            file: result.opts.from,
+            parent: result.opts.from
+          });
+          await Promise.all(
+            [
+              ...rawContent.map(async (v) => {
+                const { matched } = await uno.generate(v.raw, {
+                  id: `unocss${v.extension}`
+                });
+                for (const candidate of matched)
+                  classes.add(candidate);
+              }),
+              ...entries.map(async (file) => {
+                result.messages.push({
+                  type: "dependency",
+                  plugin: "unocss",
+                  file,
+                  parent: result.opts.from
+                });
+                const { mtimeMs } = await promises.stat(file);
+                if (fileMap.has(file) && mtimeMs <= fileMap.get(file))
+                  return;
+                else
+                  fileMap.set(file, mtimeMs);
+                const content2 = await promises.readFile(file, "utf8");
+                const { matched } = await uno.generate(content2, {
+                  id: file
+                });
+                fileClassMap.set(file, matched);
+              })
+            ]
+          );
+          for (const set of fileClassMap.values()) {
+            for (const candidate of set)
+              classes.add(candidate);
+          }
+          const c = await uno.generate(classes);
+          classes.clear();
+          const excludes = [];
+          root.walkAtRules("unocss", (rule) => {
+            if (rule.params) {
+              const source = rule.source;
+              const layers = rule.params.split(",").map((v) => v.trim());
+              const css = postcss__default.parse(
+                layers.map((i) => (i === "all" ? c.getLayers() : c.getLayer(i)) || "").filter(Boolean).join("\n")
+              );
+              css.walkDecls((declaration) => {
+                declaration.source = source;
+              });
+              rule.replaceWith(css);
+              excludes.push(rule.params);
+            }
+          });
+          root.walkAtRules("unocss", (rule) => {
+            if (!rule.params) {
+              const source = rule.source;
+              const css = postcss__default.parse(c.getLayers(void 0, excludes) || "");
+              css.walkDecls((declaration) => {
+                declaration.source = source;
+              });
+              rule.replaceWith(css);
+            }
+          });
+        }
+      }
+    ]
+  };
+}
+unocss.postcss = true;
+
+module.exports = unocss;

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import { Root, Result } from 'postcss';
+import { UserConfig } from '@unocss/core';
+
+interface UnoPostcssPluginOptions {
+    content?: (string | {
+        raw: string;
+        extension: string;
+    })[];
+    directiveMap?: {
+        apply: string;
+        screen: string;
+        theme: string;
+    };
+    cwd?: string;
+    configOrPath?: string | UserConfig;
+}
+
+declare function unocss({ content, directiveMap, cwd, configOrPath }?: UnoPostcssPluginOptions): {
+    postcssPlugin: string;
+    plugins: ((root: Root, result: Result) => Promise<void>)[];
+};
+declare namespace unocss {
+    var postcss: boolean;
+}
+
+export { UnoPostcssPluginOptions, unocss as default };

package/dist/index.mjs

@@ -0,0 +1,258 @@
+import { stat, readFile } from 'fs/promises';
+import fg from 'fast-glob';
+import postcss from 'postcss';
+import { expandVariantGroup, notNull, regexScopePlaceholder, warnOnce, createGenerator } from '@unocss/core';
+import { loadConfig } from '@unocss/config';
+import { parse, generate, clone } from 'css-tree';
+import MagicString from 'magic-string';
+
+const defaultIncludeGlobs = ["**/*.{html,js,ts,jsx,tsx,vue,svelte,astro,elm,php,phtml,mdx,md}"];
+
+function parseApply(root, uno, directiveName) {
+  root.walkAtRules(directiveName, async (rule) => {
+    if (!rule.parent)
+      return;
+    const source = rule.source;
+    const classNames = expandVariantGroup(rule.params).split(/\s+/g).map((className) => className.trim().replace(/\\/, ""));
+    const utils = (await Promise.all(
+      classNames.map((i) => uno.parseToken(i, "-"))
+    )).filter(notNull).flat().sort((a, b) => a[0] - b[0]).sort((a, b) => (a[3] ? uno.parentOrders.get(a[3]) ?? 0 : 0) - (b[3] ? uno.parentOrders.get(b[3]) ?? 0 : 0)).reduce((acc, item) => {
+      const target = acc.find((i) => i[1] === item[1] && i[3] === item[3]);
+      if (target)
+        target[2] += item[2];
+      else
+        acc.push([...item]);
+      return acc;
+    }, []);
+    if (!utils.length)
+      return;
+    for (const i of utils) {
+      const [, _selector, body, parent] = i;
+      const selector = _selector?.replace(regexScopePlaceholder, " ") || _selector;
+      if (parent || selector && selector !== ".\\-") {
+        const node = parse(rule.parent.toString(), {
+          context: "rule"
+        });
+        let newSelector = generate(node.prelude);
+        if (selector && selector !== ".\\-") {
+          const selectorAST = parse(selector, {
+            context: "selector"
+          });
+          const prelude = clone(node.prelude);
+          prelude.children.forEach((child) => {
+            const parentSelectorAst = clone(selectorAST);
+            parentSelectorAst.children.forEach((i2) => {
+              if (i2.type === "ClassSelector" && i2.name === "\\-")
+                Object.assign(i2, clone(child));
+            });
+            Object.assign(child, parentSelectorAst);
+          });
+          newSelector = generate(prelude);
+        }
+        let css = `${newSelector}{${body}}`;
+        if (parent)
+          css = `${parent}{${css}}`;
+        const css_parsed = postcss.parse(css);
+        css_parsed.walkDecls((declaration) => {
+          declaration.source = source;
+        });
+        rule.parent.after(css_parsed);
+      } else {
+        const css = postcss.parse(body);
+        css.walkDecls((declaration) => {
+          declaration.source = source;
+        });
+        rule.parent.append(css);
+      }
+    }
+    rule.remove();
+  });
+}
+
+function parseTheme(root, uno, directiveName) {
+  const themeFnRE = new RegExp(`${directiveName}\\((.*?)\\)`, "g");
+  root.walkDecls((decl) => {
+    const matches = Array.from(decl.value.matchAll(themeFnRE));
+    if (!matches.length)
+      return;
+    for (const match of matches) {
+      const rawArg = match[1].trim();
+      if (!rawArg)
+        throw new Error(`${directiveName}() expect exact one argument, but got 0`);
+      let value = uno.config.theme;
+      const keys = rawArg.slice(1, -1).split(".");
+      keys.every((key) => {
+        if (value[key] != null)
+          value = value[key];
+        else if (value[+key] != null)
+          value = value[+key];
+        else
+          return false;
+        return true;
+      });
+      if (typeof value === "string") {
+        const code = new MagicString(decl.value);
+        code.overwrite(
+          match.index,
+          match.index + match[0].length,
+          value
+        );
+        decl.value = code.toString();
+      }
+    }
+  });
+}
+
+function parseScreen(root, uno, directiveName) {
+  root.walkAtRules(directiveName, async (rule) => {
+    let breakpointName = "";
+    let prefix = "";
+    if (rule.params)
+      breakpointName = rule.params.trim();
+    if (!breakpointName)
+      return;
+    const match = breakpointName.match(/^(?:(lt|at)-)?(\w+)$/);
+    if (match) {
+      prefix = match[1];
+      breakpointName = match[2];
+    }
+    const resolveBreakpoints = () => {
+      let breakpoints;
+      if (uno.userConfig && uno.userConfig.theme)
+        breakpoints = uno.userConfig.theme.breakpoints;
+      if (!breakpoints)
+        breakpoints = uno.config.theme.breakpoints;
+      return breakpoints;
+    };
+    const variantEntries = Object.entries(resolveBreakpoints() ?? {}).map(([point, size], idx) => [point, size, idx]);
+    const generateMediaQuery = (breakpointName2, prefix2) => {
+      const [, size, idx] = variantEntries.find((i) => i[0] === breakpointName2);
+      if (prefix2) {
+        if (prefix2 === "lt")
+          return `(max-width: ${calcMaxWidthBySize(size)})`;
+        else if (prefix2 === "at")
+          return `(min-width: ${size})${variantEntries[idx + 1] ? ` and (max-width: ${calcMaxWidthBySize(variantEntries[idx + 1][1])})` : ""}`;
+        else
+          throw new Error(`breakpoint variant not supported: ${prefix2}`);
+      }
+      return `(min-width: ${size})`;
+    };
+    if (!variantEntries.find((i) => i[0] === breakpointName))
+      throw new Error(`breakpoint ${breakpointName} not found`);
+    rule.name = "media";
+    rule.params = `${generateMediaQuery(breakpointName, prefix)}`;
+  });
+}
+function calcMaxWidthBySize(size) {
+  const value = size.match(/^-?[0-9]+\.?[0-9]*/)?.[0] || "";
+  const unit = size.slice(value.length);
+  const maxWidth = parseFloat(value) - 0.1;
+  return Number.isNaN(maxWidth) ? size : `${maxWidth}${unit}`;
+}
+
+function unocss({ content, directiveMap, cwd, configOrPath } = {
+  cwd: process.cwd()
+}) {
+  const fileMap = /* @__PURE__ */ new Map();
+  const fileClassMap = /* @__PURE__ */ new Map();
+  const classes = /* @__PURE__ */ new Set();
+  const config = loadConfig(cwd, configOrPath);
+  let uno;
+  warnOnce(
+    "`@unocss/postcss` package is in an experimental state right now. It doesn't follow semver, and may introduce breaking changes in patch versions."
+  );
+  return {
+    postcssPlugin: "unocss",
+    plugins: [
+      async function(root, result) {
+        const cfg = await config;
+        if (!Object.keys(!cfg.config))
+          throw new Error("UnoCSS config file not found.");
+        if (!uno)
+          uno = createGenerator(cfg.config);
+        parseApply(root, uno, directiveMap?.apply || "apply");
+        parseTheme(root, uno, directiveMap?.theme || "theme");
+        parseScreen(root, uno, directiveMap?.screen || "screen");
+        const globs = content?.filter((v) => typeof v === "string") ?? defaultIncludeGlobs;
+        const rawContent = content?.filter((v) => typeof v === "object") ?? [];
+        const entries = await fg(globs, {
+          cwd,
+          dot: true,
+          absolute: true,
+          ignore: ["**/{.git,node_modules}/**"]
+        });
+        if (result.opts.from?.split("?")[0].endsWith(".css")) {
+          result.messages.push({
+            type: "dependency",
+            plugin: "unocss",
+            file: result.opts.from,
+            parent: result.opts.from
+          });
+          await Promise.all(
+            [
+              ...rawContent.map(async (v) => {
+                const { matched } = await uno.generate(v.raw, {
+                  id: `unocss${v.extension}`
+                });
+                for (const candidate of matched)
+                  classes.add(candidate);
+              }),
+              ...entries.map(async (file) => {
+                result.messages.push({
+                  type: "dependency",
+                  plugin: "unocss",
+                  file,
+                  parent: result.opts.from
+                });
+                const { mtimeMs } = await stat(file);
+                if (fileMap.has(file) && mtimeMs <= fileMap.get(file))
+                  return;
+                else
+                  fileMap.set(file, mtimeMs);
+                const content2 = await readFile(file, "utf8");
+                const { matched } = await uno.generate(content2, {
+                  id: file
+                });
+                fileClassMap.set(file, matched);
+              })
+            ]
+          );
+          for (const set of fileClassMap.values()) {
+            for (const candidate of set)
+              classes.add(candidate);
+          }
+          const c = await uno.generate(classes);
+          classes.clear();
+          const excludes = [];
+          root.walkAtRules("unocss", (rule) => {
+            if (rule.params) {
+              const source = rule.source;
+              const layers = rule.params.split(",").map((v) => v.trim());
+              const css = postcss.parse(
+                layers.map((i) => (i === "all" ? c.getLayers() : c.getLayer(i)) || "").filter(Boolean).join("\n")
+              );
+              css.walkDecls((declaration) => {
+                declaration.source = source;
+              });
+              rule.replaceWith(css);
+              excludes.push(rule.params);
+            }
+          });
+          root.walkAtRules("unocss", (rule) => {
+            if (!rule.params) {
+              const source = rule.source;
+              const css = postcss.parse(c.getLayers(void 0, excludes) || "");
+              css.walkDecls((declaration) => {
+                declaration.source = source;
+              });
+              rule.replaceWith(css);
+            }
+          });
+        }
+      }
+    ]
+  };
+}
+unocss.postcss = true;
+
+export { unocss as default };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@unocss/postcss",
+  "version": "0.50.0",
+  "description": "PostCSS plugin for UnoCSS",
+  "author": "sibbng <sibbngheid@gmail.com>",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/antfu",
+  "homepage": "https://github.com/unocss/unocss/tree/main/packages/postcss#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unocss/unocss.git",
+    "directory": "packages/postcss"
+  },
+  "bugs": {
+    "url": "https://github.com/unocss/unocss/issues"
+  },
+  "keywords": [],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
+  "peerDependencies": {
+    "postcss": "^8.4.21"
+  },
+  "dependencies": {
+    "@unocss/config": "0.50.0",
+    "@unocss/core": "0.50.0",
+    "css-tree": "^2.3.1",
+    "fast-glob": "^3.2.12",
+    "magic-string": "^0.27.0",
+    "postcss": "^8.4.21"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "stub": "unbuild --stub"
+  }
+}