@amoa/casting 0.1.3 → 0.1.4

package/dist/node_modules/next/dist/client/components/unstable-rethrow.server.js

@@ -0,0 +1,50 @@
+import { __module as unstableRethrow_server } from '../../../../../_virtual/unstable-rethrow.server.js';
+import { __require as requireDynamicRenderingUtils } from '../../server/dynamic-rendering-utils.js';
+import { __require as requireIsPostpone } from '../../server/lib/router-utils/is-postpone.js';
+import { __require as requireBailoutToCsr } from '../../shared/lib/lazy-dynamic/bailout-to-csr.js';
+import { __require as requireIsNextRouterError } from './is-next-router-error.js';
+import { __require as requireDynamicRendering } from '../../server/app-render/dynamic-rendering.js';
+import { __require as requireHooksServerContext } from './hooks-server-context.js';
+
+var hasRequiredUnstableRethrow_server;
+
+function requireUnstableRethrow_server () {
+	if (hasRequiredUnstableRethrow_server) return unstableRethrow_server.exports;
+	hasRequiredUnstableRethrow_server = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		Object.defineProperty(exports$1, "unstable_rethrow", {
+		  enumerable: true,
+		  get: function () {
+		    return unstable_rethrow;
+		  }
+		});
+		const _dynamicrenderingutils = requireDynamicRenderingUtils();
+		const _ispostpone = requireIsPostpone();
+		const _bailouttocsr = requireBailoutToCsr();
+		const _isnextroutererror = requireIsNextRouterError();
+		const _dynamicrendering = requireDynamicRendering();
+		const _hooksservercontext = requireHooksServerContext();
+		function unstable_rethrow(error) {
+		  if ((0, _isnextroutererror.isNextRouterError)(error) || (0, _bailouttocsr.isBailoutToCSRError)(error) || (0, _hooksservercontext.isDynamicServerError)(error) || (0, _dynamicrendering.isDynamicPostpone)(error) || (0, _ispostpone.isPostpone)(error) || (0, _dynamicrenderingutils.isHangingPromiseRejectionError)(error) || (0, _dynamicrendering.isPrerenderInterruptedError)(error)) {
+		    throw error;
+		  }
+		  if (error instanceof Error && 'cause' in error) {
+		    unstable_rethrow(error.cause);
+		  }
+		}
+		if ((typeof exports$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (unstableRethrow_server, unstableRethrow_server.exports));
+	return unstableRethrow_server.exports;
+}
+
+export { requireUnstableRethrow_server as __require };

package/dist/node_modules/next/dist/client/detect-domain-locale.js

@@ -0,0 +1,36 @@
+import { __module as detectDomainLocale } from '../../../../_virtual/detect-domain-locale.js';
+import { __require as requireDetectDomainLocale$1 } from '../shared/lib/i18n/detect-domain-locale.js';
+
+var hasRequiredDetectDomainLocale;
+
+function requireDetectDomainLocale () {
+	if (hasRequiredDetectDomainLocale) return detectDomainLocale.exports;
+	hasRequiredDetectDomainLocale = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		Object.defineProperty(exports$1, "detectDomainLocale", {
+		  enumerable: true,
+		  get: function () {
+		    return detectDomainLocale;
+		  }
+		});
+		const detectDomainLocale = (...args) => {
+		  if (process.env.__NEXT_I18N_SUPPORT) {
+		    return requireDetectDomainLocale$1().detectDomainLocale(...args);
+		  }
+		};
+		if ((typeof exports$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (detectDomainLocale, detectDomainLocale.exports));
+	return detectDomainLocale.exports;
+}
+
+export { requireDetectDomainLocale as __require };

package/dist/node_modules/next/dist/client/get-domain-locale.js

@@ -0,0 +1,51 @@
+import { __module as getDomainLocale } from '../../../../_virtual/get-domain-locale.js';
+import { __require as requireNormalizeTrailingSlash } from './normalize-trailing-slash.js';
+import { __require as requireNormalizeLocalePath } from './normalize-locale-path.js';
+import { __require as requireDetectDomainLocale } from './detect-domain-locale.js';
+
+var hasRequiredGetDomainLocale;
+
+function requireGetDomainLocale () {
+	if (hasRequiredGetDomainLocale) return getDomainLocale.exports;
+	hasRequiredGetDomainLocale = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		Object.defineProperty(exports$1, "getDomainLocale", {
+		  enumerable: true,
+		  get: function () {
+		    return getDomainLocale;
+		  }
+		});
+		const _normalizetrailingslash = requireNormalizeTrailingSlash();
+		const basePath = process.env.__NEXT_ROUTER_BASEPATH || '';
+		function getDomainLocale(path, locale, locales, domainLocales) {
+		  if (process.env.__NEXT_I18N_SUPPORT) {
+		    const normalizeLocalePath = requireNormalizeLocalePath().normalizeLocalePath;
+		    const detectDomainLocale = requireDetectDomainLocale().detectDomainLocale;
+		    const target = locale || normalizeLocalePath(path, locales).detectedLocale;
+		    const domain = detectDomainLocale(domainLocales, undefined, target);
+		    if (domain) {
+		      const proto = `http${domain.http ? '' : 's'}://`;
+		      const finalLocale = target === domain.defaultLocale ? '' : `/${target}`;
+		      return `${proto}${domain.domain}${(0, _normalizetrailingslash.normalizePathTrailingSlash)(`${basePath}${finalLocale}${path}`)}`;
+		    }
+		    return false;
+		  } else {
+		    return false;
+		  }
+		}
+		if ((typeof exports$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (getDomainLocale, getDomainLocale.exports));
+	return getDomainLocale.exports;
+}
+
+export { requireGetDomainLocale as __require };

package/dist/node_modules/next/dist/client/has-base-path.js

@@ -0,0 +1,36 @@
+import { __module as hasBasePath } from '../../../../_virtual/has-base-path.js';
+import { __require as requirePathHasPrefix } from '../shared/lib/router/utils/path-has-prefix.js';
+
+var hasRequiredHasBasePath;
+
+function requireHasBasePath () {
+	if (hasRequiredHasBasePath) return hasBasePath.exports;
+	hasRequiredHasBasePath = 1;
+	(function (module, exports$1) {
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		Object.defineProperty(exports$1, "hasBasePath", {
+		  enumerable: true,
+		  get: function () {
+		    return hasBasePath;
+		  }
+		});
+		const _pathhasprefix = requirePathHasPrefix();
+		const basePath = process.env.__NEXT_ROUTER_BASEPATH || '';
+		function hasBasePath(path) {
+		  return (0, _pathhasprefix.pathHasPrefix)(path, basePath);
+		}
+		if ((typeof exports$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (hasBasePath, hasBasePath.exports));
+	return hasBasePath.exports;
+}
+
+export { requireHasBasePath as __require };

package/dist/node_modules/next/dist/client/image-component.js

@@ -0,0 +1,343 @@
+import { __module as imageComponent } from '../../../../_virtual/image-component.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 as requireJsxRuntime } from '../../../react/jsx-runtime.js';
+import React__default from 'react';
+import ReactDOM__default from 'react-dom';
+import { __require as requireHead } from '../shared/lib/head.js';
+import { __require as requireGetImgProps } from '../shared/lib/get-img-props.js';
+import { __require as requireImageConfig } from '../shared/lib/image-config.js';
+import { __require as requireImageConfigContext_sharedRuntime } from '../shared/lib/image-config-context.shared-runtime.js';
+import { __require as requireWarnOnce } from '../shared/lib/utils/warn-once.js';
+import { __require as requireRouterContext_sharedRuntime } from '../shared/lib/router-context.shared-runtime.js';
+import { __require as requireImageLoader } from '../shared/lib/image-loader.js';
+import { __require as requireUseMergedRef } from './use-merged-ref.js';
+
+var hasRequiredImageComponent;
+
+function requireImageComponent () {
+	if (hasRequiredImageComponent) return imageComponent.exports;
+	hasRequiredImageComponent = 1;
+	(function (module, exports$1) {
+		'use client';
+
+		Object.defineProperty(exports$1, "__esModule", {
+		  value: true
+		});
+		Object.defineProperty(exports$1, "Image", {
+		  enumerable: true,
+		  get: function () {
+		    return Image;
+		  }
+		});
+		const _interop_require_default = /*@__PURE__*/ require_interop_require_default();
+		const _interop_require_wildcard = /*@__PURE__*/ require_interop_require_wildcard();
+		const _jsxruntime = requireJsxRuntime();
+		const _react = /*#__PURE__*/_interop_require_wildcard._(React__default);
+		const _reactdom = /*#__PURE__*/_interop_require_default._(ReactDOM__default);
+		const _head = /*#__PURE__*/_interop_require_default._(requireHead());
+		const _getimgprops = requireGetImgProps();
+		const _imageconfig = requireImageConfig();
+		const _imageconfigcontextsharedruntime = requireImageConfigContext_sharedRuntime();
+		const _warnonce = requireWarnOnce();
+		const _routercontextsharedruntime = requireRouterContext_sharedRuntime();
+		const _imageloader = /*#__PURE__*/_interop_require_default._(requireImageLoader());
+		const _usemergedref = requireUseMergedRef();
+		// This is replaced by webpack define plugin
+		const configEnv = process.env.__NEXT_IMAGE_OPTS;
+		if (typeof window === 'undefined') {
+		  globalThis.__NEXT_IMAGE_IMPORTED = true;
+		}
+		// See https://stackoverflow.com/q/39777833/266535 for why we use this ref
+		// handler instead of the img's onLoad attribute.
+		function handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete, unoptimized, sizesInput) {
+		  const src = img?.src;
+		  if (!img || img['data-loaded-src'] === src) {
+		    return;
+		  }
+		  img['data-loaded-src'] = src;
+		  const p = 'decode' in img ? img.decode() : Promise.resolve();
+		  p.catch(() => {}).then(() => {
+		    if (!img.parentElement || !img.isConnected) {
+		      // Exit early in case of race condition:
+		      // - onload() is called
+		      // - decode() is called but incomplete
+		      // - unmount is called
+		      // - decode() completes
+		      return;
+		    }
+		    if (placeholder !== 'empty') {
+		      setBlurComplete(true);
+		    }
+		    if (onLoadRef?.current) {
+		      // Since we don't have the SyntheticEvent here,
+		      // we must create one with the same shape.
+		      // See https://reactjs.org/docs/events.html
+		      const event = new Event('load');
+		      Object.defineProperty(event, 'target', {
+		        writable: false,
+		        value: img
+		      });
+		      let prevented = false;
+		      let stopped = false;
+		      onLoadRef.current({
+		        ...event,
+		        nativeEvent: event,
+		        currentTarget: img,
+		        target: img,
+		        isDefaultPrevented: () => prevented,
+		        isPropagationStopped: () => stopped,
+		        persist: () => {},
+		        preventDefault: () => {
+		          prevented = true;
+		          event.preventDefault();
+		        },
+		        stopPropagation: () => {
+		          stopped = true;
+		          event.stopPropagation();
+		        }
+		      });
+		    }
+		    if (onLoadingCompleteRef?.current) {
+		      onLoadingCompleteRef.current(img);
+		    }
+		    if (process.env.NODE_ENV !== 'production') {
+		      const origSrc = new URL(src, 'http://n').searchParams.get('url') || src;
+		      if (img.getAttribute('data-nimg') === 'fill') {
+		        if (!unoptimized && (!sizesInput || sizesInput === '100vw')) {
+		          let widthViewportRatio = img.getBoundingClientRect().width / window.innerWidth;
+		          if (widthViewportRatio < 0.6) {
+		            if (sizesInput === '100vw') {
+		              (0, _warnonce.warnOnce)(`Image with src "${origSrc}" has "fill" prop and "sizes" prop of "100vw", but image is not rendered at full viewport width. Please adjust "sizes" to improve page performance. Read more: https://nextjs.org/docs/api-reference/next/image#sizes`);
+		            } else {
+		              (0, _warnonce.warnOnce)(`Image with src "${origSrc}" has "fill" but is missing "sizes" prop. Please add it to improve page performance. Read more: https://nextjs.org/docs/api-reference/next/image#sizes`);
+		            }
+		          }
+		        }
+		        if (img.parentElement) {
+		          const {
+		            position
+		          } = window.getComputedStyle(img.parentElement);
+		          const valid = ['absolute', 'fixed', 'relative'];
+		          if (!valid.includes(position)) {
+		            (0, _warnonce.warnOnce)(`Image with src "${origSrc}" has "fill" and parent element with invalid "position". Provided "${position}" should be one of ${valid.map(String).join(',')}.`);
+		          }
+		        }
+		        if (img.height === 0) {
+		          (0, _warnonce.warnOnce)(`Image with src "${origSrc}" has "fill" and a height value of 0. This is likely because the parent element of the image has not been styled to have a set height.`);
+		        }
+		      }
+		      const heightModified = img.height.toString() !== img.getAttribute('height');
+		      const widthModified = img.width.toString() !== img.getAttribute('width');
+		      if (heightModified && !widthModified || !heightModified && widthModified) {
+		        (0, _warnonce.warnOnce)(`Image with src "${origSrc}" has either width or height modified, but not the other. If you use CSS to change the size of your image, also include the styles 'width: "auto"' or 'height: "auto"' to maintain the aspect ratio.`);
+		      }
+		    }
+		  });
+		}
+		function getDynamicProps(fetchPriority) {
+		  if (Boolean(_react.use)) {
+		    // In React 19.0.0 or newer, we must use camelCase
+		    // prop to avoid "Warning: Invalid DOM property".
+		    // See https://github.com/facebook/react/pull/25927
+		    return {
+		      fetchPriority
+		    };
+		  }
+		  // In React 18.2.0 or older, we must use lowercase prop
+		  // to avoid "Warning: Invalid DOM property".
+		  return {
+		    fetchpriority: fetchPriority
+		  };
+		}
+		const ImageElement = /*#__PURE__*/(0, _react.forwardRef)(({
+		  src,
+		  srcSet,
+		  sizes,
+		  height,
+		  width,
+		  decoding,
+		  className,
+		  style,
+		  fetchPriority,
+		  placeholder,
+		  loading,
+		  unoptimized,
+		  fill,
+		  onLoadRef,
+		  onLoadingCompleteRef,
+		  setBlurComplete,
+		  setShowAltText,
+		  sizesInput,
+		  onLoad,
+		  onError,
+		  ...rest
+		}, forwardedRef) => {
+		  const ownRef = (0, _react.useCallback)(img => {
+		    if (!img) {
+		      return;
+		    }
+		    if (onError) {
+		      // If the image has an error before react hydrates, then the error is lost.
+		      // The workaround is to wait until the image is mounted which is after hydration,
+		      // then we set the src again to trigger the error handler (if there was an error).
+		      // eslint-disable-next-line no-self-assign
+		      img.src = img.src;
+		    }
+		    if (process.env.NODE_ENV !== 'production') {
+		      if (!src) {
+		        console.error(`Image is missing required "src" property:`, img);
+		      }
+		      if (img.getAttribute('alt') === null) {
+		        console.error(`Image is missing required "alt" property. Please add Alternative Text to describe the image for screen readers and search engines.`);
+		      }
+		    }
+		    if (img.complete) {
+		      handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete, unoptimized, sizesInput);
+		    }
+		  }, [src, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete, onError, unoptimized, sizesInput]);
+		  const ref = (0, _usemergedref.useMergedRef)(forwardedRef, ownRef);
+		  return /*#__PURE__*/(0, _jsxruntime.jsx)("img", {
+		    ...rest,
+		    ...getDynamicProps(fetchPriority),
+		    // It's intended to keep `loading` before `src` because React updates
+		    // props in order which causes Safari/Firefox to not lazy load properly.
+		    // See https://github.com/facebook/react/issues/25883
+		    loading: loading,
+		    width: width,
+		    height: height,
+		    decoding: decoding,
+		    "data-nimg": fill ? 'fill' : '1',
+		    className: className,
+		    style: style,
+		    // It's intended to keep `src` the last attribute because React updates
+		    // attributes in order. If we keep `src` the first one, Safari will
+		    // immediately start to fetch `src`, before `sizes` and `srcSet` are even
+		    // updated by React. That causes multiple unnecessary requests if `srcSet`
+		    // and `sizes` are defined.
+		    // This bug cannot be reproduced in Chrome or Firefox.
+		    sizes: sizes,
+		    srcSet: srcSet,
+		    src: src,
+		    ref: ref,
+		    onLoad: event => {
+		      const img = event.currentTarget;
+		      handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete, unoptimized, sizesInput);
+		    },
+		    onError: event => {
+		      // if the real image fails to load, this will ensure "alt" is visible
+		      setShowAltText(true);
+		      if (placeholder !== 'empty') {
+		        // If the real image fails to load, this will still remove the placeholder.
+		        setBlurComplete(true);
+		      }
+		      if (onError) {
+		        onError(event);
+		      }
+		    }
+		  });
+		});
+		function ImagePreload({
+		  isAppRouter,
+		  imgAttributes
+		}) {
+		  const opts = {
+		    as: 'image',
+		    imageSrcSet: imgAttributes.srcSet,
+		    imageSizes: imgAttributes.sizes,
+		    crossOrigin: imgAttributes.crossOrigin,
+		    referrerPolicy: imgAttributes.referrerPolicy,
+		    ...getDynamicProps(imgAttributes.fetchPriority)
+		  };
+		  if (isAppRouter && _reactdom.default.preload) {
+		    _reactdom.default.preload(imgAttributes.src, opts);
+		    return null;
+		  }
+		  return /*#__PURE__*/(0, _jsxruntime.jsx)(_head.default, {
+		    children: /*#__PURE__*/(0, _jsxruntime.jsx)("link", {
+		      rel: "preload",
+		      // Note how we omit the `href` attribute, as it would only be relevant
+		      // for browsers that do not support `imagesrcset`, and in those cases
+		      // it would cause the incorrect image to be preloaded.
+		      //
+		      // https://html.spec.whatwg.org/multipage/semantics.html#attr-link-imagesrcset
+		      href: imgAttributes.srcSet ? undefined : imgAttributes.src,
+		      ...opts
+		    }, '__nimg-' + imgAttributes.src + imgAttributes.srcSet + imgAttributes.sizes)
+		  });
+		}
+		const Image = /*#__PURE__*/(0, _react.forwardRef)((props, forwardedRef) => {
+		  const pagesRouter = (0, _react.useContext)(_routercontextsharedruntime.RouterContext);
+		  // We're in the app directory if there is no pages router.
+		  const isAppRouter = !pagesRouter;
+		  const configContext = (0, _react.useContext)(_imageconfigcontextsharedruntime.ImageConfigContext);
+		  const config = (0, _react.useMemo)(() => {
+		    const c = configEnv || configContext || _imageconfig.imageConfigDefault;
+		    const allSizes = [...c.deviceSizes, ...c.imageSizes].sort((a, b) => a - b);
+		    const deviceSizes = c.deviceSizes.sort((a, b) => a - b);
+		    const qualities = c.qualities?.sort((a, b) => a - b);
+		    return {
+		      ...c,
+		      allSizes,
+		      deviceSizes,
+		      qualities,
+		      // During the SSR, configEnv (__NEXT_IMAGE_OPTS) does not include
+		      // security sensitive configs like `localPatterns`, which is needed
+		      // during the server render to ensure it's validated. Therefore use
+		      // configContext, which holds the config from the server for validation.
+		      localPatterns: typeof window === 'undefined' ? configContext?.localPatterns : c.localPatterns
+		    };
+		  }, [configContext]);
+		  const {
+		    onLoad,
+		    onLoadingComplete
+		  } = props;
+		  const onLoadRef = (0, _react.useRef)(onLoad);
+		  (0, _react.useEffect)(() => {
+		    onLoadRef.current = onLoad;
+		  }, [onLoad]);
+		  const onLoadingCompleteRef = (0, _react.useRef)(onLoadingComplete);
+		  (0, _react.useEffect)(() => {
+		    onLoadingCompleteRef.current = onLoadingComplete;
+		  }, [onLoadingComplete]);
+		  const [blurComplete, setBlurComplete] = (0, _react.useState)(false);
+		  const [showAltText, setShowAltText] = (0, _react.useState)(false);
+		  const {
+		    props: imgAttributes,
+		    meta: imgMeta
+		  } = (0, _getimgprops.getImgProps)(props, {
+		    defaultLoader: _imageloader.default,
+		    imgConf: config,
+		    blurComplete,
+		    showAltText
+		  });
+		  return /*#__PURE__*/(0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+		    children: [/*#__PURE__*/(0, _jsxruntime.jsx)(ImageElement, {
+		      ...imgAttributes,
+		      unoptimized: imgMeta.unoptimized,
+		      placeholder: imgMeta.placeholder,
+		      fill: imgMeta.fill,
+		      onLoadRef: onLoadRef,
+		      onLoadingCompleteRef: onLoadingCompleteRef,
+		      setBlurComplete: setBlurComplete,
+		      setShowAltText: setShowAltText,
+		      sizesInput: props.sizes,
+		      ref: forwardedRef
+		    }), imgMeta.preload ? /*#__PURE__*/(0, _jsxruntime.jsx)(ImagePreload, {
+		      isAppRouter: isAppRouter,
+		      imgAttributes: imgAttributes
+		    }) : null]
+		  });
+		});
+		if ((typeof exports$1.default === 'function' || typeof exports$1.default === 'object' && exports$1.default !== null) && typeof exports$1.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports$1.default, '__esModule', {
+		    value: true
+		  });
+		  Object.assign(exports$1.default, exports$1);
+		  module.exports = exports$1.default;
+		} 
+	} (imageComponent, imageComponent.exports));
+	return imageComponent.exports;
+}
+
+export { requireImageComponent as __require };