Normalize different asset configuration options.
@param {String} clientLibPath - clientlib subfolder
@param {Object} assets - asset configuration object
@returns {*}
170636
function normalizeAssets(clientLibPath, assets) {

  var list = assets;

  // transform object to array
  if (!_.isArray(assets)) {
    list = [];
    _.keys(assets).forEach(function (assetKey) {
      var assetItem = assets[assetKey];

      // check/transform short version
      if (_.isArray(assetItem)) {
        assetItem = {
          files: assetItem
        };
      }
      if (!assetItem.base) {
        assetItem.base = assetKey;
      }
      assetItem.type = assetKey;
      list.push(assetItem);
    });
  }

  // transform files to scr-dest mapping
  list.forEach(function (asset) {

    var mapping = [];
    var flatName = typeof asset.flatten !== "boolean" ? true : asset.flatten;
    var assetPath = path.posix.join(clientLibPath, asset.base);
    var globOptions = {};
    if (asset.cwd) {
      globOptions.cwd = asset.cwd;
    }

    asset.files.forEach(function (file) {
      var fileItem = file;

      // convert simple syntax to object
      if (_.isString(file)) {
        fileItem = {
          src: file
        };
      }

      // no magic pattern -> default behaviour
      if (!glob.hasMagic(fileItem.src)) {

        // determine default dest
        if (!fileItem.dest) {
          fileItem.dest = path.posix.basename(file);
        }

        // generate full path
        fileItem.dest = path.posix.join(assetPath, fileItem.dest);
        mapping.push(fileItem);
      }

      // resolve magic pattern
      else {
        var files = glob.sync(fileItem.src, globOptions);
        var hasCwd = !!globOptions.cwd;
        var dest = fileItem.dest ? path.posix.join(assetPath, fileItem.dest) : assetPath;

        files.forEach(function (resolvedFile) {

          // check 'flatten' option -> strip dir name
          var destFile = flatName ? path.posix.basename(resolvedFile) : resolvedFile;

          var item = {
            src: resolvedFile,
            dest: path.posix.join(dest, destFile)
          };

          // check "cwd" option -> rebuild path, because it was stripped by glob.sync()
          if (hasCwd) {
            item.src = path.posix.join(globOptions.cwd, resolvedFile);
          }

          mapping.push(item);
        });
      }
    });

    asset.files = mapping;
  });

  return list;
}
251861
function loadConfigFile(configPath) {
	logger.debug('Loading configuration file at:', configPath);

	function loadConfig() {
		return fs.readFileSync(configPath, { encoding: 'utf8' });
	}

	function parseConfig(content, extension) {
		switch (extension) {
		case '.js':
			return require(configPath);

		case '.yaml':
			return jsYaml.safeLoad(content, { filename: configPath });

		case '.json':
			try {
				return JSON.parse(content);
			} catch (error) {
				// Try to provide more specific syntax errors
				lintJson(content);

				// If no syntax errors are found, throw a generic error
				throw new Error('There was a problem loading a configuration file: ' + configPath);
			}

		case '.json5':
			return JSON5.parse(content);

		default:
			throw new Error(`Configuration file is an unsupported type [${supportedTypes.join(', ')}]: ` + configPath);
		}
	}

	var extension = path.extname(configPath);
	var content;

	try {
		content = loadConfig();
	} catch (error) {
		throw new ConfigurationError('Failed to read configuration file', configPath, error);
	}

	try {
		return parseConfig(content, extension);
	} catch (error) {
		throw new ConfigurationError('Failed to parse configuration file', configPath, error);
	}
}
530993
function configFactory(filename, options) {
    if (!_.isObject(options)) {
        options = {};
    }

    var config = WebpackConfig.loader.loadConfig(filename),
        isArray = _.isArray(config);

    if (!isArray) {
        config = [config];
    }

    config = _.map(config, function(x) {
        x.merge(options);
        x.defaults({
            output: {
                path: path.dirname(filename)
            }
        });

        return x;
    });

    return isArray ? config : _.first(config);
}
664032
function(assetsPath, projectPath) {
    if (assetsPath === undefined) {
      throw new Error('ember-cordova: Platform asset path undefined, cant build');
    }

    var platformPath = path.join(projectPath, assetsPath, 'cordova.js');
    var pluginPath = path.join(projectPath, assetsPath, 'cordova_plugins.js');

    if (!existsSync(platformPath) || !existsSync(pluginPath)) {
      logger.warn(
        'Did not find cordova.js or cordova_plugins.js at ' +
        assetsPath +
        '. Ember App LiveReload will still work, but device & plugin APIS will fail.'
      );
    }
  }
1339929
function normalizePack (input) {
  const setup = (typeof input === 'function') ? input : input.setup
  const vendor = input.vendor || []

  return {
    _path: input._path,
    setup: setup,
    vendor: vendor
  }
}
977250
function adjustBundlesPath(data, options) {
	var path = require("path");
	var configuration = clone(data.configuration);

	var bundlesPath = configuration.bundlesPath;
	Object.defineProperty(configuration, "bundlesPath", {
		configurable: true,
		get: function() {
			return path.join(bundlesPath, options.target);
		}
	});

	return assign({}, omit(data, ["configuration"]), {
		configuration: configuration
	});
}
110382
async function getJSXConfig(asset, isSourceModule) {
  // Don't enable JSX in node_modules
  if (!isSourceModule) {
    return null;
  }

  let pkg = await asset.getPackage();

  // Find a dependency that we can map to a JSX pragma
  let pragma = null;
  for (let dep in JSX_PRAGMA) {
    if (
      pkg &&
      ((pkg.dependencies && pkg.dependencies[dep]) ||
        (pkg.devDependencies && pkg.devDependencies[dep]))
    ) {
      pragma = JSX_PRAGMA[dep];
      break;
    }
  }

  if (!pragma) {
    pragma = maybeCreateFallbackPragma(asset);
  }

  if (pragma || JSX_EXTENSIONS[path.extname(asset.name)]) {
    return {
      internal: true,
      babelVersion: 7,
      config: {
        plugins: [
          [
            require('@babel/plugin-transform-react-jsx'),
            {
              pragma,
              pragmaFrag: 'React.Fragment'
            }
          ]
        ]
      }
    };
  }
}
443598
function populate_assets(output, json, options, log)
{
	// for each chunk name ("main", "common", ...)
	Object.keys(json.assetsByChunkName).forEach(function(name)
	{
		log.debug(`getting javascript and styles for chunk "${name}"`)

		// get javascript chunk real file path

		const javascript = get_assets(name, 'js')[0]
		// the second asset is usually a source map

		if (javascript)
		{
			log.debug(` (got javascript)`)
			output.javascript[name] = javascript
		}

		// get style chunk real file path

		const style = get_assets(name, 'css')[0]
		// the second asset is usually a source map

		if (style)
		{
			log.debug(` (got style)`)
			output.styles[name] = style
		}
	})

	// gets asset paths by name and extension of their chunk
	function get_assets(name, extension = 'js')
	{
		let chunk = json.assetsByChunkName[name]

		// a chunk could be a string or an array, so make sure it is an array
		if (!(Array.isArray(chunk)))
		{
			chunk = [chunk]
		}

		return chunk
			// filter by extension
			.filter(name => path.extname(extract_path(name)) === `.${extension}`)
			// adjust the real path (can be http, filesystem)
			.map(name => options.assets_base_url + name)
	}

	// 1st pass
	const parsed_assets = {}

	// global paths to parsed asset paths
	const global_paths_to_parsed_asset_paths = {}

	// define __webpack_public_path__ webpack variable
	// (resolves "ReferenceError: __webpack_public_path__ is not defined")
	const define_webpack_public_path = 'var __webpack_public_path__ = ' + JSON.stringify(options.assets_base_url) + ';\n'

	// for each user specified asset type
	for (let asset_type of Object.keys(options.assets))
	{
		// asset type settings
		const asset_type_settings = options.assets[asset_type]

		// one can supply his own filter
		const filter = (asset_type_settings.filter || default_filter) //.bind(this)
		// one can supply his own path parser
		const extract_asset_path = (asset_type_settings.path || default_asset_path) //.bind(this)
		// one can supply his own parser
		const parser = (asset_type_settings.parser || default_parser) //.bind(this)

		// guard agains typos, etc

		// for filter
		if (!asset_type_settings.filter)
		{
			log.debug(`No filter specified for "${asset_type}" assets. Using a default one.`)
		}

		// for path parser
		if (!asset_type_settings.path)
		{
			log.debug(`No path parser specified for "${asset_type}" assets. Using a default one.`)
		}

		// for parser
		if (!asset_type_settings.parser)
		{
			log.debug(`No parser specified for "${asset_type}" assets. Using a default one.`)
		}

		log.debug(`parsing assets of type "${asset_type}"`)

		// timer start
		const began_at = new Date().getTime()

		// get real paths for all the files from this asset type
		json.modules
			// take just modules of this asset type
			.filter(module =>
			{
				// check that this asset is of the asset type
				if (!filter(module, options.regular_expressions[asset_type], options, log))
				{
					return false
				}

				// guard against an empty source.
				if (!module.source)
				{
					log.error(`Module "${module.name}" has no source. Maybe Webpack compilation of this module failed. Skipping this asset.`)
					return false
				}

				// include this asset
				return true
			})
			.reduce((set, module) =>
			{
				// determine asset real path
				const asset_path = extract_asset_path(module, options, log)

				// asset module source, or asset content (or whatever else)
				const parsed_asset = parser(module, options, log)

				log.trace(`Adding asset "${asset_path}", module id ${module.id} (in webpack-stats.json)`)

				// check for naming collisions (just in case)
				if (exists(set[asset_path]))
				{
					log.error('-----------------------------------------------------------------')
					log.error(`Asset with path "${asset_path}" was overwritten because of path collision.`)
					log.error(`Use the "filter" function of this asset type to narrow the results.`)
					log.error(`Previous asset with this path:`)
					log.error(set[asset_path])
					log.error(`New asset with this path:`)
					log.error(parsed_asset)
					log.error('-----------------------------------------------------------------')
				}

				// add this asset to the list
				//
				// also resolve "ReferenceError: __webpack_public_path__ is not defined".
				// because it may be a url-loaded resource (e.g. a font inside a style).
				set[asset_path] = define_webpack_public_path + require_hacker.to_javascript_module_source(parsed_asset)

				// add path mapping
				global_paths_to_parsed_asset_paths[path.resolve(options.project_path, asset_path)] = asset_path

				// continue
				return set
			},
			parsed_assets)

		// timer stop
		log.debug(` time taken: ${new Date().getTime() - began_at} ms`)
	}

	// register a special require() hook for requiring() raw webpack modules
	const require_hook = require_hacker.global_hook('webpack-module', (required_path, module) =>
	{
		log.debug(`require()ing "${required_path}"`)

		// if Webpack aliases are supplied
		if (options.alias)
		{
			// possibly alias the path
			const aliased_global_path = alias_hook(required_path, module, options.project_path, options.alias, log)

			// if an alias is found
			if (aliased_global_path)
			{
				const result =
				{
					source : require_hacker.to_javascript_module_source(safe_require(aliased_global_path, log)),
					path   : aliased_global_path
				}

				return result
			}
		}

		// If the `required_path` is an npm package path
		// still can't simply `return` and fall back to default Node.js behaviour
		// because it could still be an asset like
		// `require('bootstrap/style.css')` inside `./style.css`.
		//
		// If the `required_path` is not an asset though
		// (which means "has no extension" in this case — should work)
		// then `require()` it as usual.
		//
		if (required_path.split(path.sep).slice(-1)[0].indexOf('.') === -1)
		{
			return
		}

		// find an asset with this path
		//
		// the require()d path will be global path in case of the for..of require() loop
		// for the assets (the code a couple of screens below).
		//
		// (it can be anything in other cases (e.g. nested require() calls from the assets))
		//
		if (exists(global_paths_to_parsed_asset_paths[required_path]))
		{
			log.debug(` found in parsed assets`)

			const result =
			{
				source : parsed_assets[global_paths_to_parsed_asset_paths[required_path]],
				path   : required_path
			}

			return result
		}

		log.debug(` not found in parsed assets, searching in webpack stats`)

		// find a webpack module which has a reason with this path

		const candidates = []

		for (let module of json.modules)
		{
			for (let reason of module.reasons)
			{
				if (reason.userRequest === required_path)
				{
					candidates.push(module)
					break
				}
			}
		}

		// guard against ambiguity

		if (candidates.length === 1)
		{
			log.debug(` found in webpack stats, module id ${candidates[0].id}`)

			// also resolve "ReferenceError: __webpack_public_path__ is not defined".
			// because it may be a url-loaded resource (e.g. a font inside a style).

			const result =
			{
				source : define_webpack_public_path + candidates[0].source,
				path   : candidates[0].identifier
			}

			return result
		}

		// if there are more than one candidate for this require()d path,
		// then try to guess which one is the one require()d

		if (candidates.length > 1)
		{
			log.debug(` More than a single candidate module was found in webpack stats for require()d path "${required_path}"`)

			for (let candidate of candidates)
			{
				log.debug(' ', candidate)
			}

			// (loaders matter so the program can't simply throw them away from the required path)
			//
			// // tries to normalize a cryptic Webpack loader path
			// // into a regular relative file path
			// // https://webpack.github.io/docs/loaders.html
			// let filesystem_required_path = last(required_path
			// 	.replace(/^!!/, '')
			// 	.replace(/^!/, '')
			// 	.replace(/^-!/, '')
			// 	.split('!'))

			const fail = () =>
			{
				throw new Error(`More than a single candidate module was found in webpack stats for require()d path "${required_path}". Enable "debug: true" flag in webpack-isomorphic-tools configuration for more info.`)
			}

			// https://webpack.github.io/docs/loaders.html
			const is_webpack_loader_path = required_path.indexOf('!') >= 0

			// if it's a Webpack loader-powered path, the code gives up
			if (is_webpack_loader_path)
			{
				fail()
			}

			// from here on it's either a filesystem path or an npm module path

			// if it's a global path it can be resolved right away
			if (is_global_path(required_path))
			{
				const result =
				{
					source : require_hacker.to_javascript_module_source(safe_require(required_path, log)),
					path   : required_path
				}

				return result
			}

			// from here on it's either a relative filesystem path or an npm module path,
			// so it can be resolved against the require()ing file path (if it can be recovered).

			// `module.filename` here can be anything, not just a filesystem absolute path,
			// since some advanced require() hook trickery is involved.
			// therefore it will be parsed.
			//
			let requiring_file_path = module.filename.replace(/\.webpack-module$/, '')

			// if it's a webpack loader-powered path, then extract the filesystem path from it
			if (requiring_file_path.indexOf('!') >= 0)
			{
				requiring_file_path = requiring_file_path.substring(requiring_file_path.lastIndexOf('!') + 1)
			}

			// make relative path global
			if (is_relative_path(requiring_file_path))
			{
				requiring_file_path = path.resolve(options.project_path, requiring_file_path)
			}

			// if `requiring_file_path` is a filesystem path (not an npm module path),
			// then the require()d path can possibly be resolved
			if (is_global_path(requiring_file_path))
			{
				log.debug(` The module is being require()d from "${requiring_file_path}", so resolving the path against this file`)

				// if it's a relative path, can try to resolve it
				if (is_relative_path(required_path))
				{
					const absolute_path = path.resolve(requiring_file_path, '..', required_path)

					const result =
					{
						source : require_hacker.to_javascript_module_source(safe_require(absolute_path, log)),
						path   : absolute_path
					}

					return result
				}

				// if it's an npm module path (e.g. 'babel-runtime/core-js/object/assign'),
				// can try to require() it from the requiring asset path
				if (is_package_path(required_path) && is_global_path(module.filename))
				{
					const absolute_path = require_hacker.resolve(required_path, module)

					const result =
					{
						source : require_hacker.to_javascript_module_source(safe_require(absolute_path, log)),
						path   : absolute_path
					}

					return result
				}
			}

			// if it's still here then it means it's either a
			fail()
		}
	})

	log.debug(`compiling assets`)

	// timer start
	const began_at = new Date().getTime()

	// evaluate parsed assets source code
	for (const asset_path of Object.keys(parsed_assets))
	{
		let compile = true

		// If this asset should be compiled at runtime then skip its compilation.
		// (runtime compilation can be used for Webpack loaders returning
		//  javascript functions or React component classes — stuff like that,
		//  because it's not serializable to `webpack-assets.json`)
		for (const asset_type of Object.keys(options.assets))
		{
			if (options.regular_expressions[asset_type].test(asset_path))
			{
				if (options.assets[asset_type].runtime)
				{
					compile = false
				}
			}
		}

		if (!compile)
		{
			output.assets[asset_path] = parsed_assets[asset_path]
			continue
		}

		// set asset value
		log.debug(`compiling asset "${asset_path}"`)
		output.assets[asset_path] = safe_require(path.resolve(options.project_path, asset_path), log)

		// inside that require() call above
		// all the assets are resolved relative to this `module`,
		// which is irrelevant because they are all absolute filesystem paths.
		//
		// if in some of those assets a nested require() call is present
		// then it will be resolved relative to that asset folder.
	}

	// unmount the previously installed require() hook
	require_hook.unmount()

	// timer stop
	log.debug(` time taken: ${new Date().getTime() - began_at} ms`)
}
492625
def normalize_path_in(self, client_file_name):
        
        _logger.p_debug("normalize_path_in(%s) with os.getcwd()=>%s", client_file_name, os.getcwd())
        
        # remove client CWD from file_path
        if client_file_name.startswith(self._CLIENT_CWD):
            file_name = client_file_name[len(self._CLIENT_CWD):]
        else:
            file_name = client_file_name
        
        # Try to find file using it's absolute path
        if os.path.isabs(file_name) and os.path.exists(file_name):
            _logger.p_debug("  => found absolute path: '%s'", file_name)
            return file_name
            
        # Can we find the file relatively to launch CWD (useful with buildout)
        f = os.path.join(self._CWD, file_name)  
        if  os.path.exists(f):
            _logger.p_debug("  => found path relative to self._CWD: '%s'", f)
            return f

        # Can we find file relatively to launch script
        f = os.path.join(sys.path[0], file_name)  
        if os.path.exists(f) and self.canonic(f) == self.mainpyfile:
            _logger.p_debug("  => found path relative to launch script: '%s'", f)
            return f
            
        # Try as an absolute path after adding .py extension 
        root, ext = os.path.splitext(file_name)
        if ext == '':
            f = file_name + '.py'
        if os.path.isabs(f):
            _logger.p_debug("  => found absolute path after adding .py extension: '%s'", f)
            return f
        
        # Can we find the file in system path
        for dir_name in sys.path:
            while os.path.islink(dir_name):
                dir_name = os.readlink(dir_name)
            f = os.path.join(dir_name, file_name)
            if os.path.exists(f):
                _logger.p_debug("  => found path in sys.path: '%s'", f)
                return f
        return None
1291682
function normalizePaths(opts) {
  for (var srcKey in opts.src) {
    if (!path.isAbsolute(opts.src[srcKey].glob)) {
      opts.src[srcKey].glob = path.resolve(opts.src[srcKey].glob);
    }
    if (!path.isAbsolute(opts.src[srcKey].basedir)) {
      opts.src[srcKey].basedir = path.resolve(opts.src[srcKey].basedir);
    }
  }
}
656125
def normalize_azure_path(path):
    # type: (str) -> str
    
    if is_none_or_empty(path):
        raise ValueError('provided path is invalid')
    _path = path.strip('/').strip('\\')
    return '/'.join(re.split('/|\\\\', _path))
1220433
function normalize(file, fn) {
  var orig = utils.extend({}, file);

  // support paths
  if (typeof fn === 'string') {
    file.type = 'path';
    file.path = fn;
    file.origPath = fn;
    file = resolve(file, file.options);

  // support functions
  } else if (typeof fn === 'function') {
    file.type = 'function';
    file.path = file.name;
    file.fn = fn;

  // support instances
  } else if (utils.isAppArg(file.app)) {
    file.type = 'app';
    file.path = file.name;
    file.app = fn;

  } else {
    throw new TypeError('expected env to be a string or function');
  }

  if (file === null) {
    var name = typeof fn === 'string' ? fn : orig.key;
    throw new Error('cannot resolve: ' + util.inspect(name));
  }
  return file;
}
833230
function normalizeResourcePath(path) {
    path = path || "";
    while (path.startsWith("/"))
        path = path.slice(1);
    while (path.endsWith("/"))
        path = path.slice(0, -1);
    return path;
}
97220
function assetStream(sourceFolder, maxAge) {

  if (maxAge === null || !isFinite(maxAge)) {
    maxAge = 3600;
  }

  console.log("Using max-age " + maxAge);

  if (!sourceFolder) {
    sourceFolder = 'dist';
  }

  var headers = {
    'Cache-Control': sprintf('max-age=%d, public', maxAge)
  };

  // Select everything BUT the entrypoints
  var src = entryPoints.map(f => "!" + f)
  src.unshift('**/*.*')

  return vfs.src(src, {
      cwd: sourceFolder
    })
    .pipe(through2((file, enc, cb) => {
      s3Init(file)
      Object.assign(file.s3.headers, headers)
      cb(null, file)
    }))
}
604288
function (logicalPath) {
        var assets = self.getAssetsForLogicalPath(logicalPath);
        return assets.map(function (asset) {
          return '<script src="' + self.prefix + '/' + asset + '"></script>';
        }).join('\n');
      }
947922
function __normalizePath(remotePath) {
    if (remotePath instanceof Buffer) {
        remotePath = remotePath.toString('utf8');
    }

    if (remotePath === '/') {
        return '';
    }

    if (remotePath.indexOf('./') === 0) {
        return remotePath.replace(/\.\//, '');
    }

    return remotePath;
}
1065814
@Override
    public Asset<?> assetAt(String path) {
        List<WebJarLib> candidates = findLibsContaining(path);

        if (candidates.size() == 1) {
            // Perfect ! only one match
            return new DefaultAsset<>(
                    "/libs/" + candidates.get(0).name + "/" + candidates.get(0).version + "/" + path,
                    candidates.get(0).get(path),
                    candidates.get(0).toString(),
                    candidates.get(0).lastModified(),
                    CacheUtils.computeEtag(candidates.get(0).lastModified(), configuration, crypto)
            );
        } else if (candidates.size() > 1) {
            // Several candidates
            logger().warn("{} WebJars provide '{}' - returning the one from {}-{}", candidates.size(), path,
                    candidates.get(0).name, candidates.get(0).version);
            return new DefaultAsset<>(
                    "/libs/" + candidates.get(0).name + "/" + candidates.get(0).version + "/" + path,
                    candidates.get(0).get(path),
                    candidates.get(0).toString(),
                    candidates.get(0).lastModified(),
                    CacheUtils.computeEtag(candidates.get(0).lastModified(), configuration, crypto)
            );
        } else {
            Matcher matcher = PATTERN.matcher(path);
            if (!matcher.matches()) {
                // It should have been handled by the path match.
                return null;
            }

            final String name = matcher.group(1);
            final String version = matcher.group(3);
            if (version != null) {
                String rel = matcher.group(4);
                // We have a name and a version
                // Try to find the matching library
                WebJarLib lib = find(name, version);
                if (lib != null) {
                    return new DefaultAsset<>(
                            rel,
                            lib.get(rel),
                            lib.toString(),
                            lib.lastModified(),
                            CacheUtils.computeEtag(lib.lastModified(), configuration, crypto)
                    );
                }
                // If not found, it may be because the version is not really the version but a segment of the path.
            }
            // If we reach this point it means that the name/version lookup has failed, try without the version
            String rel = matcher.group(4);
            if (version != null) {
                // We have a group 3
                rel = version + "/" + rel;
            }

            List<WebJarLib> libs = find(name);
            if (libs.size() == 1) {
                // Only on library has the given name
                if (libs.get(0).contains(rel)) {
                    WebJarLib lib = libs.get(0);
                    return new DefaultAsset<>(
                            "/libs/" + lib.name + "/" + lib.version + "/" + rel,
                            lib.get(rel),
                            lib.toString(),
                            lib.lastModified(),
                            CacheUtils.computeEtag(lib.lastModified(), configuration, crypto)
                    );
                }
            } else if (libs.size() > 1) {
                // Several candidates
                WebJarLib higher = null;
                ComparableVersion higherVersion = null;
                for (WebJarLib lib: libs) {
                    if (lib.contains(rel)) {
                        if(higher == null) {
                            higher = lib;
                            higherVersion = new ComparableVersion(higher.version);
                        } else {
                            ComparableVersion newVersion = new ComparableVersion(lib.version);
                            if(newVersion.compareTo(higherVersion) > 0) {
                                higher = lib;
                                higherVersion = new ComparableVersion(higher.version);
                            }
                        }
                    }
                }
                if(higher != null) {
                    logger().warn("{} WebJars match the request '{}' - returning the resource from {}-{}",
                            libs.size(), path, higher.name, higher.version);
                    return new DefaultAsset<>(
                            "/libs/" + higher.name + "/" + higher.version + "/" + rel,
                            higher.get(rel),
                            higher.toString(),
                            higher.lastModified(),
                            CacheUtils.computeEtag(higher.lastModified(), configuration, crypto)
                    );
                }

            }

            return null;
        }
    }