/**
  * Checks whether the given mimetype is present in the output's mimebundle.
  * If so, it returns the path/key to that mimetype's data. If not present,
  * it returns null.
  *
  * See also: innerMimeType
  */
 hasMimeType(mimetype: string): string | string[] | null {
   let outputs = this.base || this.remote!;
   if (nbformat.isStream(outputs) &&
       TEXT_MIMETYPES.indexOf(mimetype) !== -1) {
     return 'text';
   } else if (nbformat.isError(outputs)) {
     return 'traceback';
   } else if (nbformat.isExecuteResult(outputs) || nbformat.isDisplayData(outputs)) {
     let data = outputs.data;
     if (mimetype in data) {
       return ['data', mimetype];
     }
   }
   return null;
 }

function createDeletedCellDiffModel(
      base: nbformat.ICell, nbMimetype: string): CellDiffModel {
  let source = createDirectStringDiffModel(base.source, null);
  setMimetypeFromCellType(source, base, nbMimetype);
  let metadata = createDirectStringDiffModel(base.metadata as JSONObject, null);
  let outputs: OutputDiffModel[] | null = null;
  let executionCount: ImmutableDiffModel | null = null;
  if (nbformat.isCode(base)) {
    outputs = makeOutputModels(base.outputs, null);
    let execBase = base.execution_count;
    executionCount = createImmutableModel(execBase, null);
  }
  return new CellDiffModel(source, metadata, outputs, executionCount, base.cell_type);
}

function createAddedCellDiffModel(
      remote: nbformat.ICell, nbMimetype: string): CellDiffModel {
  let source = createDirectStringDiffModel(null, remote.source);
  setMimetypeFromCellType(source, remote, nbMimetype);
  let metadata = createDirectStringDiffModel(null, remote.metadata as JSONObject);
  let outputs: OutputDiffModel[] | null = null;
  let executionCount: ImmutableDiffModel | null = null;
  if (nbformat.isCode(remote)) {
    outputs = makeOutputModels(
      null, remote.outputs);
    executionCount = createImmutableModel(null, remote.execution_count);
  }
  return new CellDiffModel(source, metadata, outputs, executionCount, remote.cell_type);
}

function createPatchedCellDiffModel(
    base: nbformat.ICell, diff: IDiffEntry[] | null, nbMimetype: string): CellDiffModel {
  let source: StringDiffModel | null = null;
  let metadata: StringDiffModel | null = null;
  let outputs: OutputDiffModel[] | null = null;
  let executionCount: ImmutableDiffModel | null = null;

  let subDiff = getSubDiffByKey(diff, 'source');
  if (subDiff) {
    source = createPatchStringDiffModel(base.source, subDiff);
  } else {
    source = createDirectStringDiffModel(base.source, base.source);
  }
  setMimetypeFromCellType(source, base, nbMimetype);

  subDiff = getSubDiffByKey(diff, 'metadata');
  metadata = subDiff ?
    createPatchStringDiffModel(base.metadata as JSONObject, subDiff) :
    createDirectStringDiffModel(base.metadata as JSONObject, base.metadata as JSONObject);

  if (nbformat.isCode(base)) {
    let outputsBase = base.outputs;
    let outputsDiff = getSubDiffByKey(diff, 'outputs') as IDiffArrayEntry[];
    if (outputsDiff) {
      // Outputs patched
      outputs = makeOutputModels(
        outputsBase, null, outputsDiff);
    } else {
      // Outputs unchanged
      outputs = makeOutputModels(
        outputsBase, outputsBase);
    }
    let execBase = base.execution_count;
    let execDiff = getDiffEntryByKey(diff, 'execution_count') as IDiffReplace | null;
    // Pass base as remote, which means fall back to unchanged if no diff:
    executionCount = createImmutableModel(execBase, execBase, execDiff);
  }
  return new CellDiffModel(source, metadata, outputs, executionCount, base.cell_type);
}