id: element.hash,

      // id: element.hash,

      collapsibleState: TreeItemCollapsibleState.None,

      collapsibleState: TreeItemCollapsibleState.Collapsed,

      // TODO: Implement change dependency tracking
      return null;

      return await this.repository.getChangeDependencies(element);

  /**
   * A dictionary for holding a cache of change hashes to avoid recalculating them each time
   */
  private readonly changeCache: Record<string, PijulChange> = {};

      return (await this._pijul.exec(this.repositoryRoot, ['change', uri.path], { cancellationToken: token })).stdout;

      return await this.getChangeToml(uri.path, token);

  }
  /**
   * Get the TOML document describing a specific change
   * @param hash The hash of the change
   * @param cancellationToken A token for cancelling the CLI interaction
   */
  async getChangeToml (hash: string, cancellationToken?: CancellationToken): Promise<string> {
    return (await this._pijul.exec(this.repositoryRoot, ['change', hash], { cancellationToken })).stdout;
  }
  /**
   * Get the Pijul changes which the given change is dependent on
   * @param change The change to get the dependencies of
\   */
  async getChangeDependencies (change: PijulChange): Promise<PijulChange[]> {
    const changeToml = await this.getChangeToml(change.hash);
    const dependencyPattern = /[0-9A-Z]{53}/g;
    const dependencies: PijulChange[] = [];
    let match = dependencyPattern.exec(changeToml);
    while (match) {
      dependencies.push(this.changeCache[match[0]]);
      match = dependencyPattern.exec(changeToml);
    }
    return dependencies;

      changes.push(new PijulChange(hash, message.trim(), new PijulChangeAuthor(author), new Date(date)));

      const cachedChange = this.changeCache[hash];
      if (cachedChange) {
        changes.push(cachedChange);
      } else {
        const change = new PijulChange(hash, message.trim(), parsePijulChangeAuthor(author), new Date(date));
        this.changeCache[change.hash] = change;
        changes.push(change);
      }

}
/**
   * Creates a new PijulChangeAuthor by parsing an Author string in a change
   * @param authorString The full author string, in the format `[Author { name: "GarettWithOneR", full_name: Some("Garett Cooper"), email: Some("garett@garettcooper.com") }]`
   */
export function parsePijulChangeAuthor (authorString: string): PijulChangeAuthor {
  const parsePattern = /Author\s\{\sname:\s"([^"]*)",\sfull_name:\s(?:Some\("([^"]*)"\)|(None)),\semail:\s(?:Some\("([^"]*)"\)|(None))\s\}/g;
  const match = parsePattern.exec(authorString);
  if (match != null) {
    // The 4th match needs to be skipped, as it is the (None) capture group
    const [, name, fullName,, email] = match;
    return new PijulChangeAuthor(name, fullName, email);
  } else {
    throw new Error('Failed to parse author string: ' + authorString);
  }

  public readonly name: string;
  public readonly fullName?: string;
  public readonly email?: string;

   * Creates a new PijulChangeAuthor by parsing the Author string in the change
   * @param authorString The full author string, in the format `[Author { name: "GarettWithOneR", full_name: Some("Garett Cooper"), email: Some("garett@garettcooper.com") }]`

   * Creates a new PijulChangeAuthor instance

  constructor (authorString: string) {
    const parsePattern = /Author\s\{\sname:\s"([^"]*)",\sfull_name:\s(?:Some\("([^"]*)"\)|(None)),\semail:\s(?:Some\("([^"]*)"\)|(None))\s\}/g;
    const match = parsePattern.exec(authorString);
    if (match != null) {
      // The 4th match needs to be skipped, as it is the (None) capture group
      [, this.name, this.fullName,, this.email] = match;
      if (this.fullName === 'None') {
        this.fullName = undefined;
      }
      if (this.email === 'None') {
        this.fullName = undefined;
      }
    } else {
      throw new Error('Failed to parse author string: ' + authorString);
    }
  }

  constructor (
    public readonly name: string,
    public readonly fullName?: string,
    public readonly email?: string
  ) {}