bun-workspaces 1.8.2 → 1.10.0

package/src/2392.mjs

@@ -28,7 +28,8 @@ const CLI_COMMANDS_CONFIG = {
     options: {
       workspacePatterns: {
         flags: ["-W", "--workspace-patterns <patterns>"],
-        description: "Workspace patterns to match, separated by spaces",
+        description:
+          "Workspace patterns to match, separated by whitespace. Use backslashes to escape spaces if needed.",
       },
       nameOnly: {
         flags: ["-n", "--name-only"],
@@ -144,6 +145,79 @@ const CLI_COMMANDS_CONFIG = {
       "Start the bun-workspaces MCP (Model Context Protocol) server over stdio",
     options: {},
   },
+  listAffected: {
+    command: "list-affected",
+    isGlobal: false,
+    aliases: ["ls-affected"],
+    description:
+      "List workspaces affected by a set of changed files (git or file list)",
+    options: {
+      base: {
+        flags: ["-B", "--base <ref>"],
+        description:
+          "Git base ref to diff against (default is main if not configured). Cannot be used with --files",
+      },
+      head: {
+        flags: ["-H", "--head <ref>"],
+        description:
+          "Git head ref to diff against (default: HEAD). Cannot be used with --files",
+      },
+      files: {
+        flags: ["-F", "--files <files>"],
+        description:
+          "Changed files (paths/dirs/globs, '!' to exclude), separated by spaces. Use backslashes to escape spaces if needed. Bypasses git, so cannot be used with --base or --head.",
+      },
+      script: {
+        flags: ["-S", "--script <script>"],
+        description: "Resolve inputs for the named script",
+      },
+      ignoreUntracked: {
+        flags: ["--ignore-untracked"],
+        description: "Exclude untracked files",
+      },
+      ignoreUnstaged: {
+        flags: ["--ignore-unstaged"],
+        description: "Exclude unstaged files",
+      },
+      ignoreStaged: {
+        flags: ["--ignore-staged"],
+        description: "Exclude staged files",
+      },
+      ignoreUncommitted: {
+        flags: ["--ignore-uncommitted"],
+        description:
+          "Exclude all uncommitted changes (staged, unstaged, untracked)",
+      },
+      ignoreWorkspaceDeps: {
+        flags: ["--ignore-workspace-deps"],
+        description:
+          "Ignore workspace dependencies derived from package.json files",
+      },
+      ignoreExternalDeps: {
+        flags: ["--ignore-external-deps"],
+        description:
+          "Ignore changes to external dependencies (e.g. npm packages) versions in bun.lock",
+      },
+      explain: {
+        flags: ["-e", "--explain"],
+        description:
+          "Include changed-file counts and dependency reasons. With --json, outputs the full result object",
+      },
+      detailed: {
+        flags: ["-D", "--detailed"],
+        description:
+          "With --explain, render full per-file data and dependency edge chains",
+      },
+      json: {
+        flags: JSON_FLAGS,
+        description: "Output as JSON",
+      },
+      pretty: {
+        flags: PRETTY_FLAGS,
+        description: "Pretty print JSON",
+      },
+    },
+  },
   runScript: {
     command: "run-script [script] [workspacePatterns...]",
     isGlobal: false,
@@ -153,11 +227,118 @@ const CLI_COMMANDS_CONFIG = {
     options: {
       script: {
         flags: ["-S", "--script <script>"],
-        description: "The script to run.",
+        description: "The script to run. (Alternative to positional argument)",
       },
       workspacePatterns: {
         flags: ["-W", "--workspace-patterns <patterns>"],
-        description: "Workspace patterns to match, separated by spaces.",
+        description:
+          "Workspace patterns to match, separated by spaces. (Alternative to positional arguments)",
+      },
+      parallel: {
+        flags: ["-P", "--parallel [max]"],
+        description:
+          'Run the scripts in parallel. Pass "false" for series, or a concurrency limit as a number, percentage ("50%"), "auto", "default", or"unbounded"',
+      },
+      args: {
+        flags: ["-a", "--args <args>"],
+        description: "Args to append to the script command",
+      },
+      outputStyle: {
+        flags: ["-o", "--output-style <style>"],
+        description: "The output style to use",
+        values: [...OUTPUT_STYLE_VALUES],
+      },
+      groupedLines: {
+        flags: ["-L", "--grouped-lines <count>"],
+        description: `With grouped output, the max preview lines (number or "auto", default "auto")`,
+      },
+      noPrefix: {
+        flags: ["-N", "--no-prefix"],
+        description: "(DEPRECATED) Use --output-style=plain instead",
+        deprecated: true,
+      },
+      inline: {
+        flags: ["-i", "--inline"],
+        description:
+          "Run the script as an inline command from the workspace directory",
+      },
+      inlineName: {
+        flags: ["-I", "--inline-name <name>"],
+        description: "An optional name for the script when --inline is passed",
+      },
+      shell: {
+        flags: ["-s", "--shell <shell>"],
+        values: [...SCRIPT_SHELL_OPTIONS, "default"],
+        description: `When using --inline, the shell to use to run the script`,
+      },
+      depOrder: {
+        flags: ["-d", "--dep-order"],
+        description:
+          "Scripts for dependent workspaces run only after their dependencies",
+      },
+      ignoreDepFailure: {
+        flags: ["-f", "--ignore-dep-failure"],
+        description:
+          "In dependency order, continue running scripts even if a dependency fails",
+      },
+      jsonOutfile: {
+        flags: ["-j", "--json-outfile <file>"],
+        description: "Output results in a JSON file",
+      },
+    },
+  },
+  runAffected: {
+    command: "run-affected [script]",
+    isGlobal: false,
+    aliases: [],
+    description:
+      "Run a script across the workspaces affected by a set of changed files (git or file list)",
+    options: {
+      script: {
+        flags: ["-S", "--script <script>"],
+        description: "The script to run. (Alternative to positional argument)",
+      },
+      base: {
+        flags: ["-B", "--base <ref>"],
+        description:
+          "Git base ref to diff against (default is main if not configured). Cannot be used with --files",
+      },
+      head: {
+        flags: ["-H", "--head <ref>"],
+        description:
+          'Git head ref to diff against (default "HEAD"). Cannot be used with --files',
+      },
+      files: {
+        flags: ["-F", "--files <files>"],
+        description:
+          "Changed files (paths/dirs/globs, '!' to exclude), separated by whitespace. Use backslashes to escape spaces if needed. Bypasses git, so cannot be used with --base or --head.",
+      },
+      ignoreUntracked: {
+        flags: ["--ignore-untracked"],
+        description: "Exclude untracked files",
+      },
+      ignoreUnstaged: {
+        flags: ["--ignore-unstaged"],
+        description: "Exclude unstaged files",
+      },
+      ignoreStaged: {
+        flags: ["--ignore-staged"],
+        description: "Exclude staged files",
+      },
+      ignoreUncommitted: {
+        flags: ["--ignore-uncommitted"],
+        description:
+          "Exclude all uncommitted changes (staged, unstaged, untracked)",
+      },
+      ignoreWorkspaceDeps: {
+        flags: ["--ignore-workspace-deps"],
+        description:
+          "Ignore workspace dependencies derived from package.json files",
+      },
+      ignoreExternalDeps: {
+        flags: ["--ignore-external-deps"],
+        description:
+          "Ignore changes to external dependencies (e.g. npm packages) versions in bun.lock",
       },
       parallel: {
         flags: ["-P", "--parallel [max]"],

package/src/5166.mjs

@@ -2,6 +2,7 @@ const USER_ENV_VARS = {
   parallelMaxDefault: "BW_PARALLEL_MAX_DEFAULT",
   scriptShellDefault: "BW_SHELL_DEFAULT",
   includeRootWorkspaceDefault: "BW_INCLUDE_ROOT_WORKSPACE_DEFAULT",
+  affectedBaseRefDefault: "BW_AFFECTED_BASE_REF_DEFAULT",
 };
 const getUserEnvVarName = (key) => USER_ENV_VARS[key];
 

package/src/8529.mjs

@@ -16,8 +16,18 @@ const CONFIG_LOCATION_PATHS = {
   jsonFile: (name) => `${name}.json`,
   packageJson: (_, packageJsonKey) => `package.json["${packageJsonKey}"]`,
 };
+const CONFIG_LOCATION_DESCRIPTIONS =
+  /* unused pure expression or super */ null && {
+    tsFile: "TypeScript file",
+    jsFile: "JavaScript file",
+    jsoncFile: "JSONC file",
+    jsonFile: "JSON file",
+    packageJson: "package.json key",
+  };
 const createConfigLocationPath = (locationType, name, packageJsonKey) =>
   CONFIG_LOCATION_PATHS[locationType](name, packageJsonKey);
+const createConfigLocationDescription = (locationType) =>
+  CONFIG_LOCATION_DESCRIPTIONS[locationType];
 
 export {
   CONFIG_LOCATION_TYPES,

package/src/affected/affectedBaseRef.mjs

@@ -0,0 +1,12 @@
+import { getUserEnvVar } from "../config/userEnvVars/index.mjs";
+
+const DEFAULT_AFFECTED_BASE_REF = "main";
+/**
+ * Resolves the default base ref for affected workspace resolution.
+ *
+ * Precedence: explicit value (typically from root config defaults) >
+ * `BW_AFFECTED_BASE_REF_DEFAULT` env var > `"main"`.
+ */ const resolveDefaultAffectedBaseRef = (value) =>
+  value || getUserEnvVar("affectedBaseRefDefault") || DEFAULT_AFFECTED_BASE_REF;
+
+export { DEFAULT_AFFECTED_BASE_REF, resolveDefaultAffectedBaseRef };

package/src/affected/externalDependencyChanges.mjs

@@ -0,0 +1,47 @@
+/**
+ * Resolve a dep's version for a specific workspace. bun.lock encodes
+ * divergent per-workspace resolutions under a `<workspaceName>/<depName>` key
+ * when the workspace's range can't dedupe with the hoisted version. Always
+ * consult that namespaced key first; fall back to the bare key for the
+ * common (hoisted) case.
+ */ const resolveWorkspaceDepVersion = ({ lock, workspaceName, depName }) =>
+  lock.get(`${workspaceName}/${depName}`) ?? lock.get(depName) ?? null;
+/**
+ * Given each workspace's declared external deps and lockfile version maps
+ * at base vs head, emit per-workspace change entries for any external dep
+ * whose resolved version differs (including added/removed).
+ *
+ * Pure function. No I/O.
+ */ const computeExternalDependencyChanges = ({
+  workspaces,
+  baseLock,
+  headLock,
+}) => {
+  const result = new Map();
+  for (const workspace of workspaces) {
+    const changes = [];
+    for (const { name, source } of workspace.externalDependencies) {
+      const baseVersion = resolveWorkspaceDepVersion({
+        lock: baseLock,
+        workspaceName: workspace.name,
+        depName: name,
+      });
+      const headVersion = resolveWorkspaceDepVersion({
+        lock: headLock,
+        workspaceName: workspace.name,
+        depName: name,
+      });
+      if (baseVersion === headVersion) continue;
+      changes.push({
+        name,
+        source,
+        baseVersion,
+        headVersion,
+      });
+    }
+    if (changes.length) result.set(workspace.name, changes);
+  }
+  return result;
+};
+
+export { computeExternalDependencyChanges };

package/src/affected/fileAffectedWorkspaces.mjs

@@ -8,10 +8,15 @@ const GLOB_CHARACTER_REGEX = /[*?[{]/;
 const toPosixPath = (filePath) => filePath.replaceAll("\\", "/");
 const stripTrailingSlashes = (filePath) => filePath.replace(/\/+$/, "");
 const stripLeadingSlashes = (filePath) => filePath.replace(/^\/+/, "");
+const stripDotSlashSegments = (filePath) => {
+  let stripped = filePath;
+  while (stripped.startsWith("./")) stripped = stripped.slice(2);
+  return stripped === "." ? "" : stripped;
+};
 const normalizeChangedFilePath = ({ rootDirectory, filePath }) => {
   const posixFilePath = toPosixPath(filePath);
   if (!path.isAbsolute(filePath)) {
-    return posixFilePath;
+    return stripDotSlashSegments(posixFilePath);
   }
   const posixRoot = stripTrailingSlashes(toPosixPath(rootDirectory));
   if (posixFilePath === posixRoot) {
@@ -142,7 +147,10 @@ const matchChangedFilesForWorkspace = ({
   }
   return matchedFiles;
 };
-const resolveInputWorkspaceDependencies = ({ workspaceInputs }) => {
+const resolveInputWorkspaceDependencies = ({
+  workspaceInputs,
+  rootWorkspace,
+}) => {
   const inputDependenciesByName = new Map();
   const allWorkspaces = workspaceInputs.map(({ workspace }) => workspace);
   for (const { workspace, inputWorkspacePatterns } of workspaceInputs) {
@@ -153,6 +161,7 @@ const resolveInputWorkspaceDependencies = ({ workspaceInputs }) => {
     const matchedNames = matchWorkspacesByPatterns(
       inputWorkspacePatterns,
       allWorkspaces,
+      rootWorkspace,
     )
       .map((matchedWorkspace) => matchedWorkspace.name)
       .filter((matchedName) => matchedName !== workspace.name);
@@ -160,12 +169,36 @@ const resolveInputWorkspaceDependencies = ({ workspaceInputs }) => {
   }
   return inputDependenciesByName;
 };
+const collectDirectEdges = ({
+  workspace,
+  inputDependenciesByName,
+  ignoreWorkspaceDependencies,
+}) => {
+  const edges = [];
+  for (const dependencyName of inputDependenciesByName.get(workspace.name) ??
+    []) {
+    edges.push({
+      dependencyName,
+      edgeSource: "input",
+    });
+  }
+  if (!ignoreWorkspaceDependencies) {
+    for (const dependencyName of workspace.dependencies) {
+      edges.push({
+        dependencyName,
+        edgeSource: "package",
+      });
+    }
+  }
+  return edges;
+};
 const computeAffectedWorkspaceSet = ({
   workspaceInputs,
   workspaceByName,
   changedFilesByName,
+  externalDepChangesByWorkspace,
   inputDependenciesByName,
-  ignorePackageDependencies,
+  ignoreWorkspaceDependencies,
 }) => {
   const inputDependentsByName = new Map();
   for (const [workspaceName, dependencyNames] of inputDependenciesByName) {
@@ -181,7 +214,11 @@ const computeAffectedWorkspaceSet = ({
   const affected = new Set();
   const queue = [];
   for (const { workspace } of workspaceInputs) {
-    if ((changedFilesByName.get(workspace.name)?.length ?? 0) > 0) {
+    const hasChangedFiles =
+      (changedFilesByName.get(workspace.name)?.length ?? 0) > 0;
+    const hasExternalDepChanges =
+      (externalDepChangesByWorkspace.get(workspace.name)?.length ?? 0) > 0;
+    if (hasChangedFiles || hasExternalDepChanges) {
       affected.add(workspace.name);
       queue.push(workspace.name);
     }
@@ -191,7 +228,7 @@ const computeAffectedWorkspaceSet = ({
     const currentWorkspace = workspaceByName.get(currentName);
     const dependents = [
       ...(inputDependentsByName.get(currentName) ?? []),
-      ...(!ignorePackageDependencies && currentWorkspace
+      ...(!ignoreWorkspaceDependencies && currentWorkspace
         ? currentWorkspace.dependents
         : []),
     ];
@@ -204,66 +241,118 @@ const computeAffectedWorkspaceSet = ({
   }
   return affected;
 };
+/**
+ * Walk forward from `directDependencyName` through the affected dep graph,
+ * appending each next affected dep edge to the chain until we run out of
+ * affected dep edges to follow. Stops on:
+ *   - no further affected dep edges,
+ *   - revisiting a workspace already in the chain (cycle).
+ *
+ * Branching is broken deterministically by edge insertion order
+ * (input edges before package edges, declaration order within each).
+ */ const extendChainThroughAffectedDeps = ({
+  startingWorkspaceName,
+  directDependencyName,
+  directEdgeSource,
+  workspaceByName,
+  inputDependenciesByName,
+  affectedSet,
+  ignoreWorkspaceDependencies,
+}) => {
+  const chain = [
+    {
+      workspaceName: startingWorkspaceName,
+    },
+    {
+      workspaceName: directDependencyName,
+      edgeSource: directEdgeSource,
+    },
+  ];
+  const visited = new Set([startingWorkspaceName, directDependencyName]);
+  let currentName = directDependencyName;
+  while (true) {
+    const currentWorkspace = workspaceByName.get(currentName);
+    if (!currentWorkspace) break;
+    const nextEdge = collectDirectEdges({
+      workspace: currentWorkspace,
+      inputDependenciesByName,
+      ignoreWorkspaceDependencies,
+    }).find(
+      ({ dependencyName }) =>
+        !visited.has(dependencyName) &&
+        workspaceByName.has(dependencyName) &&
+        affectedSet.has(dependencyName),
+    );
+    if (!nextEdge) break;
+    chain.push({
+      workspaceName: nextEdge.dependencyName,
+      edgeSource: nextEdge.edgeSource,
+    });
+    visited.add(nextEdge.dependencyName);
+    currentName = nextEdge.dependencyName;
+  }
+  return chain;
+};
 const collectAffectedDependencies = ({
   startingWorkspace,
   workspaceByName,
   inputDependenciesByName,
   affectedSet,
-  ignorePackageDependencies,
+  ignoreWorkspaceDependencies,
 }) => {
   const results = [];
-  const visited = new Set([startingWorkspace.name]);
-  const visit = (currentName, chain) => {
-    const currentWorkspace = workspaceByName.get(currentName);
-    if (!currentWorkspace) return;
-    const edges = [];
-    for (const dependencyName of inputDependenciesByName.get(currentName) ??
-      []) {
-      edges.push({
-        dependencyName,
-        edgeSource: "input",
-      });
-    }
-    if (!ignorePackageDependencies) {
-      for (const dependencyName of currentWorkspace.dependencies) {
-        edges.push({
-          dependencyName,
-          edgeSource: "package",
-        });
-      }
-    }
-    for (const { dependencyName, edgeSource } of edges) {
-      if (visited.has(dependencyName)) continue;
-      if (!workspaceByName.has(dependencyName)) continue;
-      visited.add(dependencyName);
-      const dependencyChain = [
-        ...chain,
-        {
-          workspaceName: dependencyName,
-          edgeSource,
-        },
-      ];
-      if (affectedSet.has(dependencyName)) {
-        results.push({
-          dependencyName,
-          chain: dependencyChain,
-        });
-      }
-      visit(dependencyName, dependencyChain);
-    }
-  };
-  visit(startingWorkspace.name, [
-    {
-      workspaceName: startingWorkspace.name,
-    },
-  ]);
+  const seen = new Set([startingWorkspace.name]);
+  const directEdges = collectDirectEdges({
+    workspace: startingWorkspace,
+    inputDependenciesByName,
+    ignoreWorkspaceDependencies,
+  });
+  for (const { dependencyName, edgeSource } of directEdges) {
+    if (seen.has(dependencyName)) continue;
+    if (!workspaceByName.has(dependencyName)) continue;
+    seen.add(dependencyName);
+    if (!affectedSet.has(dependencyName)) continue;
+    results.push({
+      dependencyName,
+      chain: extendChainThroughAffectedDeps({
+        startingWorkspaceName: startingWorkspace.name,
+        directDependencyName: dependencyName,
+        directEdgeSource: edgeSource,
+        workspaceByName,
+        inputDependenciesByName,
+        affectedSet,
+        ignoreWorkspaceDependencies,
+      }),
+    });
+  }
   return results;
 };
+const filterExternalDepChangesByInputs = ({
+  changesByWorkspace,
+  workspaceInputs,
+}) => {
+  const filtered = new Map();
+  for (const { workspace, inputExternalDependencyNames } of workspaceInputs) {
+    const changes = changesByWorkspace.get(workspace.name);
+    if (!changes?.length) continue;
+    if (inputExternalDependencyNames === undefined) {
+      filtered.set(workspace.name, changes);
+      continue;
+    }
+    if (inputExternalDependencyNames.length === 0) continue;
+    const allowed = new Set(inputExternalDependencyNames);
+    const matched = changes.filter((change) => allowed.has(change.name));
+    if (matched.length) filtered.set(workspace.name, matched);
+  }
+  return filtered;
+};
 const getFileAffectedWorkspaces = async ({
   rootDirectory,
   workspaceInputs,
   changedFilePaths,
-  ignorePackageDependencies = false,
+  rootWorkspace,
+  externalDepChangesByWorkspace = new Map(),
+  ignoreWorkspaceDependencies = false,
 }) => {
   const normalizedChangedFilePaths = changedFilePaths.map((filePath) =>
     normalizeChangedFilePath({
@@ -285,24 +374,32 @@ const getFileAffectedWorkspaces = async ({
       }),
     );
   }
+  const filteredExternalDepChanges = filterExternalDepChangesByInputs({
+    changesByWorkspace: externalDepChangesByWorkspace,
+    workspaceInputs,
+  });
   const inputDependenciesByName = resolveInputWorkspaceDependencies({
     workspaceInputs,
+    rootWorkspace,
   });
   const affectedSet = computeAffectedWorkspaceSet({
     workspaceInputs,
     workspaceByName,
     changedFilesByName,
+    externalDepChangesByWorkspace: filteredExternalDepChanges,
     inputDependenciesByName,
-    ignorePackageDependencies,
+    ignoreWorkspaceDependencies,
   });
   const affectedWorkspaces = workspaceInputs.map(({ workspace }) => {
     const changedFiles = changedFilesByName.get(workspace.name) ?? [];
+    const externalDependencies =
+      filteredExternalDepChanges.get(workspace.name) ?? [];
     const dependencies = collectAffectedDependencies({
       startingWorkspace: workspace,
       workspaceByName,
       inputDependenciesByName,
       affectedSet,
-      ignorePackageDependencies,
+      ignoreWorkspaceDependencies,
     });
     return {
       workspace,
@@ -310,6 +407,7 @@ const getFileAffectedWorkspaces = async ({
       affectedReasons: {
         changedFiles,
         dependencies,
+        externalDependencies,
       },
     };
   });

package/src/affected/gitAffectedFiles.mjs

@@ -52,6 +52,38 @@ const resolveGitRoot = async (rootDirectory) => {
   }
   return result.stdout.trim();
 };
+/**
+ * Read a project-root-relative file's contents at a specific git ref via
+ * `git show <ref>:<repo-relative-path>`. Returns `null` if the file does not
+ * exist at that ref (e.g. it was added later). Throws on other git errors.
+ */ const readProjectFileAtGitRef = async ({
+  rootDirectory,
+  ref,
+  projectRelativePath,
+}) => {
+  const gitRoot = fs.realpathSync.native(
+    path.resolve(await resolveGitRoot(rootDirectory)),
+  );
+  const absoluteProjectRoot = fs.realpathSync.native(
+    path.resolve(rootDirectory),
+  );
+  const absoluteFile = path.resolve(absoluteProjectRoot, projectRelativePath);
+  const repoRelative = path
+    .relative(gitRoot, absoluteFile)
+    .split(path.sep)
+    .join("/");
+  const result = await runGit(["show", `${ref}:${repoRelative}`], gitRoot);
+  if (result.exitCode === 0) return result.stdout;
+  if (
+    result.stderr.includes("does not exist") ||
+    result.stderr.includes("exists on disk, but not in")
+  ) {
+    return null;
+  }
+  throw new GIT_AFFECTED_ERRORS.GitCommandFailed(
+    `git show ${ref}:${repoRelative} failed (exit ${result.exitCode}): ${result.stderr.trim()}`,
+  );
+};
 const toProjectFilePath = ({
   gitRoot,
   absoluteProjectRoot,
@@ -83,6 +115,10 @@ const getGitAffectedFiles = async (options) => {
   const includeStaged = !ignoreUncommitted && !ignoreStaged;
   const includeUnstaged = !ignoreUncommitted && !ignoreUnstaged;
   const includeUntracked = !ignoreUncommitted && !ignoreUntracked;
+  const [baseSha, headSha] = await Promise.all([
+    runGitOrThrow(["rev-parse", baseRef], gitRoot).then((out) => out.trim()),
+    runGitOrThrow(["rev-parse", headRef], gitRoot).then((out) => out.trim()),
+  ]);
   const collectors = [
     runGitOrThrow(
       ["diff", "--name-only", "-z", baseRef, headRef],
@@ -147,7 +183,14 @@ const getGitAffectedFiles = async (options) => {
     .sort((a, b) => a.projectFilePath.localeCompare(b.projectFilePath));
   return {
     files,
+    baseSha,
+    headSha,
   };
 };
 
-export { GIT_AFFECTED_ERRORS, GIT_AFFECTED_FILE_REASONS, getGitAffectedFiles };
+export {
+  GIT_AFFECTED_ERRORS,
+  GIT_AFFECTED_FILE_REASONS,
+  getGitAffectedFiles,
+  readProjectFileAtGitRef,
+};