@sous-io/sous 0.2.37 → 1.0.1

package/src/services/ref-resolver/container.ts

@@ -1,107 +0,0 @@
-/**
- * The Inversify container of the ref services.
- *
- * Every part is bound once and shared: the parser, every splitter, every
- * pruner, the resolver and the picker. Splitters, pruners and providers are
- * bound many times under one token each (`REF_TOKENS`), and the parser and the
- * resolver receive them as lists, so a plugin adds a splitter, a pruner or a
- * provider by binding one more under the same token on a container it builds
- * with `createRefContainer()`:
- *
- *     const container = createRefContainer();
- *     container.bind(REF_TOKENS.Splitter).to(MyNewFormSplitter);
- *     const resolver = container.get<RefResolverService>(REF_TOKENS.Resolver);
- *
- * The `#` names are bound the same way: one more `HashName` under
- * `REF_TOKENS.HashName` registers a view or a built-in, and a name bound twice
- * is an error when the registry is first read.
- *
- * Callers that have no container of their own use `sharedRefResolver`,
- * `sharedHashNames` and `sharedRefPicker`, which come from one container built the first time they
- * are read.
- */
-
-import { Container } from "inversify";
-import { builtInProviders } from "../../lib/repos/providers/index.js";
-import { EnvVarSplitter } from "./parser/env-var-splitter.js";
-import { LocationSplitter } from "./parser/location-splitter.js";
-import { NamePathSplitter } from "./parser/name-path-splitter.js";
-import { QuerySplitter } from "./parser/query-splitter.js";
-import { RangeSplitter } from "./parser/range-splitter.js";
-import { RefParser } from "./parser/ref-parser.js";
-import { RepoQualifierSplitter } from "./parser/repo-qualifier-splitter.js";
-import { CommandLinePruner } from "./pruners/command-line-pruner.js";
-import { IncludePruner } from "./pruners/include-pruner.js";
-import { ManifestPruner } from "./pruners/manifest-pruner.js";
-import { ConfigPruner, LockfilePruner } from "./pruners/stored-key-pruner.js";
-import { MemoriesHashName } from "../../lib/repos/memories-hash-name.js";
-import { HashNameRegistry, ProjectHashName } from "./hash-names.js";
-import { RefPickerService } from "./ref-picker-service.js";
-import { RefResolverService } from "./ref-resolver-service.js";
-import { REF_TOKENS } from "./tokens.js";
-
-/**
- * Builds a container holding every ref service. Each call returns a fresh
- * container, so a plugin or a test may bind more splitters or pruners without
- * touching anyone else's.
- */
-export function createRefContainer(): Container {
-  const container = new Container({ defaultScope: "Singleton" });
-
-  for (const provider of builtInProviders()) {
-    container.bind(REF_TOKENS.Provider).toConstantValue(provider);
-  }
-
-  for (const splitter of [
-    QuerySplitter,
-    RangeSplitter,
-    LocationSplitter,
-    RepoQualifierSplitter,
-    NamePathSplitter,
-    EnvVarSplitter,
-  ]) {
-    container.bind(REF_TOKENS.Splitter).to(splitter);
-  }
-
-  for (const pruner of [
-    CommandLinePruner,
-    ConfigPruner,
-    ManifestPruner,
-    LockfilePruner,
-    IncludePruner,
-  ]) {
-    container.bind(REF_TOKENS.Pruner).to(pruner);
-  }
-
-  container.bind(REF_TOKENS.HashName).to(ProjectHashName);
-  container.bind(REF_TOKENS.HashName).to(MemoriesHashName);
-  container.bind(REF_TOKENS.HashNames).to(HashNameRegistry);
-  container.bind(REF_TOKENS.Parser).to(RefParser);
-  container.bind(REF_TOKENS.Resolver).to(RefResolverService);
-  container.bind(REF_TOKENS.Picker).to(RefPickerService);
-  return container;
-}
-
-/** The container the shared instances come from, built on first use. */
-let sharedContainer: Container | undefined;
-
-/** The one container callers with no container of their own share. */
-export function getSharedRefContainer(): Container {
-  sharedContainer ??= createRefContainer();
-  return sharedContainer;
-}
-
-/** The shared resolver, for callers that have no container. */
-export function sharedRefResolver(): RefResolverService {
-  return getSharedRefContainer().get<RefResolverService>(REF_TOKENS.Resolver);
-}
-
-/** The shared registry of `#` names, for callers that have no container. */
-export function sharedHashNames(): HashNameRegistry {
-  return getSharedRefContainer().get<HashNameRegistry>(REF_TOKENS.HashNames);
-}
-
-/** The shared picker, for callers that have no container. */
-export function sharedRefPicker(): RefPickerService {
-  return getSharedRefContainer().get<RefPickerService>(REF_TOKENS.Picker);
-}

package/src/services/ref-resolver/dependency.ts

@@ -1,60 +0,0 @@
-/**
- * Settling a manifest dependency that reads more than one way, from what is
- * already at hand.
- *
- * A manifest entry usually says exactly what it means. A GitLab URL with nested
- * groups does not say where the project path ends, and a browser URL names a
- * folder, so the parser returns every reading. A release settles such an entry
- * and records the repository it settled on beside each key it resolved
- * (`RecordedDependencies`); a consumer reads that record and never probes.
- */
-
-import { sharedRefResolver } from "./container.js";
-import {
-  isConfirmedByRecord,
-  type RecordedDependencies,
-} from "./lookups/recorded-dependency-lookup.js";
-import { RefSource } from "./source.js";
-import type { SousRef } from "./types.js";
-
-/** What `settleDependency` may consult, beyond the dependency itself. */
-export type SettleDependencyOptions = {
-  /** What the declaring version's index entry records about its dependencies. */
-  recorded?: RecordedDependencies;
-  /**
-   * Whether a reading is already known to be right from what is on this
-   * machine: its repository is trusted and its cached index publishes what it
-   * names. Used only when the index recorded nothing, and it never fetches.
-   */
-  known?: (reading: SousRef) => boolean;
-};
-
-/**
- * The one reading a manifest dependency settles on, or undefined when it reads
- * more than one way and nothing at hand says which: the declaring recipe's
- * index recorded no answer, and what this machine already knows does not pick
- * exactly one.
- *
- * settleDependency("workflow/alpha");
- * // -> the recipe workflow/alpha
- *
- * @param written - The dependency as the manifest wrote it.
- * @param options - The index's record, and what is known locally.
- * @throws A ConfigError when a manifest may not write the entry that way.
- */
-export function settleDependency(
-  written: string,
-  options: SettleDependencyOptions = {}
-): SousRef | undefined {
-  const { refs } = sharedRefResolver().parse(written, RefSource.Manifest);
-  if (refs.length === 1) return refs[0];
-
-  const confirmed = refs.filter((ref) => isConfirmedByRecord(ref, options.recorded));
-  if (confirmed.length === 1) return confirmed[0];
-
-  if (options.known !== undefined) {
-    const known = refs.filter(options.known);
-    if (known.length === 1) return known[0];
-  }
-  return undefined;
-}

package/src/services/ref-resolver/format.ts

@@ -1,197 +0,0 @@
-/**
- * Printing a ref: its key (what everything is stored and compared under) and
- * its canonical written form (how sous prints it).
- */
-
-import {
-  builtInProviders,
-  providerById,
-  type RepoProvider,
-} from "../../lib/repos/providers/index.js";
-import { repoOf } from "./parts.js";
-import { KIND_LABELS, type RepoRef, type SousRef } from "./types.js";
-
-/**
- * The part of a key that names the repository: its short name, or its
- * identity when it was named by location.
- */
-function repoPart(repo: RepoRef | undefined): string | undefined {
-  if (repo === undefined) return undefined;
-  return repo.name ?? repo.location?.identity;
-}
-
-/**
- * The path part of a key, without any repository.
- *
- * @param ref - Any ref.
- */
-function pathPart(ref: SousRef): string {
-  switch (ref.kind) {
-    case "repo":
-      return ref.browsed === undefined ? "" : `tree/${ref.browsed}`;
-    case "namespace":
-      return ref.name;
-    case "recipe":
-      return ref.namespace === undefined ? ref.name : `${ref.namespace.name}/${ref.name}`;
-    case "recipeFile":
-      return `${pathPart(ref.recipe)}/${ref.path}`;
-    case "variable": {
-      const recipe = ref.recipe === undefined ? "" : `${pathPart(ref.recipe)}.`;
-      return `${recipe}${ref.name}`;
-    }
-    case "envVar":
-      return ref.name;
-  }
-}
-
-/**
- * The canonical key of a ref, with its version range and query values left
- * off, so the same thing is never keyed twice under two spellings. A
- * repository qualifier is part of the key, because the same recipe name in two
- * repositories is two things.
- *
- * refKey(namespace("workflow")); // -> "workflow"
- * refKey(recipe("task-files", "workflow", "sous-recipes")); // -> "sous-recipes:workflow/task-files"
- * refKey(variable("apiUrl", recipe)); // -> "workflow/task-files.apiUrl"
- *
- * @param ref - Any ref.
- */
-export function refKey(ref: SousRef): string {
-  const repo = ref.kind === "envVar" ? undefined : repoPart(repoOf(ref));
-  const rest = pathPart(ref);
-  if (ref.kind === "repo") return repo === undefined ? rest : rest === "" ? repo : `${repo}:${rest}`;
-  return repo === undefined ? rest : `${repo}:${rest}`;
-}
-
-/**
- * The key of a ref together with its kind, which is what tells a namespace
- * `workflow` from a repository `workflow` apart.
- *
- * @param ref - Any ref.
- */
-export function refIdentity(ref: SousRef): string {
-  return `${ref.kind} ${refKey(ref)}`;
-}
-
-/**
- * Writes the repository qualifier in front of what is named inside it: `name:`
- * for a repository this project knows by short name (whatever else it knows of
- * it), and the provider's canonical locator for one known only by location.
- */
-function qualified(
-  repo: RepoRef | undefined,
-  rest: string,
-  providers: RepoProvider[]
-): string {
-  if (repo === undefined) return rest;
-  if (repo.name !== undefined) return rest === "" ? repo.name : `${repo.name}:${rest}`;
-  if (repo.location !== undefined) {
-    const { host, repoPath } = repo.location;
-    const provider = providerById(repo.location.provider, providers);
-    if (provider !== undefined && provider.id !== "local") {
-      return provider.formatLocator(host, repoPath, rest);
-    }
-    return rest === "" ? repo.location.url : `${repo.location.url}/${rest}`;
-  }
-  return rest;
-}
-
-/**
- * The canonical written form of a ref, which is how sous prints it: the short
- * form for a short ref and each provider's own locator for a located one, then
- * the version range, then the query values.
- *
- * formatRef(parse("https://github.com/o/r/w/a@^1")[0]); // -> "github://o/r/w/a@^1"
- *
- * @param ref - Any ref.
- * @param providers - The providers that format locators. Defaults to the built-ins.
- */
-export function formatRef(ref: SousRef, providers: RepoProvider[] = builtInProviders()): string {
-  const body = qualified(ref.kind === "envVar" ? undefined : repoOf(ref), pathPart(ref), providers);
-  const written =
-    ref.kind === "recipe" || ref.kind === "recipeFile" || ref.kind === "repo"
-      ? ref.range
-      : undefined;
-  const range = written === undefined ? "" : `@${written}`;
-  const pairs = Object.entries(ref.vars ?? {}).map(
-    ([name, value]) => `${encodeURIComponent(name)}=${encodeURIComponent(value)}`
-  );
-  return `${body}${range}${pairs.length === 0 ? "" : `?${pairs.join("&")}`}`;
-}
-
-/**
- * What kind of thing a ref names, in a sentence.
- *
- * @param ref - Any ref.
- */
-export function refKindLabel(ref: SousRef): string {
-  return KIND_LABELS[ref.kind];
-}
-
-/**
- * How a ref is written to a person, so they can type it back: its key when a
- * repository's short name qualifies it, and its canonical locator when only a
- * location does (a ref that has not been matched to a repository this project
- * knows by name).
- *
- * refSpelling(recipe "task-files" in "sous-recipes") // -> "sous-recipes:workflow/task-files"
- * refSpelling(a recipe at a located repository)      // -> its canonical locator
- *
- * @param ref - Any ref.
- */
-export function refSpelling(ref: SousRef): string {
-  const repo = ref.kind === "envVar" ? undefined : repoOf(ref);
-  if (repo !== undefined && repo.name === undefined && repo.location !== undefined) {
-    return formatRef(ref);
-  }
-  return refKey(ref);
-}
-
-/** The repository a person is told a ref lives in: its short name, or where it lives. */
-function repoLabel(repo: RepoRef | undefined): string {
-  return repo?.name ?? repo?.location?.url ?? "unknown";
-}
-
-/**
- * Describes one ref in the words a person choosing between several needs: the
- * fully qualified name, and what it actually means.
- *
- * @param ref - A known ref, as a lookup returns it.
- */
-export function describeRef(ref: SousRef): string {
-  const summary = ref.description === undefined ? "" : `: ${ref.description}`;
-  const key = refSpelling(ref);
-
-  switch (ref.kind) {
-    case "repo": {
-      const where = ref.location?.url;
-      return `${key}  (the repository '${ref.name ?? key}'${where === undefined ? "" : `, at ${where}`})`;
-    }
-    case "namespace":
-      return (
-        `${key}  (the whole namespace '${ref.name}' in the ` +
-        `repository '${repoLabel(ref.repo)}')`
-      );
-    case "recipe":
-      return (
-        `${key}  (the recipe '${ref.name}' in the namespace ` +
-        `'${ref.namespace?.name ?? "unknown"}' of the repository ` +
-        `'${repoLabel(repoOf(ref))}'${summary})`
-      );
-    case "recipeFile":
-      return `${key}  (the file '${ref.path}' of the recipe '${pathPart(ref.recipe)}'${summary})`;
-    case "variable":
-      return (
-        `${key}  (the variable '${ref.name}' of the recipe ` +
-        `'${ref.recipe === undefined ? "unknown" : pathPart(ref.recipe)}'${summary})`
-      );
-    case "envVar": {
-      const first = ref.variables?.[0];
-      const answers =
-        first === undefined
-          ? ""
-          : `answering '${first.name}' of the recipe '${first.recipe === undefined ? "unknown" : pathPart(first.recipe)}'`;
-      return `${ref.name}  (the environment variable${answers === "" ? "" : ` ${answers}`}${summary})`;
-    }
-  }
-}

package/src/services/ref-resolver/glob.ts

@@ -1,115 +0,0 @@
-/**
- * Names, glob patterns and how a written name is compared with a known one.
- *
- * Every name or path part of a ref may be a glob pattern (`*`, `**`, `?`,
- * `[..]`, `{a,b}`), matched with minimatch. Plain names are compared as
- * strings. Either way the exact spelling is tried first and ignoring case is
- * the fallback, so the caller can tell which one matched.
- */
-
-import { minimatch } from "minimatch";
-
-/** A name as the parser accepts it: kebab-case, in any case. */
-export const NAME_ANY_CASE = /^[a-z][a-z0-9-]*$/i;
-
-/** A name as it is stored: lowercase kebab-case. */
-export const NAME_STORED = /^[a-z][a-z0-9-]*$/;
-
-/** A variable name, as a recipe's author writes it: camelCase. */
-export const VARIABLE_NAME = /^[a-z][a-zA-Z0-9]*$/;
-
-/** An environment variable name: whatever a shell accepts. */
-export const ENV_VAR_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
-
-/** The characters a glob pattern is made of. */
-const GLOB_CHARS = /[*?[\]{}]/;
-
-/** The characters a glob pattern standing for a name may use. */
-const GLOB_NAME = /^[A-Za-z0-9_\-.*?[\]{},!^]+$/;
-
-/** True when a string holds glob syntax. */
-export function hasGlob(text: string): boolean {
-  return GLOB_CHARS.test(text);
-}
-
-/** True when a string is a glob pattern that could stand for a name. */
-export function isGlobName(text: string): boolean {
-  return hasGlob(text) && GLOB_NAME.test(text);
-}
-
-/**
- * Splits text at `/`, except inside braces, so `{a/b,c}` stays whole.
- *
- * splitSegments("a/{b/c,d}/e"); // -> ["a", "{b/c,d}", "e"]
- *
- * @param text - The text to split.
- */
-export function splitSegments(text: string): string[] {
-  const segments: string[] = [];
-  let depth = 0;
-  let current = "";
-  for (const character of text) {
-    if (character === "{") depth += 1;
-    if (character === "}" && depth > 0) depth -= 1;
-    if (character === "/" && depth === 0) {
-      segments.push(current);
-      current = "";
-      continue;
-    }
-    current += character;
-  }
-  segments.push(current);
-  return segments;
-}
-
-/** How a written name matched a known one. */
-export type NameMatch = "exact" | "folded" | undefined;
-
-/**
- * Whether a written name (or glob pattern) matches a known one: exactly, only
- * ignoring case, or not at all.
- *
- * matchName("Workflow", "workflow"); // -> "folded"
- * matchName("work*", "workflow"); // -> "exact"
- *
- * @param written - The name or pattern as written.
- * @param known - The name as it is spelled where it is published.
- */
-export function matchName(written: string, known: string): NameMatch {
-  if (hasGlob(written)) {
-    if (minimatch(known, written, { dot: true })) return "exact";
-    return minimatch(known, written, { dot: true, nocase: true }) ? "folded" : undefined;
-  }
-  if (written === known) return "exact";
-  return written.toLowerCase() === known.toLowerCase() ? "folded" : undefined;
-}
-
-/**
- * The names that match a written one: those spelled exactly as written, or,
- * when there is none, those that differ only in case.
- *
- * matchNames("Workflow", ["workflow", "tooling"]); // -> ["workflow"]
- * matchNames("workflow", ["workflow", "Workflow"]); // -> ["workflow"]
- *
- * @param written - The name as written.
- * @param names - The names it could mean.
- */
-export function matchNames(written: string, names: Iterable<string>): string[] {
-  const all = [...names];
-  const exact = all.filter((name) => matchName(written, name) === "exact");
-  if (exact.length > 0) return exact;
-  return all.filter((name) => matchName(written, name) === "folded");
-}
-
-/**
- * Orders two strings by their UTF-8 bytes, so the order is the same on every
- * machine whatever its locale.
- *
- * ["b", "B", "a"].sort(compareBytewise); // -> ["B", "a", "b"]
- *
- * @param left - The first string.
- * @param right - The second string.
- */
-export function compareBytewise(left: string, right: string): number {
-  return Buffer.compare(Buffer.from(left), Buffer.from(right));
-}

package/src/services/ref-resolver/hash-names.ts

@@ -1,155 +0,0 @@
-/**
- * The `#` names: the built-in names an include line, a `{% render %}` path or
- * an `entryGlob` may start with, such as `#project`.
- *
- * `~` keeps meaning the home directory and recipe namespaces; `#` is for names
- * sous or a plugin provides. Each name is registered once, with the directories
- * it stands for, and a registration that repeats a name is an error naming both
- * registrants. A later layer registers a view the same way.
- *
- * A plugin adds a name by binding one more `HashName` under
- * `REF_TOKENS.HashName` on a container it builds with `createRefContainer()`.
- */
-
-import { ConfigError } from "../../lib/errors.js";
-import { compareBytewise } from "./glob.js";
-import { makeInjectable } from "./injectable.js";
-import { REF_TOKENS } from "./tokens.js";
-
-/** One file a view lists: where it sits in the view, and the real file behind it. */
-export interface ViewFile {
-  /** The path inside the view, without the `#name/` prefix, with `/` separators. */
-  readonly path: string;
-  /** The real file's absolute path. */
-  readonly file: string;
-}
-
-/** What a view needs to know about the project to list its files. */
-export interface HashViewContext {
-  /** The project's `.sous/` directory. */
-  sousDir: string;
-  /** The environment to read; decides where the recipe store is. */
-  env?: NodeJS.ProcessEnv;
-  /** The merged project config, read for the `recipes` key. */
-  settings: {
-    recipes?: { memories?: { first?: string[] | undefined; exclude?: string[] | undefined } };
-  };
-}
-
-/** One `#` name and what it stands for. */
-export interface HashName {
-  /** The name without its `#`: lowercase kebab-case, such as `project`. */
-  readonly name: string;
-  /** Who registers it, for the error a duplicate raises (`sous`, or a plugin's name). */
-  readonly registeredBy: string;
-  /** What the name is, in one sentence. */
-  readonly description: string;
-  /**
-   * The directories the name stands for, in the order they are tried. A path
-   * after the name is looked up under each in turn, the first that exists
-   * wins. Empty when the name has nothing to stand for in this project.
-   *
-   * @param scope - The settings scope the project's paths come from.
-   */
-  bases(scope: Record<string, string>): string[];
-  /**
-   * A view lists virtual files instead of standing for directories: an include
-   * of `#name/<glob>` selects among the listed paths and includes the real
-   * files behind them, in the listed order. A view has no bases.
-   *
-   * @param context - The project the files are listed for.
-   */
-  view?(context: HashViewContext): ViewFile[];
-}
-
-/** The characters a registered name may hold. */
-const VALID_NAME = /^[a-z][a-z0-9-]*$/;
-
-/** The built-in `#project`: the consuming project's root. */
-export class ProjectHashName implements HashName {
-  readonly name = "project";
-  readonly registeredBy = "sous";
-  readonly description = "the root directory of the project being built.";
-
-  bases(scope: Record<string, string>): string[] {
-    return scope.projectRoot ? [scope.projectRoot] : [];
-  }
-}
-
-makeInjectable(ProjectHashName);
-
-/** Every registered `#` name. */
-export class HashNameRegistry {
-  private readonly entries = new Map<string, HashName>();
-
-  /**
-   * @param names - The names to register, each once.
-   * @throws A ConfigError when a name is invalid or registered twice.
-   */
-  constructor(names: HashName[] = []) {
-    for (const entry of names) this.register(entry);
-  }
-
-  /**
-   * Adds a name.
-   *
-   * @param entry - The name to add.
-   * @throws A ConfigError naming both registrants when the name is already taken.
-   */
-  register(entry: HashName): void {
-    if (!VALID_NAME.test(entry.name)) {
-      throw new ConfigError(
-        `The name '#${entry.name}' registered by '${entry.registeredBy}' is invalid: a name is ` +
-          "lowercase kebab-case, a letter then letters, digits or hyphens."
-      );
-    }
-    const existing = this.entries.get(entry.name);
-    if (existing !== undefined) {
-      throw new ConfigError(
-        `The name '#${entry.name}' is registered twice: by '${existing.registeredBy}' and by ` +
-          `'${entry.registeredBy}'.`
-      );
-    }
-    this.entries.set(entry.name, entry);
-  }
-
-  /** The registered name, or undefined. */
-  get(name: string): HashName | undefined {
-    return this.entries.get(name);
-  }
-
-  /** Every registered name, sorted. */
-  list(): HashName[] {
-    return [...this.entries.values()].sort((left, right) => compareBytewise(left.name, right.name));
-  }
-
-  /**
-   * Every view's listed files, keyed by the name with its `#`.
-   *
-   * @param context - The project the files are listed for.
-   */
-  viewMap(context: HashViewContext): Record<string, ViewFile[]> {
-    const map: Record<string, ViewFile[]> = {};
-    for (const entry of this.list()) {
-      if (entry.view !== undefined) map[`#${entry.name}`] = entry.view(context);
-    }
-    return map;
-  }
-
-  /**
-   * The alias map the registered names make for a project: `#name` to its
-   * directories, leaving out a name with none.
-   *
-   * @param scope - The settings scope the project's paths come from.
-   */
-  aliasMap(scope: Record<string, string>): Record<string, string[]> {
-    const map: Record<string, string[]> = {};
-    for (const entry of this.list()) {
-      const bases = entry.bases(scope);
-      if (bases.length > 0) map[`#${entry.name}`] = bases;
-    }
-    return map;
-  }
-}
-
-makeInjectable(HashNameRegistry, [{ multi: REF_TOKENS.HashName }]);

package/src/services/ref-resolver/index.ts

@@ -1,55 +0,0 @@
-/**
- * The ref resolver service: how every sous command and template turns a
- * written ref into the thing it names.
- *
- * Import from here. `types.ts` says what a ref is, the parser reads every way a
- * text can be one, a pruner per place says which readings count there, a
- * lookup says which exist, `RefResolverService` runs the three in order, and
- * `RefPickerService` settles which meaning a run proceeds with.
- *
- * `EnvVarLookup` is not exported here. It reads the variable ladder, which
- * reaches config discovery, and config discovery reaches this module through
- * the recipe formats, so exporting it from the barrel would make an import
- * cycle that fails at load time. Import it from `lookups/env-var-lookup.js`.
- */
-
-export * from "./source.js";
-export * from "./types.js";
-export * from "./parts.js";
-export * from "./glob.js";
-export * from "./location.js";
-export * from "./format.js";
-export * from "./tokens.js";
-export * from "./hash-names.js";
-export * from "./injectable.js";
-export * from "./parser/partial-ref.js";
-export * from "./parser/ref-parser.js";
-export * from "./parser/query-splitter.js";
-export * from "./parser/range-splitter.js";
-export * from "./parser/location-splitter.js";
-export * from "./parser/repo-qualifier-splitter.js";
-export * from "./parser/name-path-splitter.js";
-export * from "./parser/env-var-splitter.js";
-export * from "./pruners/ref-pruner.js";
-export * from "./pruners/rule-helpers.js";
-export * from "./pruners/command-line-pruner.js";
-export * from "./pruners/stored-key-pruner.js";
-export * from "./pruners/manifest-pruner.js";
-export * from "./pruners/include-pruner.js";
-export * from "./lookups/ref-lookup.js";
-export * from "./lookups/chained-lookup.js";
-export * from "./lookups/catalog-matcher.js";
-export * from "./lookups/catalog-lookup.js";
-export * from "./lookups/cached-index-lookup.js";
-export * from "./lookups/recorded-dependency-lookup.js";
-export * from "./lookups/fetched-index-lookup.js";
-export * from "./lookups/variable-lookup.js";
-export * from "./ref-resolve-arguments.js";
-export * from "./ref-resolve-result.js";
-export * from "./ref-resolver-service.js";
-export * from "./ref-picker-service.js";
-export * from "./ref-report.js";
-export * from "./named-refs.js";
-export * from "./dependency.js";
-export * from "./ref-helpers.js";
-export * from "./container.js";