@intlayer/docs 9.3.3 → 9.4.0

package/docs/hi/cli/login.md

@@ -118,6 +118,34 @@ INTLAYER_CLIENT_SECRET=your_client_secret
 }
 ```
 
+## एक्सेस की को सुरक्षित रखना
+
+`intlayer login` एक **एक्सेस की** जारी करता है: एक `clientId` / `clientSecret` pair जिसे हर प्रमाणित कमांड (`push`, `pull`, `fill`, `configuration push`, `live`, …) प्रमाणीकरण के लिए उपयोग करता है।
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  editor: {
+    clientId: process.env.INTLAYER_CLIENT_ID,
+    clientSecret: process.env.INTLAYER_CLIENT_SECRET,
+  },
+};
+
+export default config;
+```
+
+> **`clientSecret` एक server-side credential है।** यह पूर्ण project-scoped API access देता है — आपकी dictionaries, आपके project और आपके organization को पढ़ने और लिखने के लिए। इसे `.env` (git-ignored) में या अपने CI secret store में रखें, और कभी भी इसे configuration file में inline न करें।
+
+Intlayer इसे केवल दस्तावेज़ित करने के बजाय लागू करता है:
+
+- `clientSecret` को **अपने bundler द्वारा inlined किए जाने वाले configuration से हटा दिया जाता है**, इसलिए यह कोई भी framework integration चाहे जो भी हो, browser bundle तक नहीं पहुंच सकता। यह केवल server-side, runtime में, environment से पढ़ा जाता है।
+- `clientId` अलग है: यह **public** project key है, ship करने के लिए सुरक्षित है, और [`@intlayer/analytics`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/analytics.md#how-events-are-authenticated) द्वारा एक short-lived, ingest-only token प्राप्त करने के लिए उपयोग किया जाता है।
+
+`clientId` को comment out करना हर प्रमाणित behavior को disable करने के लिए पर्याप्त है — remote dictionary fetching, CMS access, analytics — भले ही environment variables अभी भी परिभाषित हों।
+
+CI pipelines के लिए, [`ci` command](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/cli/ci.md) को प्राथमिकता दें, जो एकल run की अवधि के लिए credentials को inject करता है उन्हें persist करने के बजाय।
+
 ## मैनुअल कॉन्फ़िगरेशन
 
 यदि ब्राउज़र स्वचालित रूप से नहीं खुलता है, तो आप टर्मिनल में दिखाई गई URL को मैन्युअली खोल सकते हैं।

package/docs/hi/compiler.md

@@ -40,6 +40,12 @@ author: aymericzip
 
 ## Intlayer Compiler का उपयोग क्यों करें?
 
+- **स्वचालन**: शब्दकोशों में सामग्री की मैनुअल कॉपी-पेस्टिंग को समाप्त करता है।
+
+- **Speed**: अनुकूलित कंटेंट निष्कर्षण आपकी बिल्ड प्रक्रिया को तेज़ रखता है।
+
+- **Developer Experience**: Content declarations को उसी जगह रखें जहां उनका उपयोग किया जाता है, जिससे maintainability में सुधार होता है।
+
 - **स्वचालन**: सामग्री को शब्दकोशों में मैन्युअल कॉपी-पेस्ट करने की आवश्यकता समाप्त करता है।
 - **गति**: अनुकूलित सामग्री निष्कर्षण सुनिश्चित करता है कि आपका बिल्ड प्रक्रिया तेज़ बनी रहे।
 - **डेवलपर अनुभव**: सामग्री घोषणाओं को वहीं रखें जहां उनका उपयोग होता है, जिससे रखरखाव में सुधार होता है।
@@ -54,6 +60,8 @@ author: aymericzip
 - **हेयूरिस्टिक अस्पष्टता**: कंपाइलर को यह अनुमान लगाना होगा कि उपयोगकर्ता-सामना करने वाली सामग्री बनाम एप्लिकेशन लॉजिक क्या है (उदाहरण के लिए, `className="active"`, स्थिति कोड, उत्पाद ID)। जटिल कोडबेस में, यह गलत सकारात्मक या छूटी हुई स्ट्रिंग्स का कारण बन सकता है जिन्हें मैन्युअल एनोटेशन और अपवादों की आवश्यकता होती है।
 - **केवल स्थैतिक निष्कर्षण**: कंपाइलर-आधारित निष्कर्षण स्थैतिक विश्लेषण पर निर्भर करता है। स्ट्रिंग्स जो केवल रनटाइम पर मौजूद होती हैं (API त्रुटि कोड, CMS फ़ील्ड, आदि) को कंपाइलर द्वारा अकेले खोजा या अनुवादित नहीं किया जा सकता है, इसलिए आपको अभी भी एक पूरक रनटाइम i18n रणनीति की आवश्यकता है।
 
+- **Static-only extraction**: Compiler-based extraction static analysis पर निर्भर करती है। Strings जो केवल runtime पर exist करती हैं (API error codes, CMS fields, आदि) को compiler अकेले discover या translate नहीं कर सकता है, इसलिए आपको अभी भी एक complementary runtime i18n strategy की आवश्यकता है।
+
 गहरी वास्तुकला तुलना के लिए, [Compiler vs. Declarative i18n](https://github.com/aymericzip/intlayer/blob/main/docs/blog/hi/compiler_vs_declarative_i18n.md) ब्लॉग पोस्ट देखें।
 
 वैकल्पिक रूप से, अपनी सामग्री पर पूर्ण नियंत्रण रखते हुए अपनी i18n प्रक्रिया को स्वचालित करने के लिए, Intlayer एक स्वचालित निष्कर्षण कमांड `intlayer extract` (देखें [CLI दस्तावेज़ीकरण](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/cli/extract.md)) या Intlayer VS Code एक्सटेंशन का `Intlayer: extract content to Dictionary` कमांड (देखें [VS Code एक्सटेंशन दस्तावेज़ीकरण](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/vs_code_extension.md)) भी प्रदान करता है।
@@ -94,6 +102,8 @@ export default defineConfig({
 });
 ```
 
+> स्टैंडअलोन `intlayerCompiler()` प्लगइन अभी भी advanced setups के लिए exported है। इसे `intlayer()` के साथ register करना सुरक्षित है — compiler खुद को deduplicate करता है और केवल एक बार चलता है।
+
 See complete tutorial: [Intlayer Compiler with Vite+React](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_with_vite+react_compiler.md)
 
 #### फ्रेमवर्क समर्थन
@@ -104,6 +114,10 @@ Vite प्लगइन स्वचालित रूप से विभि
 - **Vue**: इसके लिए `@intlayer/vue-compiler` आवश्यक है।
 - **Svelte**: इसके लिए `@intlayer/svelte-compiler` आवश्यक है।
 
+- **Vue**: `@intlayer/vue-compiler` की आवश्यकता है।
+
+- **Svelte**: `@intlayer/svelte-compiler` की आवश्यकता है।
+
 सुनिश्चित करें कि आपने अपने फ्रेमवर्क के लिए उपयुक्त कंपाइलर पैकेज इंस्टॉल किया है:
 
 ```bash

package/docs/hi/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-08-06
+updatedAt: 2026-08-22
 title: कॉन्फ़िगरेशन (Configuration)
 description: जानें कि अपने एप्लिकेशन के लिए Intlayer को कैसे कॉन्फ़िगर करें। Intlayer को अपनी आवश्यकताओं के अनुसार अनुकूलित करने के लिए उपलब्ध विभिन्न सेटिंग्स और विकल्पों को समझें।
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 9.3.3
+    date: 2026-08-22
+    changes: "`@intlayer/analytics` इंस्टॉल होने पर एनालिटिक्स डिफ़ॉल्ट रूप से सक्षम किया गया"
   - version: 9.1.3
     date: 2026-08-06
     changes: "`routing.enableProxy` को तीन-स्थिति बनाया गया: अनसेट (auto), `true`, `false`"
@@ -380,8 +383,8 @@ const config: IntlayerConfig = {
   analytics: {
     /**
      * क्या एनालिटिक्स संग्रहण सक्षम है (पेज व्यू, कंटेंट एक्सपोज़र, A/B इवेंट्स)।
-     * एट्रिब्यूशन के लिए `editor.clientId` सेट होना आवश्यक है।
-     * डिफ़ॉल्ट: false
+     * `@intlayer/analytics` इंस्टॉल होना और एट्रिब्यूशन के लिए `editor.clientId` सेट होना आवश्यक है।
+     * डिफ़ॉल्ट: true
      */
     enabled: true,
 
@@ -726,19 +729,17 @@ export default config;
 | `liveSyncPort`               | लाइव सिंक सर्वर का पोर्ट।                                                                                                                                                                 | `number`                          | `4000`                              | `4000`                                                                                          |                                                                                                                                                                                                                                                                        |
 | `liveSyncURL`                | लाइव सिंक सर्वर का URL।                                                                                                                                                                   | `string`                          | `'http://localhost:{liveSyncPort}'` | `'https://example.com'`                                                                         | डिफ़ॉल्ट रूप से localhost की ओर इशारा करता है; दूरस्थ लाइव सिंक सर्वर की ओर इशारा करने के लिए बदला जा सकता है।                                                                                                                                                         |
 
----
-
 ### एनालिटिक्स कॉन्फ़िगरेशन (Analytics)
 
 Intlayer एनालिटिक्स से संबंधित सेटिंग्स को परिभाषित करता है: उपयोगकर्ताओं को वास्तव में दिखाए जाने वाले कंटेंट (पेज व्यू, कंटेंट एक्सपोज़र) को एकत्र करना और कंटेंट पर A/B परीक्षण को सक्षम बनाना।
 
-एनालिटिक्स पूरी तरह से ऑप्ट-इन (opt-in) है: जब तक `analytics.enabled` को स्पष्ट रूप से `true` पर सेट न किया जाए **और** एट्रिब्यूशन के लिए एक प्रोजेक्ट कुंजी (`editor.clientId`) कॉन्फ़िगर न की जाए, तब तक कुछ भी एकत्र नहीं किया जाता। अक्षम होने पर (डिफ़ॉल्ट), संपूर्ण एनालिटिक्स इंटीग्रेशन आपके एप्लिकेशन बंडल से हटा दिया जाता है (dead-code elimination)।
+एनालिटिक्स डिफ़ॉल्ट रूप से सक्षम है (ऑप्ट-आउट): `@intlayer/analytics` पैकेज इंस्टॉल होते ही **और** एट्रिब्यूशन के लिए प्रोजेक्ट कुंजी (`editor.clientId`) कॉन्फ़िगर होते ही संग्रहण शुरू हो जाता है। `analytics.enabled` को `false` पर सेट करें — या पैकेज इंस्टॉल न करें — और संपूर्ण एनालिटिक्स इंटीग्रेशन आपके एप्लिकेशन बंडल से हटा दिया जाता है (dead-code elimination)।
 
-| फ़ील्ड          | विवरण                                                                       | प्रकार    | डिफ़ॉल्ट | उदाहरण  | नोट                                                                                                                      |
-| --------------- | --------------------------------------------------------------------------- | --------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------ |
-| `enabled`       | एनालिटिक्स संग्रहण सक्षम करता है (पेज व्यू, कंटेंट एक्सपोज़र, A/B इवेंट्स)। | `boolean` | `false`  | `true`  | एट्रिब्यूशन के लिए `editor.clientId` सेट होना आवश्यक है; अन्यथा `enabled` के `true` होने पर भी एनालिटिक्स अक्षम रहता है। |
-| `flushInterval` | बैकएंड को स्वचालित बैच फ़्लश के बीच मिलीसेकंड।                              | `number`  | `20000`  | `10000` |                                                                                                                          |
-| `sampleRate`    | रिकॉर्ड करने के लिए सत्रों का अंश, `0` (कोई नहीं) से `1` (सभी) तक।          | `number`  | `1`      | `0.5`   | सैंपलिंग प्रति सत्र निर्धारक (deterministic) है, इसलिए एक रिकॉर्ड किया गया सत्र अपने सभी इवेंट्स की रिपोर्ट करता है।     |
+| फ़ील्ड          | विवरण                                                                       | प्रकार    | डिफ़ॉल्ट | उदाहरण  | नोट                                                                                                                                                            |
+| --------------- | --------------------------------------------------------------------------- | --------- | -------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `enabled`       | एनालिटिक्स संग्रहण सक्षम करता है (पेज व्यू, कंटेंट एक्सपोज़र, A/B इवेंट्स)। | `boolean` | `true`   | `false` | `@intlayer/analytics` इंस्टॉल होना और एट्रिब्यूशन के लिए `editor.clientId` सेट होना आवश्यक है; अन्यथा `enabled` के `true` होने पर भी एनालिटिक्स अक्षम रहता है। |
+| `flushInterval` | बैकएंड को स्वचालित बैच फ़्लश के बीच मिलीसेकंड।                              | `number`  | `20000`  | `10000` |                                                                                                                                                                |
+| `sampleRate`    | रिकॉर्ड करने के लिए सत्रों का अंश, `0` (कोई नहीं) से `1` (सभी) तक।          | `number`  | `1`      | `0.5`   | सैंपलिंग प्रति सत्र निर्धारक (deterministic) है, इसलिए एक रिकॉर्ड किया गया सत्र अपने सभी इवेंट्स की रिपोर्ट करता है।                                           |
 
 ---
 
@@ -979,6 +980,13 @@ Intlayer के आंतरिक पथ और आउटपुट परिण
 
 डिक्शनरी संचालन को नियंत्रित करने वाले मापदंड, जिसमें ऑटो-फिल व्यवहार और कंटेंट जनरेशन शामिल है।
 
+यह dictionary configuration दो मुख्य उद्देश्यों को पूरा करता है:
+
+1. **Default Values**: content declaration files बनाते समय default values को define करें
+2. **Fallback Behavior**: जब specific fields define नहीं हों तो fallback values प्रदान करें, जिससे आप dictionary operation behavior को globally define कर सकें
+
+कंटेंट डिक्लेरेशन फ़ाइलों और कॉन्फ़िगरेशन वैल्यूज़ कैसे लागू की जाती हैं इसके बारे में अधिक जानकारी के लिए, [कंटेंट फ़ाइल डॉक्यूमेंटेशन](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dictionary/content_file.md) देखें।
+
 | फ़ील्ड                      | विवरण                                                                                                                                                             | टाइप                                                                                                            | डिफ़ॉल्ट     | उदाहरण                                                                                      | टिप्पणी                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `fill`                      | नियंत्रित करता है कि ऑटो-फिल (AI अनुवाद) आउटपुट फ़ाइलें कैसे उत्पन्न होती हैं।                                                                                    | `boolean` &#124; <br/> `FilePathPattern` &#124; <br/> `Partial<Record<Locale, boolean &#124; FilePathPattern>>` | `true`       | `{ en: '/locales/en/{{key}}.json', fr: ({ key }) => '/locales/fr/${key}.json', es: false }` | • `true`: डिफ़ॉल्ट पाथ (स्रोत के समान फ़ाइल)।<br/>• `false`: अक्षम करें।<br/>• टेम्पलेट स्ट्रिंग/फ़ंक्शन प्रति लोकेल फ़ाइलें उत्पन्न करता है।<br/>• प्रति लोकेल ऑब्जेक्ट: प्रत्येक लोकेल अपने टेम्पलेट से मेल खाता है; `false` उस लोकेल को अनदेखा करता है।<br/>• `{{locale}}` का समावेश प्रति लोकेल जनरेशन को सक्रिय करता है।<br/>• डिक्शनरी स्तर पर `fill` हमेशा इस वैश्विक सेटिंग पर प्राथमिकता लेता है।                       |
@@ -1018,8 +1026,6 @@ Intlayer लॉग आउटपुट को अनुकूलित करन
 | `mode`   | लॉगर मोड इंगित करता है।               | `'default'` &#124; <br/> `'verbose'` &#124; <br/> `'disabled'` | `'default'`     | `'verbose'`      | • `'verbose'`: डिबगिंग के लिए अधिक जानकारी लॉग करता है।<br/>• `'disabled'`: लॉगर को पूरी तरह से बंद कर देता है। |
 | `prefix` | लॉग में सभी संदेशों के लिए प्रीफिक्स। | `string`                                                       | `'[intlayer] '` | `'[my prefix] '` |                                                                                                                 |
 
----
-
 ### AI कॉन्फ़िगरेशन (AI)
 
 Intlayer की AI सुविधाओं को नियंत्रित करने वाली सेटिंग्स, जिनमें प्रदाता, मॉडल और API की (key) शामिल हैं।
@@ -1059,8 +1065,6 @@ Intlayer अधिकतम लचीलेपन के लिए कई AI प
 | `baseURL`            | AI API के लिए बेस URL।                                                                                                                   | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                             | कोई नहीं    | `'https://api.openai.com/v1'` <br/> `'http://localhost:5000'` | स्थानीय या कस्टम AI API एंडपॉइंट की ओर इशारा कर सकता है।                                                                                                                            |
 | `dataSerialization`  | AI सुविधाओं के लिए डेटा सीरियलाइज़ेशन प्रारूप।                                                                                           | `'json'` &#124; <br/> `'toon'`                                                                                                                                                                                                                                                                                                                                                                                                                       | `undefined` | `'toon'`                                                      | • `'json'`: डिफ़ॉल्ट, विश्वसनीय; अधिक टोकन का उपयोग करता है।<br/>• `'toon'`: कम टोकन, कम स्थिर।<br/>• अतिरिक्त मापदंड संदर्भ के रूप में मॉडल को पास किए जाते हैं (तर्क प्रयास आदि)। |
 
----
-
 ### बिल्ड कॉन्फ़िगरेशन (Build)
 
 Intlayer आपके एप्लिकेशन के अंतर्राष्ट्रीयकरण को कैसे ऑप्टिमाइज़ और संकलित करता है, इसे नियंत्रित करने वाले मापदंड।
@@ -1098,8 +1102,6 @@ Intlayer कंपाइलर को नियंत्रित करने
 | `noMetadata`          | यदि `true`, कंपाइलर आउटपुट से डिक्शनरी मेटाडेटा (की (key), कंटेंट रैपर) हटा देता है।                                                                                                                                                                                                                                                        | `boolean`                                                                                                       | `false`     | `false` → `{"key":"my-key","content":{"key":"value"}}` <br/> `true` → `{"key":"value"}`                                                                  | • i18next स्वरूप या ICU MessageFormat JSON आउटपुट के लिए उपयोगी।<br/>• `loadJSON` प्लगइन के साथ अच्छी तरह काम करता है।                                                                                   |
 | `dictionaryKeyPrefix` | डिक्शनरी की प्रीफिक्स                                                                                                                                                                                                                                                                                                                       | `string`                                                                                                        | `''`        |                                                                                                                                                          | निकाले गए डिक्शनरी कीज़ के लिए वैकल्पिक प्रीफिक्स जोड़ें                                                                                                                                                 |
 
----
-
 ### कस्टम स्कीमा (Custom Schemas)
 
 | फ़ील्ड    | विवरण                                                                                            | टाइप                        |

package/docs/hi/custom_domains.md

@@ -138,6 +138,37 @@ getMultilingualUrls("/about", { currentDomain: "intlayer.org" });
 
 ये पूर्ण URL SEO के लिए `<link rel="alternate" hreflang="...">` टैग में उपयोग करने के लिए तैयार हैं।
 
+## Type Inference
+
+`routing.domains` को generated module augmentation में serialize किया जाता है, इसलिए
+`getLocalizedUrl` और `getLocalizedPath` अपने return type को exact
+URL तक narrow करते हैं जिसे एक domain-routed locale resolve करता है — prefix suppression शामिल है।
+
+```ts
+// routing: { mode: 'prefix-no-default', domains: { en: 'intlayer.org', zh: 'intlayer.zh' } }
+
+getLocalizedUrl("/about", "zh");
+//     ^? "https://intlayer.zh/about" | "/about"
+
+getLocalizedPath("/about", "zh");
+//     ^? "/about"   (कभी भी origin नहीं, और कोई /zh/ prefix नहीं)
+```
+
+URL type दोनों values का **union** है जो function return कर सकता है: locale के domain पर
+absolute URL, और relative URL जो तब return होता है जब rendered किया जा रहा page
+पहले से ही उस domain पर रहता है। `getLocalizedPath` के पास ऐसी कोई
+ambiguity नहीं है - यह कभी भी origin emit नहीं करता - इसलिए यह एक single literal रहता है।
+
+Locales जो एक domain share करते हैं अपना normal prefix type में भी keep करते हैं:
+
+```ts
+getLocalizedUrl("/about", "fr");
+//     ^? "https://intlayer.org/fr/about" | "/fr/about"
+```
+
+> `routing.domains` को बदलने के बाद types को regenerate करें (`npx intlayer build`, या कोई dev server run) - narrowing generated
+> `__RoutingRegistry` से आता है, config file से नहीं।
+
 ## प्रॉक्सी व्यवहार (Proxy Behaviour)
 
 ### Next.js
@@ -170,6 +201,8 @@ GET intlayer.zh/about
 
 `intlayerProxy` Vite प्लगइन विकास के दौरान समान तर्क लागू करता है:
 
+> Intlayer v9 के बाद से, `intlayerProxy()` सीधे `intlayer()` plugin में bundled है और `routing.enableProxy` विकल्प के माध्यम से डिफ़ॉल्ट रूप से सक्षम है (`true` डिफ़ॉल्ट रूप से)। इसे अलग से पंजीकृत करना जैसा कि नीचे दिखाया गया है अब वैकल्पिक है — यह backward compatibility के लिए और उन setups के लिए रखा गया है जिन्हें plugin order को नियंत्रित करने की आवश्यकता है। `routing.enableProxy: false` सेट करके opt out करें। [v9 release notes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/releases/v9.md) देखें।
+
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/hi/custom_url_rewrites.md

@@ -248,7 +248,7 @@ Intlayer इन पैटर्नों को आंतरिक रूप स
 
 <Tabs group='framework'>
   <Tab label="Next.js" value="nextjs">
-  
+
     ```tsx
     'use client';
 
@@ -264,7 +264,7 @@ Intlayer इन पैटर्नों को आंतरिक रूप स
   </Tab>
 
   <Tab label="React Router" value="reactrouter">
-  
+
     ```tsx
     'use client';
 
@@ -280,7 +280,7 @@ Intlayer इन पैटर्नों को आंतरिक रूप स
   </Tab>
 
   <Tab label="Vue" value="vue">
-  
+
     ```vue
     <script setup>
     import { useRewriteURL } from "vue-intlayer";
@@ -292,7 +292,7 @@ Intlayer इन पैटर्नों को आंतरिक रूप स
 
   </Tab>
   <Tab label="Solid" value="solid">
-  
+
     ```tsx
     import { useRewriteURL } from "solid-intlayer";
 
@@ -304,7 +304,7 @@ Intlayer इन पैटर्नों को आंतरिक रूप स
 
   </Tab>
   <Tab label="Svelte" value="svelte">
-  
+
     ```svelte
     <script>
     import { useRewriteURL } from "svelte-intlayer";
@@ -341,6 +341,8 @@ export function middleware(request: NextRequest) {
 
 SolidJS, Vue, और Svelte के लिए, `intlayerProxy` Vite प्लगइन विकास के दौरान री-राइट्स को प्रबंधित करता है।
 
+> Intlayer v9 के बाद से, `intlayerProxy()` सीधे `intlayer()` plugin में बंडल किया गया है और `routing.enableProxy` विकल्प (`true` डिफ़ॉल्ट रूप से) के माध्यम से डिफ़ॉल्ट रूप से सक्षम है। इसे अलग से नीचे दिखाए गए अनुसार पंजीकृत करना अब वैकल्पिक है — इसे पिछड़े संगतता के लिए और उन सेटअप के लिए रखा गया है जिन्हें plugin क्रम को नियंत्रित करने की आवश्यकता है। `routing.enableProxy: false` सेट करके बाहर निकलें। [v9 रिलीज़ नोट्स](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/releases/v9.md) देखें।
+
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/hi/dictionary/content_file.md

@@ -584,8 +584,6 @@ Variants के संयोजन में उपयोग किया जा
 
 ##### `location` ('distant' | 'locale')
 
-शब्दकोश के स्थान को दर्शाता है:
-
 - `'locale'`: स्थानीय शब्दकोश (सामग्री फ़ाइलों से)
 - `'distant'`: दूरस्थ शब्दकोश (बाहरी स्रोत से)
 

package/docs/hi/dictionary/html.md

@@ -246,7 +246,7 @@ HTML नोड पर `.use()` विधि का उपयोग करते
 
 <Tabs group="framework">
   <Tab label="React / Next.js" value="react">
-  
+
     ```tsx fileName="AppProvider.tsx"
     import { HTMLProvider } from "react-intlayer/html";
 
@@ -264,7 +264,7 @@ HTML नोड पर `.use()` विधि का उपयोग करते
 
   </Tab>
   <Tab label="Vue" value="vue">
-  
+
     ```typescript fileName="main.ts"
     import { createApp, h } from "vue";
     import { intlayer } from "vue-intlayer";
@@ -286,7 +286,7 @@ HTML नोड पर `.use()` विधि का उपयोग करते
 
   </Tab>
   <Tab label="Svelte" value="svelte">
-   
+
     ```svelte fileName="App.svelte"
     <script lang="ts">
       import { HTMLProvider } from "svelte-intlayer/html";
@@ -304,7 +304,7 @@ HTML नोड पर `.use()` विधि का उपयोग करते
 
   </Tab>
   <Tab label="Preact" value="preact">
-   
+
     ```tsx fileName="AppProvider.tsx"
     import { HTMLProvider } from "preact-intlayer/html";
 
@@ -321,7 +321,7 @@ HTML नोड पर `.use()` विधि का उपयोग करते
 
   </Tab>
   <Tab label="Solid" value="solid">
-   
+
     ```tsx fileName="AppProvider.tsx"
     import { HTMLProvider } from "solid-intlayer/html";
 
@@ -336,6 +336,8 @@ HTML नोड पर `.use()` विधि का उपयोग करते
     );
     ```
 
+> अपने HTML renderer को dynamically import करना आपके application के bundle size को कम करने का एक अच्छा तरीका है।
+
   </Tab>
   <Tab label="Angular" value="angular">
 
@@ -354,6 +356,25 @@ HTML नोड पर `.use()` विधि का उपयोग करते
     };
     ```
 
+आप अपना स्वयं का HTML renderer भी उपयोग कर सकते हैं:
+
+    ```typescript fileName="app.config.ts"
+    import { createIntlayerHTMLProvider } from "angular-intlayer/html";
+
+    export const appConfig: ApplicationConfig = {
+      providers: [
+        createIntlayerHTMLProvider({
+          renderHTML: async (html) => {
+            const { renderHTML } = await import('angular-intlayer/html');
+            return renderHTML(html);
+          },
+        }),
+      ],
+    };
+    ```
+
+> अपने HTML renderer को dynamically import करना आपके application के bundle size को कम करने का एक अच्छा तरीका है।
+
   </Tab>
 </Tabs>
 
@@ -402,9 +423,9 @@ HTML नोड पर `.use()` विधि का उपयोग करते
 
   </Tab>
   <Tab label="Vue" value="vue">
-   
+
     #### `<HTMLRenderer />` कम्पोनेन्ट
-   
+
     ```vue
     <script setup>
     import { HTMLRenderer } from "vue-intlayer/html";
@@ -417,9 +438,9 @@ HTML नोड पर `.use()` विधि का उपयोग करते
 
   </Tab>
   <Tab label="Svelte" value="svelte">
-  
+
     #### `<HTMLRenderer />` कम्पोनेन्ट
-   
+
     ```svelte
     <script lang="ts">
     import { HTMLRenderer } from "svelte-intlayer/html";
@@ -451,9 +472,9 @@ HTML नोड पर `.use()` विधि का उपयोग करते
 
   </Tab>
   <Tab label="Preact" value="preact">
-   
+
     #### `<HTMLRenderer />` कम्पोनेंट
-   
+
     ```tsx
     import { HTMLRenderer } from "preact-intlayer/html";
 
@@ -482,9 +503,9 @@ HTML नोड पर `.use()` विधि का उपयोग करते
 
   </Tab>
   <Tab label="Solid" value="solid">
-   
+
     #### `<HTMLRenderer />` कम्पोनेंट
-   
+
     ```tsx
     import { HTMLRenderer } from "solid-intlayer/html";
 
@@ -517,13 +538,13 @@ HTML नोड पर `.use()` विधि का उपयोग करते
     सर्विस का उपयोग करके HTML स्ट्रिंग रेंडर करें।
 
     ```typescript
-    import { IntlayerHTMLService } from "angular-intlayer";
+    import { IntlayerHTMLService } from "angular-intlayer/html";
 
     export class MyComponent {
       constructor(private markdownService: IntlayerHTMLService) {}
 
       renderHTML(html: string) {
-        return this.markdownService.renderMarkdown(html);
+        return this.markdownService.renderHTML(html);
       }
     }
     ```

package/docs/hi/dictionary/insertion.md

@@ -100,20 +100,6 @@ Intlayer में, सम्मिलन कंटेंट `insertion` फ़
   </Tab>
 </Tabs>
 
-```json5 fileName="**/*.content.json" contentDeclarationFormat="json"
-{
-  "$schema": "https://intlayer.org/schema.json",
-  "key": "my_key",
-  "content": {
-    "myInsertion": {
-      "nodeType": "insertion",
-      "insertion": "नमस्ते, मेरा नाम {{name}} है और मेरी उम्र {{age}} वर्ष है!",
-    },
-    "myInsertion2": "नमस्ते, मेरा नाम {{name}} है और मेरी उम्र {{age}} वर्ष है!", // Since intlayer v8, insertion function is not required anymore. The content will be automatically decorated.
-  },
-}
-```
-
 ## React Intlayer के साथ Insertion Content का उपयोग करना
 
 React कंपोनेंट के भीतर insertion content का उपयोग करने के लिए, `react-intlayer` पैकेज से `useIntlayer` हुक को इम्पोर्ट करें और उपयोग करें। यह हुक निर्दिष्ट key के लिए content प्राप्त करता है और आपको एक ऑब्जेक्ट पास करने की अनुमति देता है जो आपके content में प्रत्येक placeholder को उस मान से मैप करता है जिसे आप प्रदर्शित करना चाहते हैं।

package/docs/hi/dictionary/markdown.md

@@ -492,7 +492,7 @@ Markdown रेंडरिंग **MDX** का समर्थन करता
 
 <Tabs group="framework">
   <Tab label="React" value="react">
-  
+
     #### `<MarkdownRenderer />` घटक
 
     विशिष्ट विकल्पों के साथ एक Markdown स्ट्रिंग रेंडर करता है।
@@ -531,7 +531,7 @@ Markdown रेंडरिंग **MDX** का समर्थन करता
 
   </Tab>
   <Tab label="Next.js" value="nextjs">
-  
+
     #### `<MarkdownRenderer />` घटक
 
     विशिष्ट विकल्पों के साथ एक Markdown स्ट्रिंग रेंडर करता है।
@@ -957,21 +957,38 @@ Markdown रेंडरिंग **MDX** का समर्थन करता
   </Tab>
   <Tab label="Angular" value="angular">
 
-    ```typescript fileName="app.module.ts"
-    import { NgModule } from '@angular/core';
-    import { IntlayerMarkdownModule } from 'angular-intlayer/markdown';
+    ```typescript fileName="app.config.ts"
+    import { createIntlayerMarkdownProvider } from "angular-intlayer/markdown";
+
+    export const appConfig: ApplicationConfig = {
+      providers: [
+        createIntlayerMarkdownProvider({
+          components: {
+            h1: { class: "text-2xl font-bold" },
+          },
+        }),
+      ],
+    };
+    ```
+
+
+    > MDX समर्थित है — आपके Markdown के अंदर उपयोग किए गए किसी भी घटक नाम (उदा. `<MyCustomJSXComponent />`) को `components` मानचित्र के विरुद्ध हल किया जाता है।
+
+    आप अपने स्वयं के मार्कडाउन रेंडरर का भी उपयोग कर सकते हैं:
+
+    ```typescript fileName="app.config.ts"
+    import { createIntlayerMarkdownProvider } from "angular-intlayer/markdown";
 
-    @NgModule({
-      imports: [
-        IntlayerMarkdownModule.forRoot({
+    export const appConfig: ApplicationConfig = {
+      providers: [
+        createIntlayerMarkdownProvider({
           renderMarkdown: async (md) => {
             const { renderMarkdown } = await import('angular-intlayer/markdown');
             return renderMarkdown(md);
-          }
-        })
-      ]
-    })
-    export class AppModule {}
+          },
+        }),
+      ],
+    };
     ```
 
     > अपने Markdown रेंडरर को गतिशील रूप से आयात करना आपके एप्लिकेशन के बंडल आकार को कम करने का एक शानदार तरीका है।
@@ -1047,7 +1064,7 @@ const MyComponent = () => {
 ```
 
   </Tab>
- 
+
   <Tab label="Vue" value="vue">
 
 Vue में एक अंतर्निहित `<Suspense>` घटक है। Markdown सामग्री रेंडर करने वाले घटक को `<Suspense>` बाउंड्री में लपेटें।