@comvi/next 0.1.0

package/dist/routing/context.cjs

@@ -0,0 +1,21 @@
+"use client";
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_defineRouting = require("./defineRouting.cjs");
+let react = require("react");
+react = require_runtime.__toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region src/routing/context.tsx
+var RoutingContext = (0, react.createContext)(null);
+function RoutingProvider({ routing, children }) {
+	const value = (0, react.useMemo)(() => require_defineRouting.defineRouting(routing), [routing]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RoutingContext.Provider, {
+		value,
+		children
+	});
+}
+function useRoutingConfig() {
+	return (0, react.useContext)(RoutingContext);
+}
+//#endregion
+exports.RoutingProvider = RoutingProvider;
+exports.useRoutingConfig = useRoutingConfig;

package/dist/routing/context.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { RoutingConfig } from './types';
+export interface RoutingProviderProps {
+    routing: RoutingConfig;
+    children: React.ReactNode;
+}
+export declare function RoutingProvider({ routing, children }: RoutingProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useRoutingConfig(): Required<RoutingConfig> | null;
+//# sourceMappingURL=context.d.ts.map

package/dist/routing/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/routing/context.tsx"],"names":[],"mappings":"AAEA,OAAO,KAA6C,MAAM,OAAO,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAK7C,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,aAAa,CAAC;IACvB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,wBAAgB,eAAe,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,oBAAoB,2CAG1E;AAED,wBAAgB,gBAAgB,IAAI,QAAQ,CAAC,aAAa,CAAC,GAAG,IAAI,CAEjE"}

package/dist/routing/context.js

@@ -0,0 +1,18 @@
+"use client";
+import { defineRouting } from "./defineRouting.js";
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/routing/context.tsx
+var RoutingContext = createContext(null);
+function RoutingProvider({ routing, children }) {
+	const value = useMemo(() => defineRouting(routing), [routing]);
+	return /* @__PURE__ */ jsx(RoutingContext.Provider, {
+		value,
+		children
+	});
+}
+function useRoutingConfig() {
+	return useContext(RoutingContext);
+}
+//#endregion
+export { RoutingProvider, useRoutingConfig };

package/dist/routing/defineRouting.cjs

@@ -0,0 +1,141 @@
+//#region src/routing/defineRouting.ts
+/**
+* Define routing configuration for your app
+*
+* This configuration is used by both the middleware and navigation components
+* to handle localized routing.
+*
+* @param config - Routing configuration
+* @returns The same configuration with defaults applied
+*
+* @example
+* ```typescript
+* // i18n/routing.ts
+* import { defineRouting } from '@comvi/next/routing';
+*
+* export const routing = defineRouting({
+*   locales: ['en', 'uk', 'de'],
+*   defaultLocale: 'en',
+*   localePrefix: 'as-needed',
+* });
+* ```
+*/
+function defineRouting(config) {
+	return {
+		...config,
+		localePrefix: config.localePrefix ?? "as-needed",
+		localeCookie: config.localeCookie ?? "NEXT_LOCALE",
+		pathnames: config.pathnames ?? {}
+	};
+}
+/**
+* Type guard to check if a string is a valid locale
+*
+* Use this in layouts/pages to validate the locale parameter
+* and get proper TypeScript narrowing.
+*
+* @param locales - Array of supported locales
+* @param locale - String to check
+* @returns True if locale is valid
+*
+* @example
+* ```typescript
+* import { hasLocale } from '@comvi/next/routing';
+* import { routing } from '@/i18n/routing';
+* import { notFound } from 'next/navigation';
+*
+* export default async function Page({ params }: { params: Promise<{ locale: string }> }) {
+*   const { locale } = await params;
+*
+*   if (!hasLocale(routing.locales, locale)) {
+*     notFound();
+*   }
+*
+*   // locale is now typed as 'en' | 'uk' | 'de'
+*   return <div>Locale: {locale}</div>;
+* }
+* ```
+*/
+function hasLocale(locales, locale) {
+	return locales.includes(locale);
+}
+/**
+* Creates a getPathname function bound to your routing configuration
+*
+* Use this to construct localized pathnames for sitemaps, hreflang tags,
+* and canonical URLs.
+*
+* @param config - Your routing configuration
+* @returns A getPathname function
+*
+* @example
+* ```typescript
+* // i18n/navigation.ts
+* import { createGetPathname } from '@comvi/next/routing';
+* import { routing } from './routing';
+*
+* export const getPathname = createGetPathname(routing);
+* ```
+*
+* @example
+* ```typescript
+* // app/sitemap.ts
+* import { getPathname } from '@/i18n/navigation';
+* import { routing } from '@/i18n/routing';
+*
+* export default function sitemap() {
+*   const baseUrl = 'https://example.com';
+*   const pages = ['/', '/about', '/contact'];
+*
+*   return pages.flatMap((page) =>
+*     routing.locales.map((locale) => ({
+*       url: `${baseUrl}${getPathname({ locale, href: page })}`,
+*       lastModified: new Date(),
+*       alternates: {
+*         languages: Object.fromEntries(
+*           routing.locales.map((l) => [
+*             l,
+*             `${baseUrl}${getPathname({ locale: l, href: page })}`,
+*           ])
+*         ),
+*       },
+*     }))
+*   );
+* }
+* ```
+*
+* @example
+* ```typescript
+* // Generate hreflang tags
+* import { getPathname } from '@/i18n/navigation';
+* import { routing } from '@/i18n/routing';
+*
+* function generateHreflangTags(currentPath: string) {
+*   return routing.locales.map((locale) => ({
+*     rel: 'alternate',
+*     hrefLang: locale,
+*     href: `https://example.com${getPathname({ locale, href: currentPath })}`,
+*   }));
+* }
+* ```
+*/
+function createGetPathname(config) {
+	const { locales, defaultLocale, localePrefix, pathnames } = config;
+	return function getPathname({ locale, href }) {
+		if (!locales.includes(locale)) console.warn(`[getPathname] Unknown locale "${locale}". Expected one of: ${locales.join(", ")}`);
+		const localizedPath = pathnames[href]?.[locale] ?? href;
+		const normalizedPath = localizedPath.startsWith("/") ? localizedPath : `/${localizedPath}`;
+		switch (localePrefix) {
+			case "always": return `/${locale}${normalizedPath === "/" ? "" : normalizedPath}`;
+			case "as-needed":
+				if (locale === defaultLocale) return normalizedPath;
+				return `/${locale}${normalizedPath === "/" ? "" : normalizedPath}`;
+			case "never": return normalizedPath;
+			default: return normalizedPath;
+		}
+	};
+}
+//#endregion
+exports.createGetPathname = createGetPathname;
+exports.defineRouting = defineRouting;
+exports.hasLocale = hasLocale;

package/dist/routing/defineRouting.d.ts

@@ -0,0 +1,123 @@
+import { RoutingConfig } from './types';
+/**
+ * Define routing configuration for your app
+ *
+ * This configuration is used by both the middleware and navigation components
+ * to handle localized routing.
+ *
+ * @param config - Routing configuration
+ * @returns The same configuration with defaults applied
+ *
+ * @example
+ * ```typescript
+ * // i18n/routing.ts
+ * import { defineRouting } from '@comvi/next/routing';
+ *
+ * export const routing = defineRouting({
+ *   locales: ['en', 'uk', 'de'],
+ *   defaultLocale: 'en',
+ *   localePrefix: 'as-needed',
+ * });
+ * ```
+ */
+export declare function defineRouting<T extends string>(config: RoutingConfig<T>): Required<RoutingConfig<T>>;
+/**
+ * Type guard to check if a string is a valid locale
+ *
+ * Use this in layouts/pages to validate the locale parameter
+ * and get proper TypeScript narrowing.
+ *
+ * @param locales - Array of supported locales
+ * @param locale - String to check
+ * @returns True if locale is valid
+ *
+ * @example
+ * ```typescript
+ * import { hasLocale } from '@comvi/next/routing';
+ * import { routing } from '@/i18n/routing';
+ * import { notFound } from 'next/navigation';
+ *
+ * export default async function Page({ params }: { params: Promise<{ locale: string }> }) {
+ *   const { locale } = await params;
+ *
+ *   if (!hasLocale(routing.locales, locale)) {
+ *     notFound();
+ *   }
+ *
+ *   // locale is now typed as 'en' | 'uk' | 'de'
+ *   return <div>Locale: {locale}</div>;
+ * }
+ * ```
+ */
+export declare function hasLocale<T extends string>(locales: readonly T[], locale: string): locale is T;
+/**
+ * Options for getPathname function
+ */
+export interface GetPathnameOptions {
+    /** Target locale */
+    locale: string;
+    /** The pathname (without locale prefix) */
+    href: string;
+}
+/**
+ * Creates a getPathname function bound to your routing configuration
+ *
+ * Use this to construct localized pathnames for sitemaps, hreflang tags,
+ * and canonical URLs.
+ *
+ * @param config - Your routing configuration
+ * @returns A getPathname function
+ *
+ * @example
+ * ```typescript
+ * // i18n/navigation.ts
+ * import { createGetPathname } from '@comvi/next/routing';
+ * import { routing } from './routing';
+ *
+ * export const getPathname = createGetPathname(routing);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // app/sitemap.ts
+ * import { getPathname } from '@/i18n/navigation';
+ * import { routing } from '@/i18n/routing';
+ *
+ * export default function sitemap() {
+ *   const baseUrl = 'https://example.com';
+ *   const pages = ['/', '/about', '/contact'];
+ *
+ *   return pages.flatMap((page) =>
+ *     routing.locales.map((locale) => ({
+ *       url: `${baseUrl}${getPathname({ locale, href: page })}`,
+ *       lastModified: new Date(),
+ *       alternates: {
+ *         languages: Object.fromEntries(
+ *           routing.locales.map((l) => [
+ *             l,
+ *             `${baseUrl}${getPathname({ locale: l, href: page })}`,
+ *           ])
+ *         ),
+ *       },
+ *     }))
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Generate hreflang tags
+ * import { getPathname } from '@/i18n/navigation';
+ * import { routing } from '@/i18n/routing';
+ *
+ * function generateHreflangTags(currentPath: string) {
+ *   return routing.locales.map((locale) => ({
+ *     rel: 'alternate',
+ *     hrefLang: locale,
+ *     href: `https://example.com${getPathname({ locale, href: currentPath })}`,
+ *   }));
+ * }
+ * ```
+ */
+export declare function createGetPathname<T extends string>(config: Required<RoutingConfig<T>>): (options: GetPathnameOptions) => string;
+//# sourceMappingURL=defineRouting.d.ts.map

package/dist/routing/defineRouting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineRouting.d.ts","sourceRoot":"","sources":["../../src/routing/defineRouting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAC5C,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAO5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,CAAC,CAE9F;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,oBAAoB;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAChD,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GACjC,CAAC,OAAO,EAAE,kBAAkB,KAAK,MAAM,CAsCzC"}

package/dist/routing/defineRouting.js

@@ -0,0 +1,139 @@
+//#region src/routing/defineRouting.ts
+/**
+* Define routing configuration for your app
+*
+* This configuration is used by both the middleware and navigation components
+* to handle localized routing.
+*
+* @param config - Routing configuration
+* @returns The same configuration with defaults applied
+*
+* @example
+* ```typescript
+* // i18n/routing.ts
+* import { defineRouting } from '@comvi/next/routing';
+*
+* export const routing = defineRouting({
+*   locales: ['en', 'uk', 'de'],
+*   defaultLocale: 'en',
+*   localePrefix: 'as-needed',
+* });
+* ```
+*/
+function defineRouting(config) {
+	return {
+		...config,
+		localePrefix: config.localePrefix ?? "as-needed",
+		localeCookie: config.localeCookie ?? "NEXT_LOCALE",
+		pathnames: config.pathnames ?? {}
+	};
+}
+/**
+* Type guard to check if a string is a valid locale
+*
+* Use this in layouts/pages to validate the locale parameter
+* and get proper TypeScript narrowing.
+*
+* @param locales - Array of supported locales
+* @param locale - String to check
+* @returns True if locale is valid
+*
+* @example
+* ```typescript
+* import { hasLocale } from '@comvi/next/routing';
+* import { routing } from '@/i18n/routing';
+* import { notFound } from 'next/navigation';
+*
+* export default async function Page({ params }: { params: Promise<{ locale: string }> }) {
+*   const { locale } = await params;
+*
+*   if (!hasLocale(routing.locales, locale)) {
+*     notFound();
+*   }
+*
+*   // locale is now typed as 'en' | 'uk' | 'de'
+*   return <div>Locale: {locale}</div>;
+* }
+* ```
+*/
+function hasLocale(locales, locale) {
+	return locales.includes(locale);
+}
+/**
+* Creates a getPathname function bound to your routing configuration
+*
+* Use this to construct localized pathnames for sitemaps, hreflang tags,
+* and canonical URLs.
+*
+* @param config - Your routing configuration
+* @returns A getPathname function
+*
+* @example
+* ```typescript
+* // i18n/navigation.ts
+* import { createGetPathname } from '@comvi/next/routing';
+* import { routing } from './routing';
+*
+* export const getPathname = createGetPathname(routing);
+* ```
+*
+* @example
+* ```typescript
+* // app/sitemap.ts
+* import { getPathname } from '@/i18n/navigation';
+* import { routing } from '@/i18n/routing';
+*
+* export default function sitemap() {
+*   const baseUrl = 'https://example.com';
+*   const pages = ['/', '/about', '/contact'];
+*
+*   return pages.flatMap((page) =>
+*     routing.locales.map((locale) => ({
+*       url: `${baseUrl}${getPathname({ locale, href: page })}`,
+*       lastModified: new Date(),
+*       alternates: {
+*         languages: Object.fromEntries(
+*           routing.locales.map((l) => [
+*             l,
+*             `${baseUrl}${getPathname({ locale: l, href: page })}`,
+*           ])
+*         ),
+*       },
+*     }))
+*   );
+* }
+* ```
+*
+* @example
+* ```typescript
+* // Generate hreflang tags
+* import { getPathname } from '@/i18n/navigation';
+* import { routing } from '@/i18n/routing';
+*
+* function generateHreflangTags(currentPath: string) {
+*   return routing.locales.map((locale) => ({
+*     rel: 'alternate',
+*     hrefLang: locale,
+*     href: `https://example.com${getPathname({ locale, href: currentPath })}`,
+*   }));
+* }
+* ```
+*/
+function createGetPathname(config) {
+	const { locales, defaultLocale, localePrefix, pathnames } = config;
+	return function getPathname({ locale, href }) {
+		if (!locales.includes(locale)) console.warn(`[getPathname] Unknown locale "${locale}". Expected one of: ${locales.join(", ")}`);
+		const localizedPath = pathnames[href]?.[locale] ?? href;
+		const normalizedPath = localizedPath.startsWith("/") ? localizedPath : `/${localizedPath}`;
+		switch (localePrefix) {
+			case "always": return `/${locale}${normalizedPath === "/" ? "" : normalizedPath}`;
+			case "as-needed":
+				if (locale === defaultLocale) return normalizedPath;
+				return `/${locale}${normalizedPath === "/" ? "" : normalizedPath}`;
+			case "never": return normalizedPath;
+			default: return normalizedPath;
+		}
+	};
+}
+//#endregion
+export { createGetPathname, defineRouting, hasLocale };

package/dist/routing/hooks.cjs

@@ -0,0 +1,104 @@
+"use client";
+"use client";
+require("../_virtual/_rolldown/runtime.cjs");
+const require_context = require("./context.cjs");
+const require_utils = require("./utils.cjs");
+let react = require("react");
+let _comvi_react = require("@comvi/react");
+let next_navigation = require("next/navigation");
+//#region src/routing/hooks.ts
+/**
+* Get pathname without locale prefix
+*
+* This hook returns the current pathname with the locale prefix removed,
+* making it easier to work with routes in a locale-agnostic way.
+*
+* @returns Pathname without locale prefix
+*
+* @example
+* ```tsx
+* import { usePathname } from '@comvi/next/navigation';
+*
+* function MyComponent() {
+*   const pathname = usePathname();
+*   // If URL is /en/about, pathname is /about
+*   return <p>Current page: {pathname}</p>;
+* }
+* ```
+*/
+function usePathname() {
+	const pathname = (0, next_navigation.usePathname)() ?? "/";
+	const routing = require_context.useRoutingConfig();
+	const { locale } = (0, _comvi_react.useI18n)();
+	if (routing) return require_utils.getCanonicalPathname(require_utils.stripLocalePrefix(pathname, routing.locales), routing, locale);
+	if (pathname.startsWith(`/${locale}/`)) return pathname.slice(locale.length + 1);
+	if (pathname === `/${locale}`) return "/";
+	return pathname;
+}
+/**
+* Localized router with automatic locale prefixing
+*
+* This hook wraps Next.js useRouter and automatically adds locale
+* prefixes to navigation methods.
+*
+* @returns Localized router object
+*
+* @example
+* ```tsx
+* import { useLocalizedRouter } from '@comvi/next/navigation';
+*
+* function MyComponent() {
+*   const router = useLocalizedRouter();
+*
+*   const handleClick = () => {
+*     router.push('/about'); // Navigates to /en/about (or current locale)
+*   };
+*
+*   const handleGerman = () => {
+*     router.push('/about', 'de'); // Navigates to /de/about
+*   };
+*
+*   return <button onClick={handleClick}>Go to About</button>;
+* }
+* ```
+*/
+function useLocalizedRouter() {
+	const router = (0, next_navigation.useRouter)();
+	const { locale } = (0, _comvi_react.useI18n)();
+	const routing = require_context.useRoutingConfig();
+	const push = (0, react.useCallback)((href, targetLocale) => {
+		const localizedHref = require_utils.localizeHref(href, targetLocale ?? locale, routing ?? void 0);
+		router.push(localizedHref);
+	}, [
+		router,
+		locale,
+		routing
+	]);
+	const replace = (0, react.useCallback)((href, targetLocale) => {
+		const localizedHref = require_utils.localizeHref(href, targetLocale ?? locale, routing ?? void 0);
+		router.replace(localizedHref);
+	}, [
+		router,
+		locale,
+		routing
+	]);
+	const prefetch = (0, react.useCallback)((href, targetLocale) => {
+		const localizedHref = require_utils.localizeHref(href, targetLocale ?? locale, routing ?? void 0);
+		router.prefetch(localizedHref);
+	}, [
+		router,
+		locale,
+		routing
+	]);
+	return {
+		push,
+		replace,
+		back: router.back,
+		forward: router.forward,
+		refresh: router.refresh,
+		prefetch
+	};
+}
+//#endregion
+exports.useLocalizedRouter = useLocalizedRouter;
+exports.usePathname = usePathname;

package/dist/routing/hooks.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Get pathname without locale prefix
+ *
+ * This hook returns the current pathname with the locale prefix removed,
+ * making it easier to work with routes in a locale-agnostic way.
+ *
+ * @returns Pathname without locale prefix
+ *
+ * @example
+ * ```tsx
+ * import { usePathname } from '@comvi/next/navigation';
+ *
+ * function MyComponent() {
+ *   const pathname = usePathname();
+ *   // If URL is /en/about, pathname is /about
+ *   return <p>Current page: {pathname}</p>;
+ * }
+ * ```
+ */
+export declare function usePathname(): string;
+/**
+ * Return type for useLocalizedRouter
+ */
+export interface LocalizedRouter {
+    /** Navigate to a localized path */
+    push: (href: string, locale?: string) => void;
+    /** Replace current history entry with a localized path */
+    replace: (href: string, locale?: string) => void;
+    /** Navigate back */
+    back: () => void;
+    /** Navigate forward */
+    forward: () => void;
+    /** Refresh the current page */
+    refresh: () => void;
+    /** Prefetch a localized path */
+    prefetch: (href: string, locale?: string) => void;
+}
+/**
+ * Localized router with automatic locale prefixing
+ *
+ * This hook wraps Next.js useRouter and automatically adds locale
+ * prefixes to navigation methods.
+ *
+ * @returns Localized router object
+ *
+ * @example
+ * ```tsx
+ * import { useLocalizedRouter } from '@comvi/next/navigation';
+ *
+ * function MyComponent() {
+ *   const router = useLocalizedRouter();
+ *
+ *   const handleClick = () => {
+ *     router.push('/about'); // Navigates to /en/about (or current locale)
+ *   };
+ *
+ *   const handleGerman = () => {
+ *     router.push('/about', 'de'); // Navigates to /de/about
+ *   };
+ *
+ *   return <button onClick={handleClick}>Go to About</button>;
+ * }
+ * ```
+ */
+export declare function useLocalizedRouter(): LocalizedRouter;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/routing/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/routing/hooks.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAkBpC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,mCAAmC;IACnC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,0DAA0D;IAC1D,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,oBAAoB;IACpB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,uBAAuB;IACvB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,+BAA+B;IAC/B,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,gCAAgC;IAChC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CACnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAwCpD"}