How to use the moment.isDate function in moment

parseParams(params: any): HttpParams {
    let ret = new HttpParams();
    if (params) {
      // tslint:disable-next-line:forin
      for (const key in params) {
        let _data = params[key];
        // 将时间转化为：时间戳 (秒)
        if (moment.isDate(_data)) {
          _data = moment(_data).valueOf();
        }
        if (_data) {
          ret = ret.set(key, _data);
        }
      }
    }
    return ret;
  }

parseParams(params: any): HttpParams {
        let ret = new HttpParams();
        if (params) {
            // tslint:disable-next-line:forin
            for (const key in params) {
                let _data = params[key];
                // 将时间转化为：时间戳 (秒)
                if (moment.isDate(_data)) {
                    _data = moment(_data).unix();
                }
                ret = ret.set(key, _data);
            }
        }
        return ret;
    }

function value2Timestamp(value, format) {

    const defaultValue = new Date().getTime();

    if (typeof value === 'number') {
        return new Date(value).toString() === 'Invalid Date' ? defaultValue : value;
    } else if (typeof value === 'string') {
        let date = moment(value, format);
        return date.isValid() ? date.valueOf() : defaultValue;
    } else if (moment.isDate(value)) {
        let date = moment(value);
        return date.isValid() ? date.valueOf() : defaultValue;
    }

    return defaultValue;

}

getDateTimeInput(props) {
    props = props || this.props
    let prop = props.date || props.time || null

    let datetime, input, type
    if (prop === null) {
      datetime = Moment()
      input = null
      type = Types.MOMENT
    } else {
      datetime = this.parse(prop)
      input = datetime.format(this.format(props))
      switch (typeof prop) {
        case 'object':
          if (Moment.isDate(prop)) {
            type = Types.JS_DATE
          } else if (Moment.isMoment(prop)) {
            type = Types.MOMENT
          } else {
            type = null
          }
          break
        case 'string':
          if (prop.match(ISOregex)) {
            type = Types.ISO
          } else {
            type = Types.STRING
          }
          break
      }
    }

$.validator.addMethod('maxdate', function(value, element, params) {
        let maxDate;
        let momentMax;
        let momentValue;

        maxDate = params[0].domSelector?$(params[0].domSelector).val():params[0].maxDate;
        if (typeof maxDate === 'function') {
            maxDate = maxDate();
        }
        if (moment.isMoment(maxDate)) {
            momentMax = maxDate;
        } else if (moment.isDate(maxDate)) {
            momentMax = moment(maxDate);
        } else {
            momentMax = moment(maxDate, 'L', true);
        }

        momentValue = moment(value, 'L', true);

        params[1] = params[0].message?i18next.t(params[0].message):i18next.t('Please set a date before the', {date: momentMax.format('L')});
        return this.optional(element) || (momentValue.isValid() && momentMax.isValid() && (momentValue.isSame(momentMax) || momentValue.isBefore(momentMax)));
    }, '{1}');

stringify = function(v, truncate){
                        if (v === null) return 'null';
                        if (typeof(v) === 'undefined') return 'undefined';

                        var str; 
                        if (moment.isDate(v)) str = moment(v).format('YYYY-MM-DDTHH:mm:ss');
                        else if (typeof(v) === 'object') str = JSON.stringify(v);
                        else str = v.toString();

                        if (opt.truncate){
                            var cutoff = 60;
                            if (str.length > cutoff){
                                str = str.substr(0, cutoff) + '…'; 
                            } 
                        }
                        return str;
                    };

function prepareFrontMatter(data) {
  for (const key of Object.keys(data)) {
    const item = data[key];

    if (moment.isMoment(item)) {
      data[key] = item.utc().format('YYYY-MM-DD HH:mm:ss');
    } else if (moment.isDate(item)) {
      data[key] = moment.utc(item).format('YYYY-MM-DD HH:mm:ss');
    } else if (typeof item === 'string') {
      data[key] = `"${item}"`;
    }
  }

  return data;
}

if (false !== type) {
                                    STAT.type = type;
                                }
                            }
                        } catch {
                            STAT.type = vscode.FileType.SymbolicLink;
                        }
                    }
                }
                break;
        }

        if (vscode.FileType.File === STAT.type) {
            let date: number;
            if (Moment.isDate(item.date)) {
                date = vscode_helpers.asUTC(
                    Moment(date)
                ).unix();
            }

            STAT.ctime = date;
            STAT.mtime = date;
            STAT.size = parseInt( vscode_helpers.toStringSafe(item.size).trim() );
        }

        if (isNaN( STAT.ctime )) {
            STAT.ctime = 0;
        }
        if (isNaN( STAT.mtime )) {
            STAT.mtime = 0;
        }

export function isDate(date) {
  return moment.isDate(new Date(date));
}

function asLocalTime(val) {
    let localTime;
    if (!_.isNil(val)) {
        if (Moment.isMoment(val)) {
            localTime = val;
        }
        else if (Moment.isDate(val)) {
            localTime = Moment(val);
        }
        else {
            localTime = Moment(toStringSafe(val));
        }
    }
    if (localTime) {
        if (!localTime.isLocal()) {
            localTime = localTime.local();
        }
    }
    return localTime;
}
exports.asLocalTime = asLocalTime;