@softarc/native-federation 4.1.3 → 4.2.0

package/{src → dist}/lib/utils/file-watcher.d.ts

@@ -1,5 +1,7 @@
+import type { WatchPort, FileReaderPort } from '../domain/utils/io-port.contract.js';
 import type { NfFileWatcher, NfFileWatcherOptions } from '../domain/utils/file-watcher.contract.js';
 export declare function createNfWatcher(options?: NfFileWatcherOptions): NfFileWatcher;
+export declare function createNfWatcherCore(io: WatchPort & FileReaderPort, options?: NfFileWatcherOptions): NfFileWatcher;
 export declare function syncNfFileWatcher(watcher: NfFileWatcher, bundlerCache: {
     keys(): IterableIterator<string>;
 }): void;

package/dist/lib/utils/file-watcher.js

@@ -0,0 +1,51 @@
+import { join } from "path";
+import { nodeIo } from "./io/node-io-adapter.js";
+import { logger } from "./logger.js";
+import { toPosix } from "./path-patterns.js";
+function createNfWatcher(options = {}) {
+  return createNfWatcherCore(nodeIo, options);
+}
+function createNfWatcherCore(io, options = {}) {
+  const { onChange } = options;
+  const watchers = /* @__PURE__ */ new Map();
+  const dirtyPaths = /* @__PURE__ */ new Set();
+  const notify = (path) => {
+    if (onChange) onChange(path);
+    else dirtyPaths.add(path);
+  };
+  return {
+    addPaths(paths) {
+      const list = typeof paths === "string" ? [paths] : [...paths];
+      for (const p of list) {
+        if (watchers.has(p)) continue;
+        try {
+          const isDir = io.isDirectory(p);
+          const handle = isDir ? io.watch(p, { recursive: true }, (filename) => {
+            if (filename) notify(toPosix(join(p, filename)));
+          }) : io.watch(p, { recursive: false }, () => notify(toPosix(p)));
+          watchers.set(p, handle);
+        } catch {
+          logger.debug(`Could not watch path '${p}'.`);
+        }
+      }
+    },
+    get: () => dirtyPaths,
+    clear: () => dirtyPaths.clear(),
+    mutate: (fn) => fn(dirtyPaths),
+    async close() {
+      for (const handle of watchers.values()) {
+        handle.close();
+      }
+      watchers.clear();
+    }
+  };
+}
+function syncNfFileWatcher(watcher, bundlerCache) {
+  const files = [...bundlerCache.keys()].filter((k) => !k.includes("node_modules"));
+  if (files.length) watcher.addPaths(files);
+}
+export {
+  createNfWatcher,
+  createNfWatcherCore,
+  syncNfFileWatcher
+};

package/dist/lib/utils/hash-file.d.ts

@@ -0,0 +1,7 @@
+import type { FileReaderPort, HashPort } from '../domain/utils/io-port.contract.js';
+export type SriAlgorithm = 'sha256' | 'sha384' | 'sha512';
+type HashDeps = FileReaderPort & HashPort;
+export declare function hashFile(fileName: string): string;
+export declare function hashFileCore(io: HashDeps, fileName: string): string;
+export declare function integrityForFileCore(io: HashDeps, fileName: string, algorithm?: SriAlgorithm): string;
+export {};

package/dist/lib/utils/hash-file.js

@@ -0,0 +1,15 @@
+import { nodeIo } from "./io/node-io-adapter.js";
+function hashFile(fileName) {
+  return hashFileCore(nodeIo, fileName);
+}
+function hashFileCore(io, fileName) {
+  return io.hash("md5", io.readBytes(fileName)).hex();
+}
+function integrityForFileCore(io, fileName, algorithm = "sha384") {
+  return `${algorithm}-${io.hash(algorithm, io.readBytes(fileName)).base64()}`;
+}
+export {
+  hashFile,
+  hashFileCore,
+  integrityForFileCore
+};

package/dist/lib/utils/io/node-io-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { IoPort } from '../../domain/utils/io-port.contract.js';
+export declare const nodeIo: IoPort;

package/dist/lib/utils/io/node-io-adapter.js

@@ -0,0 +1,68 @@
+import * as fs from "fs";
+import * as crypto from "crypto";
+import fg from "fast-glob";
+const nodeIo = {
+  readText(path) {
+    return fs.readFileSync(path, "utf-8");
+  },
+  readBytes(path) {
+    return fs.readFileSync(path);
+  },
+  exists(path) {
+    return fs.existsSync(path);
+  },
+  isFile(path) {
+    try {
+      return fs.statSync(path).isFile();
+    } catch {
+      return false;
+    }
+  },
+  isDirectory(path) {
+    try {
+      return fs.statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  },
+  readDir(path) {
+    try {
+      return fs.readdirSync(path);
+    } catch {
+      return [];
+    }
+  },
+  writeText(path, data) {
+    fs.writeFileSync(path, data, "utf-8");
+  },
+  mkdirp(path) {
+    fs.mkdirSync(path, { recursive: true });
+  },
+  copyFile(from, to) {
+    fs.copyFileSync(from, to);
+  },
+  remove(path) {
+    fs.unlinkSync(path);
+  },
+  globFiles(pattern, opts) {
+    return fg.sync(pattern, { cwd: opts.cwd, onlyFiles: true, deep: Infinity });
+  },
+  hash(algorithm, data) {
+    const sum = crypto.createHash(algorithm).update(data);
+    return {
+      hex: () => sum.digest("hex"),
+      base64: () => sum.digest("base64")
+    };
+  },
+  watch(path, opts, onEvent) {
+    const watcher = opts.recursive ? fs.watch(
+      path,
+      { recursive: true },
+      (_event, filename) => onEvent(filename ? filename.toString() : null)
+    ) : fs.watch(path, () => onEvent(path));
+    return { close: () => watcher.close() };
+  }
+};
+export {
+  nodeIo
+};

package/dist/lib/utils/io/package-json-repository.d.ts

@@ -0,0 +1,5 @@
+import type { FileReaderPort } from '../../domain/utils/io-port.contract.js';
+import type { PackageJsonRepository } from '../../domain/utils/package-json.contract.js';
+export declare function getPkgFolder(packageName: string): string;
+export declare function createPackageJsonRepository(io?: FileReaderPort): PackageJsonRepository;
+export declare const sharedPackageJsonRepository: PackageJsonRepository;

package/dist/lib/utils/io/package-json-repository.js

@@ -0,0 +1,79 @@
+import * as path from "path";
+import { nodeIo } from "./node-io-adapter.js";
+import { normalize } from "../normalize.js";
+import { logger } from "../logger.js";
+function getPkgFolder(packageName) {
+  const parts = packageName.split("/");
+  let folder = parts[0];
+  if (folder.startsWith("@")) {
+    folder += "/" + parts[1];
+  }
+  return folder;
+}
+function createPackageJsonRepository(io = nodeIo) {
+  const cache = /* @__PURE__ */ new Map();
+  const readJson = (filePath) => JSON.parse(io.readText(filePath));
+  function expandFolders(child, parent) {
+    const result = [];
+    parent = normalize(parent, true);
+    child = normalize(child, true);
+    if (!child.startsWith(parent)) {
+      throw new Error(
+        `Workspace folder ${parent} needs to be a parent of the project folder ${child}`
+      );
+    }
+    let current = child;
+    while (current !== parent) {
+      result.push(current);
+      const cand = normalize(path.dirname(current), true);
+      if (cand === current) break;
+      current = cand;
+    }
+    result.push(parent);
+    return result;
+  }
+  function findPackageJsonFiles(project, workspace) {
+    return expandFolders(project, workspace).map((f) => path.join(f, "package.json")).filter((f) => io.exists(f));
+  }
+  function getPackageJsonFiles(project, workspace) {
+    const cacheKey = `${project}**${workspace}`;
+    const cached = cache.get(cacheKey);
+    if (cached) return cached;
+    const maps = findPackageJsonFiles(project, workspace).map((f) => ({
+      content: readJson(f),
+      directory: normalize(path.dirname(f), true)
+    }));
+    cache.set(cacheKey, maps);
+    return maps;
+  }
+  function findDepPackageJson(packageName, projectRoot) {
+    const mainPkgName = getPkgFolder(packageName);
+    if (!mainPkgName) throw new Error(`Package.json "${packageName}" is missing`);
+    let directory = projectRoot;
+    let mainPkgJsonPath = path.join(directory, "node_modules", mainPkgName, "package.json");
+    while (path.dirname(directory) !== directory) {
+      if (io.exists(mainPkgJsonPath)) break;
+      directory = normalize(path.dirname(directory), true);
+      mainPkgJsonPath = path.join(directory, "node_modules", mainPkgName, "package.json");
+    }
+    if (!io.exists(mainPkgJsonPath)) {
+      logger.verbose(
+        "No package.json found for " + packageName + " in " + path.dirname(mainPkgJsonPath)
+      );
+      return null;
+    }
+    return mainPkgJsonPath;
+  }
+  return {
+    getPackageJsonFiles,
+    findDepPackageJson,
+    readJson,
+    exists: (filePath) => io.exists(filePath)
+  };
+}
+const sharedPackageJsonRepository = createPackageJsonRepository();
+export {
+  createPackageJsonRepository,
+  getPkgFolder,
+  sharedPackageJsonRepository
+};

package/dist/lib/utils/logger.js

@@ -0,0 +1,29 @@
+import chalk from "chalk";
+let verbose = false;
+const debug = (msg) => verbose && console.log(chalk.bgGreen.ansi256(15)(" DBG! "), msg);
+const logger = {
+  warn: (msg) => console.warn(chalk.bgYellow.ansi256(15)(" WARN "), msg),
+  error: (msg) => console.error(chalk.bgRed.ansi256(15)(" ERRR "), msg),
+  notice: (msg) => console.log(chalk.bgYellowBright.black(" NOTE "), msg),
+  info: (msg) => console.log(chalk.bgGreen.ansi256(15)(" INFO "), msg),
+  verbose: debug,
+  // public alias, kept for backwards compatibility
+  debug,
+  measure: (start, milestone) => {
+    if (!verbose) return;
+    const [totalSeconds, nanoseconds] = process.hrtime(start);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    const milliseconds = nanoseconds / 1e6;
+    const msFormatted = milliseconds.toFixed(3);
+    const timeStr = `${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}:${msFormatted.padStart(7, "0")}ms`;
+    console.log(chalk.bgGreen.ansi256(15)(" DBG! "), `${timeStr} - ${milestone}`);
+  }
+};
+const setLogLevel = (level) => {
+  verbose = level === "verbose";
+};
+export {
+  logger,
+  setLogLevel
+};

package/dist/lib/utils/normalize.js

@@ -0,0 +1,22 @@
+import { toPosix } from "./path-patterns.js";
+function normalize(path, trailingSlash) {
+  let cand = toPosix(path);
+  if (typeof trailingSlash === "undefined") {
+    return cand;
+  }
+  while (cand.endsWith("/")) {
+    cand = cand.substring(0, cand.length - 1);
+  }
+  if (trailingSlash) {
+    return cand + "/";
+  }
+  return cand;
+}
+function normalizePackageName(fileName) {
+  const sanitized = fileName.replace(/[^A-Za-z0-9]/g, "_");
+  return sanitized.startsWith("_") ? sanitized.slice(1) : sanitized;
+}
+export {
+  normalize,
+  normalizePackageName
+};

package/dist/lib/utils/package/entry-point-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { PackageInfo, PackageJsonRepository } from '../../domain/utils/package-json.contract.js';
+export declare function resolvePackageInfo(repo: PackageJsonRepository, packageName: string, directory: string): PackageInfo | null;

package/dist/lib/utils/package/entry-point-resolver.js

@@ -0,0 +1,78 @@
+import * as path from "path";
+import { logger } from "../logger.js";
+import { findOptimalExport, resolveExportsEntry } from "./exports-resolver.js";
+import { getPkgFolder } from "../io/package-json-repository.js";
+const base = (ctx, entryPoint, esm) => ({
+  entryPoint,
+  packageName: ctx.packageName,
+  version: ctx.version,
+  esm
+});
+const STRATEGIES = [
+  (ctx) => {
+    const entry = resolveExportsEntry(ctx.mainPkgJson?.exports, ctx.relSecondaryPath);
+    if (!entry) return null;
+    return findOptimalExport(entry, base(ctx, ctx.mainPkgPath, ctx.esm)) ?? null;
+  },
+  (ctx) => ctx.mainPkgJson["module"] && ctx.relSecondaryPath === "." ? base(ctx, path.join(ctx.mainPkgPath, ctx.mainPkgJson["module"]), true) : null,
+  (ctx) => ctx.secondaryPkgJson?.module ? base(ctx, path.join(ctx.secondaryPkgPath, ctx.secondaryPkgJson.module), true) : null,
+  (ctx) => {
+    const cand = path.join(ctx.secondaryPkgPath, "index.mjs");
+    return ctx.repo.exists(cand) ? base(ctx, cand, true) : null;
+  },
+  (ctx) => ctx.secondaryPkgJson?.main ? base(ctx, path.join(ctx.secondaryPkgPath, ctx.secondaryPkgJson.main), ctx.esm) : null,
+  (ctx) => {
+    const cand = path.join(ctx.secondaryPkgPath, "index.js");
+    return ctx.repo.exists(cand) ? base(ctx, cand, ctx.esm) : null;
+  },
+  (ctx) => {
+    const cand = ctx.secondaryPkgPath + ".js";
+    return ctx.repo.exists(cand) ? base(ctx, cand, ctx.esm) : null;
+  },
+  (ctx) => {
+    const cand = ctx.secondaryPkgPath + ".mjs";
+    return ctx.repo.exists(cand) ? base(ctx, cand, ctx.esm) : null;
+  }
+];
+function resolvePackageInfo(repo, packageName, directory) {
+  const mainPkgName = getPkgFolder(packageName);
+  if (!mainPkgName) throw new Error(`Could not resolve "${packageName}" in "${directory}`);
+  const mainPkgJsonPath = repo.findDepPackageJson(packageName, directory);
+  if (!mainPkgJsonPath) return null;
+  const mainPkgPath = path.dirname(mainPkgJsonPath);
+  const mainPkgJson = repo.readJson(mainPkgJsonPath);
+  const version = mainPkgJson["version"];
+  const esm = mainPkgJson["type"] === "module";
+  if (!version) {
+    logger.warn("No version found for " + packageName);
+    return null;
+  }
+  const pathToSecondary = path.relative(mainPkgName, packageName);
+  const relSecondaryPath = !pathToSecondary ? "." : "./" + pathToSecondary.replace(/\\/g, "/");
+  const secondaryPkgPath = path.join(mainPkgPath, relSecondaryPath);
+  const secondaryPkgJsonPath = path.join(secondaryPkgPath, "package.json");
+  const secondaryPkgJson = repo.exists(secondaryPkgJsonPath) ? repo.readJson(secondaryPkgJsonPath) : null;
+  const ctx = {
+    packageName,
+    version,
+    esm,
+    mainPkgPath,
+    mainPkgJson,
+    relSecondaryPath,
+    secondaryPkgPath,
+    secondaryPkgJson,
+    repo
+  };
+  for (const strategy of STRATEGIES) {
+    const result = strategy(ctx);
+    if (result) return result;
+  }
+  logger.warn("No entry point found for " + packageName);
+  logger.warn(
+    "If you don't need this package, skip it in your federation.config.js or consider moving it into depDependencies in your package.json"
+  );
+  return null;
+}
+export {
+  resolvePackageInfo
+};

package/dist/lib/utils/package/esm-detection.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Classify a package.json `exports` condition key as ESM (`true`), CJS (`false`),
+ * or ambiguous (`undefined`).
+ */
+export declare const isESMExport: (e: string) => boolean | undefined;

package/dist/lib/utils/package/esm-detection.js

@@ -0,0 +1,10 @@
+const isESMExport = (e) => {
+  if (e === "import" || e === "module-sync") return true;
+  if (e === "module" || e === "esm" || /^es20\d{2}$/.test(e)) return true;
+  if (e === "require") return false;
+  if (e === "cjs" || e === "commonjs") return false;
+  return void 0;
+};
+export {
+  isESMExport
+};

package/dist/lib/utils/package/exports-resolver.d.ts

@@ -0,0 +1,13 @@
+import type { ExportEntry, PackageInfo } from '../../domain/utils/package-json.contract.js';
+export declare function replaceGlob(target: ExportEntry, replacement: string): ExportEntry;
+/**
+ * Walk an `exports` entry (string, conditions object, or array) to the single
+ * best target, preferring ESM. Returns a {@link PackageInfo} with `entryPoint`
+ * resolved relative to `info.entryPoint`, or `undefined` when nothing resolves.
+ */
+export declare function findOptimalExport(target: ExportEntry, info: PackageInfo, isESM?: boolean | undefined): PackageInfo | undefined;
+/**
+ * Find the `exports` field entry matching a secondary subpath (e.g. `./sub`),
+ * expanding subpath-pattern (`*`) entries. Returns `undefined` when no key matches.
+ */
+export declare function resolveExportsEntry(exports: Record<string, ExportEntry> | undefined, relSecondaryPath: string): ExportEntry;

package/dist/lib/utils/package/exports-resolver.js

@@ -0,0 +1,55 @@
+import * as path from "path";
+import { isESMExport } from "./esm-detection.js";
+function replaceGlob(target, replacement) {
+  if (!target) return void 0;
+  if (typeof target === "string") return target.replace("*", replacement);
+  return Object.entries(target).reduce(
+    (a, [k, v]) => ({
+      ...a,
+      [k]: replaceGlob(v, replacement)
+    }),
+    {}
+  );
+}
+function findOptimalExport(target, info, isESM = void 0) {
+  if (typeof target === "string") {
+    return {
+      ...info,
+      entryPoint: path.join(info.entryPoint, target),
+      esm: isESM ?? info.esm
+    };
+  }
+  if (!target) return void 0;
+  if (Array.isArray(target)) return findOptimalExport(target[0], info, isESM);
+  const exportTypes = Object.keys(target);
+  if (typeof isESM === "undefined") {
+    const esmExport = exportTypes.find((e) => isESMExport(e));
+    if (esmExport) {
+      return findOptimalExport(target[esmExport], info, true);
+    }
+  }
+  const secondBestEntry = "default" in target && target["default"] ? "default" : exportTypes.filter((e) => e !== "types")[0];
+  const secondBestExport = target[secondBestEntry];
+  return findOptimalExport(secondBestExport, info, isESM ?? isESMExport(secondBestEntry));
+}
+function resolveExportsEntry(exports, relSecondaryPath) {
+  const exportsKey = Object.keys(exports ?? {}).find((e) => {
+    if (e === relSecondaryPath) return true;
+    if (e === "./*") return true;
+    if (!e.endsWith("*")) return false;
+    const globPath = e.substring(0, e.length - 1);
+    return relSecondaryPath.startsWith(globPath);
+  });
+  if (!exportsKey || !exports) return void 0;
+  let entry = exports[exportsKey];
+  if (exportsKey.endsWith("*")) {
+    const replacement = relSecondaryPath.substring(exportsKey.length - 1);
+    entry = replaceGlob(entry, replacement);
+  }
+  return entry;
+}
+export {
+  findOptimalExport,
+  replaceGlob,
+  resolveExportsEntry
+};

package/dist/lib/utils/package/package-info.d.ts

@@ -0,0 +1,7 @@
+import type { PackageInfo, PackageJsonRepository, VersionMap } from '../../domain/utils/package-json.contract.js';
+export { sharedPackageJsonRepository } from '../io/package-json-repository.js';
+export type { PackageInfo, VersionMap, ExportCondition, ExportEntry, } from '../../domain/utils/package-json.contract.js';
+export { isESMExport } from './esm-detection.js';
+export declare function getPackageInfo(packageName: string, workspaceRoot: string, repo?: PackageJsonRepository): PackageInfo | null;
+export declare function getVersionMaps(project: string, workspace: string, repo?: PackageJsonRepository): VersionMap[];
+export declare function findDepPackageJson(packageName: string, projectRoot: string, repo?: PackageJsonRepository): string | null;

package/dist/lib/utils/package/package-info.js

@@ -0,0 +1,31 @@
+import { logger } from "../logger.js";
+import { normalize } from "../normalize.js";
+import { sharedPackageJsonRepository } from "../io/package-json-repository.js";
+import { resolvePackageInfo } from "./entry-point-resolver.js";
+import { getVersionMaps as getVersionMapsFromRepo } from "./version-maps.js";
+import { sharedPackageJsonRepository as sharedPackageJsonRepository2 } from "../io/package-json-repository.js";
+import { isESMExport } from "./esm-detection.js";
+function getPackageInfo(packageName, workspaceRoot, repo = sharedPackageJsonRepository) {
+  workspaceRoot = normalize(workspaceRoot, true);
+  for (const info of repo.getPackageJsonFiles(workspaceRoot, workspaceRoot)) {
+    const cand = resolvePackageInfo(repo, packageName, info.directory);
+    if (cand) {
+      return cand;
+    }
+  }
+  logger.warn("No meta data found for shared lib " + packageName);
+  return null;
+}
+function getVersionMaps(project, workspace, repo = sharedPackageJsonRepository) {
+  return getVersionMapsFromRepo(repo, project, workspace);
+}
+function findDepPackageJson(packageName, projectRoot, repo = sharedPackageJsonRepository) {
+  return repo.findDepPackageJson(packageName, projectRoot);
+}
+export {
+  findDepPackageJson,
+  getPackageInfo,
+  getVersionMaps,
+  isESMExport,
+  sharedPackageJsonRepository2 as sharedPackageJsonRepository
+};

package/dist/lib/utils/package/resolve-wildcard-keys.d.ts

@@ -0,0 +1,3 @@
+import type { GlobPort } from '../../domain/utils/io-port.contract.js';
+import type { KeyValuePair } from '../../domain/utils/keyvaluepair.contract.js';
+export declare function resolvePackageJsonExportsWildcardCore(io: GlobPort, keyPattern: string, valuePattern: string, cwd: string): KeyValuePair[];

package/dist/lib/utils/package/resolve-wildcard-keys.js

@@ -0,0 +1,22 @@
+import { captureWildcard, parseWildcard, substituteWildcard, toPosix } from "../path-patterns.js";
+function resolvePackageJsonExportsWildcardCore(io, keyPattern, valuePattern, cwd) {
+  const pattern = parseWildcard(valuePattern.replace(/^\.?\/+/, ""));
+  if (!pattern.hasWildcard) {
+    return [];
+  }
+  const files = io.globFiles(pattern.prefix + "**/*" + pattern.suffix, { cwd });
+  const keys = [];
+  for (const file of files) {
+    const relPath = toPosix(file).replace(/^\.\//, "");
+    const captured = captureWildcard(relPath, pattern);
+    if (captured === null) continue;
+    keys.push({
+      key: substituteWildcard(keyPattern, captured),
+      value: relPath
+    });
+  }
+  return keys;
+}
+export {
+  resolvePackageJsonExportsWildcardCore
+};

package/dist/lib/utils/package/version-maps.d.ts

@@ -0,0 +1,3 @@
+import type { PackageJsonRepository, VersionMap } from '../../domain/utils/package-json.contract.js';
+/** Extract a `{ name: version }` map from every package.json's `dependencies`. */
+export declare function getVersionMaps(repo: PackageJsonRepository, project: string, workspace: string): VersionMap[];

package/dist/lib/utils/package/version-maps.js

@@ -0,0 +1,8 @@
+function getVersionMaps(repo, project, workspace) {
+  return repo.getPackageJsonFiles(project, workspace).map((json) => ({
+    ...json.content["dependencies"]
+  }));
+}
+export {
+  getVersionMaps
+};

package/dist/lib/utils/path-patterns.d.ts

@@ -0,0 +1,14 @@
+export declare const toPosix: (p: string) => string;
+export interface WildcardPattern {
+    prefix: string;
+    suffix: string;
+    hasWildcard: boolean;
+}
+export declare function parseWildcard(pattern: string): WildcardPattern;
+export declare function matchesWildcard(value: string, pattern: string): boolean;
+/**
+ * End-anchored capture of the substring matched by `*` (which may span path
+ * separators). Returns `null` when `value` does not fit the pattern.
+ */
+export declare function captureWildcard(value: string, pattern: WildcardPattern): string | null;
+export declare function substituteWildcard(template: string, captured: string): string;

package/dist/lib/utils/path-patterns.js

@@ -0,0 +1,28 @@
+const toPosix = (p) => p.replace(/\\/g, "/");
+function parseWildcard(pattern) {
+  const i = pattern.indexOf("*");
+  if (i === -1) return { prefix: pattern, suffix: "", hasWildcard: false };
+  return { prefix: pattern.slice(0, i), suffix: pattern.slice(i + 1), hasWildcard: true };
+}
+function matchesWildcard(value, pattern) {
+  const { prefix, suffix, hasWildcard } = parseWildcard(pattern);
+  if (!hasWildcard) return value === pattern;
+  return value.startsWith(prefix) && (suffix === "" || value.endsWith(suffix));
+}
+function captureWildcard(value, pattern) {
+  const { prefix, suffix, hasWildcard } = pattern;
+  if (!hasWildcard) return value === prefix ? "" : null;
+  if (!value.startsWith(prefix)) return null;
+  if (suffix && !value.endsWith(suffix)) return null;
+  return suffix ? value.slice(prefix.length, value.length - suffix.length) : value.slice(prefix.length);
+}
+function substituteWildcard(template, captured) {
+  return template.replace("*", captured);
+}
+export {
+  captureWildcard,
+  matchesWildcard,
+  parseWildcard,
+  substituteWildcard,
+  toPosix
+};