@bleedingdev/modern-js-renderer-core 0.0.0-bootstrap → 3.9.3-ultramodern.1

package/dist/cjs/entry-client.js

@@ -0,0 +1,142 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    startNativeClientEntry: ()=>startNativeClientEntry
+});
+const index_js_namespaceObject = require("./data/index.js");
+const external_document_js_namespaceObject = require("./document.js");
+const external_localization_js_namespaceObject = require("./localization.js");
+const external_router_js_namespaceObject = require("./router.js");
+const external_abort_js_namespaceObject = require("./abort.js");
+function isNativeEntryHot(value) {
+    return 'object' == typeof value && null !== value && 'dispose' in value && 'function' == typeof value.dispose;
+}
+function clientRouteLoader(application, identity) {
+    const serverDataRoutes = new Set(application.serverDataRoutes);
+    return async (route, input)=>{
+        const loader = application.dataModules[route.id]?.loader;
+        if (loader) return (0, index_js_namespaceObject.invokeRouteData)(loader, input, {
+            production: 'production' === process.env.NODE_ENV
+        });
+        if (!serverDataRoutes.has(route.id)) return {
+            kind: 'success',
+            value: void 0,
+            status: 200
+        };
+        return (0, index_js_namespaceObject.createDataClient)(route.id, identity).loader({
+            request: input.request
+        });
+    };
+}
+function startNativeClientEntry(options, adapter) {
+    const identity = Object.freeze({
+        ...options.identity
+    });
+    const root = document.getElementById(options.rootId ?? 'root');
+    if (!root) throw new Error('The native application mount element is missing');
+    const bootstrap = document.getElementById(external_document_js_namespaceObject.RENDERER_BOOTSTRAP_ID) ? adapter.readBootstrap(document, identity) : void 0;
+    const hydrating = bootstrap?.hydrating ?? false;
+    const controller = new AbortController();
+    const { signal } = controller;
+    let disposed = false;
+    let dispose;
+    if (isNativeEntryHot(options.hot)) options.hot.dispose(()=>{
+        disposed = true;
+        controller.abort(new DOMException('The application entry was disposed', 'AbortError'));
+        dispose?.();
+    });
+    const load = async ()=>{
+        const application = await (0, external_abort_js_namespaceObject.untilAborted)(options.load(), signal);
+        const { i18n } = options;
+        let instance;
+        if (i18n) {
+            const handoff = i18n.clientHandoff();
+            instance = await (0, external_abort_js_namespaceObject.untilAborted)(i18n.create(handoff.language, handoff.resources), signal);
+            const stopPersist = i18n.persist?.(instance);
+            if (stopPersist) signal.addEventListener('abort', stopPersist, {
+                once: true
+            });
+        }
+        const current = instance;
+        const localization = i18n && current ? {
+            i18n: (0, external_localization_js_namespaceObject.nativeI18nView)(i18n, current)
+        } : {};
+        if (!(0, external_router_js_namespaceObject.isRoutedApplication)(application)) return {
+            kind: 'component',
+            component: application.default,
+            ...localization
+        };
+        const router = adapter.createRouter(application, {
+            identity,
+            loadRoute: clientRouteLoader(application, identity),
+            signal,
+            ...i18n && current ? {
+                rewrite: i18n.rewrite(()=>current.language)
+            } : {}
+        });
+        const stopSync = i18n && current ? i18n.syncWithRouter(router, current) : void 0;
+        if (stopSync) signal.addEventListener('abort', stopSync, {
+            once: true
+        });
+        try {
+            await (0, external_abort_js_namespaceObject.untilAborted)(adapter.prepareRouter(router, hydrating, signal), signal);
+        } catch (error) {
+            stopSync?.();
+            throw error;
+        }
+        return {
+            kind: 'router',
+            router,
+            ...localization
+        };
+    };
+    adapter.start({
+        root,
+        identity,
+        bootstrap,
+        signal,
+        load
+    }).then((release)=>{
+        dispose = release;
+        if (disposed) release();
+    }).catch((error)=>{
+        if (!signal.aborted) controller.abort(error);
+        if (!disposed) queueMicrotask(()=>{
+            throw error;
+        });
+    });
+}
+exports.startNativeClientEntry = __webpack_exports__.startNativeClientEntry;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "startNativeClientEntry"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/entry-server.js

@@ -0,0 +1,253 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createNativeServerEntry: ()=>createNativeServerEntry
+});
+const external_abort_js_namespaceObject = require("./abort.js");
+const index_js_namespaceObject = require("./data/index.js");
+const external_identity_js_namespaceObject = require("./identity.js");
+const external_localization_js_namespaceObject = require("./localization.js");
+const external_router_js_namespaceObject = require("./router.js");
+function serverRouteLoader(application) {
+    return async (route, input)=>{
+        const loader = application.dataModules[route.id]?.loader;
+        if (!loader) return {
+            kind: 'success',
+            value: void 0,
+            status: 200
+        };
+        return (0, index_js_namespaceObject.invokeRouteData)(loader, input, {
+            production: 'development' !== process.env.NODE_ENV
+        });
+    };
+}
+function resolveDocumentPolicy(session, vary) {
+    if (!session.responsePolicy) session.resolveResponse({
+        kind: 'document',
+        status: 200,
+        headers: [
+            [
+                'content-type',
+                'text/html; charset=utf-8'
+            ],
+            ...vary?.length ? [
+                [
+                    'vary',
+                    vary.join(', ')
+                ]
+            ] : []
+        ],
+        cache: {
+            mode: 'no-store'
+        }
+    });
+}
+const detectedVary = (language)=>language?.kind === 'language' ? language.vary : void 0;
+function createNativeServerEntry(options, adapter) {
+    const rendererIdentity = Object.freeze({
+        ...options.identity
+    });
+    const { i18n } = options;
+    const own = (request, context)=>{
+        (0, external_identity_js_namespaceObject.assertRendererIdentity)(context.entry, rendererIdentity);
+        (0, external_identity_js_namespaceObject.assertRendererIdentity)(context.session.identity, rendererIdentity);
+        if (request !== context.session.request) throw new Error('Native request/session ownership mismatch');
+    };
+    const prepare = (request, context)=>{
+        own(request, context);
+        return adapter.document({
+            documentId: crypto.randomUUID(),
+            rootId: options.rootId ?? 'root',
+            ...void 0 === context.nonce ? {} : {
+                nonce: context.nonce
+            },
+            ...void 0 === context.assets ? {} : {
+                assets: context.assets
+            }
+        }, context.nativeManifest, rendererIdentity);
+    };
+    const routedApplication = async (signal)=>{
+        const application = await (0, external_abort_js_namespaceObject.untilAborted)(options.app(), signal);
+        if (!(0, external_router_js_namespaceObject.isRoutedApplication)(application)) throw new Error('unsupported-renderer-capability: ssrByRouteIds requires native route matching.');
+        return application;
+    };
+    const nativeCSRRequestHandler = (request, context)=>adapter.run(context.session, async ()=>{
+            const document = prepare(request, context);
+            if (!i18n) {
+                resolveDocumentPolicy(context.session);
+                return adapter.renderCSR(context, document);
+            }
+            const language = i18n.resolveRequest(request);
+            if ('redirect' === language.kind) return adapter.respond(context.session, i18n.redirect(language.location));
+            resolveDocumentPolicy(context.session, detectedVary(language));
+            return adapter.renderCSR(context, {
+                ...document,
+                lang: language.language,
+                inlineData: [
+                    i18n.handoff(language.language)
+                ]
+            });
+        });
+    const nativeMatchRouteIds = (request, context)=>adapter.run(context.session, async ()=>{
+            own(request, context);
+            const application = await routedApplication(context.session.signal);
+            const router = adapter.createRouter(application, {
+                identity: rendererIdentity,
+                loadRoute: serverRouteLoader(application),
+                request,
+                context: context.session.platform.bindings,
+                session: context.session,
+                ...i18n ? {
+                    rewrite: i18n.rewrite(()=>i18n.resolveRequest(request).language)
+                } : {}
+            });
+            return (0, external_router_js_namespaceObject.matchApplicationRouteIds)(router, new URL(request.url));
+        });
+    const nativeRequestHandler = (request, context)=>adapter.run(context.session, async ()=>{
+            const document = prepare(request, context);
+            const { session } = context;
+            const application = await (0, external_abort_js_namespaceObject.untilAborted)(options.app(), session.signal);
+            const routed = (0, external_router_js_namespaceObject.isRoutedApplication)(application);
+            const nativeRequest = routed ? new Request(request, {
+                signal: session.signal
+            }) : request;
+            const language = i18n?.resolveRequest(nativeRequest);
+            if (!routed && i18n && language?.kind === 'redirect') return adapter.respond(session, i18n.redirect(language.location));
+            const localize = async (inlineData = [])=>{
+                if (!i18n || !language) return {
+                    document,
+                    localization: void 0
+                };
+                const instance = await (0, external_abort_js_namespaceObject.untilAborted)(i18n.create(language.language), session.signal);
+                return {
+                    document: {
+                        ...document,
+                        lang: instance.language,
+                        inlineData: [
+                            ...inlineData,
+                            i18n.handoff(instance.language, instance)
+                        ]
+                    },
+                    localization: (0, external_localization_js_namespaceObject.nativeI18nView)(i18n, instance)
+                };
+            };
+            if (!routed) {
+                const localized = await localize(document.inlineData);
+                resolveDocumentPolicy(session, detectedVary(language));
+                return adapter.renderComponent(context, application.default, localized.document, localized.localization);
+            }
+            const bindings = session.platform.bindings;
+            const outcomes = [];
+            const outcomeRanks = [];
+            let routeOrder;
+            const addOutcome = (rank, outcome)=>{
+                const at = outcomeRanks.findIndex((other)=>other > rank);
+                const index = at < 0 ? outcomes.length : at;
+                outcomes.splice(index, 0, outcome);
+                outcomeRanks.splice(index, 0, rank);
+            };
+            const router = adapter.createRouter(application, {
+                identity: rendererIdentity,
+                loadRoute: serverRouteLoader(application),
+                request: nativeRequest,
+                context: bindings,
+                onOutcome: (routeId, outcome)=>{
+                    if ('response' in outcome) {
+                        routeOrder ??= (0, external_router_js_namespaceObject.matchApplicationRouteIds)(router, new URL(nativeRequest.url));
+                        const rank = routeOrder.indexOf(routeId);
+                        addOutcome(rank < 0 ? 1 / 0 : rank, outcome);
+                    } else if (outcome.completion) {
+                        const completion = outcome.completion;
+                        completion.catch((error)=>session.fail(error));
+                        session.registerCleanup(()=>completion);
+                    }
+                },
+                session,
+                ...void 0 === context.nonce ? {} : {
+                    nonce: context.nonce
+                },
+                ...i18n && language ? {
+                    rewrite: i18n.rewrite(()=>language.language)
+                } : {}
+            });
+            const dataResponse = await (0, index_js_namespaceObject.handleDataRequest)({
+                request: nativeRequest,
+                identity: rendererIdentity,
+                context: bindings,
+                privateValues: [
+                    context,
+                    session,
+                    session.platform,
+                    bindings
+                ],
+                production: 'development' !== process.env.NODE_ENV,
+                selectRoute: (dataRequest, routeId, operation)=>(0, external_router_js_namespaceObject.selectApplicationDataRoute)(router, dataRequest, routeId, operation, application.dataModules)
+            });
+            if (dataResponse) return adapter.respond(session, dataResponse);
+            if (i18n && language?.kind === 'redirect') return adapter.respond(session, i18n.redirect(language.location));
+            const vary = detectedVary(language);
+            if (vary?.length) addOutcome(1 / 0, await (0, index_js_namespaceObject.normalizeDataResult)(new Response(null, {
+                headers: {
+                    vary: vary.join(', ')
+                }
+            })));
+            const localized = await localize();
+            return adapter.renderRoutes({
+                request: nativeRequest,
+                context,
+                router,
+                outcomes,
+                document: localized.document,
+                forbiddenValues: [
+                    context,
+                    session,
+                    session.platform,
+                    bindings,
+                    nativeRequest
+                ],
+                ...localized.localization ? {
+                    i18n: localized.localization
+                } : {}
+            });
+        });
+    return {
+        rendererIdentity,
+        nativeRequestHandler,
+        nativeCSRRequestHandler,
+        nativeMatchRouteIds
+    };
+}
+exports.createNativeServerEntry = __webpack_exports__.createNativeServerEntry;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNativeServerEntry"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/federation.js

@@ -0,0 +1,80 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function getFederationHost(binding) {
+    if (void 0 === binding) return;
+    if ('function' != typeof binding?.instance) throw new TypeError('The native federation host binding is invalid.');
+    const instance = binding.instance();
+    if (!instance || 'function' != typeof instance.loadRemote) throw new TypeError('The application federation runtime has not started.');
+    return instance;
+}
+async function loadFederatedModule(instance, id) {
+    if (!instance) throw new Error(`Cannot load ${id}: this application has no Module Federation runtime. Add module-federation.config.ts with its remotes.`);
+    const module = await instance.loadRemote(id);
+    if (!module) throw new Error(`Remote module ${id} is unavailable`);
+    return module;
+}
+function remoteBrowserAssets(instance, id) {
+    const target = instance.remoteHandler?.idToRemoteMap?.[id];
+    const loaded = target && instance.moduleCache?.get(target.name);
+    const snapshot = loaded && instance.snapshotHandler?.getGlobalRemoteInfo(loaded.remoteInfo).remoteSnapshot;
+    if (!snapshot || 'string' != typeof snapshot.publicPath || !snapshot.publicPath || 'string' != typeof snapshot.remoteEntry || !snapshot.remoteEntry) return;
+    const expose = snapshot.modules?.find((module)=>module.modulePath === target.expose);
+    if (!expose?.assets) return;
+    const publicPath = snapshot.publicPath;
+    const url = (file)=>/^(?:https?:)?\/\//iu.test(file) ? file : `${publicPath.replace(/\/$/u, '')}/${file.replace(/^\//u, '')}`;
+    return {
+        js: [
+            url(snapshot.remoteEntry),
+            ...(expose.assets.js?.sync ?? []).map(url)
+        ],
+        css: [
+            ...new Set([
+                ...expose.assets.css?.sync ?? [],
+                ...expose.assets.css?.async ?? []
+            ].map(url))
+        ]
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    getFederationHost: ()=>getFederationHost,
+    loadFederatedModule: ()=>loadFederatedModule,
+    remoteBrowserAssets: ()=>remoteBrowserAssets
+});
+exports.getFederationHost = __webpack_exports__.getFederationHost;
+exports.loadFederatedModule = __webpack_exports__.loadFederatedModule;
+exports.remoteBrowserAssets = __webpack_exports__.remoteBrowserAssets;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getFederationHost",
+    "loadFederatedModule",
+    "remoteBrowserAssets"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/identity.js

@@ -0,0 +1,120 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function resolveRenderer(value = 'react') {
+    if ('string' == typeof value && value.trim() === value && /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u.test(value)) return value;
+    throw new Error(`Unsupported UltraModern renderer: ${String(value)}`);
+}
+function identityCacheKey(identity) {
+    resolveRenderer(identity.renderer);
+    for (const key of [
+        'appId',
+        'entryName',
+        'buildId'
+    ])if ('string' != typeof identity[key] || 0 === identity[key].trim().length) throw new Error(`Renderer identity requires a nonempty ${key}`);
+    if (1 !== identity.protocolVersion) throw new Error('Unsupported renderer data protocol version');
+    return JSON.stringify([
+        identity.renderer,
+        identity.appId,
+        identity.entryName,
+        identity.protocolVersion,
+        identity.buildId
+    ]);
+}
+function assertRendererIdentity(actual, expected) {
+    if (identityCacheKey(actual) !== identityCacheKey(expected)) throw new Error('Renderer identity conflicts with the application build');
+}
+const IDENTITY_FIELDS = [
+    'renderer',
+    'appId',
+    'entryName',
+    'protocolVersion',
+    'buildId'
+];
+function readRendererIdentity(value, expected) {
+    if (!value || 'object' != typeof value || ![
+        Object.prototype,
+        null
+    ].includes(Object.getPrototypeOf(value)) || Object.keys(value).some((key)=>!IDENTITY_FIELDS.includes(key))) throw new Error('A renderer identity must contain only identity fields.');
+    const identity = value;
+    assertRendererIdentity(identity, expected);
+    return Object.freeze({
+        renderer: identity.renderer,
+        appId: identity.appId,
+        entryName: identity.entryName,
+        protocolVersion: identity.protocolVersion,
+        buildId: identity.buildId
+    });
+}
+function nativeModuleManifestFilename(renderer, entryName) {
+    if ('string' != typeof entryName || !entryName.trim()) throw new Error('Native module manifests require an application entry name.');
+    return `${resolveRenderer(renderer)}-module-manifest.${encodeURIComponent(entryName)}.json`;
+}
+const RENDERER_IDENTITY_HEADER = 'x-ultramodern-renderer-identity';
+function serializeRendererIdentityHeader(identity) {
+    identityCacheKey(identity);
+    return JSON.stringify({
+        renderer: identity.renderer,
+        appId: identity.appId,
+        entryName: identity.entryName,
+        protocolVersion: identity.protocolVersion,
+        buildId: identity.buildId
+    }).replace(/[\u007f-\u{10ffff}]/gu, (character)=>Array.from({
+            length: character.length
+        }, (_, index)=>`\\u${character.charCodeAt(index).toString(16).padStart(4, '0')}`).join(''));
+}
+__webpack_require__.d(__webpack_exports__, {
+    assertRendererIdentity: ()=>assertRendererIdentity,
+    identityCacheKey: ()=>identityCacheKey,
+    nativeModuleManifestFilename: ()=>nativeModuleManifestFilename,
+    readRendererIdentity: ()=>readRendererIdentity,
+    resolveRenderer: ()=>resolveRenderer,
+    serializeRendererIdentityHeader: ()=>serializeRendererIdentityHeader
+}, {
+    RENDERER_IDENTITY_HEADER: RENDERER_IDENTITY_HEADER
+});
+exports.RENDERER_IDENTITY_HEADER = __webpack_exports__.RENDERER_IDENTITY_HEADER;
+exports.assertRendererIdentity = __webpack_exports__.assertRendererIdentity;
+exports.identityCacheKey = __webpack_exports__.identityCacheKey;
+exports.nativeModuleManifestFilename = __webpack_exports__.nativeModuleManifestFilename;
+exports.readRendererIdentity = __webpack_exports__.readRendererIdentity;
+exports.resolveRenderer = __webpack_exports__.resolveRenderer;
+exports.serializeRendererIdentityHeader = __webpack_exports__.serializeRendererIdentityHeader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RENDERER_IDENTITY_HEADER",
+    "assertRendererIdentity",
+    "identityCacheKey",
+    "nativeModuleManifestFilename",
+    "readRendererIdentity",
+    "resolveRenderer",
+    "serializeRendererIdentityHeader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    assertRendererIdentity: ()=>external_identity_js_namespaceObject.assertRendererIdentity,
+    identityCacheKey: ()=>external_identity_js_namespaceObject.identityCacheKey,
+    resolveRenderer: ()=>external_identity_js_namespaceObject.resolveRenderer
+});
+const external_identity_js_namespaceObject = require("./identity.js");
+exports.assertRendererIdentity = __webpack_exports__.assertRendererIdentity;
+exports.identityCacheKey = __webpack_exports__.identityCacheKey;
+exports.resolveRenderer = __webpack_exports__.resolveRenderer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertRendererIdentity",
+    "identityCacheKey",
+    "resolveRenderer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/localization.js

@@ -0,0 +1,48 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function nativeI18nView(i18n, instance) {
+    return {
+        instance,
+        languages: i18n.languages,
+        ...void 0 === i18n.localisedUrls ? {} : {
+            localisedUrls: i18n.localisedUrls
+        }
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    nativeI18nView: ()=>nativeI18nView
+});
+exports.nativeI18nView = __webpack_exports__.nativeI18nView;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "nativeI18nView"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});