angular-intlayer 8.5.0 → 8.5.1

package/dist/cjs/@intlayer/editor/src/isEnabled.cjs

@@ -3,7 +3,7 @@ let _intlayer_config_built = require("@intlayer/config/built");
 _intlayer_config_built = require_runtime.__toESM(_intlayer_config_built);
 
 //#region ../@intlayer/editor/src/isEnabled.ts
-const isEnabled = process.env.INTLAYER_EDITOR_ENABLED !== "false" && _intlayer_config_built.default.editor?.enabled && typeof window !== "undefined" && window.self !== window.top;
+const isEnabled = process.env["INTLAYER_EDITOR_ENABLED"] !== "false" && _intlayer_config_built.default.editor?.enabled && typeof window !== "undefined" && window.self !== window.top;
 
 //#endregion
 exports.isEnabled = isEnabled;

package/dist/cjs/@intlayer/editor/src/isEnabled.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"isEnabled.cjs","names":["configuration"],"sources":["../../../../../../@intlayer/editor/src/isEnabled.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\n\nexport const isEnabled =\n  process.env.INTLAYER_EDITOR_ENABLED !== 'false' && // Allow purging a build time using bundler + env var\n  configuration.editor?.enabled && // Editor enabled in config\n  typeof window !== 'undefined' && // Client side\n  window.self !== window.top; // Is in iframe\n"],"mappings":";;;;;AAEA,MAAa,YACX,QAAQ,IAAI,4BAA4B,WACxCA,+BAAc,QAAQ,WACtB,OAAO,WAAW,eAClB,OAAO,SAAS,OAAO"}
+{"version":3,"file":"isEnabled.cjs","names":["configuration"],"sources":["../../../../../../@intlayer/editor/src/isEnabled.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\n\nexport const isEnabled =\n  process.env['INTLAYER_EDITOR_ENABLED'] !== 'false' && // Allow purging a build time using bundler + env var // Keep env['INTLAYER_EDITOR_ENABLED'] syntax for angular to treat it as\n  configuration.editor?.enabled && // Editor enabled in config\n  typeof window !== 'undefined' && // Client side\n  window.self !== window.top; // Is in iframe\n"],"mappings":";;;;;AAEA,MAAa,YACX,QAAQ,IAAI,+BAA+B,WAC3CA,+BAAc,QAAQ,WACtB,OAAO,WAAW,eAClB,OAAO,SAAS,OAAO"}

package/dist/cjs/UI/IntlayerNode.component.cjs

@@ -0,0 +1,53 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_decorateMetadata = require('../_virtual/_@oxc-project_runtime@0.115.0/helpers/decorateMetadata.cjs');
+const require_decorate = require('../_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.cjs');
+let _angular_core = require("@angular/core");
+
+//#region src/UI/IntlayerNode.component.ts
+let IntlayerNodeComponent = class IntlayerNodeComponent {
+	node;
+	vcr = (0, _angular_core.inject)(_angular_core.ViewContainerRef);
+	elRef = (0, _angular_core.inject)(_angular_core.ElementRef);
+	cdr = (0, _angular_core.inject)(_angular_core.ChangeDetectorRef);
+	ngOnChanges(changes) {
+		if (changes["node"]) this.render();
+	}
+	render() {
+		this.vcr.clear();
+		const host = this.elRef.nativeElement;
+		host.childNodes.forEach((n) => {
+			if (n.nodeType === Node.TEXT_NODE) n.parentNode?.removeChild(n);
+		});
+		if (!this.node) return;
+		const nodeInfo = typeof this.node?.children === "function" ? this.node.children() : this.node;
+		if (nodeInfo?.component && typeof nodeInfo.component !== "string") {
+			const componentRef = this.vcr.createComponent(nodeInfo.component);
+			if (nodeInfo.props) for (const [key, value] of Object.entries(nodeInfo.props)) componentRef.instance[key] = value;
+			if (nodeInfo.children) {
+				const content = nodeInfo.children;
+				if (typeof content === "string" || typeof content === "number") componentRef.location.nativeElement.appendChild(document.createTextNode(String(content)));
+			}
+			this.cdr.markForCheck();
+		} else {
+			const text = this.node?.value ?? this.node?.toString?.() ?? String(this.node);
+			host.appendChild(document.createTextNode(text));
+		}
+	}
+};
+require_decorate.__decorate([(0, _angular_core.Input)(), require_decorateMetadata.__decorateMetadata("design:type", Object)], IntlayerNodeComponent.prototype, "node", void 0);
+IntlayerNodeComponent = require_decorate.__decorate([(0, _angular_core.Component)({
+	selector: "intlayer-node",
+	standalone: true,
+	template: `<ng-container #anchor></ng-container>`,
+	styles: [`:host { display: contents; }`]
+})], IntlayerNodeComponent);
+
+//#endregion
+Object.defineProperty(exports, 'IntlayerNodeComponent', {
+  enumerable: true,
+  get: function () {
+    return IntlayerNodeComponent;
+  }
+});
+//# sourceMappingURL=IntlayerNode.component.cjs.map

package/dist/cjs/UI/IntlayerNode.component.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntlayerNode.component.cjs","names":["ViewContainerRef","ElementRef","ChangeDetectorRef"],"sources":["../../../src/UI/IntlayerNode.component.ts"],"sourcesContent":["import {\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  Input,\n  inject,\n  type OnChanges,\n  type SimpleChanges,\n  type Type,\n  ViewContainerRef,\n} from '@angular/core';\n\n/**\n * A transparent host element that renders Intlayer content nodes.\n *\n * `display: contents` makes the `<intlayer-node>` element invisible in the\n * layout — its children appear as if they were direct children of the parent,\n * so placing this component inside `<h1>`, `<p>`, etc. does not break the\n * document structure.\n *\n * ### Usage\n * ```html\n * <h1><intlayer-node [node]=\"content().title\"></intlayer-node></h1>\n * ```\n */\n@Component({\n  selector: 'intlayer-node',\n  standalone: true,\n  // The ng-content slot is the anchor point for ViewContainerRef.\n  // Wrapping text renders directly inside this host thanks to display:contents.\n  template: `<ng-container #anchor></ng-container>`,\n  // display:contents collapses the host box so it is layout-transparent.\n  styles: [`:host { display: contents; }`],\n})\nexport class IntlayerNodeComponent implements OnChanges {\n  @Input() node: any;\n\n  private vcr = inject(ViewContainerRef);\n  private elRef = inject<ElementRef<HTMLElement>>(ElementRef);\n  private cdr = inject(ChangeDetectorRef);\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['node']) {\n      this.render();\n    }\n  }\n\n  private render() {\n    // Clear previously created views / text nodes\n    this.vcr.clear();\n    const host = this.elRef.nativeElement;\n    // Remove any raw text nodes we injected directly on previous renders\n    host.childNodes.forEach((n) => {\n      if (n.nodeType === Node.TEXT_NODE) n.parentNode?.removeChild(n);\n    });\n\n    if (!this.node) return;\n\n    // The node returned by the Angular plugin is a Proxy whose `.children`\n    // property is a function returning component info (editor on) or the raw\n    // value (editor off).\n    const nodeInfo =\n      typeof this.node?.children === 'function'\n        ? this.node.children()\n        : this.node;\n\n    if (nodeInfo?.component && typeof nodeInfo.component !== 'string') {\n      // ── Editor enabled path: create the ContentSelectorWrapper component ──\n      const componentRef = this.vcr.createComponent(\n        nodeInfo.component as Type<any>\n      );\n\n      if (nodeInfo.props) {\n        for (const [key, value] of Object.entries(nodeInfo.props)) {\n          (componentRef.instance as any)[key] = value;\n        }\n      }\n\n      if (nodeInfo.children) {\n        const content = nodeInfo.children;\n        if (typeof content === 'string' || typeof content === 'number') {\n          componentRef.location.nativeElement.appendChild(\n            document.createTextNode(String(content))\n          );\n        }\n      }\n\n      this.cdr.markForCheck();\n    } else {\n      // ── Editor disabled path: render plain text inside the host ──────────\n      const text =\n        this.node?.value ?? this.node?.toString?.() ?? String(this.node);\n      // Append a text node directly inside the host element.\n      // Because the host has `display: contents`, this text is layout-wise a\n      // direct child of the surrounding element (e.g. <h1>).\n      host.appendChild(document.createTextNode(text));\n    }\n  }\n}\n"],"mappings":";;;;;;;AAkCO,kCAAM,sBAA2C;CACtD,AAAS;CAET,AAAQ,gCAAaA,+BAAiB;CACtC,AAAQ,kCAAwCC,yBAAW;CAC3D,AAAQ,gCAAaC,gCAAkB;CAEvC,YAAY,SAA8B;AACxC,MAAI,QAAQ,QACV,MAAK,QAAQ;;CAIjB,AAAQ,SAAS;AAEf,OAAK,IAAI,OAAO;EAChB,MAAM,OAAO,KAAK,MAAM;AAExB,OAAK,WAAW,SAAS,MAAM;AAC7B,OAAI,EAAE,aAAa,KAAK,UAAW,GAAE,YAAY,YAAY,EAAE;IAC/D;AAEF,MAAI,CAAC,KAAK,KAAM;EAKhB,MAAM,WACJ,OAAO,KAAK,MAAM,aAAa,aAC3B,KAAK,KAAK,UAAU,GACpB,KAAK;AAEX,MAAI,UAAU,aAAa,OAAO,SAAS,cAAc,UAAU;GAEjE,MAAM,eAAe,KAAK,IAAI,gBAC5B,SAAS,UACV;AAED,OAAI,SAAS,MACX,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,SAAS,MAAM,CACvD,CAAC,aAAa,SAAiB,OAAO;AAI1C,OAAI,SAAS,UAAU;IACrB,MAAM,UAAU,SAAS;AACzB,QAAI,OAAO,YAAY,YAAY,OAAO,YAAY,SACpD,cAAa,SAAS,cAAc,YAClC,SAAS,eAAe,OAAO,QAAQ,CAAC,CACzC;;AAIL,QAAK,IAAI,cAAc;SAClB;GAEL,MAAM,OACJ,KAAK,MAAM,SAAS,KAAK,MAAM,YAAY,IAAI,OAAO,KAAK,KAAK;AAIlE,QAAK,YAAY,SAAS,eAAe,KAAK,CAAC;;;;uDA5D3C;kFAVC;CACT,UAAU;CACV,YAAY;CAGZ,UAAU;CAEV,QAAQ,CAAC,+BAA+B;CACzC,CAAC"}

package/dist/cjs/UI/index.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_UI_IntlayerNode_component = require('./IntlayerNode.component.cjs');
+
+Object.defineProperty(exports, 'IntlayerNodeComponent', {
+  enumerable: true,
+  get: function () {
+    return require_UI_IntlayerNode_component.IntlayerNodeComponent;
+  }
+});

package/dist/cjs/client/index.cjs

@@ -1,28 +1,22 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_client_intlayerToken = require('./intlayerToken.cjs');
 const require_client_installIntlayer = require('./installIntlayer.cjs');
 const require_client_useDictionary = require('./useDictionary.cjs');
 const require_client_useDictionaryAsync = require('./useDictionaryAsync.cjs');
 const require_client_useLoadDynamic = require('./useLoadDynamic.cjs');
 const require_client_useDictionaryDynamic = require('./useDictionaryDynamic.cjs');
-const require_client_useIntl = require('./useIntl.cjs');
 const require_client_useIntlayer = require('./useIntlayer.cjs');
 const require_client_useLocale = require('./useLocale.cjs');
 
-exports.INTLAYER_TOKEN = require_client_installIntlayer.INTLAYER_TOKEN;
-Object.defineProperty(exports, 'IntlayerProvider', {
-  enumerable: true,
-  get: function () {
-    return require_client_installIntlayer.IntlayerProvider;
-  }
-});
-exports.createIntlayerClient = require_client_installIntlayer.createIntlayerClient;
+exports.INTLAYER_TOKEN = require_client_intlayerToken.INTLAYER_TOKEN;
+exports.IntlayerProvider = require_client_intlayerToken.IntlayerProvider;
+exports.createIntlayerClient = require_client_intlayerToken.createIntlayerClient;
 exports.installIntlayer = require_client_installIntlayer.installIntlayer;
 exports.isUpdatableNode = require_client_useIntlayer.isUpdatableNode;
 exports.provideIntlayer = require_client_installIntlayer.provideIntlayer;
 exports.useDictionary = require_client_useDictionary.useDictionary;
 exports.useDictionaryAsync = require_client_useDictionaryAsync.useDictionaryAsync;
 exports.useDictionaryDynamic = require_client_useDictionaryDynamic.useDictionaryDynamic;
-exports.useIntl = require_client_useIntl.useIntl;
 exports.useIntlayer = require_client_useIntlayer.useIntlayer;
 exports.useLoadDynamic = require_client_useLoadDynamic.useLoadDynamic;
 exports.useLocale = require_client_useLocale.useLocale;

package/dist/cjs/client/installIntlayer.cjs

@@ -1,44 +1,19 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_decorate = require('../_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.cjs');
-let _intlayer_config_built = require("@intlayer/config/built");
-_intlayer_config_built = require_runtime.__toESM(_intlayer_config_built);
-let _angular_core = require("@angular/core");
+const require_client_intlayerToken = require('./intlayerToken.cjs');
+const require_editor_useEditor = require('../editor/useEditor.cjs');
 
 //#region src/client/installIntlayer.ts
-const INTLAYER_TOKEN = new _angular_core.InjectionToken("intlayer");
-/**
-* Singleton instance
-*/
-let instance = null;
-let IntlayerProvider = class IntlayerProvider {
-	isCookieEnabled = (0, _angular_core.signal)(true);
-	_locale = (0, _angular_core.signal)(_intlayer_config_built.default.internationalization?.defaultLocale);
-	locale = this._locale.asReadonly();
-	setLocale = (locale) => {
-		this._locale.set(locale);
-	};
-};
-IntlayerProvider = require_decorate.__decorate([(0, _angular_core.Injectable)({ providedIn: "root" })], IntlayerProvider);
-/**
-* Create and return a single IntlayerProvider instance
-*/
-const createIntlayerClient = (locale, isCookieEnabled = true) => {
-	if (instance) return instance;
-	instance = new IntlayerProvider();
-	if (locale) instance.setLocale(locale);
-	instance.isCookieEnabled.set(isCookieEnabled);
-	return instance;
-};
 /**
 * Provides Intlayer to your Angular application.
 *
-* This function should be used in your application's provider list (e.g., in `app.config.ts`)
-* to initialize the Intlayer service.
+* Registers the Intlayer locale token **and** automatically starts the Intlayer
+* editor client (when the editor is enabled) via `provideAppInitializer`.
+*
+* This is the recommended way to set up Intlayer in `app.config.ts`.
 *
 * @param locale - Initial locale to use.
 * @param isCookieEnabled - Whether to store the locale in cookies.
-* @returns A provider configuration for Intlayer.
+* @returns An array of Angular providers for Intlayer.
 *
 * @example
 * ```ts
@@ -47,32 +22,28 @@ const createIntlayerClient = (locale, isCookieEnabled = true) => {
 * import { provideIntlayer } from 'angular-intlayer';
 *
 * export const appConfig: ApplicationConfig = {
-*   providers: [
-*     provideIntlayer({ locale: 'en' }),
-*   ],
+*   providers: [provideIntlayer()],
 * };
 * ```
 */
-const provideIntlayer = (locale, isCookieEnabled = true) => ({
-	provide: INTLAYER_TOKEN,
-	useValue: installIntlayer(locale, isCookieEnabled)
-});
+const provideIntlayer = (locale, isCookieEnabled = true) => {
+	const client = installIntlayer(locale, isCookieEnabled);
+	return [{
+		provide: require_client_intlayerToken.INTLAYER_TOKEN,
+		useValue: client
+	}, require_editor_useEditor.provideIntlayerEditor(client)];
+};
 /**
 * Helper to install the Intlayer provider.
 */
 const installIntlayer = (locale, isCookieEnabled = true) => {
-	return createIntlayerClient(locale, isCookieEnabled);
+	return require_client_intlayerToken.createIntlayerClient(locale, isCookieEnabled);
 };
 
 //#endregion
-exports.INTLAYER_TOKEN = INTLAYER_TOKEN;
-Object.defineProperty(exports, 'IntlayerProvider', {
-  enumerable: true,
-  get: function () {
-    return IntlayerProvider;
-  }
-});
-exports.createIntlayerClient = createIntlayerClient;
+exports.INTLAYER_TOKEN = require_client_intlayerToken.INTLAYER_TOKEN;
+exports.IntlayerProvider = require_client_intlayerToken.IntlayerProvider;
+exports.createIntlayerClient = require_client_intlayerToken.createIntlayerClient;
 exports.installIntlayer = installIntlayer;
 exports.provideIntlayer = provideIntlayer;
 //# sourceMappingURL=installIntlayer.cjs.map

package/dist/cjs/client/installIntlayer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"installIntlayer.cjs","names":["InjectionToken","configuration"],"sources":["../../../src/client/installIntlayer.ts"],"sourcesContent":["import { Injectable, InjectionToken, type Signal, signal } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\nexport const INTLAYER_TOKEN = new InjectionToken<IntlayerProvider>('intlayer');\n\n/**\n * Singleton instance\n */\nlet instance: IntlayerProvider | null = null;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class IntlayerProvider {\n  isCookieEnabled = signal(true);\n  private _locale = signal<LocalesValues>(\n    configuration.internationalization?.defaultLocale as LocalesValues\n  );\n\n  readonly locale: Signal<LocalesValues> = this._locale.asReadonly();\n\n  setLocale = (locale: LocalesValues) => {\n    this._locale.set(locale);\n  };\n}\n\n/**\n * Create and return a single IntlayerProvider instance\n */\nexport const createIntlayerClient = (\n  locale?: LocalesValues,\n  isCookieEnabled = true\n): IntlayerProvider => {\n  if (instance) return instance;\n\n  instance = new IntlayerProvider();\n\n  if (locale) {\n    instance.setLocale(locale);\n  }\n  instance.isCookieEnabled.set(isCookieEnabled);\n\n  return instance;\n};\n\n/**\n * Provides Intlayer to your Angular application.\n *\n * This function should be used in your application's provider list (e.g., in `app.config.ts`)\n * to initialize the Intlayer service.\n *\n * @param locale - Initial locale to use.\n * @param isCookieEnabled - Whether to store the locale in cookies.\n * @returns A provider configuration for Intlayer.\n *\n * @example\n * ```ts\n * // app.config.ts\n * import { ApplicationConfig } from '@angular/core';\n * import { provideIntlayer } from 'angular-intlayer';\n *\n * export const appConfig: ApplicationConfig = {\n *   providers: [\n *     provideIntlayer({ locale: 'en' }),\n *   ],\n * };\n * ```\n */\nexport const provideIntlayer = (\n  locale?: LocalesValues,\n  isCookieEnabled = true\n) => ({\n  provide: INTLAYER_TOKEN,\n  useValue: installIntlayer(locale, isCookieEnabled),\n});\n\n/**\n * Helper to install the Intlayer provider.\n */\nexport const installIntlayer = (\n  locale?: LocalesValues,\n  isCookieEnabled = true\n) => {\n  const client = createIntlayerClient(locale, isCookieEnabled);\n\n  // Note: Angular editor installation will be handled differently\n  // installIntlayerEditor();\n\n  return client;\n};\n"],"mappings":";;;;;;;;AAIA,MAAa,iBAAiB,IAAIA,6BAAiC,WAAW;;;;AAK9E,IAAI,WAAoC;AAKjC,6BAAM,iBAAiB;CAC5B,4CAAyB,KAAK;CAC9B,AAAQ,oCACNC,+BAAc,sBAAsB,cACrC;CAED,AAAS,SAAgC,KAAK,QAAQ,YAAY;CAElE,aAAa,WAA0B;AACrC,OAAK,QAAQ,IAAI,OAAO;;;8EAZhB,EACV,YAAY,QACb,CAAC;;;;AAiBF,MAAa,wBACX,QACA,kBAAkB,SACG;AACrB,KAAI,SAAU,QAAO;AAErB,YAAW,IAAI,kBAAkB;AAEjC,KAAI,OACF,UAAS,UAAU,OAAO;AAE5B,UAAS,gBAAgB,IAAI,gBAAgB;AAE7C,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;AA0BT,MAAa,mBACX,QACA,kBAAkB,UACd;CACJ,SAAS;CACT,UAAU,gBAAgB,QAAQ,gBAAgB;CACnD;;;;AAKD,MAAa,mBACX,QACA,kBAAkB,SACf;AAMH,QALe,qBAAqB,QAAQ,gBAAgB"}
+{"version":3,"file":"installIntlayer.cjs","names":["INTLAYER_TOKEN","provideIntlayerEditor","createIntlayerClient"],"sources":["../../../src/client/installIntlayer.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { provideIntlayerEditor } from '../editor/useEditor';\nimport {\n  createIntlayerClient,\n  INTLAYER_TOKEN,\n  IntlayerProvider,\n} from './intlayerToken';\n\nexport { createIntlayerClient, INTLAYER_TOKEN, IntlayerProvider };\n\n/**\n * Provides Intlayer to your Angular application.\n *\n * Registers the Intlayer locale token **and** automatically starts the Intlayer\n * editor client (when the editor is enabled) via `provideAppInitializer`.\n *\n * This is the recommended way to set up Intlayer in `app.config.ts`.\n *\n * @param locale - Initial locale to use.\n * @param isCookieEnabled - Whether to store the locale in cookies.\n * @returns An array of Angular providers for Intlayer.\n *\n * @example\n * ```ts\n * // app.config.ts\n * import { ApplicationConfig } from '@angular/core';\n * import { provideIntlayer } from 'angular-intlayer';\n *\n * export const appConfig: ApplicationConfig = {\n *   providers: [provideIntlayer()],\n * };\n * ```\n */\nexport const provideIntlayer = (\n  locale?: LocalesValues,\n  isCookieEnabled = true\n) => {\n  const client = installIntlayer(locale, isCookieEnabled);\n\n  return [\n    { provide: INTLAYER_TOKEN, useValue: client },\n    provideIntlayerEditor(client),\n  ];\n};\n\n/**\n * Helper to install the Intlayer provider.\n */\nexport const installIntlayer = (\n  locale?: LocalesValues,\n  isCookieEnabled = true\n) => {\n  return createIntlayerClient(locale, isCookieEnabled);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,MAAa,mBACX,QACA,kBAAkB,SACf;CACH,MAAM,SAAS,gBAAgB,QAAQ,gBAAgB;AAEvD,QAAO,CACL;EAAE,SAASA;EAAgB,UAAU;EAAQ,EAC7CC,+CAAsB,OAAO,CAC9B;;;;;AAMH,MAAa,mBACX,QACA,kBAAkB,SACf;AACH,QAAOC,kDAAqB,QAAQ,gBAAgB"}

package/dist/cjs/client/intlayerToken.cjs

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let _intlayer_config_built = require("@intlayer/config/built");
+_intlayer_config_built = require_runtime.__toESM(_intlayer_config_built);
+let _angular_core = require("@angular/core");
+
+//#region src/client/intlayerToken.ts
+var IntlayerProvider = class {
+	isCookieEnabled = (0, _angular_core.signal)(true);
+	_locale = (0, _angular_core.signal)(_intlayer_config_built.default.internationalization?.defaultLocale);
+	locale = this._locale.asReadonly();
+	setLocale = (locale) => {
+		this._locale.set(locale);
+	};
+};
+const INTLAYER_TOKEN = new _angular_core.InjectionToken("intlayer");
+/**
+* Singleton instance
+*/
+let instance = null;
+/**
+* Create and return a single IntlayerProvider instance
+*/
+const createIntlayerClient = (locale, isCookieEnabled = true) => {
+	if (instance) return instance;
+	instance = new IntlayerProvider();
+	if (locale) instance.setLocale(locale);
+	instance.isCookieEnabled.set(isCookieEnabled);
+	return instance;
+};
+
+//#endregion
+exports.INTLAYER_TOKEN = INTLAYER_TOKEN;
+exports.IntlayerProvider = IntlayerProvider;
+exports.createIntlayerClient = createIntlayerClient;
+//# sourceMappingURL=intlayerToken.cjs.map

package/dist/cjs/client/intlayerToken.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"intlayerToken.cjs","names":["configuration","InjectionToken"],"sources":["../../../src/client/intlayerToken.ts"],"sourcesContent":["import { InjectionToken, type Signal, signal } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\nexport class IntlayerProvider {\n  isCookieEnabled = signal(true);\n  private _locale = signal<LocalesValues>(\n    configuration.internationalization?.defaultLocale as LocalesValues\n  );\n\n  readonly locale: Signal<LocalesValues> = this._locale.asReadonly();\n\n  setLocale = (locale: LocalesValues) => {\n    this._locale.set(locale);\n  };\n}\n\nexport const INTLAYER_TOKEN = new InjectionToken<IntlayerProvider>('intlayer');\n\n/**\n * Singleton instance\n */\nlet instance: IntlayerProvider | null = null;\n\n/**\n * Create and return a single IntlayerProvider instance\n */\nexport const createIntlayerClient = (\n  locale?: LocalesValues,\n  isCookieEnabled = true\n): IntlayerProvider => {\n  if (instance) return instance;\n\n  instance = new IntlayerProvider();\n\n  if (locale) {\n    instance.setLocale(locale);\n  }\n  instance.isCookieEnabled.set(isCookieEnabled);\n\n  return instance;\n};\n"],"mappings":";;;;;;;AAIA,IAAa,mBAAb,MAA8B;CAC5B,4CAAyB,KAAK;CAC9B,AAAQ,oCACNA,+BAAc,sBAAsB,cACrC;CAED,AAAS,SAAgC,KAAK,QAAQ,YAAY;CAElE,aAAa,WAA0B;AACrC,OAAK,QAAQ,IAAI,OAAO;;;AAI5B,MAAa,iBAAiB,IAAIC,6BAAiC,WAAW;;;;AAK9E,IAAI,WAAoC;;;;AAKxC,MAAa,wBACX,QACA,kBAAkB,SACG;AACrB,KAAI,SAAU,QAAO;AAErB,YAAW,IAAI,kBAAkB;AAEjC,KAAI,OACF,UAAS,UAAU,OAAO;AAE5B,UAAS,gBAAgB,IAAI,gBAAgB;AAE7C,QAAO"}

package/dist/cjs/client/useDictionary.cjs

@@ -1,12 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_getDictionary = require('../getDictionary.cjs');
-const require_client_installIntlayer = require('./installIntlayer.cjs');
+const require_client_intlayerToken = require('./intlayerToken.cjs');
 let _angular_core = require("@angular/core");
 
 //#region src/client/useDictionary.ts
 const useDictionary = (dictionary, locale) => {
-	const intlayer = (0, _angular_core.inject)(require_client_installIntlayer.INTLAYER_TOKEN);
+	const intlayer = (0, _angular_core.inject)(require_client_intlayerToken.INTLAYER_TOKEN);
 	const localeTarget = (0, _angular_core.computed)(() => locale ?? intlayer?.locale());
 	return (0, _angular_core.computed)(() => require_getDictionary.getDictionary(dictionary, localeTarget()));
 };

package/dist/cjs/client/useDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.cjs","names":["INTLAYER_TOKEN","getDictionary"],"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["import { computed, inject, type Signal } from '@angular/core';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport type { DeepTransformContent } from '../plugins';\nimport { INTLAYER_TOKEN, type IntlayerProvider } from './installIntlayer';\n\nexport const useDictionary = <T extends Dictionary>(\n  dictionary: T,\n  locale?: LocalesValues\n): Signal<DeepTransformContent<T['content']>> => {\n  const intlayer = inject<IntlayerProvider>(INTLAYER_TOKEN);\n\n  const localeTarget = computed(() => locale ?? intlayer?.locale());\n\n  /** a *stable* reactive dictionary object */\n  const content = computed(() =>\n    getDictionary<T, LocalesValues>(dictionary, localeTarget())\n  );\n\n  return content; // all consumers keep full reactivity\n};\n"],"mappings":";;;;;;;AAOA,MAAa,iBACX,YACA,WAC+C;CAC/C,MAAM,qCAAoCA,8CAAe;CAEzD,MAAM,iDAA8B,UAAU,UAAU,QAAQ,CAAC;AAOjE,0CAHEC,oCAAgC,YAAY,cAAc,CAAC,CAC5D"}
+{"version":3,"file":"useDictionary.cjs","names":["INTLAYER_TOKEN","getDictionary"],"sources":["../../../src/client/useDictionary.ts"],"sourcesContent":["import { computed, inject, type Signal } from '@angular/core';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getDictionary } from '../getDictionary';\nimport type { DeepTransformContent } from '../plugins';\nimport { INTLAYER_TOKEN, type IntlayerProvider } from './installIntlayer';\n\nexport const useDictionary = <T extends Dictionary>(\n  dictionary: T,\n  locale?: LocalesValues\n): Signal<DeepTransformContent<T['content']>> => {\n  const intlayer = inject<IntlayerProvider>(INTLAYER_TOKEN);\n\n  const localeTarget = computed(() => locale ?? intlayer?.locale());\n\n  /** a *stable* reactive dictionary object */\n  const content = computed(\n    () => getDictionary<T, LocalesValues>(dictionary, localeTarget()) as any\n  );\n\n  return content; // all consumers keep full reactivity\n};\n"],"mappings":";;;;;;;AAOA,MAAa,iBACX,YACA,WAC+C;CAC/C,MAAM,qCAAoCA,4CAAe;CAEzD,MAAM,iDAA8B,UAAU,UAAU,QAAQ,CAAC;AAOjE,0CAHQC,oCAAgC,YAAY,cAAc,CAAC,CAClE"}

package/dist/cjs/client/useDictionaryAsync.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_client_installIntlayer = require('./installIntlayer.cjs');
+const require_client_intlayerToken = require('./intlayerToken.cjs');
 const require_client_useDictionary = require('./useDictionary.cjs');
 let _intlayer_config_built = require("@intlayer/config/built");
 _intlayer_config_built = require_runtime.__toESM(_intlayer_config_built);
@@ -15,7 +15,7 @@ let _angular_core = require("@angular/core");
 * If the locale is not provided, it will use the locale from the client context
 */
 const useDictionaryAsync = async (dictionaryPromise, locale) => {
-	const intlayer = (0, _angular_core.inject)(require_client_installIntlayer.INTLAYER_TOKEN);
+	const intlayer = (0, _angular_core.inject)(require_client_intlayerToken.INTLAYER_TOKEN);
 	const localeTarget = (0, _angular_core.computed)(() => locale ?? intlayer?.locale() ?? _intlayer_config_built.default?.internationalization.defaultLocale);
 	return require_client_useDictionary.useDictionary(await dictionaryPromise[localeTarget()]?.(), localeTarget());
 };

package/dist/cjs/client/useDictionaryAsync.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.cjs","names":["INTLAYER_TOKEN","configuration","useDictionary"],"sources":["../../../src/client/useDictionaryAsync.ts"],"sourcesContent":["'use client';\n\nimport { computed, inject } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type { LocalesValues, StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { INTLAYER_TOKEN, type IntlayerProvider } from './installIntlayer';\nimport { useDictionary } from './useDictionary';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionaryAsync = async <T extends Dictionary>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: LocalesValues\n) => {\n  const intlayer = inject<IntlayerProvider>(INTLAYER_TOKEN);\n\n  const localeTarget = computed(\n    () =>\n      locale ??\n      intlayer?.locale() ??\n      configuration?.internationalization.defaultLocale\n  );\n\n  const dictionary = await dictionaryPromise[localeTarget()]?.();\n\n  return useDictionary(dictionary, localeTarget() as any);\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,MAAa,qBAAqB,OAChC,mBACA,WACG;CACH,MAAM,qCAAoCA,8CAAe;CAEzD,MAAM,iDAEF,UACA,UAAU,QAAQ,IAClBC,gCAAe,qBAAqB,cACvC;AAID,QAAOC,2CAFY,MAAM,kBAAkB,cAAc,KAAK,EAE7B,cAAc,CAAQ"}
+{"version":3,"file":"useDictionaryAsync.cjs","names":["INTLAYER_TOKEN","configuration","useDictionary"],"sources":["../../../src/client/useDictionaryAsync.ts"],"sourcesContent":["'use client';\n\nimport { computed, inject } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { INTLAYER_TOKEN, type IntlayerProvider } from './installIntlayer';\nimport { useDictionary } from './useDictionary';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionaryAsync = async <T extends Dictionary>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  locale?: LocalesValues\n) => {\n  const intlayer = inject<IntlayerProvider>(INTLAYER_TOKEN);\n\n  const localeTarget = computed(\n    () =>\n      locale ??\n      intlayer?.locale() ??\n      configuration?.internationalization.defaultLocale\n  );\n\n  const dictionary = await (dictionaryPromise as any)[localeTarget()]?.();\n\n  return useDictionary(dictionary, localeTarget() as any);\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,MAAa,qBAAqB,OAChC,mBACA,WACG;CACH,MAAM,qCAAoCA,4CAAe;CAEzD,MAAM,iDAEF,UACA,UAAU,QAAQ,IAClBC,gCAAe,qBAAqB,cACvC;AAID,QAAOC,2CAFY,MAAO,kBAA0B,cAAc,KAAK,EAEtC,cAAc,CAAQ"}

package/dist/cjs/client/useDictionaryDynamic.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_client_installIntlayer = require('./installIntlayer.cjs');
+const require_client_intlayerToken = require('./intlayerToken.cjs');
 const require_client_useDictionary = require('./useDictionary.cjs');
 const require_client_useLoadDynamic = require('./useLoadDynamic.cjs');
 let _intlayer_config_built = require("@intlayer/config/built");
@@ -16,7 +16,7 @@ let _angular_core = require("@angular/core");
 * If the locale is not provided, it will use the locale from the client context
 */
 const useDictionaryDynamic = (dictionaryPromise, key, locale) => {
-	const intlayer = (0, _angular_core.inject)(require_client_installIntlayer.INTLAYER_TOKEN);
+	const intlayer = (0, _angular_core.inject)(require_client_intlayerToken.INTLAYER_TOKEN);
 	const localeTarget = (0, _angular_core.computed)(() => locale ?? intlayer?.locale() ?? _intlayer_config_built.default?.internationalization.defaultLocale);
 	return require_client_useDictionary.useDictionary(require_client_useLoadDynamic.useLoadDynamic(`${String(key)}.${localeTarget()}`, dictionaryPromise[localeTarget()]?.()), localeTarget());
 };

package/dist/cjs/client/useDictionaryDynamic.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.cjs","names":["INTLAYER_TOKEN","configuration","useDictionary","useLoadDynamic"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport { computed, inject } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type { DictionaryKeys, LocalesValues, StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { INTLAYER_TOKEN, type IntlayerProvider } from './installIntlayer';\nimport { useDictionary } from './useDictionary';\nimport { useLoadDynamic } from './useLoadDynamic';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionaryDynamic = <\n  T extends Dictionary,\n  K extends DictionaryKeys,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  locale?: LocalesValues\n) => {\n  const intlayer = inject<IntlayerProvider>(INTLAYER_TOKEN);\n\n  const localeTarget = computed(\n    () =>\n      locale ??\n      intlayer?.locale() ??\n      configuration?.internationalization.defaultLocale\n  );\n\n  const dictionary = useLoadDynamic<T>(\n    `${String(key)}.${localeTarget()}`,\n    dictionaryPromise[localeTarget()]?.()\n  ) as T;\n\n  return useDictionary(dictionary, localeTarget() as any);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,MAAa,wBAIX,mBACA,KACA,WACG;CACH,MAAM,qCAAoCA,8CAAe;CAEzD,MAAM,iDAEF,UACA,UAAU,QAAQ,IAClBC,gCAAe,qBAAqB,cACvC;AAOD,QAAOC,2CALYC,6CACjB,GAAG,OAAO,IAAI,CAAC,GAAG,cAAc,IAChC,kBAAkB,cAAc,KAAK,CACtC,EAEgC,cAAc,CAAQ"}
+{"version":3,"file":"useDictionaryDynamic.cjs","names":["INTLAYER_TOKEN","configuration","useDictionary","useLoadDynamic"],"sources":["../../../src/client/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport { computed, inject } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n  StrictModeLocaleMap,\n} from '@intlayer/types/module_augmentation';\nimport { INTLAYER_TOKEN, type IntlayerProvider } from './installIntlayer';\nimport { useDictionary } from './useDictionary';\nimport { useLoadDynamic } from './useLoadDynamic';\n\n/**\n * On the server side, Hook that transform a dictionary and return the content\n *\n * If the locale is not provided, it will use the locale from the client context\n */\nexport const useDictionaryDynamic = <\n  T extends Dictionary,\n  K extends DictionaryKeys,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  locale?: LocalesValues\n) => {\n  const intlayer = inject<IntlayerProvider>(INTLAYER_TOKEN);\n\n  const localeTarget = computed(\n    () =>\n      locale ??\n      intlayer?.locale() ??\n      configuration?.internationalization.defaultLocale\n  );\n\n  const dictionary = useLoadDynamic<T>(\n    `${String(key)}.${localeTarget()}`,\n    (dictionaryPromise as any)[localeTarget()]?.()\n  ) as T;\n\n  return useDictionary(dictionary, localeTarget() as any);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,MAAa,wBAIX,mBACA,KACA,WACG;CACH,MAAM,qCAAoCA,4CAAe;CAEzD,MAAM,iDAEF,UACA,UAAU,QAAQ,IAClBC,gCAAe,qBAAqB,cACvC;AAOD,QAAOC,2CALYC,6CACjB,GAAG,OAAO,IAAI,CAAC,GAAG,cAAc,IAC/B,kBAA0B,cAAc,KAAK,CAC/C,EAEgC,cAAc,CAAQ"}

package/dist/cjs/client/useIntlayer.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_getIntlayer = require('../getIntlayer.cjs');
-const require_client_installIntlayer = require('./installIntlayer.cjs');
+const require_client_intlayerToken = require('./intlayerToken.cjs');
 let _angular_core = require("@angular/core");
 
 //#region src/client/useIntlayer.ts
@@ -33,7 +33,7 @@ const isUpdatableNode = (val) => !!val && typeof val === "object" && typeof val.
 * ```
 */
 const useIntlayer = (key, locale) => {
-	const intlayer = (0, _angular_core.inject)(require_client_installIntlayer.INTLAYER_TOKEN);
+	const intlayer = (0, _angular_core.inject)(require_client_intlayerToken.INTLAYER_TOKEN);
 	/** which locale should we use right now? */
 	const localeTarget = (0, _angular_core.computed)(() => locale ?? intlayer.locale());
 	return (0, _angular_core.computed)(() => require_getIntlayer.getIntlayer(key, localeTarget()));

package/dist/cjs/client/useIntlayer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.cjs","names":["INTLAYER_TOKEN","getIntlayer"],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["import { computed, inject, type Signal } from '@angular/core';\nimport type { DictionaryKeys, DictionaryRegistryContent, LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getIntlayer } from '../getIntlayer';\nimport type { DeepTransformContent } from '../plugins';\nimport { INTLAYER_TOKEN, type IntlayerProvider } from './installIntlayer';\n\n/** guard utility - true only for objects generated by `renderIntlayerNode()` */\nexport const isUpdatableNode = (\n  val: unknown\n): val is { __update: (n: unknown) => void } =>\n  !!val &&\n  typeof val === 'object' &&\n  typeof (val as any).__update === 'function';\n\n/**\n * Angular hook that picks one dictionary by its key and returns its reactive content.\n *\n * It utilizes Angular signals to provide deep reactivity, ensuring your components\n * update automatically when the locale changes.\n *\n * @param key - The unique key of the dictionary to retrieve.\n * @param locale - Optional locale to override the current context locale.\n * @returns The transformed dictionary content.\n *\n * @example\n * ```ts\n * import { Component } from '@angular/core';\n * import { useIntlayer } from 'angular-intlayer';\n *\n * @Component({\n *   standalone: true,\n *   selector: 'app-my-component',\n *   template: `<div>{{ content().myField.value }}</div>`,\n * })\n * export class MyComponent {\n *   content = useIntlayer('my-dictionary-key');\n * }\n * ```\n */\nexport const useIntlayer = <T extends DictionaryKeys, L extends LocalesValues>(\n  key: T,\n  locale?: LocalesValues\n): Signal<DeepTransformContent<DictionaryRegistryContent<T>>> => {\n  const intlayer = inject<IntlayerProvider>(INTLAYER_TOKEN)!;\n\n  /** which locale should we use right now? */\n  const localeTarget = computed(() => locale ?? intlayer.locale());\n\n  /** a *stable* reactive dictionary object */\n  // @ts-ignore Type instantiation is excessively deep and possibly infinite\n  const content = computed(() => getIntlayer<T, L>(key, localeTarget() as L));\n\n  return content; // all consumers keep full reactivity\n};\n"],"mappings":";;;;;;;;AAOA,MAAa,mBACX,QAEA,CAAC,CAAC,OACF,OAAO,QAAQ,YACf,OAAQ,IAAY,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BnC,MAAa,eACX,KACA,WAC+D;CAC/D,MAAM,qCAAoCA,8CAAe;;CAGzD,MAAM,iDAA8B,UAAU,SAAS,QAAQ,CAAC;AAMhE,0CAF+BC,gCAAkB,KAAK,cAAc,CAAM,CAAC"}
+{"version":3,"file":"useIntlayer.cjs","names":["INTLAYER_TOKEN","getIntlayer"],"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["import { computed, inject, type Signal } from '@angular/core';\nimport type {\n  DictionaryKeys,\n  DictionaryRegistryContent,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { getIntlayer } from '../getIntlayer';\nimport type { DeepTransformContent } from '../plugins';\nimport { INTLAYER_TOKEN, type IntlayerProvider } from './installIntlayer';\n\n/** guard utility - true only for objects generated by `renderIntlayerNode()` */\nexport const isUpdatableNode = (\n  val: unknown\n): val is { __update: (n: unknown) => void } =>\n  !!val &&\n  typeof val === 'object' &&\n  typeof (val as any).__update === 'function';\n\n/**\n * Angular hook that picks one dictionary by its key and returns its reactive content.\n *\n * It utilizes Angular signals to provide deep reactivity, ensuring your components\n * update automatically when the locale changes.\n *\n * @param key - The unique key of the dictionary to retrieve.\n * @param locale - Optional locale to override the current context locale.\n * @returns The transformed dictionary content.\n *\n * @example\n * ```ts\n * import { Component } from '@angular/core';\n * import { useIntlayer } from 'angular-intlayer';\n *\n * @Component({\n *   standalone: true,\n *   selector: 'app-my-component',\n *   template: `<div>{{ content().myField.value }}</div>`,\n * })\n * export class MyComponent {\n *   content = useIntlayer('my-dictionary-key');\n * }\n * ```\n */\nexport const useIntlayer = <T extends DictionaryKeys, L extends LocalesValues>(\n  key: T,\n  locale?: LocalesValues\n): Signal<DeepTransformContent<DictionaryRegistryContent<T>>> => {\n  const intlayer = inject<IntlayerProvider>(INTLAYER_TOKEN)!;\n\n  /** which locale should we use right now? */\n  const localeTarget = computed(() => locale ?? intlayer.locale());\n\n  /** a *stable* reactive dictionary object */\n  // @ts-ignore Type instantiation is excessively deep and possibly infinite\n  const content = computed(\n    () => getIntlayer<T, L>(key, localeTarget() as L) as any\n  );\n\n  return content; // all consumers keep full reactivity\n};\n"],"mappings":";;;;;;;;AAWA,MAAa,mBACX,QAEA,CAAC,CAAC,OACF,OAAO,QAAQ,YACf,OAAQ,IAAY,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BnC,MAAa,eACX,KACA,WAC+D;CAC/D,MAAM,qCAAoCA,4CAAe;;CAGzD,MAAM,iDAA8B,UAAU,SAAS,QAAQ,CAAC;AAQhE,0CAHQC,gCAAkB,KAAK,cAAc,CAAM,CAClD"}

package/dist/cjs/client/useLocale.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_client_installIntlayer = require('./installIntlayer.cjs');
+const require_client_intlayerToken = require('./intlayerToken.cjs');
 const require_client_useLocaleStorage = require('./useLocaleStorage.cjs');
 let _intlayer_config_built = require("@intlayer/config/built");
 _intlayer_config_built = require_runtime.__toESM(_intlayer_config_built);
@@ -36,7 +36,7 @@ let _angular_core = require("@angular/core");
 */
 const useLocale = ({ isCookieEnabled, onLocaleChange } = {}) => {
 	const { defaultLocale, locales: availableLocales } = _intlayer_config_built.default?.internationalization ?? {};
-	const intlayer = (0, _angular_core.inject)(require_client_installIntlayer.INTLAYER_TOKEN);
+	const intlayer = (0, _angular_core.inject)(require_client_intlayerToken.INTLAYER_TOKEN);
 	const locale = (0, _angular_core.computed)(() => intlayer?.locale() ?? defaultLocale);
 	const isCookieEnabledContext = (0, _angular_core.computed)(() => intlayer?.isCookieEnabled() ?? true);
 	const setLocale = (newLocale) => {

package/dist/cjs/client/useLocale.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLocale.cjs","names":["configuration","INTLAYER_TOKEN"],"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import { computed, inject } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { INTLAYER_TOKEN, type IntlayerProvider } from './installIntlayer';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\ntype useLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: LocalesValues) => void;\n};\n\n/**\n * Angular hook to manage the current locale and related functions.\n *\n * @param props - Optional configuration for locale management.\n * @returns An object containing the current locale (signal), default locale, available locales, and a function to update the locale.\n *\n * @example\n * ```ts\n * import { Component } from '@angular/core';\n * import { useLocale } from 'angular-intlayer';\n *\n * @Component({\n *   standalone: true,\n *   selector: 'app-locale-switcher',\n *   template: `\n *     <select [value]=\"locale()\" (change)=\"setLocale($any($event.target).value)\">\n *       @for (loc of availableLocales; track loc) {\n *         <option [value]=\"loc\">{{ loc }}</option>\n *       }\n *     </select>\n *   `,\n * })\n * export class LocaleSwitcher {\n *   const { locale, setLocale, availableLocales } = useLocale();\n * }\n * ```\n */\nexport const useLocale = ({\n  isCookieEnabled,\n  onLocaleChange,\n}: useLocaleProps = {}) => {\n  const { defaultLocale, locales: availableLocales } =\n    configuration?.internationalization ?? {};\n  const intlayer = inject<IntlayerProvider>(INTLAYER_TOKEN);\n\n  // Create a reactive reference for the locale\n  const locale = computed(() => intlayer?.locale() ?? defaultLocale);\n  const isCookieEnabledContext = computed(\n    () => intlayer?.isCookieEnabled() ?? true\n  );\n\n  const setLocale = (newLocale: LocalesValues) => {\n    if (!availableLocales?.map(String).includes(newLocale)) {\n      console.error(`Locale ${newLocale} is not available`);\n      return;\n    }\n\n    if (intlayer) {\n      intlayer.setLocale(newLocale);\n    }\n    setLocaleInStorage(\n      newLocale,\n      isCookieEnabled ?? isCookieEnabledContext() ?? true\n    );\n    onLocaleChange?.(newLocale);\n  };\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    setLocale, // Function to set the locale\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,aAAa,EACxB,iBACA,mBACkB,EAAE,KAAK;CACzB,MAAM,EAAE,eAAe,SAAS,qBAC9BA,gCAAe,wBAAwB,EAAE;CAC3C,MAAM,qCAAoCC,8CAAe;CAGzD,MAAM,2CAAwB,UAAU,QAAQ,IAAI,cAAc;CAClE,MAAM,2DACE,UAAU,iBAAiB,IAAI,KACtC;CAED,MAAM,aAAa,cAA6B;AAC9C,MAAI,CAAC,kBAAkB,IAAI,OAAO,CAAC,SAAS,UAAU,EAAE;AACtD,WAAQ,MAAM,UAAU,UAAU,mBAAmB;AACrD;;AAGF,MAAI,SACF,UAAS,UAAU,UAAU;AAE/B,qDACE,WACA,mBAAmB,wBAAwB,IAAI,KAChD;AACD,mBAAiB,UAAU;;AAG7B,QAAO;EACL;EACA;EACA;EACA;EACD"}
+{"version":3,"file":"useLocale.cjs","names":["configuration","INTLAYER_TOKEN"],"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import { computed, inject } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { INTLAYER_TOKEN, type IntlayerProvider } from './installIntlayer';\nimport { setLocaleInStorage } from './useLocaleStorage';\n\ntype useLocaleProps = {\n  isCookieEnabled?: boolean;\n  onLocaleChange?: (locale: LocalesValues) => void;\n};\n\n/**\n * Angular hook to manage the current locale and related functions.\n *\n * @param props - Optional configuration for locale management.\n * @returns An object containing the current locale (signal), default locale, available locales, and a function to update the locale.\n *\n * @example\n * ```ts\n * import { Component } from '@angular/core';\n * import { useLocale } from 'angular-intlayer';\n *\n * @Component({\n *   standalone: true,\n *   selector: 'app-locale-switcher',\n *   template: `\n *     <select [value]=\"locale()\" (change)=\"setLocale($any($event.target).value)\">\n *       @for (loc of availableLocales; track loc) {\n *         <option [value]=\"loc\">{{ loc }}</option>\n *       }\n *     </select>\n *   `,\n * })\n * export class LocaleSwitcher {\n *   const { locale, setLocale, availableLocales } = useLocale();\n * }\n * ```\n */\nexport const useLocale = ({\n  isCookieEnabled,\n  onLocaleChange,\n}: useLocaleProps = {}) => {\n  const { defaultLocale, locales: availableLocales } =\n    configuration?.internationalization ?? {};\n  const intlayer = inject<IntlayerProvider>(INTLAYER_TOKEN);\n\n  // Create a reactive reference for the locale\n  const locale = computed(() => intlayer?.locale() ?? defaultLocale);\n  const isCookieEnabledContext = computed(\n    () => intlayer?.isCookieEnabled() ?? true\n  );\n\n  const setLocale = (newLocale: LocalesValues) => {\n    if (!availableLocales?.map(String).includes(newLocale)) {\n      console.error(`Locale ${newLocale} is not available`);\n      return;\n    }\n\n    if (intlayer) {\n      intlayer.setLocale(newLocale);\n    }\n    setLocaleInStorage(\n      newLocale,\n      isCookieEnabled ?? isCookieEnabledContext() ?? true\n    );\n    onLocaleChange?.(newLocale);\n  };\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    setLocale, // Function to set the locale\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,MAAa,aAAa,EACxB,iBACA,mBACkB,EAAE,KAAK;CACzB,MAAM,EAAE,eAAe,SAAS,qBAC9BA,gCAAe,wBAAwB,EAAE;CAC3C,MAAM,qCAAoCC,4CAAe;CAGzD,MAAM,2CAAwB,UAAU,QAAQ,IAAI,cAAc;CAClE,MAAM,2DACE,UAAU,iBAAiB,IAAI,KACtC;CAED,MAAM,aAAa,cAA6B;AAC9C,MAAI,CAAC,kBAAkB,IAAI,OAAO,CAAC,SAAS,UAAU,EAAE;AACtD,WAAQ,MAAM,UAAU,UAAU,mBAAmB;AACrD;;AAGF,MAAI,SACF,UAAS,UAAU,UAAU;AAE/B,qDACE,WACA,mBAAmB,wBAAwB,IAAI,KAChD;AACD,mBAAiB,UAAU;;AAG7B,QAAO;EACL;EACA;EACA;EACA;EACD"}

package/dist/cjs/editor/EditorProvider.component.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_decorateMetadata = require('../_virtual/_@oxc-project_runtime@0.115.0/helpers/decorateMetadata.cjs');
+const require_decorate = require('../_virtual/_@oxc-project_runtime@0.115.0/helpers/decorate.cjs');
+const require_editor_useEditor = require('./useEditor.cjs');
+let _angular_core = require("@angular/core");
+
+//#region src/editor/EditorProvider.component.ts
+let EditorProviderComponent = class EditorProviderComponent {
+	constructor() {
+		require_editor_useEditor.useEditor();
+	}
+};
+EditorProviderComponent = require_decorate.__decorate([(0, _angular_core.Component)({
+	selector: "intlayer-editor-provider",
+	standalone: true,
+	template: `<ng-content />`
+}), require_decorateMetadata.__decorateMetadata("design:paramtypes", [])], EditorProviderComponent);
+
+//#endregion
+Object.defineProperty(exports, 'EditorProviderComponent', {
+  enumerable: true,
+  get: function () {
+    return EditorProviderComponent;
+  }
+});
+//# sourceMappingURL=EditorProvider.component.cjs.map

package/dist/cjs/editor/EditorProvider.component.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditorProvider.component.cjs","names":[],"sources":["../../../src/editor/EditorProvider.component.ts"],"sourcesContent":["import { Component } from '@angular/core';\nimport { useEditor } from './useEditor';\n\n/**\n * Drop-in Angular equivalent of React's `EditorProvider`.\n *\n * Wrap your root component (or any subtree) with this component to automatically\n * start the Intlayer editor client.  The editor will be started on mount and\n * stopped when this component is destroyed.\n *\n * @example\n * ```html\n * <!-- app.component.html -->\n * <intlayer-editor-provider>\n *   <router-outlet />\n * </intlayer-editor-provider>\n * ```\n *\n * ```ts\n * // app.component.ts\n * import { EditorProviderComponent } from 'angular-intlayer';\n *\n * @Component({\n *   imports: [EditorProviderComponent],\n *   …\n * })\n * export class AppComponent {}\n * ```\n */\n@Component({\n  selector: 'intlayer-editor-provider',\n  standalone: true,\n  template: `<ng-content />`,\n})\nexport class EditorProviderComponent {\n  constructor() {\n    useEditor();\n  }\n}\n"],"mappings":";;;;;;;;AAkCO,oCAAM,wBAAwB;CACnC,cAAc;AACZ,sCAAW;;;oFAPJ;CACT,UAAU;CACV,YAAY;CACZ,UAAU;CACX,CAAC"}

package/dist/cjs/editor/index.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_editor_ContentSelector_component = require('./ContentSelector.component.cjs');
+const require_editor_useEditor = require('./useEditor.cjs');
+const require_editor_EditorProvider_component = require('./EditorProvider.component.cjs');
+
+Object.defineProperty(exports, 'ContentSelectorWrapperComponent', {
+  enumerable: true,
+  get: function () {
+    return require_editor_ContentSelector_component.ContentSelectorWrapperComponent;
+  }
+});
+Object.defineProperty(exports, 'EditorProviderComponent', {
+  enumerable: true,
+  get: function () {
+    return require_editor_EditorProvider_component.EditorProviderComponent;
+  }
+});
+exports.provideIntlayerEditor = require_editor_useEditor.provideIntlayerEditor;
+exports.useEditor = require_editor_useEditor.useEditor;

package/dist/cjs/editor/useEditor.cjs

@@ -1,32 +1,67 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_client_installIntlayer = require('../client/installIntlayer.cjs');
+const require_client_intlayerToken = require('../client/intlayerToken.cjs');
 let _angular_core = require("@angular/core");
 let _intlayer_editor_isEnabled = require("@intlayer/editor/isEnabled");
 
 //#region src/editor/useEditor.ts
-const useEditor = () => {
-	if (process.env.INTLAYER_EDITOR_ENABLED === "false" || !_intlayer_editor_isEnabled.isEnabled) return;
+/**
+* Initialises the Intlayer editor client singleton when the editor is enabled.
+* Syncs the current locale from the provided Intlayer client into the editor
+* manager so the editor always knows which locale the app is displaying.
+*
+* Must be called inside an Angular injection context (e.g. a component
+* constructor, `provideAppInitializer`, or `runInInjectionContext`).
+*
+* @param client - The IntlayerProvider instance to sync locale from.
+*   When omitted the function injects `INTLAYER_TOKEN` from the DI tree,
+*   so it still works when called directly from a component.
+*/
+const useEditor = (client) => {
+	if (!_intlayer_editor_isEnabled.isEnabled) return;
 	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef, { optional: true });
-	const client = (0, _angular_core.inject)(require_client_installIntlayer.INTLAYER_TOKEN, { optional: true });
 	const injector = (0, _angular_core.inject)(_angular_core.Injector);
+	const resolvedClient = client ?? (0, _angular_core.inject)(require_client_intlayerToken.INTLAYER_TOKEN, { optional: true });
+	const manager = (0, _angular_core.signal)(null);
+	let stopped = false;
 	import("@intlayer/editor").then(({ initEditorClient }) => {
-		const manager = initEditorClient();
-		if (client) {
-			const effectRef = (0, _angular_core.runInInjectionContext)(injector, () => (0, _angular_core.effect)(() => {
-				const locale = client.locale();
-				if (locale) manager.currentLocale.set(locale);
-			}));
-			destroyRef?.onDestroy(() => effectRef.destroy());
-		}
+		if (stopped) return;
+		manager.set(initEditorClient());
 	});
+	const effectRef = (0, _angular_core.runInInjectionContext)(injector, () => (0, _angular_core.effect)(() => {
+		const m = manager();
+		const locale = resolvedClient?.locale();
+		if (m && locale) m.currentLocale.set(locale);
+	}));
 	destroyRef?.onDestroy(() => {
+		stopped = true;
+		effectRef.destroy();
+		manager.set(null);
 		import("@intlayer/editor").then(({ stopEditorClient }) => {
 			stopEditorClient();
 		});
 	});
 };
+/**
+* Angular provider that wires `useEditor` into the application initialisation
+* phase via `provideAppInitializer`.
+*
+* `provideIntlayer()` already calls this internally, so you only need this
+* function when you want to manage providers individually.
+*
+* @example
+* ```ts
+* // app.config.ts
+* import { provideIntlayer, provideIntlayerEditor } from 'angular-intlayer';
+*
+* export const appConfig: ApplicationConfig = {
+*   providers: [provideIntlayer(), provideIntlayerEditor()],
+* };
+* ```
+*/
+const provideIntlayerEditor = (client) => (0, _angular_core.provideAppInitializer)(() => useEditor(client));
 
 //#endregion
+exports.provideIntlayerEditor = provideIntlayerEditor;
 exports.useEditor = useEditor;
 //# sourceMappingURL=useEditor.cjs.map

package/dist/cjs/editor/useEditor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useEditor.cjs","names":["isEnabled","DestroyRef","INTLAYER_TOKEN","Injector"],"sources":["../../../src/editor/useEditor.ts"],"sourcesContent":["import {\n  DestroyRef,\n  effect,\n  Injector,\n  inject,\n  runInInjectionContext,\n} from '@angular/core';\nimport { isEnabled } from '@intlayer/editor/isEnabled';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { INTLAYER_TOKEN, type IntlayerProvider } from '../client';\n\nexport const useEditor = () => {\n  if (process.env.INTLAYER_EDITOR_ENABLED === 'false' || !isEnabled) return;\n\n  const destroyRef = inject(DestroyRef, { optional: true });\n  const client = inject<IntlayerProvider>(INTLAYER_TOKEN, {\n    optional: true,\n  } as any);\n  const injector = inject(Injector);\n\n  import('@intlayer/editor').then(({ initEditorClient }) => {\n    const manager = initEditorClient();\n\n    if (client) {\n      const effectRef = runInInjectionContext(injector, () =>\n        effect(() => {\n          const locale = client.locale();\n          if (locale) manager.currentLocale.set(locale as Locale);\n        })\n      );\n      destroyRef?.onDestroy(() => effectRef.destroy());\n    }\n  });\n\n  destroyRef?.onDestroy(() => {\n    import('@intlayer/editor').then(({ stopEditorClient }) => {\n      stopEditorClient();\n    });\n  });\n};\n"],"mappings":";;;;;;;AAWA,MAAa,kBAAkB;AAC7B,KAAI,QAAQ,IAAI,4BAA4B,WAAW,CAACA,qCAAW;CAEnE,MAAM,uCAAoBC,0BAAY,EAAE,UAAU,MAAM,CAAC;CACzD,MAAM,mCAAkCC,+CAAgB,EACtD,UAAU,MACX,CAAQ;CACT,MAAM,qCAAkBC,uBAAS;AAEjC,QAAO,oBAAoB,MAAM,EAAE,uBAAuB;EACxD,MAAM,UAAU,kBAAkB;AAElC,MAAI,QAAQ;GACV,MAAM,qDAAkC,gDACzB;IACX,MAAM,SAAS,OAAO,QAAQ;AAC9B,QAAI,OAAQ,SAAQ,cAAc,IAAI,OAAiB;KACvD,CACH;AACD,eAAY,gBAAgB,UAAU,SAAS,CAAC;;GAElD;AAEF,aAAY,gBAAgB;AAC1B,SAAO,oBAAoB,MAAM,EAAE,uBAAuB;AACxD,qBAAkB;IAClB;GACF"}
+{"version":3,"file":"useEditor.cjs","names":["isEnabled","DestroyRef","Injector","INTLAYER_TOKEN"],"sources":["../../../src/editor/useEditor.ts"],"sourcesContent":["import {\n  DestroyRef,\n  effect,\n  Injector,\n  inject,\n  provideAppInitializer,\n  runInInjectionContext,\n  signal,\n} from '@angular/core';\nimport type { EditorStateManager } from '@intlayer/editor';\nimport { isEnabled } from '@intlayer/editor/isEnabled';\nimport type { Locale } from '@intlayer/types/allLocales';\n// Import from the standalone token file to avoid a circular dependency:\n//   installIntlayer.ts → useEditor.ts → ../client → installIntlayer.ts\nimport { INTLAYER_TOKEN, type IntlayerProvider } from '../client/intlayerToken';\n\n/**\n * Initialises the Intlayer editor client singleton when the editor is enabled.\n * Syncs the current locale from the provided Intlayer client into the editor\n * manager so the editor always knows which locale the app is displaying.\n *\n * Must be called inside an Angular injection context (e.g. a component\n * constructor, `provideAppInitializer`, or `runInInjectionContext`).\n *\n * @param client - The IntlayerProvider instance to sync locale from.\n *   When omitted the function injects `INTLAYER_TOKEN` from the DI tree,\n *   so it still works when called directly from a component.\n */\nexport const useEditor = (client?: IntlayerProvider | null): void => {\n  if (!isEnabled) return;\n\n  const destroyRef = inject(DestroyRef, { optional: true });\n  const injector = inject(Injector);\n\n  // Resolve the client: use the passed-in reference or fall back to injection.\n  const resolvedClient =\n    client ??\n    inject<IntlayerProvider>(INTLAYER_TOKEN, { optional: true } as any);\n\n  // `manager` signal is set once the async import resolves.\n  // Using a signal lets an `effect()` react to it becoming available.\n  const manager = signal<EditorStateManager | null>(null);\n\n  // Guard: prevents the async callback from acting after the view is destroyed.\n  let stopped = false;\n\n  // Initialise the editor client\n  import('@intlayer/editor').then(({ initEditorClient }) => {\n    if (stopped) return;\n    manager.set(initEditorClient());\n  });\n\n  // Keep the editor locale in sync with the Angular locale signal\n  const effectRef = runInInjectionContext(injector, () =>\n    effect(() => {\n      const m = manager();\n      const locale = resolvedClient?.locale();\n      if (m && locale) m.currentLocale.set(locale as Locale);\n    })\n  );\n\n  // Tear down on destroy\n  destroyRef?.onDestroy(() => {\n    stopped = true;\n    effectRef.destroy();\n    manager.set(null);\n    import('@intlayer/editor').then(({ stopEditorClient }) => {\n      stopEditorClient();\n    });\n  });\n};\n\n/**\n * Angular provider that wires `useEditor` into the application initialisation\n * phase via `provideAppInitializer`.\n *\n * `provideIntlayer()` already calls this internally, so you only need this\n * function when you want to manage providers individually.\n *\n * @example\n * ```ts\n * // app.config.ts\n * import { provideIntlayer, provideIntlayerEditor } from 'angular-intlayer';\n *\n * export const appConfig: ApplicationConfig = {\n *   providers: [provideIntlayer(), provideIntlayerEditor()],\n * };\n * ```\n */\nexport const provideIntlayerEditor = (client?: IntlayerProvider | null) =>\n  provideAppInitializer(() => useEditor(client));\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA4BA,MAAa,aAAa,WAA2C;AACnE,KAAI,CAACA,qCAAW;CAEhB,MAAM,uCAAoBC,0BAAY,EAAE,UAAU,MAAM,CAAC;CACzD,MAAM,qCAAkBC,uBAAS;CAGjC,MAAM,iBACJ,oCACyBC,6CAAgB,EAAE,UAAU,MAAM,CAAQ;CAIrE,MAAM,oCAA4C,KAAK;CAGvD,IAAI,UAAU;AAGd,QAAO,oBAAoB,MAAM,EAAE,uBAAuB;AACxD,MAAI,QAAS;AACb,UAAQ,IAAI,kBAAkB,CAAC;GAC/B;CAGF,MAAM,qDAAkC,gDACzB;EACX,MAAM,IAAI,SAAS;EACnB,MAAM,SAAS,gBAAgB,QAAQ;AACvC,MAAI,KAAK,OAAQ,GAAE,cAAc,IAAI,OAAiB;GACtD,CACH;AAGD,aAAY,gBAAgB;AAC1B,YAAU;AACV,YAAU,SAAS;AACnB,UAAQ,IAAI,KAAK;AACjB,SAAO,oBAAoB,MAAM,EAAE,uBAAuB;AACxD,qBAAkB;IAClB;GACF;;;;;;;;;;;;;;;;;;;AAoBJ,MAAa,yBAAyB,0DACR,UAAU,OAAO,CAAC"}