@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/dist/cjs/localisedUrls/routes.js

@@ -0,0 +1,217 @@
+"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__, {
+    applyLocalisedUrlsToRoutes: ()=>applyLocalisedUrlsToRoutes,
+    validateLocalisedUrls: ()=>validateLocalisedUrls
+});
+const external_normalise_js_namespaceObject = require("./normalise.js");
+const external_patterns_js_namespaceObject = require("./patterns.js");
+const isLocalisableRoutePath = (path)=>{
+    const pathWithoutLocale = (0, external_normalise_js_namespaceObject.stripLeadingLocaleParam)(path);
+    if (!pathWithoutLocale || '/' === pathWithoutLocale || '*' === pathWithoutLocale) return false;
+    return true;
+};
+const joinPath = (parentPath, routePath)=>{
+    if (!isLocalisableRoutePath(routePath)) return parentPath;
+    const segment = (0, external_normalise_js_namespaceObject.normaliseRoutePath)((0, external_normalise_js_namespaceObject.stripLeadingLocaleParam)(routePath) || '');
+    return (0, external_normalise_js_namespaceObject.normalisePathPattern)(`${parentPath}/${segment}`);
+};
+const isFrameworkInternalRoutePath = (canonicalPath)=>'/_mf' === canonicalPath || canonicalPath.startsWith('/_mf/');
+const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
+const formatParamSignature = (signature)=>signature.length > 0 ? signature.join(', ') : '(none)';
+const validateLocalisedUrlPatterns = (languages, localisedUrls)=>{
+    const physicalPatterns = new Map();
+    const claimedPatterns = [];
+    const claimPhysicalPattern = (sourcePattern, canonicalPath, source)=>{
+        const physicalPattern = (0, external_patterns_js_namespaceObject.getPhysicalPathPattern)(sourcePattern);
+        const existing = physicalPatterns.get(physicalPattern);
+        if (existing && existing.canonicalPath !== canonicalPath) throw new Error(`localisedUrls["${existing.canonicalPath}"] ${existing.source} and localisedUrls["${canonicalPath}"] ${source} generate the same physical route pattern "${physicalPattern}". Localised route patterns must identify exactly one canonical route.`);
+        const overlapping = claimedPatterns.find((claimed)=>claimed.canonicalPath !== canonicalPath && (0, external_patterns_js_namespaceObject.haveEqualPatternSpecificity)(claimed.pattern, sourcePattern) && (0, external_patterns_js_namespaceObject.doPathPatternsOverlap)(claimed.pattern, sourcePattern));
+        if (overlapping) throw new Error(`localisedUrls["${overlapping.canonicalPath}"] ${overlapping.source} pattern "${overlapping.pattern}" and localisedUrls["${canonicalPath}"] ${source} pattern "${sourcePattern}" are equal-specificity overlapping route patterns. Localised route patterns must identify exactly one canonical route.`);
+        physicalPatterns.set(physicalPattern, {
+            canonicalPath,
+            source
+        });
+        claimedPatterns.push({
+            canonicalPath,
+            pattern: sourcePattern,
+            source
+        });
+    };
+    for (const [canonicalPath, entry] of Object.entries(localisedUrls).sort(([left], [right])=>left < right ? -1 : left > right ? 1 : 0)){
+        const canonicalIssue = (0, external_patterns_js_namespaceObject.getPathPatternValidationIssue)(canonicalPath);
+        if (canonicalIssue) throw new Error(`localisedUrls["${canonicalPath}"] canonical pattern has ${canonicalIssue}.`);
+        const expectedSignature = (0, external_patterns_js_namespaceObject.getPathParamSignature)(canonicalPath);
+        const expectedOrderedSignature = (0, external_patterns_js_namespaceObject.getOrderedPathParamSignature)(canonicalPath);
+        claimPhysicalPattern(canonicalPath, canonicalPath, 'canonical pattern');
+        for (const language of languages){
+            const localisedPattern = entry[language];
+            if (!localisedPattern) continue;
+            const localisedIssue = (0, external_patterns_js_namespaceObject.getPathPatternValidationIssue)(localisedPattern);
+            if (localisedIssue) throw new Error(`localisedUrls["${canonicalPath}"].${language} has ${localisedIssue}.`);
+            const actualSignature = (0, external_patterns_js_namespaceObject.getPathParamSignature)(localisedPattern);
+            if (actualSignature.length !== expectedSignature.length || actualSignature.some((parameter, index)=>parameter !== expectedSignature[index])) throw new Error(`localisedUrls["${canonicalPath}"].${language} must use the same parameter signature as "${canonicalPath}": expected ${formatParamSignature(expectedSignature)}; received ${formatParamSignature(actualSignature)}.`);
+            const actualOrderedSignature = (0, external_patterns_js_namespaceObject.getOrderedPathParamSignature)(localisedPattern);
+            if (expectedOrderedSignature.some((parameter)=>'*' === parameter || parameter.endsWith('?')) && actualOrderedSignature.some((parameter, index)=>parameter !== expectedOrderedSignature[index])) throw new Error(`localisedUrls["${canonicalPath}"].${language} must keep optional and splat parameters in canonical order: expected ${formatParamSignature(expectedOrderedSignature)}; received ${formatParamSignature(actualOrderedSignature)}.`);
+            claimPhysicalPattern(localisedPattern, canonicalPath, `.${language}`);
+        }
+    }
+};
+const ensureLocalisedUrlsForPath = (canonicalPath, languages, localisedUrls)=>{
+    const entry = localisedUrls[canonicalPath];
+    if (!entry) throw new Error(`localisedUrls is enabled, but route "${canonicalPath}" does not define localised URLs for languages: ${languages.join(', ')}. Add localisedUrls["${canonicalPath}"] or set localeDetection.localisedUrls to false.`);
+    const missingLanguages = languages.filter((language)=>!entry[language]);
+    if (missingLanguages.length > 0) throw new Error(`localisedUrls["${canonicalPath}"] is missing languages: ${missingLanguages.join(', ')}. Every configured language must have a localised URL.`);
+    return entry;
+};
+const validateLocalisedUrls = (routes, languages, localisedUrls)=>{
+    validateLocalisedUrlPatterns(languages, localisedUrls);
+    const visit = (route, parentPath)=>{
+        const canonicalPath = joinPath(parentPath, route.path);
+        if (isLocalisableRoutePath(route.path) && !isFrameworkInternalRoutePath(canonicalPath)) ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls);
+        if ('children' in route && route.children) route.children.forEach((child)=>visit(child, canonicalPath));
+    };
+    routes.forEach((route)=>visit(route, ''));
+};
+const getLocalisedRouteIdSuffixes = (paths)=>{
+    const usedSuffixes = new Set();
+    return paths.map((path, index)=>{
+        if (0 === index) return;
+        const baseSuffix = legalRouteIdPart(path);
+        let suffix = baseSuffix;
+        let disambiguator = 2;
+        while(usedSuffixes.has(suffix))suffix = `${baseSuffix}_${disambiguator++}`;
+        usedSuffixes.add(suffix);
+        return suffix;
+    });
+};
+const getLocalisedRoutePaths = (canonicalPath, parentLocalisedPaths, languages, entry)=>{
+    const paths = languages.map((language)=>{
+        const fullPath = (0, external_normalise_js_namespaceObject.normalisePathPattern)(entry[language]);
+        const parentPath = (0, external_normalise_js_namespaceObject.normalisePathPattern)(parentLocalisedPaths[language] || '/');
+        if ('/' === parentPath) return (0, external_normalise_js_namespaceObject.normaliseRoutePath)(fullPath) || void 0;
+        const parentPrefix = `${parentPath}/`;
+        if (!fullPath.startsWith(parentPrefix)) throw new Error(`localisedUrls["${canonicalPath}"].${language} must be nested under "${parentPath}" because its parent route is localised there.`);
+        return (0, external_normalise_js_namespaceObject.normaliseRoutePath)(fullPath.slice(parentPath.length));
+    });
+    const uniquePaths = Array.from(new Set(paths.filter(Boolean)));
+    return uniquePaths;
+};
+const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPaths, languages, localisedUrls, projection)=>{
+    const isSplat = '*' === (0, external_normalise_js_namespaceObject.stripLeadingLocaleParam)(route.path);
+    const canonicalPath = isSplat ? (0, external_normalise_js_namespaceObject.normalisePathPattern)(`${parentCanonicalPath}/*`) : joinPath(parentCanonicalPath, route.path);
+    const localisedUrlEntry = isLocalisableRoutePath(route.path) && !isFrameworkInternalRoutePath(canonicalPath) ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls) : void 0;
+    const routeLocalisedPaths = localisedUrlEntry ? languages.reduce((acc, language)=>{
+        acc[language] = (0, external_normalise_js_namespaceObject.normalisePathPattern)(localisedUrlEntry[language]);
+        return acc;
+    }, {}) : isSplat ? Object.fromEntries(Object.entries(parentLocalisedPaths).map(([language, path])=>[
+            language,
+            (0, external_normalise_js_namespaceObject.normalisePathPattern)(`${path}/*`)
+        ])) : parentLocalisedPaths;
+    const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls, projection)) : void 0;
+    const baseRoute = {
+        ...route,
+        ...!isFrameworkInternalRoutePath(canonicalPath) ? {
+            modernLocalisedRoute: {
+                id: route.id,
+                path: route.path,
+                canonicalPath,
+                paths: localisedUrlEntry ?? (isSplat ? routeLocalisedPaths : void 0)
+            }
+        } : {},
+        ...children ? {
+            children
+        } : {}
+    };
+    if (!localisedUrlEntry) return [
+        baseRoute
+    ];
+    const localisedPaths = getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry);
+    if ('canonical' === projection) return [
+        baseRoute
+    ];
+    const leadingLocaleParam = (0, external_normalise_js_namespaceObject.getLeadingLocaleParam)(route.path);
+    const routeIdPaths = leadingLocaleParam ? localisedPaths.map((path)=>(0, external_normalise_js_namespaceObject.normaliseRoutePath)(`${leadingLocaleParam}/${path}`)) : localisedPaths;
+    const routeIdSuffixes = getLocalisedRouteIdSuffixes(routeIdPaths);
+    return localisedPaths.map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, routeIdSuffixes[index], canonicalPath));
+};
+const suffixRouteIds = (route, suffix)=>{
+    const children = 'children' in route && route.children ? route.children.map((child)=>suffixRouteIds(child, suffix)) : void 0;
+    return {
+        ...route,
+        ...route.id ? {
+            id: `${route.id}__localised_${suffix}`
+        } : {},
+        ...children ? {
+            children
+        } : {}
+    };
+};
+const collectRouteIdCounts = (routes, counts = new Map())=>{
+    for (const route of routes){
+        if (route.id) counts.set(route.id, (counts.get(route.id) ?? 0) + 1);
+        if ('children' in route && route.children) collectRouteIdCounts(route.children, counts);
+    }
+    return counts;
+};
+const validateNoNewRouteIdCollisions = (sourceRoutes, localisedRoutes)=>{
+    const sourceCounts = collectRouteIdCounts(sourceRoutes);
+    const localisedCounts = collectRouteIdCounts(localisedRoutes);
+    for (const [routeId, count] of localisedCounts)if (count > 1 && count > (sourceCounts.get(routeId) ?? 0)) throw new Error(`Localised route expansion generated duplicate route ID "${routeId}". Change the source route ID or localised path so every generated route remains identifiable.`);
+};
+const cloneRouteWithLocalisedPath = (route, path, routeIdSuffix, canonicalPath)=>{
+    const leadingLocaleParam = (0, external_normalise_js_namespaceObject.getLeadingLocaleParam)(route.path);
+    const localisedPath = leadingLocaleParam ? (0, external_normalise_js_namespaceObject.normaliseRoutePath)(`${leadingLocaleParam}/${path}`) : path;
+    const routeWithPath = {
+        ...route,
+        path: localisedPath
+    };
+    routeWithPath.modernCanonicalPath = canonicalPath;
+    return routeIdSuffix ? suffixRouteIds(routeWithPath, routeIdSuffix) : routeWithPath;
+};
+const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls, projection = 'physical')=>{
+    const rootLocalisedPaths = languages.reduce((acc, language)=>{
+        acc[language] = '/';
+        return acc;
+    }, {});
+    validateLocalisedUrls(routes, languages, localisedUrls);
+    const localisedRoutes = routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls, projection));
+    validateNoNewRouteIdCollisions(routes, localisedRoutes);
+    return localisedRoutes;
+};
+exports.applyLocalisedUrlsToRoutes = __webpack_exports__.applyLocalisedUrlsToRoutes;
+exports.validateLocalisedUrls = __webpack_exports__.validateLocalisedUrls;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyLocalisedUrlsToRoutes",
+    "validateLocalisedUrls"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/localisedUrls/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/prefetchPolicy.js

@@ -0,0 +1,52 @@
+"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 resolvePreloadFromPrefetch(prefetch, preload) {
+    if (void 0 !== preload) return preload;
+    if ('none' === prefetch) return false;
+    if ('intent' === prefetch || 'render' === prefetch || 'viewport' === prefetch) return prefetch;
+    return 'viewport';
+}
+function normalizePreloadBehavior(preload, prefetch) {
+    const resolved = resolvePreloadFromPrefetch(prefetch, preload);
+    return false === resolved ? 'none' : resolved;
+}
+__webpack_require__.d(__webpack_exports__, {
+    normalizePreloadBehavior: ()=>normalizePreloadBehavior,
+    resolvePreloadFromPrefetch: ()=>resolvePreloadFromPrefetch
+});
+exports.normalizePreloadBehavior = __webpack_exports__.normalizePreloadBehavior;
+exports.resolvePreloadFromPrefetch = __webpack_exports__.resolvePreloadFromPrefetch;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizePreloadBehavior",
+    "resolvePreloadFromPrefetch"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/rendererHead.js

@@ -57,8 +57,9 @@ var __webpack_exports__ = {};
         "createWebHeadMarkerStripper",
         "default",
         "finishHeadRender",
-        "abortHeadRender",
+        "LATE_HEAD_MESSAGE",
         "beginHeadRender",
+        "abortHeadRender",
         "completeHeadRender",
         "createHeadChunkProcessor",
         "publishHeadRender",
@@ -71,6 +72,7 @@ var __webpack_exports__ = {};
     const MARKER_SUFFIX = '"></template>';
     const RECORD_ID_WIDTH = 12;
     const MARKER_LENGTH = MARKER_PREFIX.length + 1 + 36 + RECORD_ID_WIDTH + MARKER_SUFFIX.length;
+    const LATE_HEAD_MESSAGE = "<Helmet> rendered in a boundary that completed after the shell; head tags dropped. Move it above the Suspense boundary or set server.ssrByEntries[entry].mode to 'string'.";
     const HEAD_STATE = Symbol('modern.rendererHead');
     const getState = (context)=>{
         const headContext = context;
@@ -91,7 +93,12 @@ var __webpack_exports__ = {};
         transaction.nextRecordId += 1;
         return token;
     };
-    const beginHeadRender = (context)=>{
+    const dropLateHead = (transaction)=>{
+        if (transaction.lateHeadReported) return;
+        transaction.lateHeadReported = true;
+        transaction.reportLateHead(LATE_HEAD_MESSAGE);
+    };
+    const beginHeadRender = (context, reportLateHead)=>{
         const state = getState(context);
         state.transaction = {
             recordsByToken: new Map(),
@@ -100,7 +107,9 @@ var __webpack_exports__ = {};
             nextRecordId: 0,
             nonce: globalThis.crypto.randomUUID(),
             previousRecords: state.publishedRecords,
-            sealed: false
+            sealed: false,
+            reportLateHead,
+            lateHeadReported: false
         };
         state.publish?.([]);
     };
@@ -111,7 +120,6 @@ var __webpack_exports__ = {};
         const hadPublisher = void 0 !== state.publish;
         state.publish = (records)=>publish(records);
         if (!hadPublisher) state.publish([]);
-        if (transaction.sealed) return null;
         const token = createToken(transaction);
         transaction.recordsByToken.set(token, createRecord());
         return {
@@ -141,7 +149,9 @@ var __webpack_exports__ = {};
             const token = html.slice(tokenStart, end);
             if (transaction.recordsByToken.has(token)) {
                 stripped += html.slice(cursor, start);
-                if (!transaction.sealed && !transaction.committedTokens.has(token)) {
+                if (transaction.sealed) {
+                    if (!transaction.committedTokens.has(token)) dropLateHead(transaction);
+                } else if (!transaction.committedTokens.has(token)) {
                     transaction.committedTokens.add(token);
                     transaction.committedRecords.push(transaction.recordsByToken.get(token));
                 }
@@ -227,6 +237,7 @@ var __webpack_exports__ = {};
         });
     };
     __webpack_require__.d(__webpack_exports__, {}, {
+        LATE_HEAD_MESSAGE: LATE_HEAD_MESSAGE,
         abortHeadRender: abortHeadRender,
         beginHeadRender: beginHeadRender,
         collectHeadRecord: collectHeadRecord,
@@ -238,6 +249,7 @@ var __webpack_exports__ = {};
         publishHeadRender: publishHeadRender
     });
 })();
+exports.LATE_HEAD_MESSAGE = __webpack_exports__.LATE_HEAD_MESSAGE;
 exports.abortHeadRender = __webpack_exports__.abortHeadRender;
 exports.beginHeadRender = __webpack_exports__.beginHeadRender;
 exports.collectHeadRecord = __webpack_exports__.collectHeadRecord;
@@ -248,6 +260,7 @@ exports.createWebHeadMarkerStripper = __webpack_exports__.createWebHeadMarkerStr
 exports.finishHeadRender = __webpack_exports__.finishHeadRender;
 exports.publishHeadRender = __webpack_exports__.publishHeadRender;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "LATE_HEAD_MESSAGE",
     "abortHeadRender",
     "beginHeadRender",
     "collectHeadRecord",

package/dist/cjs/request-policy/browser.js

@@ -0,0 +1,139 @@
+"use strict";
+var __webpack_modules__ = {
+    "./client" (module) {
+        module.exports = require("./client.js");
+    },
+    "./policyCore" (module) {
+        module.exports = require("./policyCore.js");
+    },
+    "./requestContext" (module) {
+        module.exports = require("./requestContext.js");
+    },
+    "./types" (module) {
+        module.exports = require("./types.js");
+    },
+    "@modern-js/create-request/client" (module) {
+        module.exports = require("@modern-js/create-request/client");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__);
+    var _modern_js_create_request_client__rspack_import_0 = __webpack_require__("@modern-js/create-request/client");
+    var _client__rspack_import_1 = __webpack_require__("./client");
+    var _policyCore__rspack_import_2 = __webpack_require__("./policyCore");
+    var _requestContext__rspack_import_3 = __webpack_require__("./requestContext");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _requestContext__rspack_import_3)if ([
+        "IdentityBindingViolationError",
+        "configure",
+        "OperationContractViolationError",
+        "default",
+        "ProducerClientNotInitializedError",
+        "ProducerDomainNotConfiguredError",
+        "createUploader",
+        "createClient",
+        "CrossOriginEnvelopePolicyError",
+        "createRequest"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_requestContext__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _types__rspack_import_4 = __webpack_require__("./types");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types__rspack_import_4)if ([
+        "IdentityBindingViolationError",
+        "configure",
+        "OperationContractViolationError",
+        "default",
+        "ProducerClientNotInitializedError",
+        "ProducerDomainNotConfiguredError",
+        "createUploader",
+        "createClient",
+        "CrossOriginEnvelopePolicyError",
+        "createRequest"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    const createClient = ()=>(0, _client__rspack_import_1.createPolicyClient)((0, _modern_js_create_request_client__rspack_import_0.createClient)(), {
+            target: 'browser',
+            resolveSourceOrigin: ()=>"u" > typeof window ? window.location.origin : void 0
+        });
+    const { configure, createRequest, createUploader } = createClient();
+    __webpack_require__.d(__webpack_exports__, {
+        CrossOriginEnvelopePolicyError: ()=>_policyCore__rspack_import_2.CrossOriginEnvelopePolicyError,
+        IdentityBindingViolationError: ()=>_policyCore__rspack_import_2.IdentityBindingViolationError,
+        OperationContractViolationError: ()=>_policyCore__rspack_import_2.OperationContractViolationError,
+        ProducerClientNotInitializedError: ()=>_policyCore__rspack_import_2.ProducerClientNotInitializedError,
+        ProducerDomainNotConfiguredError: ()=>_policyCore__rspack_import_2.ProducerDomainNotConfiguredError
+    }, {
+        configure: configure,
+        createClient: createClient,
+        createRequest: createRequest,
+        createUploader: createUploader
+    });
+})();
+exports.CrossOriginEnvelopePolicyError = __webpack_exports__.CrossOriginEnvelopePolicyError;
+exports.IdentityBindingViolationError = __webpack_exports__.IdentityBindingViolationError;
+exports.OperationContractViolationError = __webpack_exports__.OperationContractViolationError;
+exports.ProducerClientNotInitializedError = __webpack_exports__.ProducerClientNotInitializedError;
+exports.ProducerDomainNotConfiguredError = __webpack_exports__.ProducerDomainNotConfiguredError;
+exports.configure = __webpack_exports__.configure;
+exports.createClient = __webpack_exports__.createClient;
+exports.createRequest = __webpack_exports__.createRequest;
+exports.createUploader = __webpack_exports__.createUploader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CrossOriginEnvelopePolicyError",
+    "IdentityBindingViolationError",
+    "OperationContractViolationError",
+    "ProducerClientNotInitializedError",
+    "ProducerDomainNotConfiguredError",
+    "configure",
+    "createClient",
+    "createRequest",
+    "createUploader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});