refactor: split web frontend + gateway out to uniweb app (bump 0.13.0)

The SPA (web/) and the web gateway (cmd/webgw) move to a dedicated app projects/message_bus/apps/uniweb (its own Gitea sub-repo). unibus is now strictly the bus plane: membership/keys, the client library and demo peers. uniweb consumes unibus as a Go module via replace => ../unibus. No capability lost; same SPA and gateway, in their own service folder. go build/vet/test green after extraction.
2026-06-13 21:21:08 +02:00
parent fadee1a7d0
commit 9661a5ce1f
31166 changed files with 2029366 additions and 3677 deletions
@@ -0,0 +1 @@
+../../postcss@8.5.15/node_modules/postcss
@@ -0,0 +1 @@
+../../postcss-mixins@12.1.2_postcss@8.5.15/node_modules/postcss-mixins
@@ -0,0 +1 @@
+../../postcss-nested@7.0.2_postcss@8.5.15/node_modules/postcss-nested
@@ -0,0 +1,2 @@
+__snapshots__
+dist
@@ -0,0 +1,6 @@
+{
+  "printWidth": 100,
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "endOfLine": "lf"
+}
@@ -0,0 +1,3 @@
+nodeLinker: node-modules
+
+yarnPath: .yarn/releases/yarn-4.9.2.cjs
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Vitaly Rtishchev
+
+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.
@@ -0,0 +1,393 @@
+# postcss-preset-mantine
+
+[Documentation](http://mantine.dev/styles/postcss-preset)
+
+## Installation
+
+```sh
+yarn add --dev postcss postcss-preset-mantine postcss-simple-vars
+```
+
+## Usage
+
+Add `postcss-preset-mantine` to your `postcss.config.js` config:
+
+```js
+module.exports = {
+  plugins: {
+    'postcss-preset-mantine': {},
+    'postcss-simple-vars': {
+      variables: {
+        'mantine-breakpoint-xs': '36em',
+        'mantine-breakpoint-sm': '48em',
+        'mantine-breakpoint-md': '62em',
+        'mantine-breakpoint-lg': '75em',
+        'mantine-breakpoint-xl': '88em',
+      },
+    },
+  },
+};
+```
+
+## rem/em functions
+
+`rem` and `em` functions can be used to convert pixels to rem/em units.
+`16px = 1rem` and `16px = 1em`, `em` values are supposed to be used in media queries,
+`rem` everywhere else. You can learn more about units conversions in [this guide](/styles/rem).
+
+```scss
+.demo {
+  font-size: rem(16px);
+
+  @media (min-width: em(320px)) {
+    font-size: rem(32px);
+  }
+}
+```
+
+Will be transformed to:
+
+```scss
+.demo {
+  font-size: calc(1rem * var(--mantine-scale));
+
+  @media (min-width: 20em) {
+    font-size: calc(2rem * var(--mantine-scale));
+  }
+}
+```
+
+## dark and light mixins
+
+`dark` and `light` mixins can be used to create styles that will be applied only in dark or light color scheme.
+
+```scss
+.demo {
+  @mixin light {
+    color: red;
+  }
+
+  @mixin dark {
+    color: blue;
+  }
+}
+```
+
+Will be transformed to:
+
+```scss
+[data-mantine-color-scheme='light'] .demo {
+  color: red;
+}
+
+[data-mantine-color-scheme='dark'] .demo {
+  color: blue;
+}
+```
+
+Note that usually you do not need to use both `light` and `dark` mixins at the same time.
+It is easier to define styles for light color scheme and then use `dark` mixin to override them in dark color scheme.
+
+```scss
+.demo {
+  // Value for light color scheme
+  color: red;
+
+  @mixin dark {
+    // Value for dark color scheme
+    color: blue;
+  }
+}
+```
+
+To define values for light/dark color scheme on the `:root`/`html` element, use `light-root` and `dark-root` mixins instead:
+
+```scss
+:root {
+  @mixin light-root {
+    --color: red;
+  }
+
+  @mixin dark-root {
+    --color: blue;
+  }
+}
+```
+
+## smaller-than and larger-than mixins
+
+`smaller-than` and `larger-than` mixins can be used to create styles that will be applied only when screen is smaller or larger than specified breakpoint.
+
+```scss
+.demo {
+  @mixin smaller-than 320px {
+    color: red;
+  }
+
+  @mixin larger-than 320px {
+    color: blue;
+  }
+}
+```
+
+Will be transformed to:
+
+```scss
+// Breakpoint values are converted to em units
+// In smaller-than mixin 0.1px is subtracted from breakpoint value
+// to avoid intersection with larger-than mixin
+@media (max-width: 19.99375em) {
+  .demo {
+    color: red;
+  }
+}
+
+@media (min-width: 20em) {
+  .demo {
+    color: blue;
+  }
+}
+```
+
+You can also use `smaller-than` and `larger-than` mixins with [mantine breakpoints](/styles/responsive/#breakpoints-variables-in-css-modules):
+
+```scss
+.demo {
+  @mixin smaller-than $mantine-breakpoint-sm {
+    color: red;
+  }
+
+  @mixin larger-than $mantine-breakpoint-sm {
+    color: blue;
+  }
+}
+```
+
+## light-dark function
+
+`light-dark` function is an alternative to `light` and `dark` mixins. It accepts two arguments:
+first argument is rule that will be applied in light color scheme, second argument is rule that will be applied in dark color scheme.
+
+```css
+.demo {
+  color: light-dark(red, blue);
+}
+```
+
+Will be transformed to:
+
+```css
+.demo {
+  color: red;
+}
+
+[data-mantine-color-scheme='dark'] .demo {
+  color: blue;
+}
+```
+
+### light-dark with html and :root selectors
+
+Note that `light-dark` function does not work on `:root`/`html` element. Use `light-root` and `dark-root` mixins instead:
+
+```scss
+// ❌ Does not work
+:root {
+  --color: light-dark(red, blue);
+}
+
+// ✅ Works
+:root {
+  @mixin light-root {
+    --color: red;
+  }
+
+  @mixin dark-root {
+    --color: blue;
+  }
+}
+```
+
+### light-dark and !important
+
+`!important` at rule level:
+
+```scss
+.button {
+  color: light-dark(red, blue) !important;
+}
+
+// Is transformed to
+.button {
+  background: red !important;
+}
+
+[data-mantine-color-scheme='dark'] .button {
+  background: blue !important;
+}
+```
+
+`!important` at value level:
+
+```scss
+// !important at value level
+.button {
+  color: light-dark(red !important, blue);
+}
+
+// Is transformed to
+.button {
+  background: red !important;
+}
+
+[data-mantine-color-scheme='dark'] .button {
+  background: blue;
+}
+```
+
+## alpha function
+
+`alpha` function can be used to add alpha channel to color. Note that it uses [color-mix](https://caniuse.com/mdn-css_types_color_color-mix) which is not supported in some older browsers.
+
+```scss
+.demo {
+  color: alpha(var(--mantine-color-red-4), 0.5);
+  border: 1px solid alpha(#ffc, 0.2);
+}
+```
+
+Will be transformed to:
+
+```scss
+.demo {
+  color: color-mix(in srgb, var(--mantine-color-red-4), transparent 50%);
+  border: 1px solid color-mix(in srgb, #ffc, transparent 80%);
+}
+```
+
+## lighten and darken functions
+
+`lighten` and `darken` functions work similar to `alpha` function, but instead of adding alpha channel they add white or black color to the color with [color-mix](https://caniuse.com/mdn-css_types_color_color-mix).
+
+```scss
+.demo {
+  color: lighten(var(--mantine-color-red-4), 0.5);
+  border: 1px solid darken(#ffc, 0.2);
+}
+```
+
+Will be transformed to:
+
+```scss
+.demo {
+  color: color-mix(in srgb, var(--mantine-color-red-4), white 50%);
+  border: 1px solid color-mix(in srgb, #ffc, black 20%);
+}
+```
+
+## hover mixin
+
+`hover` mixin can be used to create styles that will be applied on hover.
+
+```css
+.demo {
+  @mixin hover {
+    color: orange;
+  }
+}
+```
+
+Will be transformed to:
+
+```css
+@media (hover: hover) {
+  .demo:hover {
+    color: orange;
+  }
+}
+
+@media (hover: none) {
+  .demo:active {
+    color: orange;
+  }
+}
+```
+
+## rtl/ltr mixins
+
+`rtl` mixin can be used to create styles that will be applied when `dir="rtl"` is set on parent element (usually `<html />`).
+
+```scss
+.demo {
+  margin-left: 1rem;
+
+  @mixin rtl {
+    margin-left: 0;
+    margin-right: 1rem;
+  }
+}
+```
+
+Will be transformed to:
+
+```css
+.demo {
+  margin-left: 1rem;
+}
+
+[dir='rtl'] .demo {
+  margin-left: 0;
+  margin-right: 1rem;
+}
+```
+
+`ltr` mixin works the same way, but for `dir="ltr"`:
+
+```scss
+.demo {
+  margin-left: 1rem;
+
+  @mixin ltr {
+    margin-left: 0;
+    margin-right: 1rem;
+  }
+}
+```
+
+Will be transformed to:
+
+```css
+.demo {
+  margin-left: 1rem;
+}
+
+[dir='ltr'] .demo {
+  margin-left: 0;
+  margin-right: 1rem;
+}
+```
+
+## not-rtl/not-ltr mixins
+
+`not-rtl`/`not-ltr` mixins can be used to create styles that will be applied when the direction is set to the opposite value or not set at all.
+For example, `not-rtl` styles will be applied when `dir="ltr"` or when `dir` is not set at all.
+
+```scss
+.demo {
+  @mixin not-rtl {
+    margin-right: 1rem;
+  }
+}
+```
+
+Will be transformed to:
+
+```css
+:root:not([dir='rtl']) .demo {
+  margin-right: 1rem;
+}
+```
+
+## License
+
+MIT License
@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const unitsConverters = require('./converters');
+const rem = unitsConverters.remStrict;
+module.exports = () => {
+    return {
+        postcssPlugin: 'postcss-auto-rem',
+        Declaration: (decl) => {
+            if (!decl.value.includes('px')) {
+                return;
+            }
+            if (decl.prop === 'content') {
+                return;
+            }
+            decl.value = rem(decl.value);
+        },
+    };
+};
+module.exports.postcss = true;
@@ -0,0 +1,100 @@
+"use strict";
+function scaleRem(remValue) {
+    if (remValue === '0rem') {
+        return '0rem';
+    }
+    return `calc(${remValue} * var(--mantine-scale))`;
+}
+function createConverter(units, { shouldScale = false, transformUnitLess = true } = {}) {
+    function converter(value) {
+        if ((value === 0 || value === '0') && transformUnitLess) {
+            return `0${units}`;
+        }
+        if (typeof value === 'number') {
+            const val = `${value / 16}${units}`;
+            return shouldScale ? scaleRem(val) : val;
+        }
+        if (typeof value === 'string') {
+            if (value.startsWith('calc(') ||
+                value.startsWith('clamp(') ||
+                value.includes('rgba(') ||
+                value.includes('var(') ||
+                value.includes('min(') ||
+                value.includes('max(') ||
+                value.includes('url(') ||
+                value.includes('linear-gradient(') ||
+                value.includes('radial-gradient(') ||
+                value.includes('repeating-linear-gradient(') ||
+                value.includes('repeating-radial-gradient(')) {
+                return value;
+            }
+            if (value.includes(',')) {
+                return value
+                    .split(',')
+                    .map((val) => converter(val))
+                    .join(',');
+            }
+            if (value.includes(' ')) {
+                return value
+                    .split(' ')
+                    .map((val) => converter(val))
+                    .join(' ');
+            }
+            if (value.includes(units)) {
+                return shouldScale ? scaleRem(value) : value;
+            }
+            const replaced = value.replace('px', '');
+            if (replaced === value && !transformUnitLess) {
+                return value;
+            }
+            if (!Number.isNaN(Number(replaced))) {
+                const val = `${Number(replaced) / 16}${units}`;
+                return shouldScale ? scaleRem(val) : val;
+            }
+        }
+        return value;
+    }
+    return converter;
+}
+const rem = createConverter('rem', { shouldScale: true });
+const remStrict = createConverter('rem', { shouldScale: true, transformUnitLess: false });
+const remNoScale = createConverter('rem');
+const em = createConverter('em');
+function getTransformedScaledValue(value) {
+    if (typeof value !== 'string' || !value.includes('var(--mantine-scale)')) {
+        return value;
+    }
+    return value
+        .match(/^calc\((.*?)\)$/)?.[1]
+        .split('*')[0]
+        .trim();
+}
+function px(value) {
+    const transformedValue = getTransformedScaledValue(value);
+    if (typeof transformedValue === 'number') {
+        return transformedValue;
+    }
+    if (typeof transformedValue === 'string') {
+        if (transformedValue.includes('calc') || transformedValue.includes('var')) {
+            return transformedValue;
+        }
+        if (transformedValue.includes('px')) {
+            return Number(transformedValue.replace('px', ''));
+        }
+        if (transformedValue.includes('rem')) {
+            return Number(transformedValue.replace('rem', '')) * 16;
+        }
+        if (transformedValue.includes('em')) {
+            return Number(transformedValue.replace('em', '')) * 16;
+        }
+        return Number(transformedValue);
+    }
+    return NaN;
+}
+module.exports = {
+    px,
+    em,
+    rem,
+    remStrict,
+    remNoScale,
+};
@@ -0,0 +1 @@
+declare module "postcss-preset-mantine";
@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getValueRegexp = (name) => new RegExp('\\b' + name + '\\(([^()]+)\\)', 'g');
+const getVarRegexp = (name) => new RegExp('\\b' + name + '\\(([^()]*\\([^()]*\\)[^()]*)+\\)', 'g');
+function replaceValues(root, fn, replace) {
+    root.replaceValues(getValueRegexp(fn), { fast: `${fn}(` }, (_, values) => replace(values));
+    root.replaceValues(getVarRegexp(fn), { fast: `${fn}(` }, (_, values) => replace(values));
+}
+function getParsedColor(input) {
+    if (typeof input !== 'string') {
+        return null;
+    }
+    const color = input.trim();
+    const lastCommaIndex = color.lastIndexOf(',');
+    if (lastCommaIndex === -1) {
+        return null;
+    }
+    const rawPayload = color.slice(lastCommaIndex + 1).trim();
+    const payload = rawPayload.endsWith('%')
+        ? Number(rawPayload.slice(0, -1)) / 100
+        : Number(color.slice(lastCommaIndex + 1));
+    if (Number.isNaN(payload)) {
+        return null;
+    }
+    return {
+        color: color.slice(0, lastCommaIndex).trim(),
+        payload: Math.max(0, Math.min(1, payload)),
+    };
+}
+function alpha(input) {
+    const parsed = getParsedColor(input);
+    if (!parsed) {
+        return input;
+    }
+    if (parsed.payload === 1) {
+        return parsed.color;
+    }
+    if (parsed.payload === 0) {
+        return 'transparent';
+    }
+    const mixPercentage = (1 - parsed.payload) * 100;
+    return `color-mix(in srgb, ${parsed.color}, transparent ${mixPercentage}%)`;
+}
+function lighten(input) {
+    const parsed = getParsedColor(input);
+    if (!parsed) {
+        return input;
+    }
+    return `color-mix(in srgb, ${parsed.color}, white ${parsed.payload * 100}%)`;
+}
+function darken(input) {
+    const parsed = getParsedColor(input);
+    if (!parsed) {
+        return input;
+    }
+    return `color-mix(in srgb, ${parsed.color}, black ${parsed.payload * 100}%)`;
+}
+module.exports = () => {
+    return {
+        postcssPlugin: 'postcss-mantine-color-mix',
+        Once(root) {
+            replaceValues(root, 'alpha', alpha);
+            replaceValues(root, 'lighten', lighten);
+            replaceValues(root, 'darken', darken);
+        },
+    };
+};
+module.exports.postcss = true;
@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const postcss_1 = require("postcss");
+const FUNCTION = 'light-dark(';
+function splitStringAtCharacter(character, search) {
+    let characterIndex = 0;
+    let openedParentheses = 0;
+    while (characterIndex < search.length &&
+        (search[characterIndex] !== character || openedParentheses)) {
+        if (search[characterIndex] === '(') {
+            openedParentheses += 1;
+        }
+        if (search[characterIndex] === ')') {
+            openedParentheses -= 1;
+        }
+        characterIndex += 1;
+    }
+    return [search.slice(0, characterIndex), search.slice(characterIndex + 1)];
+}
+function getLightDarkValue(value) {
+    const [prefix, ...search] = value.split(FUNCTION);
+    if (!search.length) {
+        return { light: value, dark: value };
+    }
+    const [macro, suffix] = splitStringAtCharacter(')', search.join(FUNCTION));
+    const [light, dark] = splitStringAtCharacter(',', macro);
+    const parsedSuffix = getLightDarkValue(suffix);
+    return {
+        light: prefix + getLightDarkValue(light.trim()).light + parsedSuffix.light,
+        dark: prefix + getLightDarkValue(dark.trim()).dark + parsedSuffix.dark,
+    };
+}
+module.exports = () => {
+    return {
+        postcssPlugin: 'postcss-light-dark',
+        Once(root) {
+            root.walkDecls((decl) => {
+                const { value } = decl;
+                const regex = /\blight-dark\b/;
+                if (regex.test(value)) {
+                    const { light: lightVal, dark: darkVal } = getLightDarkValue(value);
+                    const darkMixin = (0, postcss_1.atRule)({ name: 'mixin', params: 'dark' });
+                    darkMixin.append(decl.clone({ value: darkVal }));
+                    decl.parent?.insertAfter(decl, darkMixin);
+                    decl.parent?.insertAfter(decl, decl.clone({ value: lightVal }));
+                    decl.remove();
+                }
+            });
+        },
+    };
+};
+module.exports.postcss = true;
@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const converters = require('./converters');
+const getRegExp = (units) => new RegExp('\\b' + units + '\\(([^()]+)\\)', 'g');
+const emRegExp = getRegExp('em');
+const remRegExp = getRegExp('rem');
+module.exports = () => {
+    return {
+        postcssPlugin: 'postcss-rem-em',
+        Once(root) {
+            root.replaceValues(remRegExp, { fast: `rem(` }, (_, values) => converters.rem(values));
+            root.replaceValues(emRegExp, { fast: `em(` }, (_, values) => converters.em(values));
+        },
+        AtRule: {
+            media: (atRule) => {
+                atRule.params = atRule.params
+                    .replace(remRegExp, (value) => converters.remNoScale(value.replace(/rem\((.*?)\)/g, '$1')))
+                    .replace(emRegExp, (value) => converters.em(value.replace(/em\((.*?)\)/g, '$1')));
+            },
+            container: (atRule) => {
+                atRule.params = atRule.params
+                    .replace(remRegExp, (value) => converters.remNoScale(value.replace(/rem\((.*?)\)/g, '$1')))
+                    .replace(emRegExp, (value) => converters.em(value.replace(/em\((.*?)\)/g, '$1')));
+            },
+        },
+    };
+};
+module.exports.postcss = true;
@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nested = require('postcss-nested');
+const mixins = require('postcss-mixins');
+const remEm = require('./postcss-rem-em');
+const colorMixAlpha = require('./postcss-color-mix');
+const lightDark = require('./postcss-light-dark');
+const converters = require('./converters');
+const autorem = require('./auto-rem');
+function colorSchemeMixin(colorScheme, type = 'default') {
+    if (type === 'where') {
+        return {
+            [`:where([data-mantine-color-scheme='${colorScheme}']) &`]: {
+                '@mixin-content': {},
+            },
+        };
+    }
+    return {
+        [`[data-mantine-color-scheme='${colorScheme}'] &`]: {
+            '@mixin-content': {},
+        },
+    };
+}
+function rootColorSchemeMixin(colorScheme, type = 'default') {
+    if (type === 'where') {
+        return {
+            [`&:where(:root[data-mantine-color-scheme='${colorScheme}'])`]: {
+                '@mixin-content': {},
+            },
+        };
+    }
+    return {
+        [`&[data-mantine-color-scheme='${colorScheme}']`]: {
+            '@mixin-content': {},
+        },
+    };
+}
+const hoverMixin = {
+    '@media (hover: hover)': {
+        '&:hover': {
+            '@mixin-content': {},
+        },
+    },
+    '@media (hover: none)': {
+        '&:active': {
+            '@mixin-content': {},
+        },
+    },
+};
+const hoverWhereMixin = {
+    '@media (hover: hover)': {
+        '&:where(:hover)': {
+            '@mixin-content': {},
+        },
+    },
+    '@media (hover: none)': {
+        '&:where(:active)': {
+            '@mixin-content': {},
+        },
+    },
+};
+const rtlMixin = {
+    '[dir="rtl"] &': {
+        '@mixin-content': {},
+    },
+};
+const ltrMixin = {
+    '[dir="ltr"] &': {
+        '@mixin-content': {},
+    },
+};
+const notRtlMixin = {
+    ':root:not([dir="rtl"]) &': {
+        '@mixin-content': {},
+    },
+};
+const notLtrMixin = {
+    ':root:not([dir="ltr"]) &': {
+        '@mixin-content': {},
+    },
+};
+const rtlWhereMixin = {
+    ':where([dir="rtl"]) &': {
+        '@mixin-content': {},
+    },
+};
+const ltrWhereMixin = {
+    ':where([dir="ltr"]) &': {
+        '@mixin-content': {},
+    },
+};
+const notRtlWhereMixin = {
+    ':where([dir="ltr"]) &': {
+        '@mixin-content': {},
+    },
+};
+const notLtrWhereMixin = {
+    ':where([dir="ltr"]) &': {
+        '@mixin-content': {},
+    },
+};
+const smallerThanMixin = (_mixin, breakpoint) => ({
+    [`@media (max-width: ${converters.em(converters.px(breakpoint) - 0.1)})`]: {
+        '@mixin-content': {},
+    },
+});
+const largerThanMixin = (_mixin, breakpoint) => ({
+    [`@media (min-width: ${converters.em(breakpoint)})`]: {
+        '@mixin-content': {},
+    },
+});
+const defaultFeatures = {
+    lightDarkFunction: true,
+    nested: true,
+    colorMixAlpha: true,
+    remEmFunctions: true,
+    mixins: true,
+};
+module.exports = (options = {}) => {
+    const features = {
+        ...defaultFeatures,
+        ...(options.features || {}),
+    };
+    const plugins = [];
+    if (options.autoRem) {
+        plugins.push(autorem());
+    }
+    if (features.lightDarkFunction) {
+        plugins.push(lightDark());
+    }
+    if (features.nested) {
+        plugins.push(nested());
+    }
+    if (features.colorMixAlpha) {
+        plugins.push(colorMixAlpha());
+    }
+    if (features.remEmFunctions) {
+        plugins.push(remEm());
+    }
+    if (features.mixins) {
+        plugins.push(mixins({
+            mixins: {
+                light: colorSchemeMixin('light'),
+                dark: colorSchemeMixin('dark'),
+                'light-root': rootColorSchemeMixin('light'),
+                'dark-root': rootColorSchemeMixin('dark'),
+                'where-light': colorSchemeMixin('light', 'where'),
+                'where-dark': colorSchemeMixin('dark', 'where'),
+                'where-light-root': rootColorSchemeMixin('light', 'where'),
+                'where-dark-root': rootColorSchemeMixin('dark', 'where'),
+                hover: hoverMixin,
+                'where-hover': hoverWhereMixin,
+                rtl: rtlMixin,
+                ltr: ltrMixin,
+                'not-rtl': notRtlMixin,
+                'not-ltr': notLtrMixin,
+                'where-rtl': rtlWhereMixin,
+                'where-ltr': ltrWhereMixin,
+                'where-not-rtl': notRtlWhereMixin,
+                'where-not-ltr': notLtrWhereMixin,
+                'smaller-than': smallerThanMixin,
+                'larger-than': largerThanMixin,
+                ...(options.mixins || {}),
+            },
+        }));
+    }
+    return {
+        postcssPlugin: 'postcss-preset-mantine',
+        plugins,
+    };
+};
+module.exports.postcss = true;
@@ -0,0 +1,17 @@
+// @ts-check
+
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  tseslint.configs.recommended,
+  {
+    rules: {
+      '@typescript-eslint/no-var-requires': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-require-imports': 'off',
+    },
+  },
+  { ignores: ['**/*.{mjs,cjs,js,d.ts,d.mts}'] }
+);
@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};
@@ -0,0 +1,61 @@
+{
+  "name": "postcss-preset-mantine",
+  "version": "1.18.0",
+  "description": "PostCSS preset for Mantine (7.0+) applications",
+  "main": "dist/preset.js",
+  "types": "dist/index.d.ts",
+  "peerDependencies": {
+    "postcss": ">=8.0.0"
+  },
+  "dependencies": {
+    "postcss-mixins": "^12.0.0",
+    "postcss-nested": "^7.0.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.23.0",
+    "@types/fs-extra": "^11",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.13.14",
+    "@types/postcss-mixins": "^9.0.6",
+    "@types/signale": "^1",
+    "eslint": "^9.23.0",
+    "fs-extra": "^11.3.0",
+    "jest": "^29.7.0",
+    "postcss": "^8.5.3",
+    "prettier": "^3.5.3",
+    "signale": "^1.4.0",
+    "simple-git": "^3.27.0",
+    "ts-jest": "^29.3.0",
+    "tsc": "^2.0.4",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.2",
+    "typescript-eslint": "^8.28.0",
+    "version-next": "^1.0.2",
+    "zx": "^8.6.0"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json && echo 'declare module \"postcss-preset-mantine\";' > dist/index.d.ts",
+    "lint": "eslint src --cache",
+    "prettier:check": "prettier --check src",
+    "typecheck": "tsc --noEmit",
+    "jest": "jest",
+    "jest:update-snapshots": "jest --updateSnapshot",
+    "prepublish": "yarn test && yarn build",
+    "test": "npm run lint && npm run prettier:check && npm run typecheck && npm run jest",
+    "clean": "rm -rf dist",
+    "release": "tsx scripts/release"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mantinedev/postcss-preset-mantine"
+  },
+  "keywords": [
+    "postcss",
+    "mantine",
+    "react",
+    "css"
+  ],
+  "author": "rtivital@gmail.com",
+  "license": "MIT",
+  "packageManager": "yarn@4.9.2"
+}
@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "lib": ["es2018", "dom"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "target": "esnext",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": false
+  },
+  "exclude": ["node_modules", "dist", "src/**/*.test.ts", "src/tests/**", "./scripts"]
+}
				`@@ -0,0 +1 @@`
				`../../postcss-mixins@12.1.2_postcss@8.5.15/node_modules/postcss-mixins`
				`@@ -0,0 +1 @@`
				`../../postcss-nested@7.0.2_postcss@8.5.15/node_modules/postcss-nested`