@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-AKK56GNX.js

@@ -1,205 +0,0 @@
-import {
-  PLATFORM_TEMP_ROOT
-} from "./chunk-ILGPZ47M.js";
-import {
-  PROBE_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/josh/process-identity.ts
-import { execFileSync, spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { readFileSync, rmSync } from "node:fs";
-import { createServer } from "node:net";
-import path from "node:path";
-var PS_COMMAND = "/bin/ps";
-var FORMAT_FLAG = "-o";
-var START_TIME_FORMAT = "lstart=";
-var PID_FLAG = "-p";
-var PROBE_ENVIRONMENT = { TZ: "UTC", LC_ALL: "C" };
-var LIVENESS_SIGNAL = 0;
-var NO_SUCH_PROCESS = "ESRCH";
-var LOWEST_REAL_PID = 1;
-var PROC_START_FIELD_INDEX = 19;
-var BEACON_SCHEME = "socket:";
-var BEACON_SUFFIX = ".sock";
-var BEACON_PREFIX = `josh-process-identity-${String(process.getuid?.() ?? "")}-`;
-var BEACON_ID_LENGTH = 36;
-var BEACON_ID_PATTERN = /^[\da-f-]+$/u;
-var WINDOWS_PLATFORM = "win32";
-var BEACON_LIVE_STATUS = 0;
-var BEACON_UNKNOWN_STATUS = 1;
-var BEACON_GONE_STATUS = 2;
-var SOCKET_PROBE_SOURCE = `const net=require('node:net');const socket=net.createConnection(process.argv[1]);socket.once('connect',()=>process.exit(${String(BEACON_LIVE_STATUS)}));socket.once('error',(error)=>process.exit(['ECONNREFUSED','ENOENT'].includes(error.code)?${String(BEACON_GONE_STATUS)}:${String(BEACON_UNKNOWN_STATUS)}));socket.setTimeout(1000,()=>process.exit(${String(BEACON_UNKNOWN_STATUS)}));`;
-var beacons = /* @__PURE__ */ new Map();
-var exit_cleanup = { is_registered: false };
-function signal_refusal(pid) {
-  try {
-    process.kill(pid, LIVENESS_SIGNAL);
-    return void 0;
-  } catch (error) {
-    return error.code ?? NO_SUCH_PROCESS;
-  }
-}
-function is_live_pid(pid) {
-  return pid >= LOWEST_REAL_PID && signal_refusal(pid) === void 0;
-}
-function is_present_pid(pid) {
-  return pid >= LOWEST_REAL_PID && signal_refusal(pid) !== NO_SUCH_PROCESS;
-}
-function read_proc_start(pid) {
-  try {
-    const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
-    const fields = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/u);
-    const start = fields[PROC_START_FIELD_INDEX];
-    return start === void 0 ? void 0 : `proc:${start}`;
-  } catch {
-    return void 0;
-  }
-}
-function read_ps_start(pid) {
-  try {
-    const printed = execFileSync(
-      PS_COMMAND,
-      [FORMAT_FLAG, START_TIME_FORMAT, PID_FLAG, String(pid)],
-      {
-        encoding: "utf8",
-        timeout: PROBE_TIMEOUT_MS,
-        stdio: ["ignore", "pipe", "ignore"],
-        env: PROBE_ENVIRONMENT
-      }
-    ).trim();
-    return printed.length > 0 ? printed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-var START_PROBES = { read_proc_start, read_ps_start };
-function safe_probe(probe, pid) {
-  try {
-    return probe(pid);
-  } catch {
-    return void 0;
-  }
-}
-function read_start(pid, probes = START_PROBES) {
-  return safe_probe(probes.read_proc_start, pid) ?? safe_probe(probes.read_ps_start, pid);
-}
-function close_beacon(token) {
-  const server = beacons.get(token);
-  if (server === void 0) return;
-  beacons.delete(token);
-  server.close();
-  rmSync(token.slice(BEACON_SCHEME.length), { force: true });
-}
-function close_beacons() {
-  for (const token of beacons.keys()) close_beacon(token);
-}
-function ensure_exit_cleanup() {
-  if (exit_cleanup.is_registered) return;
-  exit_cleanup.is_registered = true;
-  process.once("exit", close_beacons);
-}
-function ignore_beacon_error() {
-}
-function bind_beacon(target) {
-  return createServer().on("error", ignore_beacon_error).listen(target);
-}
-function try_bind_beacon(bind, target) {
-  try {
-    const server = bind(target);
-    return server.listening ? server : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function open_beacon(bind = bind_beacon) {
-  const target = path.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID()}${BEACON_SUFFIX}`);
-  const token = `${BEACON_SCHEME}${target}`;
-  const server = try_bind_beacon(bind, target);
-  if (server === void 0) return void 0;
-  server.unref();
-  beacons.set(token, server);
-  ensure_exit_cleanup();
-  return token;
-}
-function resolve_own_start(probes = START_PROBES, platform = process.platform) {
-  const start = read_start(process.pid, probes);
-  if (start !== void 0 || platform === WINDOWS_PLATFORM) return start;
-  return open_beacon();
-}
-function is_valid_beacon_name(name) {
-  if (!name.startsWith(BEACON_PREFIX) || !name.endsWith(BEACON_SUFFIX)) return false;
-  const id = name.slice(BEACON_PREFIX.length, -BEACON_SUFFIX.length);
-  return id.length === BEACON_ID_LENGTH && BEACON_ID_PATTERN.test(id);
-}
-function beacon_target(token) {
-  if (!token.startsWith(BEACON_SCHEME)) return void 0;
-  const target = token.slice(BEACON_SCHEME.length);
-  if (path.dirname(target) !== PLATFORM_TEMP_ROOT) return void 0;
-  return is_valid_beacon_name(path.basename(target)) ? target : void 0;
-}
-function run_socket_probe(target, kill_after_ms = PROBE_TIMEOUT_MS) {
-  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
-    stdio: "ignore",
-    timeout: kill_after_ms
-  }).status ?? void 0;
-}
-function is_live_beacon(target, probe = run_socket_probe) {
-  const own = beacons.get(`${BEACON_SCHEME}${target}`);
-  if (own !== void 0) return own.listening;
-  const status = probe(target);
-  if (status === BEACON_LIVE_STATUS) return true;
-  return status === BEACON_GONE_STATUS ? false : void 0;
-}
-function has_matching_start(pid, recorded_start, read) {
-  const observed = read(pid);
-  return observed === void 0 ? void 0 : observed === recorded_start;
-}
-function matches_recorded_start(pid, recorded_start, read) {
-  const target = beacon_target(recorded_start);
-  return target === void 0 ? has_matching_start(pid, recorded_start, read) : is_live_beacon(target);
-}
-var own_probe = /* @__PURE__ */ new Map();
-function own_start() {
-  if (!own_probe.has(process.pid)) own_probe.set(process.pid, resolve_own_start());
-  return own_probe.get(process.pid);
-}
-function own_fields() {
-  const start = own_start();
-  return { pid: process.pid, ...start !== void 0 && { process_start: start } };
-}
-function is_same_process(pid, recorded_start, read = read_start) {
-  if (pid === void 0 || !is_live_pid(pid)) return false;
-  if (recorded_start === void 0) return void 0;
-  return matches_recorded_start(pid, recorded_start, read);
-}
-function is_present_process(pid, recorded_start, read = read_start) {
-  if (!is_present_pid(pid)) return false;
-  if (recorded_start === void 0) return void 0;
-  return matches_recorded_start(pid, recorded_start, read);
-}
-function is_own_process(pid, recorded_start) {
-  return pid === process.pid && recorded_start === own_start();
-}
-var process_identity = {
-  PROBE_ENVIRONMENT,
-  START_PROBES,
-  START_TIME_FORMAT,
-  close_beacon,
-  is_live_beacon,
-  is_live_pid,
-  is_own_process,
-  is_present_pid,
-  is_present_process,
-  is_same_process,
-  open_beacon,
-  own_fields,
-  own_start,
-  read_start,
-  resolve_own_start,
-  run_socket_probe
-};
-
-export {
-  process_identity
-};

package/dist/commands/chunk-AKQYYHP2.js

@@ -1,461 +0,0 @@
-import {
-  git_push_transport,
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-import {
-  git_spawn_sync
-} from "./chunk-B77ZMVHS.js";
-import {
-  PORCELAIN_FLAG,
-  UNTRACKED_FILES_FLAG
-} from "./chunk-B5GXZK3E.js";
-import {
-  create_spawn_error
-} from "./chunk-VJE3RJAX.js";
-import {
-  SUITE_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/git/git-diff-reads.ts
-var REFS_REMOTES_ORIGIN_PREFIX = "refs/remotes/origin/";
-var NAME_ONLY_FLAG = "--name-only";
-var DEFAULT_BRANCH_FALLBACK = "main";
-var DEFAULT_BRANCH_ARGUMENTS = ["symbolic-ref", "refs/remotes/origin/HEAD"];
-function default_branch_of(output) {
-  const trimmed = output?.trim() ?? "";
-  if (!trimmed.startsWith(REFS_REMOTES_ORIGIN_PREFIX)) return DEFAULT_BRANCH_FALLBACK;
-  return trimmed.slice(REFS_REMOTES_ORIGIN_PREFIX.length);
-}
-async function get_default_branch() {
-  try {
-    return default_branch_of(await git_spawn.read([...DEFAULT_BRANCH_ARGUMENTS]));
-  } catch {
-    return DEFAULT_BRANCH_FALLBACK;
-  }
-}
-var MERGE_BASE_COMMAND = "merge-base";
-function reference_check_arguments(reference) {
-  return ["rev-parse", "--verify", "--quiet", reference];
-}
-function remote_reference_of(default_branch) {
-  return `${REFS_REMOTES_ORIGIN_PREFIX}${default_branch}`;
-}
-async function reference_exists(reference) {
-  try {
-    await git_spawn.read([...reference_check_arguments(reference)]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function default_branch_reference() {
-  const default_branch = await get_default_branch();
-  const remote_reference = remote_reference_of(default_branch);
-  return await reference_exists(remote_reference) ? remote_reference : default_branch;
-}
-function merge_base_arguments(reference) {
-  return [MERGE_BASE_COMMAND, reference, "HEAD"];
-}
-function incoming_base_arguments(reference) {
-  return [MERGE_BASE_COMMAND, reference, "MERGE_HEAD"];
-}
-function later_base_arguments(base, incoming) {
-  return [MERGE_BASE_COMMAND, "--independent", base, incoming];
-}
-function later_base_of(output, base) {
-  const [later = ""] = output?.split("\n", 1) ?? [];
-  return later === "" ? base : later;
-}
-async function change_base() {
-  const default_branch = await default_branch_reference();
-  try {
-    return await git_spawn.read([...merge_base_arguments(default_branch)]);
-  } catch {
-    return default_branch;
-  }
-}
-async function diff_main(file_path) {
-  return await git_spawn.read(["diff", await change_base(), "--", file_path]);
-}
-var NO_PATH_QUOTING = ["-c", "core.quotePath=false"];
-var NO_RELATIVE_PATHS = "--no-relative";
-var NO_RENAME_DETECTION = "--no-renames";
-async function change_base_commit() {
-  return await git_spawn.read(["rev-parse", await change_base()]);
-}
-function names_since_arguments(commit2) {
-  return [
-    ...NO_PATH_QUOTING,
-    "diff",
-    NAME_ONLY_FLAG,
-    NO_RELATIVE_PATHS,
-    NO_RENAME_DETECTION,
-    commit2,
-    "--"
-  ];
-}
-async function diff_names_since(commit2) {
-  return await git_spawn.read([...names_since_arguments(commit2)]);
-}
-async function tree_names_at(commit2, paths) {
-  return await git_spawn.read([
-    ...NO_PATH_QUOTING,
-    "ls-tree",
-    "-r",
-    NAME_ONLY_FLAG,
-    "--full-tree",
-    commit2,
-    "--",
-    ...paths
-  ]);
-}
-async function diff_main_names() {
-  return await diff_names_since(await change_base());
-}
-async function diff_cached_names() {
-  return await git_spawn.read([
-    ...NO_PATH_QUOTING,
-    "diff",
-    "--cached",
-    NAME_ONLY_FLAG,
-    NO_RELATIVE_PATHS,
-    NO_RENAME_DETECTION
-  ]);
-}
-async function diff_numstat_since(base) {
-  return await git_spawn.read([
-    ...NO_PATH_QUOTING,
-    "diff",
-    "--numstat",
-    NO_RELATIVE_PATHS,
-    NO_RENAME_DETECTION,
-    base,
-    "--"
-  ]);
-}
-var WHOLE_TREE_PATHSPEC = ":/";
-var UNTRACKED_ARGUMENTS = [
-  ...NO_PATH_QUOTING,
-  "ls-files",
-  "--others",
-  "--exclude-standard",
-  "--full-name",
-  WHOLE_TREE_PATHSPEC
-];
-async function untracked_names() {
-  return await git_spawn.read([...UNTRACKED_ARGUMENTS]);
-}
-var git_diff_reads = {
-  DEFAULT_BRANCH_ARGUMENTS,
-  UNTRACKED_ARGUMENTS,
-  change_base,
-  change_base_commit,
-  default_branch_of,
-  default_branch_reference,
-  diff_cached_names,
-  diff_main,
-  diff_main_names,
-  diff_numstat_since,
-  diff_names_since,
-  get_default_branch,
-  incoming_base_arguments,
-  later_base_arguments,
-  later_base_of,
-  merge_base_arguments,
-  names_since_arguments,
-  reference_check_arguments,
-  remote_reference_of,
-  tree_names_at,
-  untracked_names
-};
-
-// scripts/git/git-pre-push-hook.ts
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-var REMOTE = "origin";
-var HOOK_NAME = "pre-push";
-var PROBE_HOOK_NAME = "kit-hook-run-probe";
-var ALLOW_UNKNOWN_HOOK_NAME_FLAG = "--allow-unknown-hook-name";
-var HOOK_RUN = "run";
-var STDIN_FILE = "refs";
-var TEMPORARY_PREFIX = "kit-pre-push-";
-var ZERO_DIGIT = "0";
-async function read_remote_oid(branch2) {
-  try {
-    return await git_spawn.read([
-      "rev-parse",
-      "--verify",
-      "--quiet",
-      `refs/remotes/${REMOTE}/${branch2}`
-    ]);
-  } catch {
-    return void 0;
-  }
-}
-async function read_push_references() {
-  const [branch2, local_oid] = await Promise.all([
-    git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]),
-    git_spawn.read(["rev-parse", "HEAD"])
-  ]);
-  return { branch: branch2, local_oid, remote_oid: await read_remote_oid(branch2) };
-}
-function to_stdin_line(references) {
-  const reference = `refs/heads/${references.branch}`;
-  const remote_oid = references.remote_oid ?? ZERO_DIGIT.repeat(references.local_oid.length);
-  return `${reference} ${references.local_oid} ${reference} ${remote_oid}
-`;
-}
-function to_hook_run_arguments(stdin_path, hook_name) {
-  return [HOOK_RUN, "--ignore-missing", `--to-stdin=${stdin_path}`, hook_name];
-}
-async function can_probe(probe_arguments) {
-  try {
-    await git_spawn.read(["hook", ...probe_arguments]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function can_run_hooks(stdin_path) {
-  const [, ...options] = to_hook_run_arguments(stdin_path, PROBE_HOOK_NAME);
-  if (await can_probe([HOOK_RUN, ALLOW_UNKNOWN_HOOK_NAME_FLAG, ...options])) return true;
-  return await can_probe([HOOK_RUN, ...options]);
-}
-async function run_with_stdin(stdin_line) {
-  const directory = await mkdtemp(path.join(tmpdir(), TEMPORARY_PREFIX));
-  const stdin_path = path.join(directory, STDIN_FILE);
-  try {
-    await writeFile(stdin_path, stdin_line);
-    if (!await can_run_hooks(stdin_path)) return false;
-    const url = await git_spawn.read(["remote", "get-url", REMOTE]);
-    await git_spawn.with_output(
-      "hook",
-      [...to_hook_run_arguments(stdin_path, HOOK_NAME), "--", REMOTE, url],
-      { timeout_ms: SUITE_TIMEOUT_MS }
-    );
-    return true;
-  } finally {
-    await rm(directory, { force: true, recursive: true });
-  }
-}
-async function run() {
-  const references = await read_push_references();
-  if (references.local_oid === references.remote_oid) return true;
-  return await run_with_stdin(to_stdin_line(references));
-}
-var git_pre_push_hook = {
-  run
-};
-
-// scripts/git/git-command.ts
-var BRANCH_ARGUMENTS = ["rev-parse", "--abbrev-ref", "HEAD"];
-async function branch() {
-  return await git_spawn.read([...BRANCH_ARGUMENTS]);
-}
-async function branch_at(directory) {
-  return await git_spawn.read(["-C", directory, ...BRANCH_ARGUMENTS]);
-}
-async function status(directory) {
-  const location = directory === void 0 ? [] : ["-C", directory];
-  return await git_spawn.read([...location, "status", PORCELAIN_FLAG, UNTRACKED_FILES_FLAG]);
-}
-async function repository_root() {
-  const result = git_spawn_sync.toplevel();
-  if (result.exit_code !== 0) throw create_spawn_error("rev-parse", result.exit_code);
-  return result.stdout.trim();
-}
-async function head_commit() {
-  return await git_spawn.read(["rev-parse", "HEAD"]);
-}
-var GIT_DIRECTORY_ARGUMENTS = [
-  "rev-parse",
-  "--absolute-git-dir",
-  "--path-format=absolute",
-  "--git-common-dir"
-];
-async function git_directories() {
-  const output = await git_spawn.read([...GIT_DIRECTORY_ARGUMENTS]);
-  return output.split("\n").filter((line) => line !== "");
-}
-async function diff_cached(file_path) {
-  return await git_spawn.read(["diff", "--cached", file_path]);
-}
-async function fetch_branch(branch_name) {
-  const refspec = `+refs/heads/${branch_name}:refs/remotes/origin/${branch_name}`;
-  return await git_spawn.read_remote(["fetch", "origin", refspec]);
-}
-async function merge_fast_forward(branch_name) {
-  return await git_spawn.read(["merge", "--ff-only", `origin/${branch_name}`], SUITE_TIMEOUT_MS);
-}
-async function fast_forward_local(branch_name) {
-  return await git_spawn.read_remote(["fetch", "origin", `${branch_name}:${branch_name}`]);
-}
-async function merge_branch(branch_name, message) {
-  const message_arguments = message === void 0 ? [] : ["-m", message];
-  await git_spawn.with_output("merge", [...message_arguments, `origin/${branch_name}`], {
-    timeout_ms: SUITE_TIMEOUT_MS
-  });
-}
-async function checkout_b(branch_name) {
-  return await git_spawn.read(["checkout", "-b", branch_name], SUITE_TIMEOUT_MS);
-}
-async function checkout(branch_name) {
-  return await git_spawn.read(["checkout", branch_name], SUITE_TIMEOUT_MS);
-}
-async function commit(message) {
-  await git_spawn.with_output("commit", ["-m", message], { timeout_ms: SUITE_TIMEOUT_MS });
-}
-async function delete_branch(branch_name) {
-  await git_spawn.read(["branch", "-d", branch_name]);
-}
-async function read_commit_count(revisions) {
-  const output = await git_spawn.read(["rev-list", "--count", ...revisions]);
-  const parsed = Number(output);
-  if (output.length > 0 && Number.isFinite(parsed)) return parsed;
-  throw new Error(
-    `\`git rev-list --count ${revisions.join(" ")}\` printed \`${output}\` rather than a count`
-  );
-}
-async function commit_count_beyond(base, tip) {
-  return await read_commit_count([`${base}..${tip}`]);
-}
-async function commit_count_unpushed(branch_name) {
-  return await read_commit_count([branch_name, "--not", "--remotes"]);
-}
-function is_exit_code_128(cause) {
-  return typeof cause === "object" && cause !== null && "exit_code" in cause && cause.exit_code === "128";
-}
-function is_upstream_not_set_error(error) {
-  if (!(error instanceof Error)) return false;
-  const { cause } = error;
-  return cause !== void 0 && is_exit_code_128(cause);
-}
-var NO_VERIFY_FLAG = "--no-verify";
-async function push_with_upstream(branch_name, verify_flags) {
-  await git_push_transport.push([...verify_flags, "--set-upstream", "origin", branch_name]);
-}
-async function push() {
-  const verify_flags = await git_pre_push_hook.run() ? [NO_VERIFY_FLAG] : [];
-  try {
-    await git_push_transport.push([...verify_flags]);
-  } catch (error) {
-    if (is_upstream_not_set_error(error)) {
-      const current_branch = await branch();
-      await push_with_upstream(current_branch, verify_flags);
-      return;
-    }
-    throw error;
-  }
-}
-async function pull_fast_forward() {
-  await git_spawn.with_output_remote("pull", ["--ff-only"]);
-}
-var SHORT_NAME_FORMAT = "--format=%(refname:short)";
-var REMOTES_FLAG = "--remotes";
-async function list_branches(flags, pattern) {
-  try {
-    const output = await git_spawn.read([
-      "branch",
-      "--list",
-      SHORT_NAME_FORMAT,
-      ...flags,
-      pattern
-    ]);
-    return output.split("\n").filter((line) => line.trim() !== "");
-  } catch {
-    return [];
-  }
-}
-async function branch_names(pattern) {
-  return await list_branches([], pattern);
-}
-async function branch_names_remote(pattern) {
-  return await list_branches([REMOTES_FLAG], pattern);
-}
-async function branch_exists(branch_name) {
-  const names = await branch_names(branch_name);
-  return names.length > 0;
-}
-var ALL_PATHS_PATHSPEC = ":/";
-function exclude_pathspec(file_path) {
-  return `:(exclude,top)${file_path}`;
-}
-async function add_tracked(excluded_paths) {
-  const exclusions = excluded_paths.map((file_path) => exclude_pathspec(file_path));
-  await git_spawn.read(["add", "-u", "--", ALL_PATHS_PATHSPEC, ...exclusions]);
-}
-async function add_path(file_path) {
-  await git_spawn.with_output("add", ["--", file_path]);
-}
-var FIRST_PARENT_FLAG = "--first-parent";
-async function log_first_parent(limit, file_path, tip = "HEAD") {
-  const output = await git_spawn.read([
-    "log",
-    FIRST_PARENT_FLAG,
-    "--format=%H",
-    `-n`,
-    String(limit),
-    tip,
-    "--",
-    file_path
-  ]);
-  return output.split("\n").filter((line) => line.length > 0);
-}
-async function show_file(spec) {
-  return await git_spawn.read(["show", spec]);
-}
-var MERGE_COUNT_ARGUMENTS = [
-  "rev-list",
-  "--count",
-  "--merges",
-  FIRST_PARENT_FLAG
-];
-function merge_count_arguments(range) {
-  return [...MERGE_COUNT_ARGUMENTS, range];
-}
-async function count_merges(range) {
-  const output = await git_spawn.read(merge_count_arguments(range));
-  const parsed = Number(output.trim());
-  return Number.isFinite(parsed) ? parsed : 0;
-}
-var git_command = {
-  GIT_DIRECTORY_ARGUMENTS,
-  branch,
-  branch_at,
-  status,
-  repository_root,
-  head_commit,
-  git_directories,
-  diff_cached,
-  // The default branch, the change base and every reading against it are `git-diff-reads.ts`'s,
-  // re-exported here so no call site, mock or spy moved with them.
-  ...git_diff_reads,
-  fetch_branch,
-  merge_fast_forward,
-  fast_forward_local,
-  merge_branch,
-  checkout_b,
-  checkout,
-  commit,
-  commit_count_beyond,
-  commit_count_unpushed,
-  delete_branch,
-  push,
-  pull_fast_forward,
-  branch_exists,
-  branch_names,
-  branch_names_remote,
-  add_tracked,
-  add_path,
-  log_first_parent,
-  show_file,
-  count_merges,
-  merge_count_arguments,
-  is_upstream_not_set_error
-};
-
-export {
-  git_diff_reads,
-  git_command
-};