How to use the krl-stdlib/types.isMap function in krl-stdlib

], function (ctx, args) {
  if (!_.has(args, 'name')) {
    throw new Error('send_directive needs a name string')
  }
  if (!ktypes.isString(args.name)) {
    throw new TypeError('send_directive was given ' + ktypes.toString(args.name) + ' instead of a name string')
  }
  if (!_.has(args, 'options')) {
    args.options = {}
  } else if (!ktypes.isMap(args.options)) {
    throw new TypeError('send_directive was given ' + ktypes.toString(args.options) + ' instead of an options map')
  }

  return ctx.addActionResponse(ctx, 'directive', {
    name: args.name,
    options: args.options
  })
})

var clean = function(policy){
    if( ! ktypes.isMap(policy)){
        throw new TypeError("Policy definition should be a Map, but was " + ktypes.typeOf(policy));
    }

    if(isBlank(policy.name)){
        throw new Error("missing `policy.name`");
    }

    assertOnlyAllowedProperties("Policy", policy, ["name", "event", "query"]);

    if(policy.event){
        assertOnlyAllowedProperties("Policy.event", policy.event, ["deny", "allow"]);
    }
    if(policy.query){
        assertOnlyAllowedProperties("Policy.query", policy.query, ["deny", "allow"]);
    }

function ensureMap (arg, defaultTo) {
  return ktypes.isMap(arg)
    ? arg
    : defaultTo
}

], function (ctx, args) {
        var d = moment()
        if (_.has(args, 'opts')) {
          if (!ktypes.isMap(args.opts)) {
            throw new TypeError('time:now was given ' + ktypes.toString(args.opts) + ' instead of an opts map')
          }
          if (_.has(args.opts, 'tz')) {
            d.tz(args.opts.tz)
          }
        }
        return d.toISOString()
      }),
      'new': mkKRLfn([

return _.map(rules, function(rule_orig){
        if( ! ktypes.isMap(rule_orig)){
            throw new Error("Policy rules must be Maps, not " + ktypes.typeOf(rule_orig));
        }
        assertOnlyAllowedProperties("Policy.query rule", rule_orig, ["rid", "name"]);

        var rule = {};
        if(!isBlank(rule_orig.rid)){
            rule.rid = rule_orig.rid.trim();
        }
        if(!isBlank(rule_orig.name)){
            rule.name = rule_orig.name.trim();
        }
        return rule;
    });
};

throw new Error('time:add needs a date string')
        }
        if (!_.has(args, 'spec')) {
          throw new Error('time:add needs a spec map')
        }

        var dateStr = ktypes.toString(args.date)
        var d = newDate(dateStr, true)
        if (d === null) {
          if (ktypes.isString(args.date)) {
            throw new Error('time:add was given an invalid date string (' + dateStr + ')')
          }
          throw new TypeError('time:add was given ' + ktypes.toString(dateStr) + ' instead of a date string')
        }

        if (!ktypes.isMap(args.spec)) {
          throw new TypeError('time:add was given ' + ktypes.toString(args.spec) + ' instead of a spec map')
        }

        d.add(args.spec)

        return d.toISOString()
      }),
      'strftime': mkKRLfn([