vue-intlayer 5.3.13 → 5.4.0

package/dist/esm/editor/communicator.mjs

@@ -0,0 +1,37 @@
+import a from "@intlayer/config/built";
+import { v4 as u } from "uuid";
+import { reactive as l, inject as i } from "vue";
+const { editor: n } = a, o = {
+  postMessage: () => null,
+  allowedOrigins: [
+    n == null ? void 0 : n.applicationURL,
+    n == null ? void 0 : n.editorURL,
+    n == null ? void 0 : n.cmsURL
+  ],
+  senderId: ""
+};
+let t = null;
+const r = Symbol("Communicator"), m = (e = { postMessage: () => null }) => t || (t = l({
+  ...o,
+  ...e,
+  senderId: u()
+}), t), g = (e, s = { postMessage: () => null }) => {
+  const c = m(s);
+  e.provide(r, c);
+}, C = () => {
+  try {
+    return i(r, o);
+  } catch {
+    return console.warn(
+      "useCommunicator: inject can only be used in setup(). Returning default communicator."
+    ), {
+      postMessage: () => null,
+      senderId: ""
+    };
+  }
+};
+export {
+  m as createCommunicator,
+  g as installCommunicator,
+  C as useCommunicator
+};

package/dist/esm/editor/configuration.mjs

@@ -0,0 +1,13 @@
+import t from "@intlayer/config/built";
+import { MessageKey as i } from "@intlayer/editor";
+import { onMounted as n } from "vue";
+import { useCrossFrameState as e } from "./useCrossFrameState.mjs";
+const a = () => {
+  const [o, r] = e(i.INTLAYER_CONFIGURATION);
+  n(() => {
+    o && r(t);
+  });
+};
+export {
+  a as useConfiguration
+};

package/dist/esm/editor/createSharedComposable.mjs

@@ -0,0 +1,15 @@
+import { effectScope as p, getCurrentScope as c, onScopeDispose as i } from "vue";
+function u(t) {
+  return c() ? (i(t), !0) : !1;
+}
+const a = (t) => {
+  let r = 0, o, e;
+  const s = () => {
+    r -= 1, e && r <= 0 && (e.stop(), o = void 0, e = void 0);
+  };
+  return (...n) => (r += 1, e || (e = p(!0), o = e.run(() => t(...n))), u(s), o);
+};
+export {
+  a as createSharedComposable,
+  u as tryOnScopeDispose
+};

package/dist/esm/editor/dictionariesRecord.mjs

@@ -0,0 +1,49 @@
+import n from "@intlayer/dictionaries-entry";
+import { MessageKey as a } from "@intlayer/editor";
+import { ref as s, readonly as l, inject as m, watch as D } from "vue";
+import { createSharedComposable as d } from "./createSharedComposable.mjs";
+import { useCrossFrameState as R } from "./useCrossFrameState.mjs";
+let i = null;
+const t = Symbol(
+  "intlayerDictionariesRecord"
+), u = () => {
+  if (i) return i;
+  const e = s(n);
+  return i = {
+    localeDictionaries: l(e),
+    setLocaleDictionaries: (o) => {
+      e.value = o ?? {};
+    },
+    setLocaleDictionary(o) {
+      e.value = {
+        ...e.value,
+        [o.key]: o
+      };
+    }
+  }, i;
+}, L = (e) => {
+  const o = u();
+  e.provide(t, o);
+}, _ = d(() => {
+  const e = m(
+    t
+  );
+  if (!e)
+    throw new Error("DictionariesRecord state not found");
+  const [o, r] = R(
+    a.INTLAYER_LOCALE_DICTIONARIES_CHANGED,
+    void 0
+  );
+  D(
+    e.localeDictionaries,
+    (c) => {
+      r(c);
+    },
+    { immediate: !0 }
+  );
+});
+export {
+  u as createDictionaryRecordClient,
+  L as installDictionariesRecord,
+  _ as useDictionariesRecord
+};

package/dist/esm/editor/editedContent.mjs

@@ -0,0 +1,43 @@
+import { getContentNodeByKeyPath as c } from "@intlayer/core";
+import { MessageKey as C } from "@intlayer/editor";
+import { ref as E, readonly as l, inject as u, watch as s } from "vue";
+import { createSharedComposable as m } from "./createSharedComposable.mjs";
+import { useCrossFrameState as f } from "./useCrossFrameState.mjs";
+let o = null;
+const a = Symbol("EditedContent"), p = () => {
+  if (o) return o;
+  const t = E({});
+  return o = {
+    editedContent: l(t),
+    getEditedContentValue: (e, r) => {
+      var d, i;
+      const n = (i = (d = t.value) == null ? void 0 : d[e]) == null ? void 0 : i.content;
+      if (n)
+        return c(n, r);
+    },
+    setEditedContent: (e) => {
+      t.value = e;
+    }
+  }, o;
+}, D = (t) => {
+  const e = p();
+  t.provide(a, e);
+}, h = m(() => {
+  const t = u(a);
+  if (!t)
+    throw new Error("EditedContent state not found");
+  const [e, r] = f(
+    C.INTLAYER_EDITED_CONTENT_CHANGED,
+    {}
+  );
+  return s(e, (n) => {
+    t.editedContent.value = n ?? {};
+  }), s(t, (n) => {
+    r(n.editedContent.value);
+  }), t;
+});
+export {
+  p as createEditedContentClient,
+  D as installEditedContent,
+  h as useEditedContent
+};

package/dist/esm/editor/editorEnabled.mjs

@@ -0,0 +1,36 @@
+import { MessageKey as s } from "@intlayer/editor";
+import { inject as l, onMounted as i, ref as n, computed as E } from "vue";
+import { createSharedComposable as d } from "./createSharedComposable.mjs";
+import { useCrossFrameMessageListener as c } from "./useCrossFrameMessageListener.mjs";
+let o = null;
+const r = Symbol("EditorEnabled"), m = () => {
+  if (o) return o;
+  const e = n(!1), t = n(!1), a = E(() => e.value && t.value);
+  return o = {
+    wrapperEnabled: e,
+    isInIframe: t,
+    enabled: a
+  }, o;
+}, w = (e) => {
+  const t = m();
+  e.provide(r, t);
+}, I = d(() => {
+  const e = l(
+    r
+  );
+  if (!e)
+    throw new Error("EditorEnabled state not found");
+  return c(
+    `${s.INTLAYER_EDITOR_ENABLED}/post`,
+    (t) => {
+      e.wrapperEnabled.value = t;
+    }
+  ), i(() => {
+    e.isInIframe.value = window.self !== window.top;
+  }), e;
+});
+export {
+  m as createEditorEnabledClient,
+  w as installEditorEnabled,
+  I as useEditorEnabled
+};

package/dist/esm/editor/editorLocale.mjs

@@ -0,0 +1,29 @@
+import { MessageKey as e } from "@intlayer/editor";
+import { inject as m, watch as i } from "vue";
+import { INTLAYER_SYMBOL as a } from "../client/installIntlayer.mjs";
+import "@intlayer/core";
+import { createSharedComposable as p } from "./createSharedComposable.mjs";
+import "./communicator.mjs";
+import { useCrossFrameState as s } from "./useCrossFrameState.mjs";
+import "@intlayer/config/built";
+import "@intlayer/dictionaries-entry";
+import "./installIntlayerEditor.mjs";
+import "../client/useLocaleCookie.mjs";
+const w = p(() => {
+  const t = m(a);
+  if (!t)
+    throw new Error("IntlayerEditor state not found");
+  const [n, o] = s(
+    e.INTLAYER_CURRENT_LOCALE
+  );
+  return i(
+    t.locale,
+    (r) => {
+      o(r);
+    },
+    { immediate: !0 }
+  ), t;
+});
+export {
+  w as useEditorLocale
+};

package/dist/esm/editor/focusDictionary.mjs

@@ -0,0 +1,39 @@
+import { MessageKey as i } from "@intlayer/editor";
+import { ref as u, readonly as a, inject as f, watch as r } from "vue";
+import { createSharedComposable as l } from "./createSharedComposable.mjs";
+import { useCrossFrameState as C } from "./useCrossFrameState.mjs";
+let n = null;
+const c = Symbol("FocusDictionary"), d = () => {
+  if (n) return n;
+  const t = u(null), e = (o) => {
+    t.value = o;
+  }, s = (o) => {
+    t.value && e({ ...t.value, keyPath: o });
+  };
+  return n = {
+    focusedContent: a(t),
+    setFocusedContent: e,
+    setFocusedContentKeyPath: s
+  }, n;
+}, S = (t) => {
+  const e = d();
+  t.provide(c, e);
+}, O = l(() => {
+  const t = f(
+    c
+  ), [e, s] = C(
+    i.INTLAYER_FOCUSED_CONTENT_CHANGED
+  );
+  if (!t)
+    throw new Error("FocusDictionary state not found");
+  return r(t.focusedContent, (o) => {
+    JSON.stringify(o) !== JSON.stringify(e.value) && s(o);
+  }), r(e, (o) => {
+    JSON.stringify(o) !== JSON.stringify(t.focusedContent.value) && t.setFocusedContent(o ?? null);
+  }), t;
+});
+export {
+  d as createFocusDictionaryClient,
+  S as installFocusDictionary,
+  O as useFocusDictionary
+};

package/dist/esm/editor/index.mjs

@@ -0,0 +1,6 @@
+import { _ as e } from "../../ContentSelectorWrapper.vue_vue_type_script_setup_true_lang-BML9iRiS.mjs";
+import { installIntlayerEditor as a } from "./installIntlayerEditor.mjs";
+export {
+  e as ContentSelectorWrapper,
+  a as installIntlayerEditor
+};

package/dist/esm/editor/installIntlayerEditor.mjs

@@ -0,0 +1,18 @@
+import t from "@intlayer/config/built";
+import { installChangedContent as n } from "./changedContent.mjs";
+import { installCommunicator as r } from "./communicator.mjs";
+import { installDictionariesRecord as e } from "./dictionariesRecord.mjs";
+import { installEditedContent as s } from "./editedContent.mjs";
+import { installEditorEnabled as l } from "./editorEnabled.mjs";
+import { installFocusDictionary as m } from "./focusDictionary.mjs";
+const { editor: i } = t, { applicationURL: a, editorURL: d, cmsURL: f } = i ?? {}, c = (o) => {
+  typeof window > "u" || !(window.self !== window.top) || (i.applicationURL.length > 0 && window.postMessage(o, i.applicationURL), i.editorURL.length > 0 && window.parent.postMessage(o, i.editorURL), i.cmsURL.length > 0 && window.parent.postMessage(o, i.cmsURL));
+}, h = (o) => {
+  r(o, {
+    postMessage: c,
+    allowedOrigins: [a, d, f]
+  }), l(o), n(o), e(o), s(o), m(o);
+};
+export {
+  h as installIntlayerEditor
+};

package/dist/esm/editor/useCrossFrameMessageListener.mjs

@@ -0,0 +1,31 @@
+import { compareUrls as f } from "@intlayer/editor";
+import { onScopeDispose as p, getCurrentInstance as d } from "vue";
+import { useCommunicator as m } from "./communicator.mjs";
+const r = /* @__PURE__ */ new Map();
+let u = !1;
+function l(e, t) {
+  let s = r.get(e);
+  s || (s = /* @__PURE__ */ new Set(), r.set(e, s)), s.add(t);
+}
+function b(e, t) {
+  const s = r.get(e);
+  s && (s.delete(t), s.size === 0 && r.delete(e));
+}
+function g(e, t) {
+  u || (window.addEventListener("message", (s) => {
+    var i;
+    const { type: o, data: n, senderId: c } = s.data ?? {};
+    o && c !== t && (!e || e.includes("*") || e.some((a) => f(a, s.origin))) && ((i = r.get(o)) == null || i.forEach((a) => a(n)));
+  }), u = !0);
+}
+const h = (e, t) => {
+  const { allowedOrigins: s, postMessage: o, senderId: n } = m();
+  return g(s, n), t ? (l(e, t), p(() => b(e, t))) : d() || console.warn(
+    "useCrossFrameMessageListener called outside a component without a callback; nothing to listen for."
+  ), (i) => {
+    o({ type: e, data: i, senderId: n });
+  };
+};
+export {
+  h as useCrossFrameMessageListener
+};

package/dist/esm/editor/useCrossFrameState.mjs

@@ -0,0 +1,44 @@
+import { getCurrentInstance as C, ref as y } from "vue";
+import { useCommunicator as $ } from "./communicator.mjs";
+import { useCrossFrameMessageListener as m } from "./useCrossFrameMessageListener.mjs";
+const f = /* @__PURE__ */ new Map(), S = (t, i) => typeof t == "function" ? t(i) : t, F = (t) => t == null ? t : JSON.parse(JSON.stringify(t)), I = (t, i, v = { emit: !0, receive: !0 }) => {
+  if (f.has(t)) {
+    const { state: s, setState: r, postState: a } = f.get(t);
+    return [s, r, a];
+  }
+  C() || console.warn(
+    "useCrossFrameState called outside a component setup function - reactivity may be limited"
+  );
+  const { emit: u = !0, receive: p = !0 } = v, e = y(S(i)), { postMessage: n, senderId: o } = $(), c = (s) => {
+    !u || typeof n != "function" || typeof s > "u" || n({
+      type: `${t}/post`,
+      data: s,
+      senderId: o
+    });
+  }, d = (s) => {
+    const r = S(s, e.value), a = F(r);
+    e.value = a, c(a);
+  }, l = () => {
+    typeof n == "function" && n({
+      type: `${t}/post`,
+      data: e.value,
+      senderId: o
+    });
+  };
+  c(e.value), p && typeof n == "function" && typeof e.value > "u" && n({ type: `${t}/get`, senderId: o }), m(
+    `${t}/post`,
+    p ? (s) => {
+      e.value = s;
+    } : void 0
+  );
+  const g = (s, r) => {
+    u && r !== o && c(e.value);
+  };
+  return m(
+    `${t}/get`,
+    u ? g : void 0
+  ), f.set(t, { state: e, setState: d, postState: l }), [e, d, l];
+};
+export {
+  I as useCrossFrameState
+};

package/dist/esm/editor/useCrossURLPathState.mjs

@@ -0,0 +1,26 @@
+import { MessageKey as p } from "@intlayer/editor";
+import { getCurrentInstance as w, onMounted as d, onBeforeUnmount as l } from "vue";
+import { useCrossFrameState as u } from "./useCrossFrameState.mjs";
+const m = (o, a) => u(p.INTLAYER_URL_CHANGE, o, a), E = (o) => {
+  const [a, s] = m(o, {
+    emit: !0,
+    receive: !1
+  }), i = w();
+  let t, n;
+  const e = () => s(window.location.pathname);
+  return i ? (d(() => {
+    t = history.pushState, n = history.replaceState;
+    const r = (c) => (...h) => {
+      c.apply(history, h), window.dispatchEvent(new Event("locationchange"));
+    };
+    history.pushState = r(t), history.replaceState = r(n), window.addEventListener("locationchange", e), window.addEventListener("popstate", e), window.addEventListener("hashchange", e), e();
+  }), l(() => {
+    window.removeEventListener("locationchange", e), window.removeEventListener("popstate", e), window.removeEventListener("hashchange", e), t && (history.pushState = t), n && (history.replaceState = n);
+  })) : console.warn(
+    "useCrossURLPathSetter must be called within a component setup function"
+  ), [a, s];
+};
+export {
+  E as useCrossURLPathSetter,
+  m as useCrossURLPathState
+};

package/dist/esm/editor/useEditedContentRenderer.mjs

@@ -0,0 +1,17 @@
+import { inject as n, computed as d } from "vue";
+import { createSharedComposable as i } from "./createSharedComposable.mjs";
+const u = i(
+  (t, o, r) => {
+    const e = n(
+      "editedContentActions",
+      null
+    );
+    return d(() => (e == null ? void 0 : e.getEditedContentValue(
+      t,
+      o
+    )) ?? r);
+  }
+);
+export {
+  u as useEditedContentRenderer
+};

package/dist/esm/editor/useEditor.mjs

@@ -0,0 +1,14 @@
+import { useConfiguration as r } from "./configuration.mjs";
+import { createSharedComposable as e } from "./createSharedComposable.mjs";
+import { useDictionariesRecord as t } from "./dictionariesRecord.mjs";
+import { useEditorEnabled as i } from "./editorEnabled.mjs";
+import { useEditorLocale as o } from "./editorLocale.mjs";
+import { useFocusDictionary as m } from "./focusDictionary.mjs";
+import { useCrossURLPathSetter as s } from "./useCrossURLPathState.mjs";
+import { useIframeClickMerger as a } from "./useIframeClickInterceptor.mjs";
+const E = e(() => {
+  r(), i(), m(), a(), s(), o(), t(), o();
+});
+export {
+  E as useEditor
+};

package/dist/esm/editor/useIframeClickInterceptor.mjs

@@ -0,0 +1,23 @@
+import { MessageKey as o, mergeIframeClick as m } from "@intlayer/editor";
+import { getCurrentInstance as a, onMounted as c, onBeforeUnmount as i } from "vue";
+import { createSharedComposable as n } from "./createSharedComposable.mjs";
+import { useCrossFrameMessageListener as r } from "./useCrossFrameMessageListener.mjs";
+const I = n(() => {
+  const t = r(
+    o.INTLAYER_IFRAME_CLICKED
+  ), s = a(), e = () => {
+    t();
+  };
+  s ? (c(() => window.addEventListener("mousedown", e)), i(() => window.removeEventListener("mousedown", e))) : console.warn(
+    "useIframeClickInterceptor must be called within a component setup function"
+  );
+}), d = n(() => {
+  I(), r(
+    `${o.INTLAYER_IFRAME_CLICKED}/get`,
+    m
+  );
+});
+export {
+  I as useIframeClickInterceptor,
+  d as useIframeClickMerger
+};

package/dist/esm/getDictionary.mjs

@@ -0,0 +1,17 @@
+import { getDictionary as n } from "@intlayer/core";
+import { intlayerNodePlugins as e, markdownPlugin as a } from "./plugins.mjs";
+const m = (t, i, o) => {
+  const r = [
+    e,
+    a,
+    ...o ?? []
+  ];
+  return n(
+    t,
+    i,
+    r
+  );
+};
+export {
+  m as getDictionary
+};

package/dist/esm/getIntlayer.mjs

@@ -0,0 +1,13 @@
+import { getIntlayer as o } from "@intlayer/core";
+import { intlayerNodePlugins as l, markdownPlugin as a } from "./plugins.mjs";
+const m = (t, r, n) => {
+  const e = [
+    l,
+    a,
+    ...n ?? []
+  ];
+  return o(t, r, e);
+};
+export {
+  m as getIntlayer
+};

package/dist/esm/index.mjs

@@ -1,3 +1,25 @@
-export * from "./intlayerPlugin.mjs";
-export * from "./intlayerMiddlewarePlugin.mjs";
-//# sourceMappingURL=index.mjs.map
+import { INTLAYER_SYMBOL as t, createIntlayerClient as o, installIntlayer as n } from "./client/installIntlayer.mjs";
+import { useDictionary as l } from "./client/useDictionary.mjs";
+import { useIntlayer as m } from "./client/useIntlayer.mjs";
+import { useLocale as f } from "./client/useLocale.mjs";
+import { getDictionary as x } from "./getDictionary.mjs";
+import { getIntlayer as s } from "./getIntlayer.mjs";
+import { INTLAYER_MARKDOWN_SYMBOL as d, createIntlayerMarkdownClient as g, installIntlayerMarkdown as M, useMarkdown as c } from "./markdown/installIntlayerMarkdown.mjs";
+import { intlayerNodePlugins as w, markdownPlugin as L, markdownStringPlugin as N } from "./plugins.mjs";
+export {
+  d as INTLAYER_MARKDOWN_SYMBOL,
+  t as INTLAYER_SYMBOL,
+  o as createIntlayerClient,
+  g as createIntlayerMarkdownClient,
+  x as getDictionary,
+  s as getIntlayer,
+  n as installIntlayer,
+  M as installIntlayerMarkdown,
+  w as intlayerNodePlugins,
+  L as markdownPlugin,
+  N as markdownStringPlugin,
+  l as useDictionary,
+  m as useIntlayer,
+  f as useLocale,
+  c as useMarkdown
+};

package/dist/esm/markdown/index.mjs

@@ -0,0 +1,7 @@
+import { INTLAYER_MARKDOWN_SYMBOL as e, createIntlayerMarkdownClient as n, installIntlayerMarkdown as t, useMarkdown as l } from "./installIntlayerMarkdown.mjs";
+export {
+  e as INTLAYER_MARKDOWN_SYMBOL,
+  n as createIntlayerMarkdownClient,
+  t as installIntlayerMarkdown,
+  l as useMarkdown
+};

package/dist/esm/markdown/installIntlayerMarkdown.mjs

@@ -0,0 +1,25 @@
+import { inject as a } from "vue";
+const t = Symbol("intlayerMarkdown");
+let n = null;
+const d = (r) => n || (n = {
+  renderMarkdown: r
+}, n), s = (r, e) => {
+  const o = d(e);
+  r.provide(t, o);
+}, l = () => {
+  const r = a(
+    t,
+    {
+      renderMarkdown: (e) => e
+    }
+  );
+  if (!r)
+    throw new Error("useMarkdown must be used within a MarkdownProvider");
+  return r;
+};
+export {
+  t as INTLAYER_MARKDOWN_SYMBOL,
+  d as createIntlayerMarkdownClient,
+  s as installIntlayerMarkdown,
+  l as useMarkdown
+};

package/dist/esm/plugins.mjs

@@ -0,0 +1,90 @@
+import { getMarkdownMetadata as u, NodeType as i } from "@intlayer/core";
+import { h as d } from "vue";
+import { _ as l } from "../ContentSelectorWrapper.vue_vue_type_script_setup_true_lang-BML9iRiS.mjs";
+import "./editor/installIntlayerEditor.mjs";
+import { useMarkdown as p } from "./markdown/installIntlayerMarkdown.mjs";
+import { renderIntlayerNode as o } from "./renderIntlayerNode.mjs";
+const b = {
+  id: "intlayer-node-plugin",
+  canHandle: (n) => typeof n == "bigint" || typeof n == "string" || typeof n == "number",
+  transform: (n, { children: t, ...r }) => o({
+    ...r,
+    value: t,
+    children: () => d(
+      // EditorSelectorRenderer, // Maximum stack size exceeded
+      l,
+      {
+        dictionaryKey: r.dictionaryKey,
+        keyPath: r.keyPath
+      },
+      {
+        default: () => t
+      }
+    )
+  })
+}, f = {
+  id: "markdown-string-plugin",
+  canHandle: (n) => typeof n == "string",
+  transform: (n, t, r) => {
+    const {
+      plugins: y,
+      // Removed to avoid next error - Functions cannot be passed directly to Client Components
+      ...e
+    } = t, m = u(n), s = r(m, {
+      plugins: [{
+        id: "markdown-metadata-plugin",
+        canHandle: (a) => typeof a == "string" || typeof a == "number" || typeof a == "boolean" || !a,
+        transform: (a, c) => o({
+          ...c,
+          value: a,
+          children: n
+        })
+      }],
+      dictionaryKey: e.dictionaryKey,
+      keyPath: []
+    });
+    return o({
+      ...t,
+      value: n,
+      children: d(
+        // EditorSelectorRenderer, // Maximum stack size exceeded
+        l,
+        {
+          dictionaryKey: e.dictionaryKey,
+          keyPath: e.keyPath
+        },
+        {
+          default: () => {
+            const { renderMarkdown: a } = p();
+            return a(n);
+          }
+        }
+      ),
+      additionalProps: {
+        metadata: s
+      }
+    });
+  }
+}, H = {
+  id: "markdown-plugin",
+  canHandle: (n) => typeof n == "object" && (n == null ? void 0 : n.nodeType) === i.Markdown,
+  transform: (n, t, r) => {
+    const y = [
+      ...t.keyPath,
+      {
+        type: i.Markdown
+      }
+    ], e = n[i.Markdown];
+    return r(e, {
+      ...t,
+      children: e,
+      keyPath: y,
+      plugins: [f, ...t.plugins ?? []]
+    });
+  }
+};
+export {
+  b as intlayerNodePlugins,
+  H as markdownPlugin,
+  f as markdownStringPlugin
+};

package/dist/esm/renderIntlayerNode.mjs

@@ -0,0 +1,12 @@
+const o = (n) => {
+  const { children: r, value: e, additionalProps: t = {} } = n;
+  return {
+    render: () => typeof r == "function" ? r() : r,
+    toString: () => e,
+    value: e,
+    ...t
+  };
+};
+export {
+  o as renderIntlayerNode
+};

package/dist/esm/server/IntlayerServerProvider.mjs

@@ -0,0 +1,12 @@
+import n from "@intlayer/config/built";
+import { createServerContext as a, getServerContext as c } from "./serverContext.mjs";
+var o;
+const { defaultLocale: r } = ((o = n) == null ? void 0 : o.internationalization) ?? {}, t = a(r), s = (e = r) => {
+  t.provide(e);
+}, m = () => c(t), p = (e) => t.consume(e);
+export {
+  t as IntlayerServerContext,
+  m as getIntlayerLocale,
+  s as provideIntlayerLocale,
+  p as withIntlayerLocale
+};