@regardio/react 0.3.2

package/dist/utils/locale.d.ts

@@ -0,0 +1,22 @@
+import { LanguageDetectorLingui } from '@regardio/js/intl/language-detector';
+import { createCookie } from 'react-router';
+export interface LocaleConfigOptions {
+    defaultLocale: string;
+    supportedLocales: readonly string[];
+    cookieOptions?: {
+        name?: string;
+        maxAge?: number;
+        httpOnly?: boolean;
+        secure?: boolean;
+        sameSite?: 'strict' | 'lax' | 'none';
+    };
+    detectionOptions?: {
+        order?: Array<'urlPath' | 'cookie' | 'header'>;
+    };
+}
+export interface LocaleConfig {
+    localeCookie: ReturnType<typeof createCookie>;
+    languageDetector: LanguageDetectorLingui;
+}
+export declare function createLocaleConfig(options: LocaleConfigOptions): LocaleConfig;
+//# sourceMappingURL=locale.d.ts.map

package/dist/utils/locale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale.d.ts","sourceRoot":"","sources":["../../src/utils/locale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAK5C,MAAM,WAAW,mBAAmB;IAIlC,aAAa,EAAE,MAAM,CAAC;IAKtB,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAKpC,aAAa,CAAC,EAAE;QAId,IAAI,CAAC,EAAE,MAAM,CAAC;QAKd,MAAM,CAAC,EAAE,MAAM,CAAC;QAKhB,QAAQ,CAAC,EAAE,OAAO,CAAC;QAKnB,MAAM,CAAC,EAAE,OAAO,CAAC;QAKjB,QAAQ,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;KACtC,CAAC;IAKF,gBAAgB,CAAC,EAAE;QAIjB,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC,CAAC;KAChD,CAAC;CACH;AAKD,MAAM,WAAW,YAAY;IAI3B,YAAY,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;IAK9C,gBAAgB,EAAE,sBAAsB,CAAC;CAC1C;AAoBD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,GAAG,YAAY,CAmC7E"}

package/dist/utils/locale.js

@@ -0,0 +1,25 @@
+import { LanguageDetectorLingui } from '@regardio/js/intl/language-detector';
+import { createCookie } from 'react-router';
+export function createLocaleConfig(options) {
+    const { defaultLocale, supportedLocales, cookieOptions = {}, detectionOptions = {} } = options;
+    const { name = 'locale', maxAge = 60 * 60 * 24 * 365, httpOnly = false, secure = import.meta.env.MODE !== 'development', sameSite = 'lax', } = cookieOptions;
+    const { order = ['urlPath', 'cookie', 'header'] } = detectionOptions;
+    const localeCookie = createCookie(name, {
+        httpOnly,
+        maxAge,
+        sameSite,
+        secure,
+    });
+    const languageDetector = new LanguageDetectorLingui({
+        detection: {
+            cookie: localeCookie,
+            fallbackLanguage: defaultLocale,
+            order,
+            supportedLanguages: [...supportedLocales],
+        },
+    });
+    return {
+        languageDetector,
+        localeCookie,
+    };
+}

package/dist/utils/locale.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=locale.test.d.ts.map

package/dist/utils/locale.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale.test.d.ts","sourceRoot":"","sources":["../../src/utils/locale.test.ts"],"names":[],"mappings":""}

package/dist/utils/locale.test.js

@@ -0,0 +1,99 @@
+import { LanguageDetectorLingui } from '@regardio/js/intl/language-detector';
+import { beforeEach, describe, expect, test } from 'vitest';
+import { createLocaleConfig } from './locale';
+describe('createLocaleConfig', () => {
+    const originalEnvMode = import.meta.env.MODE;
+    beforeEach(() => {
+        import.meta.env.MODE = originalEnvMode;
+    });
+    test('creates config with default options', async () => {
+        const config = createLocaleConfig({
+            defaultLocale: 'en',
+            supportedLocales: ['en', 'de'],
+        });
+        expect(config.localeCookie).toBeDefined();
+        expect(config.localeCookie.name).toBe('locale');
+        const request = new Request('https://example.com', {
+            headers: {
+                Cookie: await config.localeCookie.serialize('en'),
+            },
+        });
+        const parsedValue = await config.localeCookie.parse(request.headers.get('Cookie'));
+        expect(parsedValue).toBe('en');
+        expect(config.languageDetector).toBeInstanceOf(LanguageDetectorLingui);
+        const mockRequest = new Request('https://example.com/en/page', {
+            headers: { 'Accept-Language': 'de' },
+        });
+        const detectedLocale = await config.languageDetector.getLocale(mockRequest);
+        expect(detectedLocale).toBe('en');
+    });
+    test('creates config with custom cookie options', async () => {
+        const config = createLocaleConfig({
+            cookieOptions: {
+                httpOnly: true,
+                maxAge: 3600,
+                name: 'custom-locale',
+                sameSite: 'strict',
+                secure: true,
+            },
+            defaultLocale: 'fr',
+            supportedLocales: ['fr', 'es'],
+        });
+        expect(config.localeCookie.name).toBe('custom-locale');
+        const cookieHeader = await config.localeCookie.serialize('fr');
+        console.log('Custom cookie header:', cookieHeader);
+        expect(typeof cookieHeader).toBe('string');
+        expect(cookieHeader.includes('custom-locale=')).toBe(true);
+        expect(/samesite=strict/i.test(cookieHeader)).toBe(true);
+        expect(/httponly/i.test(cookieHeader)).toBe(true);
+        expect(/secure/i.test(cookieHeader)).toBe(true);
+        expect(/max-age=3600/i.test(cookieHeader)).toBe(true);
+    });
+    test('creates config with custom detection order', async () => {
+        const config = createLocaleConfig({
+            defaultLocale: 'de',
+            detectionOptions: {
+                order: ['header', 'cookie', 'urlPath'],
+            },
+            supportedLocales: ['de', 'en'],
+        });
+        const mockRequest = new Request('https://example.com/en/page', {
+            headers: { 'Accept-Language': 'de' },
+        });
+        const detectedLocale = await config.languageDetector.getLocale(mockRequest);
+        expect(detectedLocale).toBe('de');
+    });
+    test('secure cookie defaults to true in production environment', async () => {
+        import.meta.env.MODE = 'production';
+        const config = createLocaleConfig({
+            defaultLocale: 'en',
+            supportedLocales: ['en', 'de'],
+        });
+        const cookieHeader = await config.localeCookie.serialize('en');
+        console.log('Production cookie header:', cookieHeader);
+        expect(typeof cookieHeader).toBe('string');
+        expect(/secure/i.test(cookieHeader)).toBe(true);
+    });
+    test('secure cookie defaults to false in development environment', async () => {
+        import.meta.env.MODE = 'development';
+        const config = createLocaleConfig({
+            defaultLocale: 'en',
+            supportedLocales: ['en', 'de'],
+        });
+        const cookieHeader = await config.localeCookie.serialize('en');
+        console.log('Development cookie header:', cookieHeader);
+        expect(typeof cookieHeader).toBe('string');
+        expect(/secure/i.test(cookieHeader)).toBe(false);
+    });
+    test('handles readonly supportedLocales array', async () => {
+        const supportedLocales = ['en', 'de'];
+        const config = createLocaleConfig({
+            defaultLocale: 'en',
+            supportedLocales,
+        });
+        const enRequest = new Request('https://example.com/en/page');
+        expect(await config.languageDetector.getLocale(enRequest)).toBe('en');
+        const deRequest = new Request('https://example.com/de/page');
+        expect(await config.languageDetector.getLocale(deRequest)).toBe('de');
+    });
+});

package/dist/utils/text.d.ts

@@ -0,0 +1,7 @@
+import React, { type ReactNode } from 'react';
+export declare const lowerCaseSzett: (text: ReactNode | string, _returnType?: "string") => ReactNode;
+export declare function toBoolean(value: string | boolean | null | undefined): boolean;
+export declare function shy(input: string | ReactNode | null): string | ReactNode | null;
+export declare function typographicQuotes(text: string, locale: string): string;
+export declare function replaceSpecialChars(text: string, locale: string): React.ReactNode;
+//# sourceMappingURL=text.d.ts.map

package/dist/utils/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/utils/text.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAmD,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAE/F,eAAO,MAAM,cAAc,GAAI,MAAM,SAAS,GAAG,MAAM,EAAE,cAAc,QAAQ,KAAG,SA2CjF,CAAC;AAEF,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAM7E;AAkCD,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAU/E;AA6FD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAWtE;AAKD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,mBAE/D"}

package/dist/utils/text.js

@@ -0,0 +1,102 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { cloneElement, isValidElement } from 'react';
+export const lowerCaseSzett = (text, _returnType) => {
+    const processString = (str) => {
+        const parts = str.split(/(ß)/g);
+        return parts.map((part, index) => part === 'ß' ? (_jsx("span", { className: "lowercase", children: part }, index.toString())) : (part));
+    };
+    if (typeof text === 'string') {
+        return processString(text);
+    }
+    if (isValidElement(text)) {
+        const element = text;
+        const { children, ...props } = element.props;
+        return cloneElement(element, {
+            ...props,
+            children: lowerCaseSzett(children),
+        });
+    }
+    if (Array.isArray(text)) {
+        return text.map((child, index) => (_jsx(React.Fragment, { children: lowerCaseSzett(child) }, index.toString())));
+    }
+    return text;
+};
+export function toBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    return value === 'true' || value === '1';
+}
+function replaceShyInString(input) {
+    return input.replace(/­/g, '\u00AD');
+}
+function replaceShyInReactNode(node) {
+    if (typeof node === 'string') {
+        return node.replace(/\u00AD/g, '');
+    }
+    if (isValidElement(node)) {
+        const element = node;
+        const { children, ...props } = element.props;
+        return cloneElement(element, {
+            ...props,
+            children: replaceShyInReactNode(children),
+        });
+    }
+    if (Array.isArray(node)) {
+        return node.map((child, index) => (_jsx(React.Fragment, { children: replaceShyInReactNode(child) }, index.toString())));
+    }
+    return node;
+}
+export function shy(input) {
+    if (input === null) {
+        return null;
+    }
+    if (typeof input === 'string') {
+        return replaceShyInString(input);
+    }
+    return replaceShyInReactNode(input);
+}
+const quoteStyles = {
+    cs: { close: '\u201D', closeSingle: '\u2019', open: '\u201E', openSingle: '\u201A' },
+    da: { close: '\u00AB', closeSingle: '\u203A', open: '\u00BB', openSingle: '\u2039' },
+    de: { close: '\u201D', closeSingle: '\u2019', open: '\u201E', openSingle: '\u201A' },
+    'de-ch': { close: '\u00BB', closeSingle: '\u203A', open: '\u00AB', openSingle: '\u2039' },
+    en: { close: '\u201D', closeSingle: '\u2019', open: '\u201C', openSingle: '\u2018' },
+    es: { close: '\u00BB', closeSingle: '\u201D', open: '\u00AB', openSingle: '\u201C' },
+    fi: { close: '\u201D', closeSingle: '\u2019', open: '\u201D', openSingle: '\u2019' },
+    fr: { close: ' \u00BB', closeSingle: ' \u203A', open: '\u00AB ', openSingle: '\u2039 ' },
+    hu: { close: '\u201D', closeSingle: '\u2019', open: '\u201E', openSingle: '\u201A' },
+    it: { close: '\u00BB', closeSingle: '\u201D', open: '\u00AB', openSingle: '\u201C' },
+    ja: { close: '\u300D', closeSingle: '\u300F', open: '\u300C', openSingle: '\u300E' },
+    nl: { close: '\u2019', closeSingle: '\u2019', open: '\u2018', openSingle: '\u2018' },
+    no: { close: '\u00AB', closeSingle: '\u203A', open: '\u00BB', openSingle: '\u2039' },
+    pl: { close: '\u201D', closeSingle: '\u2019', open: '\u201E', openSingle: '\u201A' },
+    pt: { close: '\u00BB', closeSingle: '\u201D', open: '\u00AB', openSingle: '\u201C' },
+    ru: { close: '\u00BB', closeSingle: '\u2019', open: '\u00AB', openSingle: '\u201A' },
+    sv: { close: '\u201D', closeSingle: '\u2019', open: '\u201D', openSingle: '\u2019' },
+    zh: { close: '\u300D', closeSingle: '\u300F', open: '\u300C', openSingle: '\u300E' },
+};
+function getQuoteStyle(locale) {
+    const normalized = locale.toLowerCase();
+    const exactMatch = quoteStyles[normalized];
+    if (exactMatch) {
+        return exactMatch;
+    }
+    const baseLanguage = normalized.split('-')[0];
+    if (baseLanguage) {
+        const baseMatch = quoteStyles[baseLanguage];
+        if (baseMatch) {
+            return baseMatch;
+        }
+    }
+    return quoteStyles.en;
+}
+export function typographicQuotes(text, locale) {
+    const style = getQuoteStyle(locale);
+    let result = text.replace(/"([^"]*)"/g, `${style.open}$1${style.close}`);
+    result = result.replace(/'([^']*)'/g, `${style.openSingle}$1${style.closeSingle}`);
+    return result;
+}
+export function replaceSpecialChars(text, locale) {
+    return shy(typographicQuotes(text, locale));
+}

package/dist/utils/text.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=text.test.d.ts.map

package/dist/utils/text.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.test.d.ts","sourceRoot":"","sources":["../../src/utils/text.test.ts"],"names":[],"mappings":""}

package/dist/utils/text.test.js

@@ -0,0 +1,122 @@
+import { describe, expect, test } from 'vitest';
+import { replaceSpecialChars, shy, toBoolean, typographicQuotes } from './text';
+describe('toBoolean', () => {
+    test('returns true for boolean true', () => {
+        expect(toBoolean(true)).toBe(true);
+    });
+    test('returns false for boolean false', () => {
+        expect(toBoolean(false)).toBe(false);
+    });
+    test('returns true for string "true"', () => {
+        expect(toBoolean('true')).toBe(true);
+    });
+    test('returns true for string "1"', () => {
+        expect(toBoolean('1')).toBe(true);
+    });
+    test('returns false for string "false"', () => {
+        expect(toBoolean('false')).toBe(false);
+    });
+    test('returns false for string "0"', () => {
+        expect(toBoolean('0')).toBe(false);
+    });
+    test('returns false for null', () => {
+        expect(toBoolean(null)).toBe(false);
+    });
+    test('returns false for undefined', () => {
+        expect(toBoolean(undefined)).toBe(false);
+    });
+    test('returns false for other strings', () => {
+        expect(toBoolean('yes')).toBe(false);
+        expect(toBoolean('no')).toBe(false);
+        expect(toBoolean('')).toBe(false);
+    });
+});
+describe('shy', () => {
+    test('returns null for null input', () => {
+        expect(shy(null)).toBe(null);
+    });
+    test('replaces ­ with soft hyphen in strings', () => {
+        const result = shy('hello­world');
+        expect(result).toBe('hello\u00ADworld');
+    });
+    test('handles strings without ­', () => {
+        expect(shy('hello world')).toBe('hello world');
+    });
+    test('handles multiple ­ occurrences', () => {
+        const result = shy('one­two­three');
+        expect(result).toBe('one\u00ADtwo\u00ADthree');
+    });
+});
+describe('replaceSpecialChars', () => {
+    test('replaces straight quotes for de locale', () => {
+        const result = replaceSpecialChars('"Hello"', 'de');
+        const str = String(result);
+        expect(str).not.toContain('"Hello"');
+        expect(str).toContain('Hello');
+    });
+    test('replaces straight quotes for de-DE locale', () => {
+        const result = replaceSpecialChars('"Hello"', 'de-DE');
+        const str = String(result);
+        expect(str).not.toContain('"Hello"');
+        expect(str).toContain('Hello');
+    });
+    test('replaces straight quotes for en locale', () => {
+        const result = replaceSpecialChars('"Hello"', 'en');
+        const str = String(result);
+        expect(str).not.toContain('"Hello"');
+        expect(str).toContain('Hello');
+    });
+    test('handles multiple quoted strings', () => {
+        const result = replaceSpecialChars('"one" and "two"', 'de');
+        const str = String(result);
+        expect(str).toContain('one');
+        expect(str).toContain('two');
+        expect(str).toContain('and');
+    });
+    test('also applies shy replacement', () => {
+        const result = replaceSpecialChars('"Hello­World"', 'en');
+        expect(String(result)).toContain('\u00AD');
+    });
+});
+describe('typographicQuotes', () => {
+    test('replaces double quotes with English curly quotes', () => {
+        const result = typographicQuotes('"Hello"', 'en');
+        expect(result).toBe('\u201CHello\u201D');
+    });
+    test('replaces double quotes with German quotes', () => {
+        const result = typographicQuotes('"Hello"', 'de');
+        expect(result).toBe('\u201EHello\u201D');
+    });
+    test('replaces double quotes with French guillemets', () => {
+        const result = typographicQuotes('"Hello"', 'fr');
+        expect(result).toBe('\u00AB Hello \u00BB');
+    });
+    test('handles de-DE locale (falls back to de)', () => {
+        const result = typographicQuotes('"Hello"', 'de-DE');
+        expect(result).toBe('\u201EHello\u201D');
+    });
+    test('handles de-CH locale (Swiss German with guillemets)', () => {
+        const result = typographicQuotes('"Hello"', 'de-CH');
+        expect(result).toBe('\u00ABHello\u00BB');
+    });
+    test('handles unknown locale (falls back to English)', () => {
+        const result = typographicQuotes('"Hello"', 'xx-YY');
+        expect(result).toBe('\u201CHello\u201D');
+    });
+    test('replaces single quotes', () => {
+        const result = typographicQuotes("'Hello'", 'en');
+        expect(result).toBe('\u2018Hello\u2019');
+    });
+    test('handles multiple quoted strings', () => {
+        const result = typographicQuotes('"one" and "two"', 'de');
+        expect(result).toBe('\u201Eone\u201D and \u201Etwo\u201D');
+    });
+    test('handles Japanese quotes', () => {
+        const result = typographicQuotes('"Hello"', 'ja');
+        expect(result).toBe('\u300CHello\u300D');
+    });
+    test('preserves text without quotes', () => {
+        const result = typographicQuotes('Hello World', 'en');
+        expect(result).toBe('Hello World');
+    });
+});

package/package.json

@@ -0,0 +1,117 @@
+{
+  "$schema": "https://www.schemastore.org/package.json",
+  "author": "Bernd Matzner <bernd.matzner@regard.io>",
+  "bugs": {
+    "url": "https://github.com/regardio/react/issues"
+  },
+  "dependencies": {
+    "@base-ui/react": "1.0.0",
+    "@maptiler/leaflet-maptilersdk": "4.1.1",
+    "@maptiler/sdk": "3.9.0",
+    "@mdx-js/react": "3.1.1",
+    "@regardio/js": "0.3.0",
+    "@supabase/supabase-js": "2.89.0",
+    "cmdk": "1.1.1",
+    "cva": "beta",
+    "embla-carousel": "8.6.0",
+    "embla-carousel-react": "8.6.0",
+    "fluid-tailwindcss": "1.0.5",
+    "input-otp": "1.4.2",
+    "intl-parse-accept-language": "1.0.0",
+    "leaflet": "alpha",
+    "lucide-react": "0.562.0",
+    "markdown-to-jsx": "9.5.0",
+    "react": "19.2.3",
+    "react-day-picker": "9.13.0",
+    "react-dom": "19.2.3",
+    "react-hook-form": "7.70.0",
+    "react-resizable-panels": "4.2.1",
+    "react-router": "7.11.0",
+    "tailwind-merge": "3.4.0",
+    "vaul": "1.1.2",
+    "zod": "4.3.5"
+  },
+  "description": "Regardio React UI components",
+  "devDependencies": {
+    "@regardio/dev": "1.9.4",
+    "@storybook/addon-a11y": "10.1.11",
+    "@storybook/addon-docs": "10.1.11",
+    "@storybook/addon-vitest": "10.1.11",
+    "@storybook/react-vite": "10.1.11",
+    "@tailwindcss/vite": "4.1.18",
+    "@testing-library/jest-dom": "6.9.1",
+    "@testing-library/react": "16.3.1",
+    "@total-typescript/ts-reset": "0.6.1",
+    "@types/leaflet": "1.9.21",
+    "@types/node": "25.0.3",
+    "@types/react": "19.2.7",
+    "@types/react-dom": "19.2.3",
+    "@vitejs/plugin-react": "5.1.2",
+    "@vitest/browser-playwright": "4.0.16",
+    "@vitest/coverage-v8": "4.0.16",
+    "@vitest/ui": "4.0.16",
+    "jsdom": "27.4.0",
+    "playwright": "^1.57.0",
+    "storybook": "10.1.11",
+    "tailwindcss": "4.1.18",
+    "typescript": "5.9.3",
+    "vite": "7.3.0",
+    "vitest": "4.0.16"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    "./components/*": {
+      "import": "./dist/components/*.js",
+      "types": "./dist/components/*.d.ts"
+    },
+    "./hooks/*": {
+      "import": "./dist/hooks/*.js",
+      "types": "./dist/hooks/*.d.ts"
+    },
+    "./tailwind.css": "./src/styles/tailwind.css",
+    "./utils/*": {
+      "import": "./dist/utils/*.js",
+      "types": "./dist/utils/*.d.ts"
+    }
+  },
+  "files": ["dist", "src"],
+  "homepage": "https://github.com/regardio/react/blob/main/README.md",
+  "keywords": ["react", "components", "ui", "regardio", "tailwindcss"],
+  "license": "MIT",
+  "name": "@regardio/react",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "directory": "packages/react",
+    "type": "git",
+    "url": "https://github.com/regardio/react.git"
+  },
+  "scripts": {
+    "build": "exec-tsc --project tsconfig.build.json",
+    "clean": "exec-clean .turbo dist",
+    "dev": "exec-tsc --project tsconfig.build.json --watch",
+    "fix": "exec-p fix:*",
+    "fix:biome": "lint-biome check --write --unsafe .",
+    "fix:md": "lint-md --fix",
+    "lint": "exec-p lint:*",
+    "lint:biome": "lint-biome check .",
+    "lint:md": "lint-md",
+    "prepare": "exec-husky",
+    "release": "flow-release",
+    "report": "exec-s report:*",
+    "report:unit": "vitest run --reporter html",
+    "storybook": "storybook dev -p 6006",
+    "storybook:build": "storybook build -o storybook-static",
+    "test": "exec-s test:*",
+    "test:unit": "vitest run",
+    "typecheck": "exec-tsc --noEmit",
+    "version": "flow-changeset version"
+  },
+  "sideEffects": ["./src/styles/tailwind.css"],
+  "type": "module",
+  "version": "0.3.2"
+}