How to use the vscode-languageserver-protocol.Disposable.create function in vscode-languageserver-protocol

let { id } = service
    if (!id) logger.error('invalid service configuration. ', service.name)
    if (this.registered.get(id)) return
    this.registered.set(id, service)
    logger.info(`registered service "${id}"`)
    if (this.shouldStart(service)) {
      service.start() // tslint:disable-line
    }
    if (service.state == ServiceStat.Running) {
      this.emit('ready', id)
    }
    service.onServiceReady(() => {
      logger.info(`service ${id} started`)
      this.emit('ready', id)
    }, null, this.disposables)
    return Disposable.create(() => {
      service.stop()
      service.dispose()
      this.registered.delete(id)
    })
  }

if (provider.onDidChange) {
      provider.onDidChange(async uri => {
        let doc = this.getDocument(uri.toString())
        if (doc) {
          let { buffer } = doc
          let tokenSource = new CancellationTokenSource()
          let content = await Promise.resolve(provider.provideTextDocumentContent(uri, tokenSource.token))
          await buffer.setLines(content.split('\n'), {
            start: 0,
            end: -1,
            strictIndexing: false
          })
        }
      }, null, disposables)
    }
    return Disposable.create(() => {
      this.schemeProviderMap.delete(scheme)
      disposeAll(disposables)
      this.setupDynamicAutocmd()
    })
  }

public register(selector: DocumentSelector, provider: DocumentSymbolProvider): Disposable {
    let item: ProviderItem = {
      id: uuid(),
      selector,
      provider
    }
    this.providers.add(item)
    return Disposable.create(() => {
      this.providers.delete(item)
    })
  }

public register(selector: DocumentSelector,
    provider: DocumentFormattingEditProvider,
    priority = 0): Disposable {
    let item: ProviderItem = {
      id: uuid(),
      selector,
      priority,
      provider
    }
    this.providers.add(item)
    return Disposable.create(() => {
      this.providers.delete(item)
    })
  }

public register(selector: DocumentSelector, provider: WorkspaceSymbolProvider): Disposable {
    let item: ProviderItem = {
      id: uuid(),
      selector,
      provider
    }
    this.providers.add(item)
    return Disposable.create(() => {
      this.providers.delete(item)
    })
  }

public watchOption(key: string, callback: (oldValue: any, newValue: any) => Thenable | void, disposables?: Disposable[]): void {
    let watching = this.watchedOptions.has(key)
    if (!watching) {
      this.watchedOptions.add(key)
      this.setupDynamicAutocmd()
    }
    let disposable = events.on('OptionSet', async (changed: string, oldValue: any, newValue: any) => {
      if (changed == key && callback) {
        await Promise.resolve(callback(oldValue, newValue))
      }
    })
    if (disposables) {
      disposables.push(
        Disposable.create(() => {
          disposable.dispose()
          if (watching) return
          this.watchedOptions.delete(key)
          this.setupDynamicAutocmd()
        })
      )
    }
  }

export function regist(sourceMap: Map): Disposable {
  sourceMap.set('gocode', new Gocode())
  return Disposable.create(() => {
    sourceMap.delete('gocode')
  })
}

export function regist(sourceMap: Map): Disposable {
  sourceMap.set('emoji', new Emoji())
  return Disposable.create(() => {
    sourceMap.delete('emoji')
  })
}

constructor(client: ITypeScriptServiceClient) {
    this.statusItem = workspace.createStatusBarItem(10, { progress: true })
    const disposables: Disposable[] = []
    disposables.push(client.onDidBeginInstallTypings(e => this._onBegin(e.eventId)))
    disposables.push(client.onDidEndInstallTypings(e => this._onEndOrTimeout(e.eventId)))
    disposables.push(client.onTypesInstallerInitializationFailed(_ =>
      this.onTypesInstallerInitializationFailed()
    ))
    this._disposable = Disposable.create(() => {
      disposables.forEach(disposable => {
        disposable.dispose()
      })
    })
  }

public constructor(
    client: ITypeScriptServiceClient,
    commandManager: CommandManager
  ) {
    let cmd = new ProjectErrorCommand(client)
    commandManager.register(cmd)
    this.disposables.push(Disposable.create(() => {
      commandManager.unregister(cmd.id)
    }))
  }