@bleedingdev/modern-js-bff-effect 3.8.3-ultramodern.2

package/dist/cjs/effect/module.js

@@ -0,0 +1,118 @@
+"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__, {
+    resolveEffectBffModuleHandler: ()=>resolveEffectBffModuleHandler
+});
+const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const external_entry_shape_js_namespaceObject = require("./entry-shape.js");
+const external_handler_js_namespaceObject = require("./handler.js");
+function isRequestHandler(value) {
+    return 'function' == typeof value;
+}
+function shareDispose(dispose) {
+    let disposePromise;
+    return ()=>{
+        disposePromise ??= Promise.resolve().then(dispose);
+        return disposePromise;
+    };
+}
+function rejectLegacyEffectModuleShape(options, shape) {
+    options.onWarning?.(`${external_entry_shape_js_namespaceObject.strictEffectApproachMessage} Rejected ${shape}.`);
+    return true;
+}
+function callEffectBffRequestHandler(handler, request, context) {
+    return void 0 === context ? handler(request) : handler(request, context);
+}
+function createLoadedHandler(webHandler) {
+    return {
+        handler: (request, context)=>callEffectBffRequestHandler(webHandler.handler, request, context),
+        dispose: shareDispose(webHandler.dispose)
+    };
+}
+function createLoadedHttpApiHandler(webHandler) {
+    return createLoadedHandler({
+        handler: webHandler.handler,
+        dispose: webHandler.dispose
+    });
+}
+function classifyEffectBffRuntimeEntryShape(module) {
+    return (0, external_entry_shape_js_namespaceObject.classifyEffectBffEntryModule)(module, {
+        isRequestHandler,
+        isValidatorAwareHandlerFactory: external_entry_shape_js_namespaceObject.isValidatorAwareHandlerFactory,
+        isHttpApi: httpapi_namespaceObject.HttpApi.isHttpApi
+    });
+}
+function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
+    if (!facts) return null;
+    if (facts.legacyShape) {
+        if (rejectLegacyEffectModuleShape(options, facts.legacyShape)) return null;
+    }
+    if ('function' == typeof facts.createHandler) {
+        if (facts.createHandlerValidatorAware) {
+            const factory = facts.createHandler;
+            const webHandler = factory({
+                openapi: options.openapi,
+                dataPlatform: options.dataPlatform,
+                validateRequest: options.validateRequest
+            });
+            return createLoadedHandler(webHandler);
+        }
+        if (void 0 === facts.api || !facts.hasRuntimeLayer) {
+            rejectLegacyEffectModuleShape(options, 'unbranded `createHandler` export');
+            return null;
+        }
+        options.onWarning?.(`${external_entry_shape_js_namespaceObject.strictEffectApproachMessage} Ignored unbranded \`createHandler\` export and rebuilt the handler from its { api, layer } exports.`);
+    }
+    if (void 0 !== facts.api && facts.hasRuntimeLayer) {
+        if (void 0 === facts.createHandler) options.onWarning?.('[BFF][Effect] Detected { api, layer } export without createHandler. Prefer `defineEffectBff(...)` from @modern-js/bff-effect/effect to avoid module instance mismatch.');
+        const webHandler = (0, external_handler_js_namespaceObject.createHttpApiHandler)({
+            api: facts.api,
+            layer: facts.layer,
+            openapi: options.openapi,
+            dataPlatform: options.dataPlatform,
+            validateRequest: options.validateRequest
+        });
+        return createLoadedHttpApiHandler(webHandler);
+    }
+    return null;
+}
+function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {}) {
+    return resolveClassifiedEffectBffModuleHandler(classifyEffectBffRuntimeEntryShape(normalizedModule), options);
+}
+function resolveEffectBffModuleHandler(mod, options = {}) {
+    return Promise.resolve(resolveNormalizedEffectBffModuleHandler(mod, options));
+}
+exports.resolveEffectBffModuleHandler = __webpack_exports__.resolveEffectBffModuleHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveEffectBffModuleHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect/operation-context.js

@@ -0,0 +1,116 @@
+"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__, {
+    createEffectOperationContext: ()=>createEffectOperationContext,
+    kEffectContextStorage: ()=>kEffectContextStorage
+});
+const create_request_namespaceObject = require("@modern-js/create-request");
+const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.effectContextStorage');
+const readHeader = (headers, header)=>{
+    const value = headers.get(header);
+    return value && value.length > 0 ? value : void 0;
+};
+const copyStringField = (target, details, key)=>{
+    const value = details[key];
+    if ('string' == typeof value && value.length > 0) target[key] = value;
+};
+const readOperationContextDetails = (request)=>{
+    const rawDetails = readHeader(request.headers, create_request_namespaceObject.BFF_OPERATION_CONTEXT_DETAIL_HEADER);
+    if (!rawDetails) return {};
+    try {
+        const parsed = JSON.parse(rawDetails);
+        if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) return {};
+        const details = parsed;
+        const safeDetails = {};
+        copyStringField(safeDetails, details, 'requestId');
+        copyStringField(safeDetails, details, 'operationId');
+        copyStringField(safeDetails, details, 'schemaHash');
+        copyStringField(safeDetails, details, 'traceparent');
+        copyStringField(safeDetails, details, 'traceId');
+        copyStringField(safeDetails, details, 'spanId');
+        if ('number' == typeof details.operationVersion) safeDetails.operationVersion = details.operationVersion;
+        return safeDetails;
+    } catch  {
+        return {};
+    }
+};
+const createEffectOperationContext = ({ request, path, method })=>{
+    const details = readOperationContextDetails(request);
+    const operationDetails = {
+        ...details
+    };
+    delete operationDetails.traceparent;
+    delete operationDetails.traceId;
+    delete operationDetails.spanId;
+    const servicePath = new URL(request.url).pathname;
+    const headerTraceparent = readHeader(request.headers, create_request_namespaceObject.BFF_TRACEPARENT_HEADER);
+    const headerTraceContext = (0, create_request_namespaceObject.parseTraceparent)(headerTraceparent);
+    const detailTraceContext = (0, create_request_namespaceObject.parseTraceparent)(details.traceparent);
+    const traceparent = headerTraceContext ? headerTraceparent : detailTraceContext ? details.traceparent : void 0;
+    const parsedTraceparent = headerTraceContext || detailTraceContext || (details.traceId && details.spanId ? {
+        traceId: details.traceId,
+        spanId: details.spanId
+    } : void 0);
+    const locale = readHeader(request.headers, create_request_namespaceObject.BFF_LOCALE_HEADER);
+    const headerOperationId = readHeader(request.headers, create_request_namespaceObject.BFF_OPERATION_CONTEXT_HEADER);
+    return {
+        ...operationDetails,
+        ...headerOperationId || details.operationId ? {
+            operationId: headerOperationId || details.operationId
+        } : {},
+        routePath: servicePath,
+        method: (method || request.method || 'GET').toUpperCase(),
+        source: 'effect-adapter',
+        ...path && path !== servicePath ? {
+            attributes: {
+                mountedPath: path
+            }
+        } : {},
+        ...locale ? {
+            locale
+        } : {},
+        ...traceparent ? {
+            traceparent
+        } : {},
+        ...parsedTraceparent ? {
+            traceId: parsedTraceparent.traceId,
+            spanId: parsedTraceparent.spanId
+        } : {}
+    };
+};
+exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
+exports.kEffectContextStorage = __webpack_exports__.kEffectContextStorage;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEffectOperationContext",
+    "kEffectContextStorage"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect/rpcSerialization.js

@@ -0,0 +1,54 @@
+"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__, {
+    getRpcSerializationLayer: ()=>getRpcSerializationLayer
+});
+const rpc_namespaceObject = require("effect/unstable/rpc");
+function getRpcSerializationLayer(serialization) {
+    switch(serialization){
+        case 'ndjson':
+            return rpc_namespaceObject.RpcSerialization.layerNdjson;
+        case 'jsonRpc':
+            return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
+        case 'ndJsonRpc':
+            return rpc_namespaceObject.RpcSerialization.layerNdJsonRpc();
+        case 'msgPack':
+            return rpc_namespaceObject.RpcSerialization.layerMsgPack;
+        default:
+            return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
+    }
+}
+exports.getRpcSerializationLayer = __webpack_exports__.getRpcSerializationLayer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getRpcSerializationLayer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect-client/batch.js

@@ -0,0 +1,73 @@
+"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__, {
+    configureGeneratedEffectClientRuntime: ()=>configureGeneratedEffectClientRuntime
+});
+const index_js_namespaceObject = require("../data-platform/index.js");
+const external_envelope_js_namespaceObject = require("./envelope.js");
+const resolveRuntimeFetch = ()=>'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
+const configureGeneratedEffectClientRuntime = (config, configureRequest)=>{
+    const defaultOrigin = config.defaultOrigin;
+    if (config.requestId && configureRequest) {
+        const configurePayload = {
+            requestId: config.requestId,
+            requireEnvelope: true,
+            identityBinding: {
+                enabled: true,
+                strict: true
+            },
+            operationContract: {
+                enabled: true,
+                strict: true,
+                requireSchemaHash: true,
+                requireOperationVersion: true
+            },
+            setDomain: ()=>(0, external_envelope_js_namespaceObject.resolveOrigin)(defaultOrigin)
+        };
+        const runtimeFetch = resolveRuntimeFetch();
+        if (false !== config.batch.enabled && runtimeFetch) configurePayload.request = (0, index_js_namespaceObject.createDataBatchTransport)({
+            fetch: runtimeFetch,
+            endpoint: config.batch.endpoint,
+            flushIntervalMs: config.batch.flushIntervalMs,
+            maxBatchSize: config.batch.maxBatchSize,
+            maxBatchBytes: config.batch.maxBatchBytes,
+            requestTimeoutMs: config.batch.requestTimeoutMs,
+            allowedMethods: config.batch.allowedMethods
+        });
+        configureRequest(configurePayload);
+    }
+};
+exports.configureGeneratedEffectClientRuntime = __webpack_exports__.configureGeneratedEffectClientRuntime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "configureGeneratedEffectClientRuntime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect-client/envelope.js

@@ -0,0 +1,145 @@
+"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__, {
+    prepareEffectRequest: ()=>prepareEffectRequest,
+    resolveOrigin: ()=>resolveOrigin
+});
+const index_js_namespaceObject = require("../data-platform/index.js");
+const external_guards_js_namespaceObject = require("./guards.js");
+const external_request_js_namespaceObject = require("./request.js");
+const external_request_context_js_namespaceObject = require("./request-context.js");
+const DATA_REQUEST_MODES = new Set([
+    'cache-first',
+    'stale-while-revalidate',
+    'network-only'
+]);
+const DATA_MUTATION_MODES = new Set([
+    'optimistic',
+    'pessimistic',
+    'fire-and-forget'
+]);
+const isDataRequestMode = (value)=>'string' == typeof value && DATA_REQUEST_MODES.has(value);
+const isDataMutationMode = (value)=>'string' == typeof value && DATA_MUTATION_MODES.has(value);
+const normalizeOrigin = (value)=>{
+    if ('string' != typeof value || 0 === value.length) return;
+    try {
+        return new URL(value).origin;
+    } catch  {
+        return;
+    }
+};
+const resolveOrigin = (defaultOrigin)=>{
+    if ("u" > typeof window && window.location && 'string' == typeof window.location.origin && window.location.origin) return window.location.origin;
+    const globalLocation = globalThis?.location;
+    if (globalLocation && 'string' == typeof globalLocation.origin && globalLocation.origin) return globalLocation.origin;
+    return defaultOrigin;
+};
+const resolveTargetOrigin = (dataPlatform, defaultOrigin)=>{
+    const explicitTargetOrigin = (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.targetOrigin) || (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.endpointOrigin);
+    if (explicitTargetOrigin) return explicitTargetOrigin;
+    return defaultOrigin;
+};
+const shouldAttachEnvelopeHeader = (dataPlatform, defaultOrigin)=>{
+    if (true === dataPlatform.allowCrossOriginEnvelope) return true;
+    const currentOrigin = normalizeOrigin(resolveOrigin(defaultOrigin));
+    const targetOrigin = normalizeOrigin(resolveTargetOrigin(dataPlatform, defaultOrigin));
+    if (!currentOrigin || !targetOrigin) return true;
+    return currentOrigin === targetOrigin;
+};
+const toEnvelopeInput = (normalizedRequest)=>{
+    const payload = {};
+    if ((0, external_guards_js_namespaceObject.isRecord)(normalizedRequest.params)) payload.path = normalizedRequest.params;
+    if ((0, external_guards_js_namespaceObject.isRecord)(normalizedRequest.query)) payload.query = normalizedRequest.query;
+    if ('data' in normalizedRequest && void 0 !== normalizedRequest.data) payload.data = normalizedRequest.data;
+    if ('body' in normalizedRequest && void 0 !== normalizedRequest.body) payload.body = normalizedRequest.body;
+    if ("u" > typeof FormData && normalizedRequest.formData instanceof FormData) payload.formData = Array.from(normalizedRequest.formData.entries()).map(([key, value])=>[
+            key,
+            String(value)
+        ]);
+    if ("u" > typeof URLSearchParams && normalizedRequest.formUrlencoded instanceof URLSearchParams) payload.formUrlencoded = normalizedRequest.formUrlencoded.toString();
+    return payload;
+};
+const prepareEffectRequest = (options)=>{
+    const { endpoint, operation, request, config, createEffectRequestContext } = options;
+    const defaultOrigin = config.defaultOrigin;
+    const normalizedRequest = (0, external_request_context_js_namespaceObject.applyRequestContext)((0, external_request_js_namespaceObject.normalizeRequest)(endpoint.method, request), request, createEffectRequestContext);
+    const dataPlatform = (0, external_guards_js_namespaceObject.isRecord)(request) && (0, external_guards_js_namespaceObject.isRecord)(request.dataPlatform) ? request.dataPlatform : {};
+    const strictEnvelope = true === dataPlatform.requireEnvelope || true === dataPlatform.strict;
+    if (!strictEnvelope && !shouldAttachEnvelopeHeader(dataPlatform, defaultOrigin)) return normalizedRequest;
+    try {
+        const namespace = (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.appNamespace) || config.appNamespace;
+        const origin = (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.origin) || resolveOrigin(defaultOrigin);
+        const envelope = (0, index_js_namespaceObject.createRequestEnvelope)({
+            operation: {
+                ...operation,
+                appNamespace: namespace
+            },
+            scope: {
+                appNamespace: namespace,
+                origin,
+                tenantId: (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.tenantId),
+                userId: (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.userId),
+                sessionId: (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.sessionId)
+            },
+            requestInput: {
+                method: endpoint.method,
+                routePath: endpoint.routePath,
+                payload: toEnvelopeInput(normalizedRequest)
+            },
+            requestMode: isDataRequestMode(dataPlatform.requestMode) ? dataPlatform.requestMode : void 0,
+            mutationMode: isDataMutationMode(dataPlatform.mutationMode) ? dataPlatform.mutationMode : void 0,
+            selectionPlan: (0, external_guards_js_namespaceObject.isRecord)(dataPlatform.selectionPlan) ? dataPlatform.selectionPlan : void 0,
+            traceContext: (0, external_guards_js_namespaceObject.isRecord)(dataPlatform.traceContext) ? dataPlatform.traceContext : void 0,
+            requireTraceContext: true === dataPlatform.requireTraceContext
+        });
+        const headerName = (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.envelopeHeader) || index_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER;
+        const headers = (0, external_guards_js_namespaceObject.isRecord)(normalizedRequest.headers) ? {
+            ...normalizedRequest.headers
+        } : {};
+        if (false === dataPlatform.batch) headers[index_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER] = 'off';
+        headers[headerName] = (0, index_js_namespaceObject.encodeRequestEnvelopeHeader)(envelope);
+        return {
+            ...normalizedRequest,
+            headers
+        };
+    } catch (error) {
+        if (strictEnvelope) throw error;
+        return normalizedRequest;
+    }
+};
+exports.prepareEffectRequest = __webpack_exports__.prepareEffectRequest;
+exports.resolveOrigin = __webpack_exports__.resolveOrigin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "prepareEffectRequest",
+    "resolveOrigin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect-client/guards.js

@@ -0,0 +1,44 @@
+"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__);
+const isRecord = (value)=>'object' == typeof value && null !== value;
+const stringOrUndefined = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+__webpack_require__.d(__webpack_exports__, {}, {
+    isRecord: isRecord,
+    stringOrUndefined: stringOrUndefined
+});
+exports.isRecord = __webpack_exports__.isRecord;
+exports.stringOrUndefined = __webpack_exports__.stringOrUndefined;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isRecord",
+    "stringOrUndefined"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});