@amoa/casting 0.1.5 → 0.1.6

package/dist/node_modules/next/dist/shared/lib/router/utils/parse-path.js

@@ -1,46 +0,0 @@
-import { __exports as parsePath } from '../../../../../../../_virtual/parse-path.js';
-
-/**
- * Given a path this function will find the pathname, query and hash and return
- * them. This is useful to parse full paths on the client side.
- * @param path A path to parse e.g. /foo/bar?id=1#hash
- */
-
-var hasRequiredParsePath;
-
-function requireParsePath () {
-	if (hasRequiredParsePath) return parsePath;
-	hasRequiredParsePath = 1;
-	(function (exports$1) {
-
-		Object.defineProperty(exports$1, "__esModule", {
-		  value: true
-		});
-		Object.defineProperty(exports$1, "parsePath", {
-		  enumerable: true,
-		  get: function () {
-		    return parsePath;
-		  }
-		});
-		function parsePath(path) {
-		  const hashIndex = path.indexOf('#');
-		  const queryIndex = path.indexOf('?');
-		  const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
-		  if (hasQuery || hashIndex > -1) {
-		    return {
-		      pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
-		      query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : undefined) : '',
-		      hash: hashIndex > -1 ? path.slice(hashIndex) : ''
-		    };
-		  }
-		  return {
-		    pathname: path,
-		    query: '',
-		    hash: ''
-		  };
-		} 
-	} (parsePath));
-	return parsePath;
-}
-
-export { requireParsePath as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/path-has-prefix.js

@@ -1,34 +0,0 @@
-import { __exports as pathHasPrefix } from '../../../../../../../_virtual/path-has-prefix.js';
-import { __require as requireParsePath } from './parse-path.js';
-
-var hasRequiredPathHasPrefix;
-
-function requirePathHasPrefix () {
-	if (hasRequiredPathHasPrefix) return pathHasPrefix;
-	hasRequiredPathHasPrefix = 1;
-	(function (exports$1) {
-
-		Object.defineProperty(exports$1, "__esModule", {
-		  value: true
-		});
-		Object.defineProperty(exports$1, "pathHasPrefix", {
-		  enumerable: true,
-		  get: function () {
-		    return pathHasPrefix;
-		  }
-		});
-		const _parsepath = requireParsePath();
-		function pathHasPrefix(path, prefix) {
-		  if (typeof path !== 'string') {
-		    return false;
-		  }
-		  const {
-		    pathname
-		  } = (0, _parsepath.parsePath)(path);
-		  return pathname === prefix || pathname.startsWith(prefix + '/');
-		} 
-	} (pathHasPrefix));
-	return pathHasPrefix;
-}
-
-export { requirePathHasPrefix as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/querystring.js

@@ -1,82 +0,0 @@
-import { __exports as querystring } from '../../../../../../../_virtual/querystring.js';
-
-var hasRequiredQuerystring;
-
-function requireQuerystring () {
-	if (hasRequiredQuerystring) return querystring;
-	hasRequiredQuerystring = 1;
-	(function (exports$1) {
-
-		Object.defineProperty(exports$1, "__esModule", {
-		  value: true
-		});
-		function _export(target, all) {
-		  for (var name in all) Object.defineProperty(target, name, {
-		    enumerable: true,
-		    get: all[name]
-		  });
-		}
-		_export(exports$1, {
-		  assign: function () {
-		    return assign;
-		  },
-		  searchParamsToUrlQuery: function () {
-		    return searchParamsToUrlQuery;
-		  },
-		  urlQueryToSearchParams: function () {
-		    return urlQueryToSearchParams;
-		  }
-		});
-		function searchParamsToUrlQuery(searchParams) {
-		  const query = {};
-		  for (const [key, value] of searchParams.entries()) {
-		    const existing = query[key];
-		    if (typeof existing === 'undefined') {
-		      query[key] = value;
-		    } else if (Array.isArray(existing)) {
-		      existing.push(value);
-		    } else {
-		      query[key] = [existing, value];
-		    }
-		  }
-		  return query;
-		}
-		function stringifyUrlQueryParam(param) {
-		  if (typeof param === 'string') {
-		    return param;
-		  }
-		  if (typeof param === 'number' && !isNaN(param) || typeof param === 'boolean') {
-		    return String(param);
-		  } else {
-		    return '';
-		  }
-		}
-		function urlQueryToSearchParams(query) {
-		  const searchParams = new URLSearchParams();
-		  for (const [key, value] of Object.entries(query)) {
-		    if (Array.isArray(value)) {
-		      for (const item of value) {
-		        searchParams.append(key, stringifyUrlQueryParam(item));
-		      }
-		    } else {
-		      searchParams.set(key, stringifyUrlQueryParam(value));
-		    }
-		  }
-		  return searchParams;
-		}
-		function assign(target, ...searchParamsList) {
-		  for (const searchParams of searchParamsList) {
-		    for (const key of searchParams.keys()) {
-		      target.delete(key);
-		    }
-		    for (const [key, value] of searchParams.entries()) {
-		      target.append(key, value);
-		    }
-		  }
-		  return target;
-		} 
-	} (querystring));
-	return querystring;
-}
-
-export { requireQuerystring as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js

@@ -1,34 +0,0 @@
-import { __exports as removeTrailingSlash } from '../../../../../../../_virtual/remove-trailing-slash.js';
-
-/**
- * Removes the trailing slash for a given route or page path. Preserves the
- * root page. Examples:
- *   - `/foo/bar/` -> `/foo/bar`
- *   - `/foo/bar` -> `/foo/bar`
- *   - `/` -> `/`
- */
-
-var hasRequiredRemoveTrailingSlash;
-
-function requireRemoveTrailingSlash () {
-	if (hasRequiredRemoveTrailingSlash) return removeTrailingSlash;
-	hasRequiredRemoveTrailingSlash = 1;
-	(function (exports$1) {
-
-		Object.defineProperty(exports$1, "__esModule", {
-		  value: true
-		});
-		Object.defineProperty(exports$1, "removeTrailingSlash", {
-		  enumerable: true,
-		  get: function () {
-		    return removeTrailingSlash;
-		  }
-		});
-		function removeTrailingSlash(route) {
-		  return route.replace(/\/$/, '') || '/';
-		} 
-	} (removeTrailingSlash));
-	return removeTrailingSlash;
-}
-
-export { requireRemoveTrailingSlash as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/resolve-param-value.js

@@ -1,128 +0,0 @@
-import { __exports as resolveParamValue } from '../../../../../../../_virtual/resolve-param-value.js';
-import { __require as requireInvariantError } from '../../invariant-error.js';
-import { __require as requireInterceptionPrefixFromParamType } from './interception-prefix-from-param-type.js';
-
-var hasRequiredResolveParamValue;
-
-function requireResolveParamValue () {
-	if (hasRequiredResolveParamValue) return resolveParamValue;
-	hasRequiredResolveParamValue = 1;
-	(function (exports$1) {
-
-		Object.defineProperty(exports$1, "__esModule", {
-		  value: true
-		});
-		Object.defineProperty(exports$1, "resolveParamValue", {
-		  enumerable: true,
-		  get: function () {
-		    return resolveParamValue;
-		  }
-		});
-		const _invarianterror = requireInvariantError();
-		const _interceptionprefixfromparamtype = requireInterceptionPrefixFromParamType();
-		/**
-		 * Extracts the param value from a path segment, handling interception markers
-		 * based on the expected param type.
-		 *
-		 * @param pathSegment - The path segment to extract the value from
-		 * @param params - The current params object for resolving dynamic param references
-		 * @param paramType - The expected param type which may include interception marker info
-		 * @returns The extracted param value
-		 */
-		function getParamValueFromSegment(pathSegment, params, paramType) {
-		  // If the segment is dynamic, resolve it from the params object
-		  if (pathSegment.type === 'dynamic') {
-		    return params[pathSegment.param.paramName];
-		  }
-		  // If the paramType indicates this is an intercepted param, strip the marker
-		  // that matches the interception marker in the param type
-		  const interceptionPrefix = (0, _interceptionprefixfromparamtype.interceptionPrefixFromParamType)(paramType);
-		  if (interceptionPrefix === pathSegment.interceptionMarker) {
-		    return pathSegment.name.replace(pathSegment.interceptionMarker, '');
-		  }
-		  // For static segments, use the name
-		  return pathSegment.name;
-		}
-		function resolveParamValue(paramName, paramType, depth, route, params) {
-		  switch (paramType) {
-		    case 'catchall':
-		    case 'optional-catchall':
-		    case 'catchall-intercepted-(..)(..)':
-		    case 'catchall-intercepted-(.)':
-		    case 'catchall-intercepted-(..)':
-		    case 'catchall-intercepted-(...)':
-		      // For catchall routes, derive from pathname using depth to determine
-		      // which segments to use
-		      const processedSegments = [];
-		      // Process segments to handle any embedded dynamic params
-		      for (let index = depth; index < route.segments.length; index++) {
-		        const pathSegment = route.segments[index];
-		        if (pathSegment.type === 'static') {
-		          let value = pathSegment.name;
-		          // For intercepted catch-all params, strip the marker from the first segment
-		          const interceptionPrefix = (0, _interceptionprefixfromparamtype.interceptionPrefixFromParamType)(paramType);
-		          if (interceptionPrefix && index === depth && interceptionPrefix === pathSegment.interceptionMarker) {
-		            // Strip the interception marker from the value
-		            value = value.replace(pathSegment.interceptionMarker, '');
-		          }
-		          processedSegments.push(value);
-		        } else {
-		          // If the segment is a param placeholder, check if we have its value
-		          if (!params.hasOwnProperty(pathSegment.param.paramName)) {
-		            // If the segment is an optional catchall, we can break out of the
-		            // loop because it's optional!
-		            if (pathSegment.param.paramType === 'optional-catchall') {
-		              break;
-		            }
-		            // Unknown param placeholder in pathname - can't derive full value
-		            return undefined;
-		          }
-		          // If the segment matches a param, use the param value
-		          // We don't encode values here as that's handled during retrieval.
-		          const paramValue = params[pathSegment.param.paramName];
-		          if (Array.isArray(paramValue)) {
-		            processedSegments.push(...paramValue);
-		          } else {
-		            processedSegments.push(paramValue);
-		          }
-		        }
-		      }
-		      if (processedSegments.length > 0) {
-		        return processedSegments;
-		      } else if (paramType === 'optional-catchall') {
-		        return undefined;
-		      } else {
-		        // We shouldn't be able to match a catchall segment without any path
-		        // segments if it's not an optional catchall
-		        throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected empty path segments match for a route "${route.pathname}" with param "${paramName}" of type "${paramType}"`), "__NEXT_ERROR_CODE", {
-		          value: "E931",
-		          enumerable: false,
-		          configurable: true
-		        });
-		      }
-		    case 'dynamic':
-		    case 'dynamic-intercepted-(..)(..)':
-		    case 'dynamic-intercepted-(.)':
-		    case 'dynamic-intercepted-(..)':
-		    case 'dynamic-intercepted-(...)':
-		      // For regular dynamic parameters, take the segment at this depth
-		      if (depth < route.segments.length) {
-		        const pathSegment = route.segments[depth];
-		        // Check if the segment at this depth is a placeholder for an unknown param
-		        if (pathSegment.type === 'dynamic' && !params.hasOwnProperty(pathSegment.param.paramName)) {
-		          // The segment is a placeholder like [category] and we don't have the value
-		          return undefined;
-		        }
-		        // If the segment matches a param, use the param value from params object
-		        // Otherwise it's a static segment, just use it directly
-		        // We don't encode values here as that's handled during retrieval
-		        return getParamValueFromSegment(pathSegment, params, paramType);
-		      }
-		      return undefined;
-		  }
-		} 
-	} (resolveParamValue));
-	return resolveParamValue;
-}
-
-export { requireResolveParamValue as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/route-match-utils.js

@@ -1,122 +0,0 @@
-import { __exports as routeMatchUtils } from '../../../../../../../_virtual/route-match-utils.js';
-import { __require as requirePathToRegexp } from '../../../../compiled/path-to-regexp/index.js';
-import { __require as requireRoutePatternNormalizer } from '../../../../lib/route-pattern-normalizer.js';
-
-/**
- * Client-safe utilities for route matching that don't import server-side
- * utilities to avoid bundling issues with Turbopack
- */
-
-var hasRequiredRouteMatchUtils;
-
-function requireRouteMatchUtils () {
-	if (hasRequiredRouteMatchUtils) return routeMatchUtils;
-	hasRequiredRouteMatchUtils = 1;
-	(function (exports$1) {
-
-		Object.defineProperty(exports$1, "__esModule", {
-		  value: true
-		});
-		function _export(target, all) {
-		  for (var name in all) Object.defineProperty(target, name, {
-		    enumerable: true,
-		    get: all[name]
-		  });
-		}
-		_export(exports$1, {
-		  safeCompile: function () {
-		    return safeCompile;
-		  },
-		  safePathToRegexp: function () {
-		    return safePathToRegexp;
-		  },
-		  safeRegexpToFunction: function () {
-		    return safeRegexpToFunction;
-		  },
-		  safeRouteMatcher: function () {
-		    return safeRouteMatcher;
-		  }
-		});
-		const _pathtoregexp = requirePathToRegexp();
-		const _routepatternnormalizer = requireRoutePatternNormalizer();
-		function safePathToRegexp(route, keys, options) {
-		  if (typeof route !== 'string') {
-		    return (0, _pathtoregexp.pathToRegexp)(route, keys, options);
-		  }
-		  // Check if normalization is needed and cache the result
-		  const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
-		  const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
-		  try {
-		    return (0, _pathtoregexp.pathToRegexp)(routeToUse, keys, options);
-		  } catch (error) {
-		    // Only try normalization if we haven't already normalized
-		    if (!needsNormalization) {
-		      try {
-		        const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
-		        return (0, _pathtoregexp.pathToRegexp)(normalizedRoute, keys, options);
-		      } catch (retryError) {
-		        // If that doesn't work, fall back to original error
-		        throw error;
-		      }
-		    }
-		    throw error;
-		  }
-		}
-		function safeCompile(route, options) {
-		  // Check if normalization is needed and cache the result
-		  const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
-		  const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
-		  try {
-		    const compiler = (0, _pathtoregexp.compile)(routeToUse, options);
-		    // If we normalized the route, wrap the compiler to strip separators from output
-		    // The normalization inserts _NEXTSEP_ as a literal string in the pattern to satisfy
-		    // path-to-regexp validation, but we don't want it in the final compiled URL
-		    if (needsNormalization) {
-		      return params => {
-		        return (0, _routepatternnormalizer.stripNormalizedSeparators)(compiler(params));
-		      };
-		    }
-		    return compiler;
-		  } catch (error) {
-		    // Only try normalization if we haven't already normalized
-		    if (!needsNormalization) {
-		      try {
-		        const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
-		        const compiler = (0, _pathtoregexp.compile)(normalizedRoute, options);
-		        // Wrap the compiler to strip separators from output
-		        return params => {
-		          return (0, _routepatternnormalizer.stripNormalizedSeparators)(compiler(params));
-		        };
-		      } catch (retryError) {
-		        // If that doesn't work, fall back to original error
-		        throw error;
-		      }
-		    }
-		    throw error;
-		  }
-		}
-		function safeRegexpToFunction(regexp, keys) {
-		  const originalMatcher = (0, _pathtoregexp.regexpToFunction)(regexp, keys || []);
-		  return pathname => {
-		    const result = originalMatcher(pathname);
-		    if (!result) return false;
-		    // Clean parameters before returning
-		    return {
-		      ...result,
-		      params: (0, _routepatternnormalizer.stripParameterSeparators)(result.params)
-		    };
-		  };
-		}
-		function safeRouteMatcher(matcherFn) {
-		  return pathname => {
-		    const result = matcherFn(pathname);
-		    if (!result) return false;
-		    // Clean parameters before returning
-		    return (0, _routepatternnormalizer.stripParameterSeparators)(result);
-		  };
-		} 
-	} (routeMatchUtils));
-	return routeMatchUtils;
-}
-
-export { requireRouteMatchUtils as __require };

package/dist/node_modules/next/dist/shared/lib/router/utils/route-matcher.js

@@ -1,61 +0,0 @@
-import { __exports as routeMatcher } from '../../../../../../../_virtual/route-matcher.js';
-import { __require as requireUtils } from '../../utils.js';
-import { __require as requireRouteMatchUtils } from './route-match-utils.js';
-
-var hasRequiredRouteMatcher;
-
-function requireRouteMatcher () {
-	if (hasRequiredRouteMatcher) return routeMatcher;
-	hasRequiredRouteMatcher = 1;
-	(function (exports$1) {
-
-		Object.defineProperty(exports$1, "__esModule", {
-		  value: true
-		});
-		Object.defineProperty(exports$1, "getRouteMatcher", {
-		  enumerable: true,
-		  get: function () {
-		    return getRouteMatcher;
-		  }
-		});
-		const _utils = requireUtils();
-		const _routematchutils = requireRouteMatchUtils();
-		function getRouteMatcher({
-		  re,
-		  groups
-		}) {
-		  const rawMatcher = pathname => {
-		    const routeMatch = re.exec(pathname);
-		    if (!routeMatch) return false;
-		    const decode = param => {
-		      try {
-		        return decodeURIComponent(param);
-		      } catch {
-		        throw Object.defineProperty(new _utils.DecodeError('failed to decode param'), "__NEXT_ERROR_CODE", {
-		          value: "E528",
-		          enumerable: false,
-		          configurable: true
-		        });
-		      }
-		    };
-		    const params = {};
-		    for (const [key, group] of Object.entries(groups)) {
-		      const match = routeMatch[group.pos];
-		      if (match !== undefined) {
-		        if (group.repeat) {
-		          params[key] = match.split('/').map(entry => decode(entry));
-		        } else {
-		          params[key] = decode(match);
-		        }
-		      }
-		    }
-		    return params;
-		  };
-		  // Wrap with safe matcher to handle parameter cleaning
-		  return (0, _routematchutils.safeRouteMatcher)(rawMatcher);
-		} 
-	} (routeMatcher));
-	return routeMatcher;
-}
-
-export { requireRouteMatcher as __require };