@intlayer/docs 9.5.5 → 9.5.7

package/blog/hi/next-intl_vs_intlayer-next-intl.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-09-13
-updatedAt: 2026-09-13
+updatedAt: 2026-09-22
 title: "next-intl vs @intlayer/next-intl: समान API, विभिन्न Bundle"
 description: जब एक Next.js ऐप्लिकेशन के next-intl imports को @intlayer/next-intl compat adapter द्वारा परोसा जाता है तो क्या बदलता है। Bundle size, leakage, component size और hydration को समान कोड पर मापा गया है, साथ ही adapter क्या रखता है, अनदेखा करता है और क्या प्रतिस्थापित नहीं कर सकता है।
 keywords:
@@ -26,6 +26,8 @@ author: aymericzip
 
 # next-intl VS @intlayer/next-intl | समान API, विभिन्न Bundle
 
+![next-intl VS Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/assets/i18next-next-intl-intlayer.webp?raw=true)
+
 `@intlayer/next-intl` एक compat adapter है: यह `next-intl` API (`useTranslations`, `getTranslations`, `useLocale`, `t.rich()`, ICU plurals, `NextIntlClientProvider`...) को expose करता है और इसे Intlayer द्वारा compiled dictionaries से serve करता है। application code नहीं बदलता है। bundle बदलता है।
 
 यह article दोनों की तुलना एक ही Next.js application पर करता है, जो एक बार `next-intl` के साथ और एक बार adapter के साथ built है। नंबर [Benchmark Bloom](https://github.com/intlayer-org/benchmark-bloom) से आते हैं, एक open-source suite जो record करता है कि browser actually क्या download करता है। अगर आप `next-intl` vs Intlayer की तुलना libraries के रूप में चाहते हैं, तो [next-intl vs Intlayer](https://intlayer.org/blog/next-intl-vs-intlayer) पढ़ें। यह एक इस बारे में है कि adapter क्या बदलता है जब आप अपने components को जैसे हैं वैसे ही रखते हैं।
@@ -109,6 +111,10 @@ const AboutPage = () => {
 
 ### Next.js पर परिणाम
 
+उन मेट्रिक्स और लाइब्रेरीज़ को चुनें जिनकी आपको परवाह है:
+
+<I18nBenchmark framework="nextjs" vertical/>
+
 | Setup                     | Strategy       | Lib size (gz) | Page JS avg (gz) | Locale leak | Page leak | Component avg (gz) | E2E reactivity |   Hydration |
 | ------------------------- | -------------- | ------------: | ---------------: | ----------: | --------: | -----------------: | -------------: | ----------: |
 | **base** (no i18n)        | -              |        0.0 KB |         141.0 KB |        0.0% |      0.0% |             0.9 KB |        13.4 ms |     11.8 ms |
@@ -129,6 +135,15 @@ const AboutPage = () => {
 - **Hydration 2 ms तेज़ है** (12.8 vs 14.7 ms): RSC payload से React hydrate कर सकने से पहले deserialize करने के लिए कोई message object नहीं है।
 - **Adapter native runtime नहीं है।** `next-intlayer` **141.3 KB** पर बैठता है, base app के ऊपर +0.3 KB, एक 5.5 KB runtime के साथ। Adapter `next-intl` API surface (`useFormatter`, `t.rich`, ICU resolver) को Intlayer के core के शीर्ष पर ले जाता है, इसलिए 8.0 KB और page प्रति +6 KB। यह bridge है, destination नहीं।
 
+<ClickToOpenIframe
+src="https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-nextjs.md"
+width="100%"
+height="600px"
+style="border:none;"
+/>
+
+> [Next.js बेंचमार्क रिपोर्ट](https://intlayer.org/hi/doc/benchmark/nextjs) में पूरी तालिका, प्रत्येक लाइब्रेरी और प्रत्येक रणनीति देखें।
+
 ### TanStack Start पर परिणाम (`use-intl`)
 
 `use-intl` `next-intl` का framework-agnostic core है। इसका adapter, `@intlayer/use-intl`, एक Vite plugin (`@intlayer/use-intl/plugin`) के साथ एक ही design का पालन करता है।
@@ -152,11 +167,24 @@ const AboutPage = () => {
 - **Locale switching तेजी है।** Optimized `use-intl` setups को `html[lang]` अपडेट करने में **13-21 ms** लगते हैं; adapter को **4-9 ms** लगते हैं। कम components re-render होते हैं, और कुछ भी message tree से re-picked नहीं होता है।
 - **`static` हर locale रखता है।** Adapter की `static` row 49.7% locale leakage दिखाती है, native Intlayer के `static` mode के समान: सभी locales bundled हैं, केवल page के dictionaries हैं। Config की एक line (`importMode: 'dynamic'`) इसे हटा देती है।
 
+<ClickToOpenIframe
+src="https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-tanstack.md"
+width="100%"
+height="600px"
+style="border:none;"
+/>
+
+> [TanStack Start बेंचमार्क रिपोर्ट](https://intlayer.org/hi/doc/benchmark/tanstack) में पूरी तालिका देखें।
+
 ## संख्याएं क्यों बदलती हैं
 
+![The Intlayer compiler extracts content from components](https://github.com/aymericzip/intlayer/blob/main/docs/assets/compiler.webp?raw=true)
+
 Component में कुछ नहीं बदला, इसलिए gains पूरी तरह से इस बात से आते हैं कि `useTranslations` किस चीज से bound है।
 
-**`next-intl` के साथ**, binding provider है। `NextIntlClientProvider` पूरे locale के लिए संपूर्ण `messages` object प्राप्त करता है; हर `useTranslations("about")` इससे पढ़ता है। Bundler एक component को देखता है जो एक hook import करता है जो एक context पढ़ता है, और यह नहीं जान सकता कि केवल `about` branch का उपयोग किया जा रहा है। नीचे दिए गए routes सभी एक ही message object को साझा करते हैं, इसलिए page-leak column तब तक ~90% पढ़ता है जब तक आप स्वयं file को split न करें।
+**`next-intl` के साथ**, binding provider है। `NextIntlClientProvider` पूरे locale के लिए संपूर्ण `messages` object प्राप्त करता है; हर `useTranslations("about")` इससे पढ़ता है। Bundler एक component को देखता है जो एक hook import करता है जो एक context पढ़ता है, और यह नहीं जान सकता कि केवल `about` branch का उपयोग किया जा रहा है। नीचे दिए गए routes सभी एक ही message object को साझा करते हैं, इसलिए page-leak column तब तक ~90% पढ़ता है जब तक आप स्वयं file को split न करें, और अपव्यय एक साथ दो अक्षों, पृष्ठों और भाषाओं पर बढ़ता है:
+
+![Theoretical content leakage by architecture](https://github.com/aymericzip/intlayer/blob/main/docs/assets/theorical_content_leakage.webp?raw=true)
 
 ```bash
 .
@@ -280,25 +308,106 @@ export default withIntlayer(nextConfig);
 
 ## शुरुआत करने से पहले जानने योग्य सीमाएं
 
-- **Routing config `intlayer.config.ts` में move हो जाता है।** `createNavigation(routing)` और `createMiddleware(routing)` अपनी signature को बनाए रखते हैं लेकिन argument को ignore करते हैं: locales, default locale और prefix strategy Intlayer के `routing` config से आते हैं। अगर आप `next-intl` के localized `pathnames` (`/about` → `/a-propos`) का उपयोग करते हैं, तो adapter उन्हें interpolate नहीं करता; Intlayer का `routing.rewrite` उस case को cover करता है लेकिन यह एक अलग change है।
-- **Namespace-less `useTranslations()` bound नहीं है।** optimize pass को एक static namespace की जरूरत है यह जानने के लिए कि कौन सा dictionary import करना है। एक bare call अभी भी काम करती है, एक runtime registry के माध्यम से जो every dictionary को reference करती है, जो बिल्कुल वही leakage है जिसे आप हटाने की कोशिश कर रहे थे। namespace pass करें।
-- **एडेप्टर मुफ्त नहीं है।** `next-intlayer` के लिए 5.5 KB की तुलना में 8.0 KB रनटाइम, और नेटिव बिल्ड के ऊपर +6-7 KB प्रति पेज। यह `next-intl` API सतह के लिए भुगतान करता है। यदि आप उस बिंदु तक पहुंचते हैं जहां हर घटक को `useIntlayer` में स्थानांतरित किया गया है, तो एडेप्टर को छोड़ दें।
-- **प्रदाता पर `messages`, `timeZone`, `now` को अनदेखा किया जाता है।** फॉर्मेटर नेटिव `Intl` द्वारा समर्थित हैं और केवल लोकेल उनके आउटपुट को प्रभावित करता है; यदि आप एक принудительした समय क्षेत्र या hydration-स्थिर तारीखों के लिए एक निश्चित `now` पर निर्भर करते हैं, तो इसे कॉल साइट पर संभालें।
+<AccordionGroup>
+<Accordion header="रूटिंग कॉन्फ़िग intlayer.config.ts में जाता है">
+
+`createNavigation(routing)` और `createMiddleware(routing)` अपने सिग्नेचर बनाए रखते हैं लेकिन तर्क को अनदेखा करते हैं: भाषाएँ, डिफ़ॉल्ट भाषा और उपसर्ग रणनीति Intlayer के `routing` कॉन्फ़िग से आती हैं। यदि आप `next-intl` के स्थानीयकृत `pathnames` (`/about` से `/a-propos`) का उपयोग करते हैं, तो एडॉप्टर उन्हें इंटरपोलेट नहीं करता है; Intlayer का `routing.rewrite` उस मामले को कवर करता है लेकिन यह एक अलग बदलाव है।
+
+</Accordion>
+<Accordion header="बिना नेमस्पेस वाला useTranslations() बाउंड नहीं है">
+
+ऑप्टिमाइज़ पास को यह जानने के लिए एक स्थिर नेमस्पेस की आवश्यकता होती है कि किस डिक्शनरी को आयात करना है। बिना नेमस्पेस वाला कॉल अभी भी काम करता है, एक रनटाइम रजिस्ट्री के माध्यम से जो प्रत्येक डिक्शनरी को संदर्भित करती है, जो वास्तव में वही रिसाव है जिसे आप हटाने की कोशिश कर रहे थे। नेमस्पेस पास करें।
+
+</Accordion>
+<Accordion header="एडॉप्टर मुफ़्त नहीं है">
+
+`next-intlayer` के 5.5 KB के मुकाबले 8.0 KB का रनटाइम, और नेटिव बिल्ड पर प्रति पृष्ठ +6-7 KB। यह `next-intl` API सतह की कीमत चुकाता है। यदि आप उस बिंदु पर पहुँचते हैं जहाँ प्रत्येक घटक को `useIntlayer` में स्थानांतरित कर दिया गया है, तो एडॉप्टर को हटा दें।
+
+</Accordion>
+<Accordion header="प्रदाता पर messages, timeZone और now को अनदेखा किया जाता है">
+
+फॉर्मेटर्स नेटिव `Intl` द्वारा समर्थित हैं और केवल भाषा उनके आउटपुट को प्रभावित करती है। यदि आप हाइड्रेशन-स्थिर तिथियों के लिए मजबूर समय क्षेत्र या एक निश्चित `now` पर भरोसा करते हैं, तो इसे कॉल साइट पर संभालें। [दिनांक, समय और संख्या स्वरूपण](https://intlayer.org/hi/blog/date-time-number-formatting-locales) देखें।
+
+</Accordion>
+</AccordionGroup>
 
 ## कौन सा उपयोग करें?
 
-- **`next-intl` पर रहें** यदि आपका ऐप छोटा है, आपका बंडल चिंता का विषय नहीं है, और आपकी टीम namespaces और प्रति पेज `pick()` का मालिकाना करने में सहज है।
-- **`@intlayer/next-intl` का उपयोग करें** यदि आप आज `next-intl` पर हैं और bundle, leakage और hydration gains, typed keys और CLI / CMS tooling चाहते हैं बिना rewrite के। यह किसी भी मौजूदा `next-intl` codebase के लिए अनुशंसित entry point है।
-- **Native (`next-intlayer`) पर जाएं** नई projects के लिए, या एक बार adapter ने अपना काम कर दिया हो। यह तीनों में सबसे हल्का है (5.5 KB, +0.3 KB प्रति page) और synchronous server components, per-component `.content.ts` files और पूरे feature set को unlock करता है।
+<AccordionGroup>
+<Accordion header="next-intl पर बने रहें">
+
+यदि आपका ऐप छोटा है, आपका बंडल चिंता का विषय नहीं है, और आपकी टीम प्रति पृष्ठ नेमस्पेस और `pick()` का प्रबंधन करने में सहज है।
+
+</Accordion>
+<Accordion header="@intlayer/next-intl का उपयोग करें">
+
+यदि आप आज `next-intl` पर हैं और बिना दोबारा लिखे बंडल, रिसाव और हाइड्रेशन लाभ, टाइप की गई कुंजियाँ और CLI / CMS टूल चाहते हैं। यह किसी भी मौजूदा `next-intl` कोडबेस के लिए अनुशंसित प्रवेश बिंदु है।
+
+</Accordion>
+<Accordion header="नेटिव (next-intlayer) पर जाएँ">
+
+नई परियोजनाओं के लिए, या एक बार एडॉप्टर द्वारा अपना काम पूरा कर लेने के बाद। यह तीनों में सबसे हल्का है (5.5 KB, +0.3 KB प्रति पृष्ठ) और सिंक्रोनस सर्वर घटकों, प्रति-घटक `.content.ts` फाइलों और पूर्ण फीचर सेट को अनलॉक करता है। [Next.js के साथ Intlayer](https://intlayer.org/hi/doc/environment/nextjs) से शुरुआत करें।
+
+</Accordion>
+</AccordionGroup>
+
+## FAQ
+
+<FAQ>
+
+<Question title="क्या मेरा एप्लिकेशन कोड वास्तव में अछूता रहता है?">
+
+Next.js पर, घटकों के लिए हाँ: बेंचमार्क बिल्ड ने केवल `next.config.ts` और `intlayer.config.ts` को बदला। `src/i18n.ts` में `getRequestConfig`, प्रदाता पर `messages` प्रॉप और प्रति-पृष्ठ `pick()` कॉल डेड कोड बन जाते हैं जिन्हें आप बाद में हटा सकते हैं।
+
+</Question>
+
+<Question title="ICU संदेशों का क्या होता है?">
+
+वे काम करते रहते हैं। `t("key", { count })`, `t.rich()`, `t.markup()`, `select`, `selectordinal`, `#` और `{ts, date, long}` Intlayer के ICU रिज़ॉल्वर द्वारा हल किए जाते हैं। [ICU संदेश प्रारूप](https://intlayer.org/hi/blog/icu-message-format) देखें।
+
+</Question>
+
+<Question title="एडॉप्टर नेटिव next-intlayer से भारी क्यों है?">
+
+यह Intlayer के कोर के ऊपर `next-intl` API सतह को ले जाता है: `useFormatter`, `t.rich`, ICU रिज़ॉल्वर, नेविगेशन हेल्पर्स। यह 5.5 KB के मुकाबले 8.0 KB है, और प्रति पृष्ठ +6 KB है। यह एक पुल है, गंतव्य नहीं।
+
+</Question>
+
+<Question title="क्या मैं घटक दर घटक माइग्रेट कर सकता हूँ?">
+
+हाँ। कोई भी घटक सह-स्थित `.content.ts` के साथ `useTranslations("about")` से `useIntlayer("about")` पर स्विच कर सकता है। JSON और `.content.ts` डिक्शनरी सह-अस्तित्व में रहती हैं और विलीन हो जाती हैं।
+
+</Question>
+
+<Question title="क्या स्थानीयकृत पाथनेम काम करते हैं?">
+
+`next-intl` के `pathnames` के माध्यम से नहीं: एडॉप्टर टाइपिंग के लिए इसे स्वीकार करता है लेकिन इसे इंटरपोलेट नहीं करता है। इसके बजाय Intlayer के `routing.rewrite` का उपयोग करें।
+
+</Question>
+
+</FAQ>
 
 ## संबंधित तुलनाएं
 
-- [next-intl vs Intlayer](https://intlayer.org/blog/next-intl-vs-intlayer) (libraries, same benchmark)
-- [i18next vs @intlayer/i18next](https://intlayer.org/blog/i18next-vs-intlayer-i18next) (same adapter series)
-- [Lingui vs @intlayer/lingui](https://intlayer.org/blog/lingui-vs-intlayer-lingui) (same adapter series)
-- [vue-i18n vs @intlayer/vue-i18n](https://intlayer.org/blog/vue-i18n-vs-intlayer-vue-i18n) (same adapter series)
-- [माइग्रेशन गाइड: next-intl से Intlayer तक](https://intlayer.org/doc/migration/next-intl)
-- [Compat adapter संदर्भ: next-intl](https://intlayer.org/doc/compatibility/next-intl)
+समान एडॉप्टर श्रृंखला:
+
+- [i18next vs @intlayer/i18next](https://intlayer.org/hi/blog/i18next-vs-intlayer-i18next)
+- [Lingui vs @intlayer/lingui](https://intlayer.org/hi/blog/lingui-vs-intlayer-lingui)
+- [vue-i18n vs @intlayer/vue-i18n](https://intlayer.org/hi/blog/vue-i18n-vs-intlayer-vue-i18n)
+
+लाइब्रेरीज़ की आमने-सामने तुलना:
+
+- [next-intl vs Intlayer](https://intlayer.org/hi/blog/next-intl-vs-intlayer), समान बेंचमार्क
+- [next-i18next vs next-intl vs Intlayer](https://intlayer.org/hi/blog/next-i18next-vs-next-intl-vs-intlayer)
+- [Is next-intl outdated?](https://intlayer.org/hi/blog/is-next-intl-outdated)
+
+संदर्भ दस्तावेज़:
+
+- [Compat adapter: next-intl](https://intlayer.org/hi/doc/compatibility/next-intl)
+- [माइग्रेशन गाइड: next-intl से Intlayer](https://intlayer.org/hi/doc/migration/next-intl)
+- [Next.js बेंचमार्क रिपोर्ट](https://intlayer.org/hi/doc/benchmark/nextjs) और [TanStack Start बेंचमार्क रिपोर्ट](https://intlayer.org/hi/doc/benchmark/tanstack)
+- [बंडल अनुकूलन](https://intlayer.org/hi/doc/concept/bundle-optimization) और [Intlayer कंपाइलर](https://intlayer.org/hi/doc/compiler)
+- [विजुअल एडिटर](https://intlayer.org/hi/doc/concept/editor), [CMS](https://intlayer.org/hi/doc/concept/cms) और [AI अनुवाद](https://intlayer.org/hi/doc/concept/auto-fill)
 
 ## निष्कर्ष
 

package/blog/hi/next-intl_vs_intlayer.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-09-13
-updatedAt: 2026-09-13
+updatedAt: 2026-09-22
 title: "next-intl बनाम Intlayer: 2026 बेंचमार्क और तुलना"
 description: "Next.js App Router और TanStack Start पर next-intl और Intlayer की तुलना। बंडल साइज़, कंटेंट लीकेज, कंपोनेंट साइज़, हाइड्रेशन, लोकेल स्विचिंग और डेवलपर अनुभव।"
 keywords:
@@ -22,11 +22,11 @@ author: aymericzip
 
 # next-intl बनाम Intlayer | React और Next.js अंतर्राष्ट्रीयकरण (i18n) बेंचमार्क
 
-`next-intl` आज Next.js App Router के लिए डिफ़ॉल्ट विकल्प है: राउटिंग के साथ गहरा एकीकरण, संपूर्ण ICU MessageFormat समर्थन, और क्लासिक i18n सिस्टम का उपयोग करने वाले किसी भी व्यक्ति के लिए एक परिचित डेवलपर अनुभव।
+![next-intl VS Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/assets/i18next-next-intl-intlayer.webp?raw=true)
 
-`Intlayer` समस्या पर पुनर्विचार करता है: कोई केंद्रीकृत डिक्शनरी नहीं, रूट्स के साथ नेमस्पेस का मिलान करने का कोई मैन्युअल काम नहीं। सामग्री प्रत्येक कंपोनेंट के बगल में घोषित की जाती है, और एक बिल्ड-टाइम कंपाइलर केवल वही बंडल करता है जिसकी प्रत्येक पेज को आवश्यकता होती है।
+`next-intl` Next.js के लिए सबसे लोकप्रिय i18n लाइब्रेरी है। Intlayer एक कंपाइलर-आधारित, घटक-क्षेत्रीय विकल्प है। दोनों App Router एप्लिकेशन का स्थानीयकरण करते हैं। सवाल यह है कि ऐप बनने के बाद प्रत्येक की लागत क्या है।
 
-यह लेख [Benchmark Bloom](https://github.com/intlayer-org/benchmark-bloom) के डेटा का उपयोग करके दोनों की तुलना करता है, जो एक ओपन-सोर्स टेस्ट सूट है जो प्रत्येक लाइब्रेरी के साथ समान एप्लिकेशन बनाता है और रिकॉर्ड करता है कि ब्राउज़र वास्तव में क्या डाउनलोड और निष्पादित करता है।
+यह लेख कोई ट्यूटोरियल नहीं है। यह [Benchmark Bloom](https://github.com/intlayer-org/benchmark-bloom) के आंकड़ों द्वारा समर्थित एक तुलना है, जो एक ओपन-सोर्स बेंचमार्क सूट है जो प्रत्येक लाइब्रेरी के साथ एक ही एप्लिकेशन बनाता है और मापता है कि ब्राउज़र वास्तव में क्या डाउनलोड और निष्पादित करता है।
 
 <TOC/>
 
@@ -89,6 +89,10 @@ Intlayer में कोई "scoped" संस्करण नहीं है:
 
 ### Next.js (App Router) पर परिणाम
 
+अपनी पसंद के मेट्रिक्स और लाइब्रेरी चुनें:
+
+<I18nBenchmark framework="nextjs" vertical/>
+
 | लाइब्रेरी                      | रणनीति         | लाइब्रेरी साइज़ (gz) | पेज JS औसत (gz) | लोकेल लीक |  पेज लीक | कंपोनेंट औसत (gz) | E2E प्रतिक्रियाशीलता | हाइड्रेशन |
 | ------------------------------ | -------------- | -------------------: | --------------: | --------: | -------: | ----------------: | -------------------: | --------: |
 | **base** (बिना i18n)           | -              |               0.0 KB |        141.0 KB |      0.0% |     0.0% |            0.9 KB |              13.4 ms |   11.8 ms |
@@ -107,8 +111,19 @@ Intlayer में कोई "scoped" संस्करण नहीं है:
 - **लीकेज।** सबसे आम सेटअप (`static` और `dynamic`) में, `next-intl` हर पेज पर **~90% अन्य पेजों की सामग्री** भेजता है, क्योंकि पूरी `en.json` क्लाइंट प्रोवाइडर में जाती है। 0% तक पहुँचने के लिए सावधानीपूर्वक मैनुअल विभाजन की आवश्यकता होती है, जबकि Intlayer स्वचालित रूप से 0% पर है।
 - **कंपोनेंट साइज़।** `useTranslations()` को कॉल करने वाला कंपोनेंट औसतन 21.8 KB का होता है; `useIntlayer()` के साथ वही कंपोनेंट केवल 6.9 KB का होता है।
 
+<ClickToOpenIframe
+src="https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-nextjs.md"
+width="100%"
+height="600px"
+style="border:none;"
+/>
+
+> पूरी तालिका, प्रत्येक लाइब्रेरी और रणनीति, [Next.js बेंचमार्क रिपोर्ट](https://intlayer.org/hi/doc/benchmark/nextjs) में उपलब्ध है।
+
 ### TanStack Start (`use-intl`) पर परिणाम
 
+`use-intl` `next-intl` का फ्रेमवर्क-अज्ञेय कोर है। वही API, वही संदेश प्रारूप। TanStack Start पर `intlayer` के साथ इसकी तुलना Next.js-विशिष्ट भागों को समीकरण से हटा देती है।
+
 | लाइब्रेरी                     | रणनीति         | लाइब्रेरी साइज़ (gz) | पेज JS औसत (gz) | लोकेल लीक |  पेज लीक | कंपोनेंट औसत (gz) | E2E प्रतिक्रियाशीलता |
 | ----------------------------- | -------------- | -------------------: | --------------: | --------: | -------: | ----------------: | -------------------: |
 | **base** (बिना i18n)          | -              |               0.0 KB |        111.0 KB |      0.0% |     0.0% |            0.7 KB |               8.1 ms |
@@ -127,8 +142,19 @@ Intlayer में कोई "scoped" संस्करण नहीं है:
 - कंपोनेंट के स्तर पर वास्तुकला का अंतर स्पष्ट है: `use-intl` के साथ 76-87 KB बनाम Intlayer के साथ 6-8 KB।
 - **लोकेल स्विचिंग** Intlayer के साथ 2x-4x तेज़ है (3 ms बनाम 7-21 ms)।
 
+<ClickToOpenIframe
+src="https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-tanstack.md"
+width="100%"
+height="600px"
+style="border:none;"
+/>
+
+> पूरी तालिका [TanStack Start बेंचमार्क रिपोर्ट](https://intlayer.org/hi/doc/benchmark/tanstack) में उपलब्ध है।
+
 ## अंतर क्यों है? केंद्रीकृत कैटलॉग बनाम कंपाइल की गई डिक्शनरी
 
+![Centralized catalogs versus per-component dictionaries](https://github.com/aymericzip/intlayer/blob/main/docs/assets/project_stucture_18n_vs_intlayer.png?raw=true)
+
 `next-intl` क्लासिक मॉडल का पालन करता है: प्रति लोकेल एक JSON, जो `getRequestConfig` में लोड होता है, `NextIntlClientProvider` में पास होता है, और `t("namespace.key")` द्वारा पढ़ा जाता है।
 
 ```bash
@@ -150,6 +176,10 @@ Intlayer में कोई "scoped" संस्करण नहीं है:
 
 रनटाइम यह नहीं जान सकता कि कोई पेज किन कुंजियों का उपयोग करेगा, इसलिए संपूर्ण कैटलॉग भेजना ही सुरक्षित डिफ़ॉल्ट है।
 
+वहां तक न पहुँचने की लागत दो अक्षों पर एक साथ बढ़ती है, पृष्ठ और भाषाएँ:
+
+![Theoretical content leakage by architecture](https://github.com/aymericzip/intlayer/blob/main/docs/assets/theorical_content_leakage.webp?raw=true)
+
 Intlayer जिम्मेदारी को बदल देता है। सामग्री सीधे कंपोनेंट के बगल में घोषित की जाती है:
 
 ```bash
@@ -177,7 +207,8 @@ Intlayer जिम्मेदारी को बदल देता है।
 
 ### क्लाइंट कंपोनेंट
 
-**next-intl**
+<Tabs defaultTab="intlayer" group="techno">
+<Tab label="next-intl" value="next-intl">
 
 ```json fileName="messages/en.json"
 {
@@ -188,7 +219,7 @@ Intlayer जिम्मेदारी को बदल देता है।
 }
 ```
 
-```tsx fileName="src/components/Counter.tsx"
+```tsx fileName="src/components/ClientCounter.tsx"
 "use client";
 
 import { useState } from "react";
@@ -210,7 +241,10 @@ export const Counter = () => {
 };
 ```
 
-**Intlayer**
+> इस घटक को प्रस्तुत करने वाले प्रत्येक पृष्ठ पर `NextIntlClientProvider` को दिए जाने वाले संदेशों में `counter` नेमस्पेस शामिल करना याद रखें।
+
+</Tab>
+<Tab label="Intlayer" value="intlayer">
 
 ```ts fileName="src/components/Counter/index.content.ts"
 import { t, type Dictionary } from "intlayer";
@@ -249,11 +283,16 @@ export const Counter = () => {
 };
 ```
 
+पृष्ठ पर कुछ भी पंजीकृत करने की आवश्यकता नहीं है: घटक अपनी सामग्री स्वयं लाता है।
+
+</Tab>
+</Tabs>
 ### सिंक्रोनस सर्वर कंपोनेंट
 
 डिज़ाइन सिस्टम के घटक (जैसे नेवबार, फूटर, कार्ड) अक्सर सर्वर कंपोनेंट होते हैं जिन्हें क्लाइंट कंपोनेंट के चिल्ड्रन के रूप में रेंडर किया जाता है, इसलिए वे `async` नहीं हो सकते।
 
-**next-intl**
+<Tabs defaultTab="intlayer" group="techno">
+<Tab label="next-intl" value="next-intl">
 
 ```tsx fileName="src/components/ServerCounter.tsx"
 type ServerCounterProps = {
@@ -269,7 +308,10 @@ export const ServerCounter = ({ t, formattedCount }: ServerCounterProps) => (
 );
 ```
 
-**Intlayer**
+पृष्ठ को `await getTranslations("counter")` और `await getFormatter()` करना होगा, फिर परिणामों को प्रॉप्स के रूप में नीचे भेजना होगा। घटक अब आत्मनिर्भर नहीं रहा।
+
+</Tab>
+<Tab label="Intlayer" value="intlayer">
 
 ```tsx fileName="src/components/ServerCounter.tsx"
 import { useIntlayer } from "next-intlayer/server";
@@ -288,9 +330,12 @@ export const ServerCounter = ({ count }: { count: number }) => {
 };
 ```
 
+</Tab>
+</Tabs>
 ### मेटाडेटा (Metadata)
 
-**next-intl**
+<Tabs defaultTab="intlayer" group="techno">
+<Tab label="next-intl" value="next-intl">
 
 ```tsx fileName="src/app/[locale]/about/page.tsx"
 import type { Metadata } from "next";
@@ -323,7 +368,8 @@ export const generateMetadata = async ({
 };
 ```
 
-**Intlayer**
+</Tab>
+<Tab label="Intlayer" value="intlayer">
 
 ```tsx fileName="src/app/[locale]/about/page.tsx"
 import { getIntlayer, getMultilingualUrls } from "intlayer";
@@ -347,6 +393,9 @@ export const generateMetadata = async ({
 };
 ```
 
+</Tab>
+</Tabs>
+
 ## next-intl API बनाए रखें, Intlayer का आउटपुट प्राप्त करें
 
 उपरोक्त बेंचमार्क परिणाम प्राप्त करने के लिए आपको अपने कंपोनेंट्स को दोबारा लिखने की आवश्यकता नहीं है। `@intlayer/next-intl` एक ड्रॉप-इन एडेप्टर है: यह `useTranslations`, `getTranslations`, `useFormatter`, `t.rich()` और ICU प्लुरल्स को बनाए रखता है, और उन्हें Intlayer डिक्शनरी से परोसता है।
@@ -368,17 +417,84 @@ export default withIntlayer(nextConfig);
 
 ## कब किसे चुनें?
 
-- **next-intl चुनें** यदि आप Next.js समुदाय मानक चाहते हैं, ICU MessageFormat पर बहुत अधिक निर्भर हैं, आपका ऐप छोटा से मध्यम है, या आप केंद्रीकृत JSON आधारित अनुवाद प्लेटफॉर्म (Crowdin, Phrase, Lokalise...) के साथ एकीकृत हैं।
-- **Intlayer चुनें** यदि आप **कंपोनेंट-स्कोप्ड कंटेंट**, **सख्त TypeScript**, **बिल्ड-टाइम गायब-कुंजी एरर**, **शून्य-प्रयास ट्री-शेकिंग और लेज़ी लोडिंग**, सिंक्रोनस सर्वर कंपोनेंट्स, और बिल्ट-इन एडिटोरियल टूलिंग (विजुअल एडिटर, CMS, AI अनुवाद, MCP सर्वर) चाहते हैं।
-- **`@intlayer/next-intl` चुनें** यदि आप पहले से ही `next-intl` पर हैं और बिना दोबारा लिखे बंडल लाभ चाहते हैं।
+<AccordionGroup>
+<Accordion header="next-intl चुनें">
+
+आप Next.js के लिए इकोसिस्टम मानक चाहते हैं, ICU MessageFormat पर निर्भर करते हैं, आपका ऐप छोटे से मध्यम आकार का है, या आप किसी ऐसे अनुवाद प्लेटफ़ॉर्म (Crowdin, Phrase, Lokalise...) के साथ एकीकृत होते हैं जो केंद्रीकृत JSON की अपेक्षा करता है। यदि प्रदर्शन मायने रखता है तो कैटलॉग को नेमस्पेस में विभाजित करने और प्रति पृष्ठ `pick()` के साथ संदेश चुनने के लिए समय निकालें।
+
+</Accordion>
+<Accordion header="Intlayer चुनें">
+
+आप **कंपोनेंट-स्कोप्ड सामग्री**, **सख्त TypeScript**, **बिल्ड-टाइम गुम कुंजी त्रुटियां**, **प्रयासहीन ट्री-शेकिंग और लेज़ी लोडिंग**, सिंक्रोनस सर्वर कंपोनेंट और अंतर्निहित संपादकीय उपकरण ([विजुअल एडिटर](https://intlayer.org/hi/doc/concept/editor), [CMS](https://intlayer.org/hi/doc/concept/cms), [AI अनुवाद](https://intlayer.org/hi/doc/concept/auto-fill), [MCP सर्वर](https://intlayer.org/hi/doc/mcp-server)) चाहते हैं। बड़े, मॉड्यूलर कोडबेस और डिज़ाइन सिस्टम के लिए विशेष रूप से प्रासंगिक।
+
+</Accordion>
+<Accordion header="@intlayer/next-intl चुनें">
+
+आप पहले से ही `next-intl` पर हैं और बिना दोबारा लिखे बंडल लाभ चाहते हैं। [कम्पैटिबिलिटी एडेप्टर](https://intlayer.org/hi/doc/compatibility/next-intl) आपके इम्पोर्ट और आपकी `messages/{locale}.json` फ़ाइल को सत्य के एकल स्रोत के रूप में रखता है। [next-intl vs @intlayer/next-intl](https://intlayer.org/hi/blog/next-intl-vs-intlayer-next-intl) में एक साथ मापा गया।
+
+</Accordion>
+</AccordionGroup>
+
+## अक्सर पूछे जाने वाले प्रश्न (FAQ)
+
+<FAQ>
+
+<Question title="क्या next-intl Intlayer से धीमा है?">
+
+रेंडर समय पर नहीं। अंतर इसमें है कि क्लाइंट को क्या भेजा जाता है: `next-intl` प्रत्येक पृष्ठ पर **+12.6 KB gzip** रनटाइम की लागत लेता है और अधिकांश सेटअप में प्रत्येक पृष्ठ के साथ विदेशी पृष्ठों के लगभग 90% टेक्स्ट भेजता है। भाषा बदलना और हाइड्रेशन Next.js पर तुलनीय हैं (15-18 ms); TanStack Start पर `use-intl` 7-21 ms लेता है जबकि Intlayer केवल 3-4 ms लेता है।
+
+</Question>
+
+<Question title="क्या मैं next-intl के साथ 0% लीकेज प्राप्त कर सकता हूँ?">
+
+हाँ, `scoped-dynamic` सेटअप के साथ: `messages/{locale}.json` को प्रति रूट एक नेमस्पेस में विभाजित करें, फिर प्रत्येक पृष्ठ में `pick(messages, [...])` का उपयोग करें और कंपोनेंट बदलने पर उस मैपिंग को सही बनाए रखें। बेंचमार्क की `scoped-*` पंक्तियाँ ठीक उसी काम को दर्शाती हैं। Intlayer बिना किसी अतिरिक्त प्रयास के 0% तक पहुँच जाता है क्योंकि कंपाइलर कंपोनेंट के अनुसार सामग्री को सीमित करता है। [बंडल ऑप्टिमाइज़ेशन](https://intlayer.org/hi/doc/concept/bundle-optimization) देखें।
+
+</Question>
+
+<Question title="क्या मुझे माइग्रेट करने के लिए अपने कंपोनेंट फिर से लिखने होंगे?">
+
+नहीं। `@intlayer/next-intl` `useTranslations`, `getTranslations`, `useFormatter`, `t.rich()`, ICU बहुवचन और नेविगेशन सहायकों को बरकरार रखता है, और उन्हें संकलित शब्दकोशों से प्रस्तुत करता है। `next.config.ts` में केवल एक प्लगइन पंक्ति। चरण दर चरण [next-intl माइग्रेशन गाइड](https://intlayer.org/hi/doc/migration/next-intl) में देखें।
+
+</Question>
+
+<Question title="क्या Intlayer ICU MessageFormat का समर्थन करता है?">
+
+मूल API पर ICU समर्थन पर कार्य प्रगति पर है। कम्पैटिबिलिटी एडेप्टर (`@intlayer/next-intl`, `@intlayer/use-intl`) ICU चलाते हैं: बहुवचन, `select`, `selectordinal`, `#` और `{ts, date, long}` Intlayer के ICU रिज़ॉल्वर से गुजरते हैं। विवरण के लिए [ICU संदेश प्रारूप](https://intlayer.org/hi/blog/icu-message-format) पढ़ें।
+
+</Question>
+
+<Question title="क्या मैं अपनी messages/{locale}.json फ़ाइलें रख सकता हूँ?">
+
+हाँ। [JSON सिंक प्लगइन](https://intlayer.org/hi/doc/compatibility/next-intl) उन्हें पढ़ता है, उनकी शीर्ष-स्तरीय कुंजियों को शब्दकोशों में विभाजित करता है, और जब CLI या CMS उन्हें अपडेट करता है तो अनुवादों को उन्हीं फ़ाइलों में वापस लिखता है। आपके अनुवादकों का कार्यप्रवाह नहीं बदलता है।
+
+</Question>
+
+</FAQ>
 
 ## संबंधित तुलनाएँ
 
-- [i18next बनाम Intlayer](https://intlayer.org/hi/blog/i18next-vs-intlayer) (समान बेंचमार्क)
-- [Lingui बनाम Intlayer](https://intlayer.org/hi/blog/lingui-vs-intlayer) (समान बेंचमार्क)
-- [vue-i18n बनाम Intlayer बेंचमार्क](https://intlayer.org/hi/blog/vue-i18n-vs-intlayer-benchmark) (समान बेंचमार्क)
-- [next-i18next बनाम next-intl बनाम Intlayer](https://intlayer.org/hi/blog/next-i18next-vs-next-intl-vs-intlayer)
-- [क्या next-intl पुराना हो चुका है?](https://intlayer.org/hi/blog/is-next-intl-outdated)
+वही बेंचमार्क, अन्य लाइब्रेरीज़:
+
+- [i18next vs Intlayer](https://intlayer.org/hi/blog/i18next-vs-intlayer)
+- [Lingui vs Intlayer](https://intlayer.org/hi/blog/lingui-vs-intlayer)
+- [vue-i18n vs Intlayer benchmark](https://intlayer.org/hi/blog/vue-i18n-vs-intlayer-benchmark)
+- [next-i18next vs next-intl vs Intlayer](https://intlayer.org/hi/blog/next-i18next-vs-next-intl-vs-intlayer)
+- [react-i18next vs react-intl vs Intlayer](https://intlayer.org/hi/blog/react-i18next-vs-react-intl-vs-intlayer)
+
+next-intl पर गहराई से जानें:
+
+- [next-intl vs @intlayer/next-intl](https://intlayer.org/hi/blog/next-intl-vs-intlayer-next-intl), उसी ऐप पर मापा गया एडेप्टर
+- [Is next-intl outdated?](https://intlayer.org/hi/blog/is-next-intl-outdated)
+- [Using Intlayer with next-intl](https://intlayer.org/hi/blog/intlayer-with-next-intl)
+- [How to internationalize a Next.js app with next-intl](https://intlayer.org/hi/blog/nextjs-internationalization-using-next-intl)
+
+संदर्भ दस्तावेज़:
+
+- [Next.js बेंचमार्क रिपोर्ट](https://intlayer.org/hi/doc/benchmark/nextjs) और [TanStack Start बेंचमार्क रिपोर्ट](https://intlayer.org/hi/doc/benchmark/tanstack)
+- [कम्पैटिबिलिटी एडेप्टर: next-intl](https://intlayer.org/hi/doc/compatibility/next-intl) और [माइग्रेशन गाइड](https://intlayer.org/hi/doc/migration/next-intl)
+- [बंडल ऑप्टिमाइज़ेशन](https://intlayer.org/hi/doc/concept/bundle-optimization) और [Intlayer कंपाइलर](https://intlayer.org/hi/doc/compiler)
+- [प्रति-कंपोनेंट बनाम केंद्रीकृत i18n](https://intlayer.org/hi/blog/per-component-vs-centralized-i18n)
+- [कंपाइलर-संचालित बनाम घोषणात्मक i18n](https://intlayer.org/hi/blog/compiler-vs-declarative-i18n)
 
 ## GitHub STARS
 

package/blog/hi/transform_existing_vite_react_app_using_compiler.md

@@ -284,7 +284,9 @@ const pathList = [
   { path: "/about", changefreq: "monthly", priority: 0.7 },
 ];
 
-const sitemapXml = generateSitemap(pathList, { siteUrl: SITE_URL });
+const sitemapXml = generateSitemap(pathList, {
+  siteUrl: "https://example.com",
+});
 fs.writeFileSync(path.join(__dirname, "public", "sitemap.xml"), sitemapXml);
 
 const getAllMultilingualUrls = (urls) =>
@@ -297,7 +299,7 @@ const robotsTxt = [
   "Allow: /",
   ...disallowedPaths.map((path) => `Disallow: ${path}`),
   "",
-  `Sitemap: ${SITE_URL}/sitemap.xml`,
+  `Sitemap: https://example.com/sitemap.xml`,
 ].join("\n");
 
 fs.writeFileSync(path.join(__dirname, "public", "robots.txt"), robotsTxt);