lkd-web-kit 0.7.8 → 0.7.10

package/dist/node_modules/next/dist/client/script.js

@@ -0,0 +1,362 @@
+import { __module as script } from '../../../../_virtual/script.js';
+import { __require as require_interop_require_default } from '../../../@swc/helpers/cjs/_interop_require_default.js';
+import { __require as require_interop_require_wildcard } from '../../../@swc/helpers/cjs/_interop_require_wildcard.js';
+import require$$2 from 'react/jsx-runtime';
+import require$$3 from 'react-dom';
+import React__default from 'react';
+import { __require as requireHeadManagerContext_sharedRuntime } from '../shared/lib/head-manager-context.shared-runtime.js';
+import { __require as requireSetAttributesFromProps } from './set-attributes-from-props.js';
+import { __require as requireRequestIdleCallback } from './request-idle-callback.js';
+
+var hasRequiredScript;
+
+function requireScript () {
+	if (hasRequiredScript) return script.exports;
+	hasRequiredScript = 1;
+	(function (module, exports) {
+		'use client';
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    default: function() {
+		        return _default;
+		    },
+		    handleClientScriptLoad: function() {
+		        return handleClientScriptLoad;
+		    },
+		    initScriptLoader: function() {
+		        return initScriptLoader;
+		    }
+		});
+		const _interop_require_default = /*@__PURE__*/ require_interop_require_default();
+		const _interop_require_wildcard = /*@__PURE__*/ require_interop_require_wildcard();
+		const _jsxruntime = require$$2;
+		const _reactdom = /*#__PURE__*/ _interop_require_default._(require$$3);
+		const _react = /*#__PURE__*/ _interop_require_wildcard._(React__default);
+		const _headmanagercontextsharedruntime = requireHeadManagerContext_sharedRuntime();
+		const _setattributesfromprops = requireSetAttributesFromProps();
+		const _requestidlecallback = requireRequestIdleCallback();
+		const ScriptCache = new Map();
+		const LoadCache = new Set();
+		const insertStylesheets = (stylesheets)=>{
+		    // Case 1: Styles for afterInteractive/lazyOnload with appDir injected via handleClientScriptLoad
+		    //
+		    // Using ReactDOM.preinit to feature detect appDir and inject styles
+		    // Stylesheets might have already been loaded if initialized with Script component
+		    // Re-inject styles here to handle scripts loaded via handleClientScriptLoad
+		    // ReactDOM.preinit handles dedup and ensures the styles are loaded only once
+		    if (_reactdom.default.preinit) {
+		        stylesheets.forEach((stylesheet)=>{
+		            _reactdom.default.preinit(stylesheet, {
+		                as: 'style'
+		            });
+		        });
+		        return;
+		    }
+		    // Case 2: Styles for afterInteractive/lazyOnload with pages injected via handleClientScriptLoad
+		    //
+		    // We use this function to load styles when appdir is not detected
+		    // TODO: Use React float APIs to load styles once available for pages dir
+		    if (typeof window !== 'undefined') {
+		        let head = document.head;
+		        stylesheets.forEach((stylesheet)=>{
+		            let link = document.createElement('link');
+		            link.type = 'text/css';
+		            link.rel = 'stylesheet';
+		            link.href = stylesheet;
+		            head.appendChild(link);
+		        });
+		    }
+		};
+		const loadScript = (props)=>{
+		    const { src, id, onLoad = ()=>{}, onReady = null, dangerouslySetInnerHTML, children = '', strategy = 'afterInteractive', onError, stylesheets } = props;
+		    const cacheKey = id || src;
+		    // Script has already loaded
+		    if (cacheKey && LoadCache.has(cacheKey)) {
+		        return;
+		    }
+		    // Contents of this script are already loading/loaded
+		    if (ScriptCache.has(src)) {
+		        LoadCache.add(cacheKey);
+		        // It is possible that multiple `next/script` components all have same "src", but has different "onLoad"
+		        // This is to make sure the same remote script will only load once, but "onLoad" are executed in order
+		        ScriptCache.get(src).then(onLoad, onError);
+		        return;
+		    }
+		    /** Execute after the script first loaded */ const afterLoad = ()=>{
+		        // Run onReady for the first time after load event
+		        if (onReady) {
+		            onReady();
+		        }
+		        // add cacheKey to LoadCache when load successfully
+		        LoadCache.add(cacheKey);
+		    };
+		    const el = document.createElement('script');
+		    const loadPromise = new Promise((resolve, reject)=>{
+		        el.addEventListener('load', function(e) {
+		            resolve();
+		            if (onLoad) {
+		                onLoad.call(this, e);
+		            }
+		            afterLoad();
+		        });
+		        el.addEventListener('error', function(e) {
+		            reject(e);
+		        });
+		    }).catch(function(e) {
+		        if (onError) {
+		            onError(e);
+		        }
+		    });
+		    if (dangerouslySetInnerHTML) {
+		        // Casting since lib.dom.d.ts doesn't have TrustedHTML yet.
+		        el.innerHTML = dangerouslySetInnerHTML.__html || '';
+		        afterLoad();
+		    } else if (children) {
+		        el.textContent = typeof children === 'string' ? children : Array.isArray(children) ? children.join('') : '';
+		        afterLoad();
+		    } else if (src) {
+		        el.src = src;
+		        // do not add cacheKey into LoadCache for remote script here
+		        // cacheKey will be added to LoadCache when it is actually loaded (see loadPromise above)
+		        ScriptCache.set(src, loadPromise);
+		    }
+		    (0, _setattributesfromprops.setAttributesFromProps)(el, props);
+		    if (strategy === 'worker') {
+		        el.setAttribute('type', 'text/partytown');
+		    }
+		    el.setAttribute('data-nscript', strategy);
+		    // Load styles associated with this script
+		    if (stylesheets) {
+		        insertStylesheets(stylesheets);
+		    }
+		    document.body.appendChild(el);
+		};
+		function handleClientScriptLoad(props) {
+		    const { strategy = 'afterInteractive' } = props;
+		    if (strategy === 'lazyOnload') {
+		        window.addEventListener('load', ()=>{
+		            (0, _requestidlecallback.requestIdleCallback)(()=>loadScript(props));
+		        });
+		    } else {
+		        loadScript(props);
+		    }
+		}
+		function loadLazyScript(props) {
+		    if (document.readyState === 'complete') {
+		        (0, _requestidlecallback.requestIdleCallback)(()=>loadScript(props));
+		    } else {
+		        window.addEventListener('load', ()=>{
+		            (0, _requestidlecallback.requestIdleCallback)(()=>loadScript(props));
+		        });
+		    }
+		}
+		function addBeforeInteractiveToCache() {
+		    const scripts = [
+		        ...document.querySelectorAll('[data-nscript="beforeInteractive"]'),
+		        ...document.querySelectorAll('[data-nscript="beforePageRender"]')
+		    ];
+		    scripts.forEach((script)=>{
+		        const cacheKey = script.id || script.getAttribute('src');
+		        LoadCache.add(cacheKey);
+		    });
+		}
+		function initScriptLoader(scriptLoaderItems) {
+		    scriptLoaderItems.forEach(handleClientScriptLoad);
+		    addBeforeInteractiveToCache();
+		}
+		/**
+		 * Load a third-party scripts in an optimized way.
+		 *
+		 * Read more: [Next.js Docs: `next/script`](https://nextjs.org/docs/app/api-reference/components/script)
+		 */ function Script(props) {
+		    const { id, src = '', onLoad = ()=>{}, onReady = null, strategy = 'afterInteractive', onError, stylesheets, ...restProps } = props;
+		    // Context is available only during SSR
+		    let { updateScripts, scripts, getIsSsr, appDir, nonce } = (0, _react.useContext)(_headmanagercontextsharedruntime.HeadManagerContext);
+		    // if a nonce is explicitly passed to the script tag, favor that over the automatic handling
+		    nonce = restProps.nonce || nonce;
+		    /**
+		   * - First mount:
+		   *   1. The useEffect for onReady executes
+		   *   2. hasOnReadyEffectCalled.current is false, but the script hasn't loaded yet (not in LoadCache)
+		   *      onReady is skipped, set hasOnReadyEffectCalled.current to true
+		   *   3. The useEffect for loadScript executes
+		   *   4. hasLoadScriptEffectCalled.current is false, loadScript executes
+		   *      Once the script is loaded, the onLoad and onReady will be called by then
+		   *   [If strict mode is enabled / is wrapped in <OffScreen /> component]
+		   *   5. The useEffect for onReady executes again
+		   *   6. hasOnReadyEffectCalled.current is true, so entire effect is skipped
+		   *   7. The useEffect for loadScript executes again
+		   *   8. hasLoadScriptEffectCalled.current is true, so entire effect is skipped
+		   *
+		   * - Second mount:
+		   *   1. The useEffect for onReady executes
+		   *   2. hasOnReadyEffectCalled.current is false, but the script has already loaded (found in LoadCache)
+		   *      onReady is called, set hasOnReadyEffectCalled.current to true
+		   *   3. The useEffect for loadScript executes
+		   *   4. The script is already loaded, loadScript bails out
+		   *   [If strict mode is enabled / is wrapped in <OffScreen /> component]
+		   *   5. The useEffect for onReady executes again
+		   *   6. hasOnReadyEffectCalled.current is true, so entire effect is skipped
+		   *   7. The useEffect for loadScript executes again
+		   *   8. hasLoadScriptEffectCalled.current is true, so entire effect is skipped
+		   */ const hasOnReadyEffectCalled = (0, _react.useRef)(false);
+		    (0, _react.useEffect)(()=>{
+		        const cacheKey = id || src;
+		        if (!hasOnReadyEffectCalled.current) {
+		            // Run onReady if script has loaded before but component is re-mounted
+		            if (onReady && cacheKey && LoadCache.has(cacheKey)) {
+		                onReady();
+		            }
+		            hasOnReadyEffectCalled.current = true;
+		        }
+		    }, [
+		        onReady,
+		        id,
+		        src
+		    ]);
+		    const hasLoadScriptEffectCalled = (0, _react.useRef)(false);
+		    (0, _react.useEffect)(()=>{
+		        if (!hasLoadScriptEffectCalled.current) {
+		            if (strategy === 'afterInteractive') {
+		                loadScript(props);
+		            } else if (strategy === 'lazyOnload') {
+		                loadLazyScript(props);
+		            }
+		            hasLoadScriptEffectCalled.current = true;
+		        }
+		    }, [
+		        props,
+		        strategy
+		    ]);
+		    if (strategy === 'beforeInteractive' || strategy === 'worker') {
+		        if (updateScripts) {
+		            scripts[strategy] = (scripts[strategy] || []).concat([
+		                {
+		                    id,
+		                    src,
+		                    onLoad,
+		                    onReady,
+		                    onError,
+		                    ...restProps,
+		                    nonce
+		                }
+		            ]);
+		            updateScripts(scripts);
+		        } else if (getIsSsr && getIsSsr()) {
+		            // Script has already loaded during SSR
+		            LoadCache.add(id || src);
+		        } else if (getIsSsr && !getIsSsr()) {
+		            loadScript({
+		                ...props,
+		                nonce
+		            });
+		        }
+		    }
+		    // For the app directory, we need React Float to preload these scripts.
+		    if (appDir) {
+		        // Injecting stylesheets here handles beforeInteractive and worker scripts correctly
+		        // For other strategies injecting here ensures correct stylesheet order
+		        // ReactDOM.preinit handles loading the styles in the correct order,
+		        // also ensures the stylesheet is loaded only once and in a consistent manner
+		        //
+		        // Case 1: Styles for beforeInteractive/worker with appDir - handled here
+		        // Case 2: Styles for beforeInteractive/worker with pages dir - Not handled yet
+		        // Case 3: Styles for afterInteractive/lazyOnload with appDir - handled here
+		        // Case 4: Styles for afterInteractive/lazyOnload with pages dir - handled in insertStylesheets function
+		        if (stylesheets) {
+		            stylesheets.forEach((styleSrc)=>{
+		                _reactdom.default.preinit(styleSrc, {
+		                    as: 'style'
+		                });
+		            });
+		        }
+		        // Before interactive scripts need to be loaded by Next.js' runtime instead
+		        // of native <script> tags, because they no longer have `defer`.
+		        if (strategy === 'beforeInteractive') {
+		            if (!src) {
+		                // For inlined scripts, we put the content in `children`.
+		                if (restProps.dangerouslySetInnerHTML) {
+		                    // Casting since lib.dom.d.ts doesn't have TrustedHTML yet.
+		                    restProps.children = restProps.dangerouslySetInnerHTML.__html;
+		                    delete restProps.dangerouslySetInnerHTML;
+		                }
+		                return /*#__PURE__*/ (0, _jsxruntime.jsx)("script", {
+		                    nonce: nonce,
+		                    dangerouslySetInnerHTML: {
+		                        __html: `(self.__next_s=self.__next_s||[]).push(${JSON.stringify([
+		                            0,
+		                            {
+		                                ...restProps,
+		                                id
+		                            }
+		                        ])})`
+		                    }
+		                });
+		            } else {
+		                // @ts-ignore
+		                _reactdom.default.preload(src, restProps.integrity ? {
+		                    as: 'script',
+		                    integrity: restProps.integrity,
+		                    nonce,
+		                    crossOrigin: restProps.crossOrigin
+		                } : {
+		                    as: 'script',
+		                    nonce,
+		                    crossOrigin: restProps.crossOrigin
+		                });
+		                return /*#__PURE__*/ (0, _jsxruntime.jsx)("script", {
+		                    nonce: nonce,
+		                    dangerouslySetInnerHTML: {
+		                        __html: `(self.__next_s=self.__next_s||[]).push(${JSON.stringify([
+		                            src,
+		                            {
+		                                ...restProps,
+		                                id
+		                            }
+		                        ])})`
+		                    }
+		                });
+		            }
+		        } else if (strategy === 'afterInteractive') {
+		            if (src) {
+		                // @ts-ignore
+		                _reactdom.default.preload(src, restProps.integrity ? {
+		                    as: 'script',
+		                    integrity: restProps.integrity,
+		                    nonce,
+		                    crossOrigin: restProps.crossOrigin
+		                } : {
+		                    as: 'script',
+		                    nonce,
+		                    crossOrigin: restProps.crossOrigin
+		                });
+		            }
+		        }
+		    }
+		    return null;
+		}
+		Object.defineProperty(Script, '__nextScript', {
+		    value: true
+		});
+		const _default = Script;
+
+		if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports.default, '__esModule', { value: true });
+		  Object.assign(exports.default, exports);
+		  module.exports = exports.default;
+		}
+
+		
+	} (script, script.exports));
+	return script.exports;
+}
+
+export { requireScript as __require };

package/dist/node_modules/next/dist/client/set-attributes-from-props.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const setAttributesFromProps = require('../../../../_virtual/set-attributes-from-props.cjs');
+
+var hasRequiredSetAttributesFromProps;
+
+function requireSetAttributesFromProps () {
+	if (hasRequiredSetAttributesFromProps) return setAttributesFromProps.__module.exports;
+	hasRequiredSetAttributesFromProps = 1;
+	(function (module, exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "setAttributesFromProps", {
+		    enumerable: true,
+		    get: function() {
+		        return setAttributesFromProps;
+		    }
+		});
+		const DOMAttributeNames = {
+		    acceptCharset: 'accept-charset',
+		    className: 'class',
+		    htmlFor: 'for',
+		    httpEquiv: 'http-equiv',
+		    noModule: 'noModule'
+		};
+		const ignoreProps = [
+		    'onLoad',
+		    'onReady',
+		    'dangerouslySetInnerHTML',
+		    'children',
+		    'onError',
+		    'strategy',
+		    'stylesheets'
+		];
+		function isBooleanScriptAttribute(attr) {
+		    return [
+		        'async',
+		        'defer',
+		        'noModule'
+		    ].includes(attr);
+		}
+		function setAttributesFromProps(el, props) {
+		    for (const [p, value] of Object.entries(props)){
+		        if (!props.hasOwnProperty(p)) continue;
+		        if (ignoreProps.includes(p)) continue;
+		        // we don't render undefined props to the DOM
+		        if (value === undefined) {
+		            continue;
+		        }
+		        const attr = DOMAttributeNames[p] || p.toLowerCase();
+		        if (el.tagName === 'SCRIPT' && isBooleanScriptAttribute(attr)) {
+		            el[attr] = !!value;
+		        } else {
+		            el.setAttribute(attr, String(value));
+		        }
+		        // Remove falsy non-zero boolean attributes so they are correctly interpreted
+		        // (e.g. if we set them to false, this coerces to the string "false", which the browser interprets as true)
+		        if (value === false || el.tagName === 'SCRIPT' && isBooleanScriptAttribute(attr) && (!value || value === 'false')) {
+		            // Call setAttribute before, as we need to set and unset the attribute to override force async:
+		            // https://html.spec.whatwg.org/multipage/scripting.html#script-force-async
+		            el.setAttribute(attr, '');
+		            el.removeAttribute(attr);
+		        }
+		    }
+		}
+
+		if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports.default, '__esModule', { value: true });
+		  Object.assign(exports.default, exports);
+		  module.exports = exports.default;
+		}
+
+		
+	} (setAttributesFromProps.__module, setAttributesFromProps.__module.exports));
+	return setAttributesFromProps.__module.exports;
+}
+
+exports.__require = requireSetAttributesFromProps;

package/dist/node_modules/next/dist/client/set-attributes-from-props.js

@@ -0,0 +1,77 @@
+import { __module as setAttributesFromProps } from '../../../../_virtual/set-attributes-from-props.js';
+
+var hasRequiredSetAttributesFromProps;
+
+function requireSetAttributesFromProps () {
+	if (hasRequiredSetAttributesFromProps) return setAttributesFromProps.exports;
+	hasRequiredSetAttributesFromProps = 1;
+	(function (module, exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "setAttributesFromProps", {
+		    enumerable: true,
+		    get: function() {
+		        return setAttributesFromProps;
+		    }
+		});
+		const DOMAttributeNames = {
+		    acceptCharset: 'accept-charset',
+		    className: 'class',
+		    htmlFor: 'for',
+		    httpEquiv: 'http-equiv',
+		    noModule: 'noModule'
+		};
+		const ignoreProps = [
+		    'onLoad',
+		    'onReady',
+		    'dangerouslySetInnerHTML',
+		    'children',
+		    'onError',
+		    'strategy',
+		    'stylesheets'
+		];
+		function isBooleanScriptAttribute(attr) {
+		    return [
+		        'async',
+		        'defer',
+		        'noModule'
+		    ].includes(attr);
+		}
+		function setAttributesFromProps(el, props) {
+		    for (const [p, value] of Object.entries(props)){
+		        if (!props.hasOwnProperty(p)) continue;
+		        if (ignoreProps.includes(p)) continue;
+		        // we don't render undefined props to the DOM
+		        if (value === undefined) {
+		            continue;
+		        }
+		        const attr = DOMAttributeNames[p] || p.toLowerCase();
+		        if (el.tagName === 'SCRIPT' && isBooleanScriptAttribute(attr)) {
+		            el[attr] = !!value;
+		        } else {
+		            el.setAttribute(attr, String(value));
+		        }
+		        // Remove falsy non-zero boolean attributes so they are correctly interpreted
+		        // (e.g. if we set them to false, this coerces to the string "false", which the browser interprets as true)
+		        if (value === false || el.tagName === 'SCRIPT' && isBooleanScriptAttribute(attr) && (!value || value === 'false')) {
+		            // Call setAttribute before, as we need to set and unset the attribute to override force async:
+		            // https://html.spec.whatwg.org/multipage/scripting.html#script-force-async
+		            el.setAttribute(attr, '');
+		            el.removeAttribute(attr);
+		        }
+		    }
+		}
+
+		if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports.default, '__esModule', { value: true });
+		  Object.assign(exports.default, exports);
+		  module.exports = exports.default;
+		}
+
+		
+	} (setAttributesFromProps, setAttributesFromProps.exports));
+	return setAttributesFromProps.exports;
+}
+
+export { requireSetAttributesFromProps as __require };

package/dist/node_modules/next/dist/client/trusted-types.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const trustedTypes = require('../../../../_virtual/trusted-types.cjs');
+
+/**
+ * Stores the Trusted Types Policy. Starts as undefined and can be set to null
+ * if Trusted Types is not supported in the browser.
+ */
+
+var hasRequiredTrustedTypes;
+
+function requireTrustedTypes () {
+	if (hasRequiredTrustedTypes) return trustedTypes.__module.exports;
+	hasRequiredTrustedTypes = 1;
+	(function (module, exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "__unsafeCreateTrustedScriptURL", {
+		    enumerable: true,
+		    get: function() {
+		        return __unsafeCreateTrustedScriptURL;
+		    }
+		});
+		let policy;
+		/**
+		 * Getter for the Trusted Types Policy. If it is undefined, it is instantiated
+		 * here or set to null if Trusted Types is not supported in the browser.
+		 */ function getPolicy() {
+		    if (typeof policy === 'undefined' && typeof window !== 'undefined') {
+		        policy = window.trustedTypes?.createPolicy('nextjs', {
+		            createHTML: (input)=>input,
+		            createScript: (input)=>input,
+		            createScriptURL: (input)=>input
+		        }) || null;
+		    }
+		    return policy;
+		}
+		function __unsafeCreateTrustedScriptURL(url) {
+		    return getPolicy()?.createScriptURL(url) || url;
+		}
+
+		if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports.default, '__esModule', { value: true });
+		  Object.assign(exports.default, exports);
+		  module.exports = exports.default;
+		}
+
+		
+	} (trustedTypes.__module, trustedTypes.__module.exports));
+	return trustedTypes.__module.exports;
+}
+
+exports.__require = requireTrustedTypes;

package/dist/node_modules/next/dist/client/trusted-types.js

@@ -0,0 +1,52 @@
+import { __module as trustedTypes } from '../../../../_virtual/trusted-types.js';
+
+/**
+ * Stores the Trusted Types Policy. Starts as undefined and can be set to null
+ * if Trusted Types is not supported in the browser.
+ */
+
+var hasRequiredTrustedTypes;
+
+function requireTrustedTypes () {
+	if (hasRequiredTrustedTypes) return trustedTypes.exports;
+	hasRequiredTrustedTypes = 1;
+	(function (module, exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "__unsafeCreateTrustedScriptURL", {
+		    enumerable: true,
+		    get: function() {
+		        return __unsafeCreateTrustedScriptURL;
+		    }
+		});
+		let policy;
+		/**
+		 * Getter for the Trusted Types Policy. If it is undefined, it is instantiated
+		 * here or set to null if Trusted Types is not supported in the browser.
+		 */ function getPolicy() {
+		    if (typeof policy === 'undefined' && typeof window !== 'undefined') {
+		        policy = window.trustedTypes?.createPolicy('nextjs', {
+		            createHTML: (input)=>input,
+		            createScript: (input)=>input,
+		            createScriptURL: (input)=>input
+		        }) || null;
+		    }
+		    return policy;
+		}
+		function __unsafeCreateTrustedScriptURL(url) {
+		    return getPolicy()?.createScriptURL(url) || url;
+		}
+
+		if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports.default, '__esModule', { value: true });
+		  Object.assign(exports.default, exports);
+		  module.exports = exports.default;
+		}
+
+		
+	} (trustedTypes, trustedTypes.exports));
+	return trustedTypes.exports;
+}
+
+export { requireTrustedTypes as __require };

package/dist/node_modules/next/dist/client/with-router.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const withRouter = require('../../../../_virtual/with-router.cjs');
+const require$$2 = require('react/jsx-runtime');
+require('react');
+const router = require('./router.cjs');
+
+var hasRequiredWithRouter;
+
+function requireWithRouter () {
+	if (hasRequiredWithRouter) return withRouter.__module.exports;
+	hasRequiredWithRouter = 1;
+	(function (module, exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "default", {
+		    enumerable: true,
+		    get: function() {
+		        return withRouter;
+		    }
+		});
+		const _jsxruntime = require$$2;
+		const _router = router.__require();
+		function withRouter(ComposedComponent) {
+		    function WithRouterWrapper(props) {
+		        return /*#__PURE__*/ (0, _jsxruntime.jsx)(ComposedComponent, {
+		            router: (0, _router.useRouter)(),
+		            ...props
+		        });
+		    }
+		    WithRouterWrapper.getInitialProps = ComposedComponent.getInitialProps;
+		    WithRouterWrapper.origGetInitialProps = ComposedComponent.origGetInitialProps;
+		    if (process.env.NODE_ENV !== 'production') {
+		        const name = ComposedComponent.displayName || ComposedComponent.name || 'Unknown';
+		        WithRouterWrapper.displayName = `withRouter(${name})`;
+		    }
+		    return WithRouterWrapper;
+		}
+
+		if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports.default, '__esModule', { value: true });
+		  Object.assign(exports.default, exports);
+		  module.exports = exports.default;
+		}
+
+		
+	} (withRouter.__module, withRouter.__module.exports));
+	return withRouter.__module.exports;
+}
+
+exports.__require = requireWithRouter;