@jsenv/core 40.0.2 → 40.0.4

package/dist/js/main.js

@@ -1,994 +0,0 @@
-import { createMagicSource } from "@jsenv/sourcemap";
-
-/*
- * Link to things doing pattern matching:
- * https://git-scm.com/docs/gitignore
- * https://github.com/kaelzhang/node-ignore
- */
-
-/** @module jsenv_url_meta **/
-/**
- * An object representing the result of applying a pattern to an url
- * @typedef {Object} MatchResult
- * @property {boolean} matched Indicates if url matched pattern
- * @property {number} patternIndex Index where pattern stopped matching url, otherwise pattern.length
- * @property {number} urlIndex Index where url stopped matching pattern, otherwise url.length
- * @property {Array} matchGroups Array of strings captured during pattern matching
- */
-
-/**
- * Apply a pattern to an url
- * @param {Object} applyPatternMatchingParams
- * @param {string} applyPatternMatchingParams.pattern "*", "**" and trailing slash have special meaning
- * @param {string} applyPatternMatchingParams.url a string representing an url
- * @return {MatchResult}
- */
-const applyPattern = ({ url, pattern }) => {
-  const { matched, patternIndex, index, groups } = applyMatching(pattern, url);
-  const matchGroups = [];
-  let groupIndex = 0;
-  for (const group of groups) {
-    if (group.name) {
-      matchGroups[group.name] = group.string;
-    } else {
-      matchGroups[groupIndex] = group.string;
-      groupIndex++;
-    }
-  }
-  return {
-    matched,
-    patternIndex,
-    urlIndex: index,
-    matchGroups,
-  };
-};
-
-const applyMatching = (pattern, string) => {
-  const groups = [];
-  let patternIndex = 0;
-  let index = 0;
-  let remainingPattern = pattern;
-  let remainingString = string;
-  let restoreIndexes = true;
-
-  const consumePattern = (count) => {
-    const subpattern = remainingPattern.slice(0, count);
-    remainingPattern = remainingPattern.slice(count);
-    patternIndex += count;
-    return subpattern;
-  };
-  const consumeString = (count) => {
-    const substring = remainingString.slice(0, count);
-    remainingString = remainingString.slice(count);
-    index += count;
-    return substring;
-  };
-  const consumeRemainingString = () => {
-    return consumeString(remainingString.length);
-  };
-
-  let matched;
-  const iterate = () => {
-    const patternIndexBefore = patternIndex;
-    const indexBefore = index;
-    matched = matchOne();
-    if (matched === undefined) {
-      consumePattern(1);
-      consumeString(1);
-      iterate();
-      return;
-    }
-    if (matched === false && restoreIndexes) {
-      patternIndex = patternIndexBefore;
-      index = indexBefore;
-    }
-  };
-  const matchOne = () => {
-    // pattern consumed
-    if (remainingPattern === "") {
-      if (remainingString === "") {
-        return true; // string fully matched pattern
-      }
-      if (remainingString[0] === "?") {
-        // match search params
-        consumeRemainingString();
-
-        return true;
-      }
-      // if remainingString
-      return false; // fails because string longer than expect
-    }
-    // -- from this point pattern is not consumed --
-    // string consumed, pattern not consumed
-    if (remainingString === "") {
-      if (remainingPattern === "**") {
-        // trailing "**" is optional
-        consumePattern(2);
-        return true;
-      }
-      if (remainingPattern === "*") {
-        groups.push({ string: "" });
-      }
-      return false; // fail because string shorter than expect
-    }
-    // -- from this point pattern and string are not consumed --
-    // fast path trailing slash
-    if (remainingPattern === "/") {
-      if (remainingString[0] === "/") {
-        // trailing slash match remaining
-        consumePattern(1);
-        groups.push({ string: consumeRemainingString() });
-        return true;
-      }
-      return false;
-    }
-    // fast path trailing '**'
-    if (remainingPattern === "**") {
-      consumePattern(2);
-      consumeRemainingString();
-      return true;
-    }
-    if (remainingPattern.slice(0, 4) === "/**/") {
-      consumePattern(3); // consumes "/**/"
-      const skipResult = skipUntilMatch({
-        pattern: remainingPattern,
-        string: remainingString,
-        canSkipSlash: true,
-      });
-      groups.push(...skipResult.groups);
-      consumePattern(skipResult.patternIndex);
-      consumeRemainingString();
-      restoreIndexes = false;
-      return skipResult.matched;
-    }
-    // pattern leading **
-    if (remainingPattern.slice(0, 2) === "**") {
-      consumePattern(2); // consumes "**"
-      let skipAllowed = true;
-      if (remainingPattern[0] === "/") {
-        consumePattern(1); // consumes "/"
-        // when remainingPattern was preceeded by "**/"
-        // and remainingString have no "/"
-        // then skip is not allowed, a regular match will be performed
-        if (!remainingString.includes("/")) {
-          skipAllowed = false;
-        }
-      }
-      // pattern ending with "**" or "**/" match remaining string
-      if (remainingPattern === "") {
-        consumeRemainingString();
-        return true;
-      }
-      if (skipAllowed) {
-        const skipResult = skipUntilMatch({
-          pattern: remainingPattern,
-          string: remainingString,
-          canSkipSlash: true,
-        });
-        groups.push(...skipResult.groups);
-        consumePattern(skipResult.patternIndex);
-        consumeRemainingString();
-        restoreIndexes = false;
-        return skipResult.matched;
-      }
-    }
-    if (remainingPattern[0] === "*") {
-      consumePattern(1); // consumes "*"
-      if (remainingPattern === "") {
-        // matches everything except "/"
-        const slashIndex = remainingString.indexOf("/");
-        if (slashIndex === -1) {
-          groups.push({ string: consumeRemainingString() });
-          return true;
-        }
-        groups.push({ string: consumeString(slashIndex) });
-        return false;
-      }
-      // the next char must not the one expect by remainingPattern[0]
-      // because * is greedy and expect to skip at least one char
-      if (remainingPattern[0] === remainingString[0]) {
-        groups.push({ string: "" });
-        patternIndex = patternIndex - 1;
-        return false;
-      }
-      const skipResult = skipUntilMatch({
-        pattern: remainingPattern,
-        string: remainingString,
-        canSkipSlash: false,
-      });
-      groups.push(skipResult.group, ...skipResult.groups);
-      consumePattern(skipResult.patternIndex);
-      consumeString(skipResult.index);
-      restoreIndexes = false;
-      return skipResult.matched;
-    }
-    if (remainingPattern[0] !== remainingString[0]) {
-      return false;
-    }
-    return undefined;
-  };
-  iterate();
-
-  return {
-    matched,
-    patternIndex,
-    index,
-    groups,
-  };
-};
-
-const skipUntilMatch = ({ pattern, string, canSkipSlash }) => {
-  let index = 0;
-  let remainingString = string;
-  let longestAttemptRange = null;
-  let isLastAttempt = false;
-
-  const failure = () => {
-    return {
-      matched: false,
-      patternIndex: longestAttemptRange.patternIndex,
-      index: longestAttemptRange.index + longestAttemptRange.length,
-      groups: longestAttemptRange.groups,
-      group: {
-        string: string.slice(0, longestAttemptRange.index),
-      },
-    };
-  };
-
-  const tryToMatch = () => {
-    const matchAttempt = applyMatching(pattern, remainingString);
-    if (matchAttempt.matched) {
-      return {
-        matched: true,
-        patternIndex: matchAttempt.patternIndex,
-        index: index + matchAttempt.index,
-        groups: matchAttempt.groups,
-        group: {
-          string:
-            remainingString === ""
-              ? string
-              : string.slice(0, -remainingString.length),
-        },
-      };
-    }
-    const attemptIndex = matchAttempt.index;
-    const attemptRange = {
-      patternIndex: matchAttempt.patternIndex,
-      index,
-      length: attemptIndex,
-      groups: matchAttempt.groups,
-    };
-    if (
-      !longestAttemptRange ||
-      longestAttemptRange.length < attemptRange.length
-    ) {
-      longestAttemptRange = attemptRange;
-    }
-    if (isLastAttempt) {
-      return failure();
-    }
-    const nextIndex = attemptIndex + 1;
-    if (nextIndex >= remainingString.length) {
-      return failure();
-    }
-    if (remainingString[0] === "/") {
-      if (!canSkipSlash) {
-        return failure();
-      }
-      // when it's the last slash, the next attempt is the last
-      if (remainingString.indexOf("/", 1) === -1) {
-        isLastAttempt = true;
-      }
-    }
-    // search against the next unattempted string
-    index += nextIndex;
-    remainingString = remainingString.slice(nextIndex);
-    return tryToMatch();
-  };
-  return tryToMatch();
-};
-
-const applyPatternMatching = ({ url, pattern }) => {
-  assertUrlLike(pattern, "pattern");
-  if (url && typeof url.href === "string") url = url.href;
-  assertUrlLike(url, "url");
-  return applyPattern({ url, pattern });
-};
-
-const resolveAssociations = (associations, baseUrl) => {
-  if (baseUrl && typeof baseUrl.href === "string") baseUrl = baseUrl.href;
-  assertUrlLike(baseUrl, "baseUrl");
-
-  const associationsResolved = {};
-  for (const key of Object.keys(associations)) {
-    const value = associations[key];
-    if (typeof value === "object" && value !== null) {
-      const valueMapResolved = {};
-      for (const pattern of Object.keys(value)) {
-        const valueAssociated = value[pattern];
-        let patternResolved;
-        try {
-          patternResolved = String(new URL(pattern, baseUrl));
-        } catch {
-          // it's not really an url, no need to perform url resolution nor encoding
-          patternResolved = pattern;
-        }
-
-        valueMapResolved[patternResolved] = valueAssociated;
-      }
-      associationsResolved[key] = valueMapResolved;
-    } else {
-      associationsResolved[key] = value;
-    }
-  }
-  return associationsResolved;
-};
-
-const asFlatAssociations = (associations) => {
-  if (!isPlainObject(associations)) {
-    throw new TypeError(
-      `associations must be a plain object, got ${associations}`,
-    );
-  }
-  const flatAssociations = {};
-  for (const associationName of Object.keys(associations)) {
-    const associationValue = associations[associationName];
-    if (!isPlainObject(associationValue)) {
-      continue;
-    }
-    for (const pattern of Object.keys(associationValue)) {
-      const patternValue = associationValue[pattern];
-      const previousValue = flatAssociations[pattern];
-      if (isPlainObject(previousValue)) {
-        flatAssociations[pattern] = {
-          ...previousValue,
-          [associationName]: patternValue,
-        };
-      } else {
-        flatAssociations[pattern] = {
-          [associationName]: patternValue,
-        };
-      }
-    }
-  }
-  return flatAssociations;
-};
-
-const applyAssociations = ({ url, associations }) => {
-  if (url && typeof url.href === "string") url = url.href;
-  assertUrlLike(url);
-  const flatAssociations = asFlatAssociations(associations);
-  let associatedValue = {};
-  for (const pattern of Object.keys(flatAssociations)) {
-    const { matched } = applyPatternMatching({
-      pattern,
-      url,
-    });
-    if (matched) {
-      const value = flatAssociations[pattern];
-      associatedValue = deepAssign(associatedValue, value);
-    }
-  }
-  return associatedValue;
-};
-
-const deepAssign = (firstValue, secondValue) => {
-  if (!isPlainObject(firstValue)) {
-    if (isPlainObject(secondValue)) {
-      return deepAssign({}, secondValue);
-    }
-    return secondValue;
-  }
-  if (!isPlainObject(secondValue)) {
-    return secondValue;
-  }
-  for (const key of Object.keys(secondValue)) {
-    const leftPopertyValue = firstValue[key];
-    const rightPropertyValue = secondValue[key];
-    firstValue[key] = deepAssign(leftPopertyValue, rightPropertyValue);
-  }
-  return firstValue;
-};
-
-const urlChildMayMatch = ({ url, associations, predicate }) => {
-  if (url && typeof url.href === "string") url = url.href;
-  assertUrlLike(url, "url");
-  // the function was meants to be used on url ending with '/'
-  if (!url.endsWith("/")) {
-    throw new Error(`url should end with /, got ${url}`);
-  }
-  if (typeof predicate !== "function") {
-    throw new TypeError(`predicate must be a function, got ${predicate}`);
-  }
-  const flatAssociations = asFlatAssociations(associations);
-  // for full match we must create an object to allow pattern to override previous ones
-  let fullMatchMeta = {};
-  let someFullMatch = false;
-  // for partial match, any meta satisfying predicate will be valid because
-  // we don't know for sure if pattern will still match for a file inside pathname
-  const partialMatchMetaArray = [];
-  for (const pattern of Object.keys(flatAssociations)) {
-    const value = flatAssociations[pattern];
-    const matchResult = applyPatternMatching({
-      pattern,
-      url,
-    });
-    if (matchResult.matched) {
-      someFullMatch = true;
-      if (isPlainObject(fullMatchMeta) && isPlainObject(value)) {
-        fullMatchMeta = {
-          ...fullMatchMeta,
-          ...value,
-        };
-      } else {
-        fullMatchMeta = value;
-      }
-    } else if (someFullMatch === false && matchResult.urlIndex >= url.length) {
-      partialMatchMetaArray.push(value);
-    }
-  }
-  if (someFullMatch) {
-    return Boolean(predicate(fullMatchMeta));
-  }
-  return partialMatchMetaArray.some((partialMatchMeta) =>
-    predicate(partialMatchMeta),
-  );
-};
-
-const applyAliases = ({ url, aliases }) => {
-  let aliasFullMatchResult;
-  const aliasMatchingKey = Object.keys(aliases).find((key) => {
-    const aliasMatchResult = applyPatternMatching({
-      pattern: key,
-      url,
-    });
-    if (aliasMatchResult.matched) {
-      aliasFullMatchResult = aliasMatchResult;
-      return true;
-    }
-    return false;
-  });
-  if (!aliasMatchingKey) {
-    return url;
-  }
-  const { matchGroups } = aliasFullMatchResult;
-  const alias = aliases[aliasMatchingKey];
-  const parts = alias.split("*");
-  let newUrl = "";
-  let index = 0;
-  for (const part of parts) {
-    newUrl += `${part}`;
-    if (index < parts.length - 1) {
-      newUrl += matchGroups[index];
-    }
-    index++;
-  }
-  return newUrl;
-};
-
-const matches = (url, patterns) => {
-  return Boolean(
-    applyAssociations({
-      url,
-      associations: {
-        yes: patterns,
-      },
-    }).yes,
-  );
-};
-
-// const assertSpecifierMetaMap = (value, checkComposition = true) => {
-//   if (!isPlainObject(value)) {
-//     throw new TypeError(
-//       `specifierMetaMap must be a plain object, got ${value}`,
-//     );
-//   }
-//   if (checkComposition) {
-//     const plainObject = value;
-//     Object.keys(plainObject).forEach((key) => {
-//       assertUrlLike(key, "specifierMetaMap key");
-//       const value = plainObject[key];
-//       if (value !== null && !isPlainObject(value)) {
-//         throw new TypeError(
-//           `specifierMetaMap value must be a plain object or null, got ${value} under key ${key}`,
-//         );
-//       }
-//     });
-//   }
-// };
-const assertUrlLike = (value, name = "url") => {
-  if (typeof value !== "string") {
-    throw new TypeError(`${name} must be a url string, got ${value}`);
-  }
-  if (isWindowsPathnameSpecifier(value)) {
-    throw new TypeError(
-      `${name} must be a url but looks like a windows pathname, got ${value}`,
-    );
-  }
-  if (!hasScheme(value)) {
-    throw new TypeError(
-      `${name} must be a url and no scheme found, got ${value}`,
-    );
-  }
-};
-const isPlainObject = (value) => {
-  if (value === null) {
-    return false;
-  }
-  if (typeof value === "object") {
-    if (Array.isArray(value)) {
-      return false;
-    }
-    return true;
-  }
-  return false;
-};
-const isWindowsPathnameSpecifier = (specifier) => {
-  const firstChar = specifier[0];
-  if (!/[a-zA-Z]/.test(firstChar)) return false;
-  const secondChar = specifier[1];
-  if (secondChar !== ":") return false;
-  const thirdChar = specifier[2];
-  return thirdChar === "/" || thirdChar === "\\";
-};
-const hasScheme = (specifier) => /^[a-zA-Z]+:/.test(specifier);
-
-const createFilter = (patterns, url, map = (v) => v) => {
-  const associations = resolveAssociations(
-    {
-      yes: patterns,
-    },
-    url,
-  );
-  return (url) => {
-    const meta = applyAssociations({ url, associations });
-    return Boolean(map(meta.yes));
-  };
-};
-
-const URL_META = {
-  resolveAssociations,
-  applyAssociations,
-  applyAliases,
-  applyPatternMatching,
-  urlChildMayMatch,
-  matches,
-  createFilter,
-};
-
-const pathnameToExtension = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/");
-  const filename =
-    slashLastIndex === -1 ? pathname : pathname.slice(slashLastIndex + 1);
-  if (filename.match(/@([0-9])+(\.[0-9]+)?(\.[0-9]+)?$/)) {
-    return "";
-  }
-  const dotLastIndex = filename.lastIndexOf(".");
-  if (dotLastIndex === -1) {
-    return "";
-  }
-  // if (dotLastIndex === pathname.length - 1) return ""
-  const extension = filename.slice(dotLastIndex);
-  return extension;
-};
-
-const resourceToPathname = (resource) => {
-  const searchSeparatorIndex = resource.indexOf("?");
-  if (searchSeparatorIndex > -1) {
-    return resource.slice(0, searchSeparatorIndex);
-  }
-  const hashIndex = resource.indexOf("#");
-  if (hashIndex > -1) {
-    return resource.slice(0, hashIndex);
-  }
-  return resource;
-};
-
-const urlToScheme = (url) => {
-  const urlString = String(url);
-  const colonIndex = urlString.indexOf(":");
-  if (colonIndex === -1) {
-    return "";
-  }
-
-  const scheme = urlString.slice(0, colonIndex);
-  return scheme;
-};
-
-const urlToResource = (url) => {
-  const scheme = urlToScheme(url);
-
-  if (scheme === "file") {
-    const urlAsStringWithoutFileProtocol = String(url).slice("file://".length);
-    return urlAsStringWithoutFileProtocol;
-  }
-
-  if (scheme === "https" || scheme === "http") {
-    // remove origin
-    const afterProtocol = String(url).slice(scheme.length + "://".length);
-    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length);
-    const urlAsStringWithoutOrigin = afterProtocol.slice(pathnameSlashIndex);
-    return urlAsStringWithoutOrigin;
-  }
-
-  const urlAsStringWithoutProtocol = String(url).slice(scheme.length + 1);
-  return urlAsStringWithoutProtocol;
-};
-
-const urlToPathname = (url) => {
-  const resource = urlToResource(url);
-  const pathname = resourceToPathname(resource);
-  return pathname;
-};
-
-const urlToFilename = (url) => {
-  const pathname = urlToPathname(url);
-  return pathnameToFilename(pathname);
-};
-
-const pathnameToFilename = (pathname) => {
-  const pathnameBeforeLastSlash = pathname.endsWith("/")
-    ? pathname.slice(0, -1)
-    : pathname;
-  const slashLastIndex = pathnameBeforeLastSlash.lastIndexOf("/");
-  const filename =
-    slashLastIndex === -1
-      ? pathnameBeforeLastSlash
-      : pathnameBeforeLastSlash.slice(slashLastIndex + 1);
-  return filename;
-};
-
-const urlToBasename = (url, removeAllExtensions) => {
-  const filename = urlToFilename(url);
-  const basename = filenameToBasename(filename);
-  {
-    return basename;
-  }
-};
-
-const filenameToBasename = (filename) => {
-  const dotLastIndex = filename.lastIndexOf(".");
-  const basename =
-    dotLastIndex === -1 ? filename : filename.slice(0, dotLastIndex);
-  return basename;
-};
-
-const urlToExtension = (url) => {
-  const pathname = urlToPathname(url);
-  return pathnameToExtension(pathname);
-};
-
-const urlToOrigin = (url) => {
-  const urlString = String(url);
-  if (urlString.startsWith("file://")) {
-    return `file://`;
-  }
-  return new URL(urlString).origin;
-};
-
-const asUrlWithoutSearch = (url) => {
-  url = String(url);
-  if (url.includes("?")) {
-    const urlObject = new URL(url);
-    urlObject.search = "";
-    return urlObject.href;
-  }
-  return url;
-};
-
-const isValidUrl = (url) => {
-  try {
-    // eslint-disable-next-line no-new
-    new URL(url);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-const asSpecifierWithoutSearch = (specifier) => {
-  if (isValidUrl(specifier)) {
-    return asUrlWithoutSearch(specifier);
-  }
-  const [beforeQuestion] = specifier.split("?");
-  return beforeQuestion;
-};
-
-// normalize url search params:
-// Using URLSearchParams to alter the url search params
-// can result into "file:///file.css?css_module"
-// becoming "file:///file.css?css_module="
-// we want to get rid of the "=" and consider it's the same url
-const normalizeUrl = (url) => {
-  if (url.includes("?")) {
-    // disable on data urls (would mess up base64 encoding)
-    if (url.startsWith("data:")) {
-      return url;
-    }
-    return url.replace(/[=](?=&|$)/g, "");
-  }
-  return url;
-};
-
-const injectQueryParamsIntoSpecifier = (specifier, params) => {
-  if (isValidUrl(specifier)) {
-    return injectQueryParams(specifier, params);
-  }
-  const [beforeQuestion, afterQuestion = ""] = specifier.split("?");
-  const searchParams = new URLSearchParams(afterQuestion);
-  Object.keys(params).forEach((key) => {
-    const value = params[key];
-    if (value === undefined) {
-      searchParams.delete(key);
-    } else {
-      searchParams.set(key, value);
-    }
-  });
-  let paramsString = searchParams.toString();
-  if (paramsString) {
-    paramsString = paramsString.replace(/[=](?=&|$)/g, "");
-    return `${beforeQuestion}?${paramsString}`;
-  }
-  return beforeQuestion;
-};
-
-const injectQueryParams = (url, params) => {
-  const urlObject = new URL(url);
-  const { searchParams } = urlObject;
-  Object.keys(params).forEach((key) => {
-    const value = params[key];
-    if (value === undefined) {
-      searchParams.delete(key);
-    } else {
-      searchParams.set(key, value);
-    }
-  });
-  const urlWithParams = urlObject.href;
-  return normalizeUrl(urlWithParams);
-};
-
-const injectQueryParamWithoutEncoding = (url, key, value) => {
-  const urlObject = new URL(url);
-  let { origin, pathname, search, hash } = urlObject;
-  // origin is "null" for "file://" urls with Node.js
-  if (origin === "null" && urlObject.href.startsWith("file:")) {
-    origin = "file://";
-  }
-  if (search === "") {
-    search = `?${key}=${value}`;
-  } else {
-    search += `${key}=${value}`;
-  }
-  return `${origin}${pathname}${search}${hash}`;
-};
-const injectQueryParamIntoSpecifierWithoutEncoding = (
-  specifier,
-  key,
-  value,
-) => {
-  if (isValidUrl(specifier)) {
-    return injectQueryParamWithoutEncoding(specifier, key, value);
-  }
-  const [beforeQuestion, afterQuestion = ""] = specifier.split("?");
-  const searchParams = new URLSearchParams(afterQuestion);
-  let search = searchParams.toString();
-  if (search === "") {
-    search = `?${key}=${value}`;
-  } else {
-    search = `?${search}&${key}=${value}`;
-  }
-  return `${beforeQuestion}${search}`;
-};
-
-const renderUrlOrRelativeUrlFilename = (urlOrRelativeUrl, renderer) => {
-  const questionIndex = urlOrRelativeUrl.indexOf("?");
-  const beforeQuestion =
-    questionIndex === -1
-      ? urlOrRelativeUrl
-      : urlOrRelativeUrl.slice(0, questionIndex);
-  const afterQuestion =
-    questionIndex === -1 ? "" : urlOrRelativeUrl.slice(questionIndex);
-  const beforeLastSlash = beforeQuestion.endsWith("/")
-    ? beforeQuestion.slice(0, -1)
-    : beforeQuestion;
-  const slashLastIndex = beforeLastSlash.lastIndexOf("/");
-  const beforeFilename =
-    slashLastIndex === -1 ? "" : beforeQuestion.slice(0, slashLastIndex + 1);
-  const filename =
-    slashLastIndex === -1
-      ? beforeQuestion
-      : beforeQuestion.slice(slashLastIndex + 1);
-  const dotLastIndex = filename.lastIndexOf(".");
-  const basename =
-    dotLastIndex === -1 ? filename : filename.slice(0, dotLastIndex);
-  const extension = dotLastIndex === -1 ? "" : filename.slice(dotLastIndex);
-  const newFilename = renderer({
-    basename,
-    extension,
-  });
-  return `${beforeFilename}${newFilename}${afterQuestion}`;
-};
-
-const setUrlExtension = (url, extension) => {
-  const origin = urlToOrigin(url);
-  const currentExtension = urlToExtension(url);
-  if (typeof extension === "function") {
-    extension = extension(currentExtension);
-  }
-  const resource = urlToResource(url);
-  const [pathname, search] = resource.split("?");
-  const pathnameWithoutExtension = currentExtension
-    ? pathname.slice(0, -currentExtension.length)
-    : pathname;
-  let newPathname;
-  if (pathnameWithoutExtension.endsWith("/")) {
-    newPathname = pathnameWithoutExtension.slice(0, -1);
-    newPathname += extension;
-    newPathname += "/";
-  } else {
-    newPathname = pathnameWithoutExtension;
-    newPathname += extension;
-  }
-  return `${origin}${newPathname}${search ? `?${search}` : ""}`;
-};
-
-const setUrlFilename = (url, filename) => {
-  const parentPathname = new URL("./", url).pathname;
-  return transformUrlPathname(url, (pathname) => {
-    if (typeof filename === "function") {
-      filename = filename(pathnameToFilename(pathname));
-    }
-    return `${parentPathname}${filename}`;
-  });
-};
-
-const setUrlBasename = (url, basename) => {
-  return setUrlFilename(url, (filename) => {
-    if (typeof basename === "function") {
-      basename = basename(filenameToBasename(filename));
-    }
-    return `${basename}${urlToExtension(url)}`;
-  });
-};
-
-const transformUrlPathname = (url, transformer) => {
-  if (typeof url === "string") {
-    const urlObject = new URL(url);
-    const { pathname } = urlObject;
-    const pathnameTransformed = transformer(pathname);
-    if (pathnameTransformed === pathname) {
-      return url;
-    }
-    let { origin } = urlObject;
-    // origin is "null" for "file://" urls with Node.js
-    if (origin === "null" && urlObject.href.startsWith("file:")) {
-      origin = "file://";
-    }
-    const { search, hash } = urlObject;
-    const urlWithPathnameTransformed = `${origin}${pathnameTransformed}${search}${hash}`;
-    return urlWithPathnameTransformed;
-  }
-  const pathnameTransformed = transformer(url.pathname);
-  url.pathname = pathnameTransformed;
-  return url;
-};
-const ensurePathnameTrailingSlash = (url) => {
-  return transformUrlPathname(url, (pathname) => {
-    return pathname.endsWith("/") ? pathname : `${pathname}/`;
-  });
-};
-
-const jsenvPluginInjections = (rawAssociations) => {
-  let resolvedAssociations;
-
-  return {
-    name: "jsenv:injections",
-    appliesDuring: "*",
-    init: (context) => {
-      resolvedAssociations = URL_META.resolveAssociations(
-        { injectionsGetter: rawAssociations },
-        context.rootDirectoryUrl,
-      );
-    },
-    transformUrlContent: async (urlInfo) => {
-      const { injectionsGetter } = URL_META.applyAssociations({
-        url: asUrlWithoutSearch(urlInfo.url),
-        associations: resolvedAssociations,
-      });
-      if (!injectionsGetter) {
-        return null;
-      }
-      if (typeof injectionsGetter !== "function") {
-        throw new TypeError("injectionsGetter must be a function");
-      }
-      const injections = await injectionsGetter(urlInfo);
-      if (!injections) {
-        return null;
-      }
-      const keys = Object.keys(injections);
-      if (keys.length === 0) {
-        return null;
-      }
-      return replacePlaceholders(urlInfo.content, injections, urlInfo);
-    },
-  };
-};
-
-const injectionSymbol = Symbol.for("jsenv_injection");
-const INJECTIONS = {
-  optional: (value) => {
-    return { [injectionSymbol]: "optional", value };
-  },
-};
-
-// we export this because it is imported by jsenv_plugin_placeholder.js and unit test
-const replacePlaceholders = (content, replacements, urlInfo) => {
-  const magicSource = createMagicSource(content);
-  for (const key of Object.keys(replacements)) {
-    let index = content.indexOf(key);
-    const replacement = replacements[key];
-    let isOptional;
-    let value;
-    if (replacement && replacement[injectionSymbol]) {
-      const valueBehindSymbol = replacement[injectionSymbol];
-      isOptional = valueBehindSymbol === "optional";
-      value = replacement.value;
-    } else {
-      value = replacement;
-    }
-    if (index === -1) {
-      if (!isOptional) {
-        urlInfo.context.logger.warn(
-          `placeholder "${key}" not found in ${urlInfo.url}.
---- suggestion a ---
-Add "${key}" in that file.
---- suggestion b ---
-Fix eventual typo in "${key}"?
---- suggestion c ---
-Mark injection as optional using INJECTIONS.optional():
-import { INJECTIONS } from "@jsenv/core";
-
-return {
-  "${key}": INJECTIONS.optional(${JSON.stringify(value)}),
-};`,
-        );
-      }
-      continue;
-    }
-
-    while (index !== -1) {
-      const start = index;
-      const end = index + key.length;
-      magicSource.replace({
-        start,
-        end,
-        replacement:
-          urlInfo.type === "js_classic" ||
-          urlInfo.type === "js_module" ||
-          urlInfo.type === "html"
-            ? JSON.stringify(value, null, "  ")
-            : value,
-      });
-      index = content.indexOf(key, end);
-    }
-  }
-  return magicSource.toContentAndSourcemap();
-};
-
-// dev
-const startDevServer = async (...args) => {
-  const namespace = await import("./start_dev_server.js");
-  return namespace.startDevServer(...args);
-};
-
-// build
-const build = async (...args) => {
-  const namespace = await import("./build.js").then(n => n.build);
-  return namespace.build(...args);
-};
-const startBuildServer = async (...args) => {
-  const namespace = await import("./start_build_server.js");
-  return namespace.startBuildServer(...args);
-};
-
-export { INJECTIONS, URL_META, asSpecifierWithoutSearch, asUrlWithoutSearch, build, ensurePathnameTrailingSlash, injectQueryParamIntoSpecifierWithoutEncoding, injectQueryParams, injectQueryParamsIntoSpecifier, jsenvPluginInjections, normalizeUrl, renderUrlOrRelativeUrlFilename, replacePlaceholders, setUrlBasename, setUrlExtension, setUrlFilename, startBuildServer, startDevServer, urlToBasename, urlToExtension, urlToFilename, urlToPathname };