How to use the handlebars.registerHelper function in handlebars

const Handlebars = require('handlebars')

Handlebars.registerHelper('toLowerCase', value => {
  return value.toLowerCase()
})

Handlebars.registerHelper('json', context => {
  if (!context) {
    return JSON.stringify({})
  }

  return JSON.stringify(context, null, 2)
})

Handlebars.registerHelper('transformToArray', arr => {
  return `'${arr.join('\',\'')}'`
})

Handlebars.registerHelper('validMethod', (method, options) => {
  const authorizedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'PATCH']

  /* eslint-disable no-undef */
  if (arguments.length < 3) {
    throw new Error('Handlebars Helper validMethod needs 1 parameter')
  }
  /* eslint-enable no-undef */

  if (authorizedMethods.indexOf(method.toUpperCase()) === -1) {
    return options.inverse(this)
  }

} else {
          return Handlebars.helpers.local("calculator");
        }
    });


    Handlebars.registerHelper('ifShowSearch', function(results, options) { // if equal
      if(!results[0] || results[0].data.template !== "noResult") {
        return options.fn(this);
      } else {
        return options.inverse(this);
      }
    });


    Handlebars.registerHelper('mobileWikipediaUrls', function(url) {
        return url.replace("http://de.wikipedia.org/wiki","https://de.m.wikipedia.org/wiki");
    });

    Handlebars.registerHelper('eachIncludeParent', function ( context, options ) {
        var fn = options.fn,
            inverse = options.inverse,
            ret = "",
            _context = [];

        $.each(context, function (index, object) {
            var _object = $.extend({}, object);
            _context.push(_object);
        });

        if ( _context && _context.length > 0 ) {
            for ( var i = 0, j = _context.length; i < j; i++ ) {

import Handlebars from 'handlebars';

// Provide handlebars with the ability to look up a model's attributes from within a template.
Handlebars.registerHelper('get', function(model, attribute) {
  return model.get(attribute);
});

Handlebars.registerHelper('ternary', function(test, yes, no) {
  return test ? yes : no;
});

Handlebars.registerHelper('i18n', function(messageName) {
  var message = chrome.i18n.getMessage(messageName);

  if (message === '') {
    throw new Error('Failed to find message: ' + messageName);
  }

  return chrome.i18n.getMessage(messageName);
});

return selected[index] ? "selected" : "";
});
Handlebars.registerHelper("enabled", (isEnabled: boolean) => {
	// Adds the "disabled" form attribute if the element should be disabled
	return !isEnabled ? "disabled" : "";
});
Handlebars.registerHelper("slug", (input: string): string => {
	return encodeURIComponent(input.toLowerCase());
});
Handlebars.registerHelper("numberFormat", (n: number): string => {
	return n.toLocaleString();
});
Handlebars.registerHelper("toLowerCase", (n: number): string => {
	return n.toString().toLowerCase();
});
Handlebars.registerHelper("toJSONString", (stat: StatisticEntry): string => {
	return JSON.stringify(stat);
});
Handlebars.registerHelper("removeSpaces", (input: string): string => {
	return input.replace(/ /g, "-");
});
Handlebars.registerHelper("join", (arr: T[]): string  => {
	return arr.join(", ");
});
for (let name of ["sidebar", "login-methods", "form"]) {
	Handlebars.registerPartial(name, fs.readFileSync(path.resolve(STATIC_ROOT, "partials", `${name}.html`), "utf8"));
}

templateRoutes.route("/dashboard").get((request, response) => response.redirect("/"));
templateRoutes.route("/").get(authenticateWithRedirect, async (request, response) => {
	let user = request.user as IUser;

// HOOKS beforePageJson
    json = Hooks.instance.trigger('beforePageJson', json)

    Handlebars.registerHelper('abe', compileAbe) // HandlebarsJS unique text helper
    Handlebars.registerHelper('i18nAbe', translate) // HandlebarsJS unique text helper
    Handlebars.registerHelper('math', math) // HandlebarsJS unique text helper
    Handlebars.registerHelper('moduloIf', moduloIf) // HandlebarsJS helper for modulo test
    Handlebars.registerHelper('testObj', testObj) // 
    Handlebars.registerHelper('attrAbe', attrAbe) // 
    Handlebars.registerHelper('printJson', printJson)
    Handlebars.registerHelper('printBlock', printBlock)
    Handlebars.registerHelper('className', className)
    Handlebars.registerHelper('cleanTab', cleanTab)
    Handlebars.registerHelper('slugify', handlebarsHelperSlugify({Handlebars: Handlebars}).slugify)
    Handlebars.registerHelper('printConfig', printConfig)
    Handlebars.registerHelper('ifIn', ifIn)
    Handlebars.registerHelper('ifCond', ifCond)
    Handlebars.registerHelper('abeImport', abeImport)
    Handlebars.registerHelper('listPage', listPage)
    HandlebarsIntl.registerWith(Handlebars)

    Hooks.instance.trigger('afterHandlebarsHelpers', Handlebars)

    let util = new Util()
    let intlData = config.intlData

    text = this._removeHidden(text)
    text = this._addAbeTag(text)

    abeEngine.instance.content = json

    // var pattNode = />({{abe.*?type=[\'|\"][text|rich|textarea]+[\'|\"][\s\S].*?}})/g,

filterByKind(children, options, consts.kindStringProperty),
);

Handlebars.registerHelper('filterTagExample', (children, options) =>
  filterByTag(children, options, consts.tagTypeExample),
);

Handlebars.registerHelper('constructParamTable', (parameters) => constructParamTable(parameters));

Handlebars.registerHelper('renderMethodReturnType', (type) => renderMethodReturnType(type));

Handlebars.registerHelper('methodBracket', (parameters) => renderMethodBracket(parameters));

Handlebars.registerHelper('getSourceLink', (sources) => renderSourceLink(sources));

Handlebars.registerHelper('newLine', renderNewLine);

Handlebars.registerHelper('cleanHyperLink', (str) => cleanHyperLink(str));

// Processors
const apiProcessor = new APIProcessor();
apiProcessor.run(Handlebars);

const pagesProcessor = new PagesProcessor();
pagesProcessor.run();

const exampleProcessor = new ExampleProcessor();
exampleProcessor.run(Handlebars);

const configProcessor = new ConfigProcessor();
configProcessor.run({ apiChildren: apiProcessor.apiChildren });

Handlebars.registerHelper('highlightjs', function(...args) {
		const arg = analyzeArguments(...args);
		const context = arg.get(this);
		const option = Object.assign({'class': 'js'}, arg.hash);

		const result = highlightjs.highlight(option.class, context, true);

		return `\n${result}`;
	});


	Handlebars.registerHelper('wrapscript', function(...args) {
		const script = Handlebars.helpers.babel.call(this, ...args);
		return `//wrapscript\n(function() {\n${script}\n})();`;
	});
	Handlebars.registerHelper('code', function(...args) {
		const arg = analyzeArguments(...args);
		const option = Object.assign({class: 'js'}, arg.hash);
		option.code = arg.get(this);
		let template;
		if (typeof Handlebars.partials.code !== 'function') {
			template = Handlebars.compile(Handlebars.partials.code);
		} else {
			template = Handlebars.partials.code;
		}

		return new Handlebars.SafeString(template(option));
	});
	Handlebars.registerHelper('json', function(...args) {
		const arg = analyzeArguments(...args);
		const code = arg.get(this);
		const result = JSON.parse(code);

//each property helper
Handlebars.registerHelper('eachProperty', function(context, options) {
    var ret = "";
    for(var key in context) {
        ret = ret + options.fn({key: key, value: context[key]});
    }
    return ret;
});

//markdown
Handlebars.registerHelper('md', function(string) {
    return string ? new Handlebars.SafeString(marked(string)) : '';
});

//markdown block
Handlebars.registerHelper('mdb', function(options) {
    return new Handlebars.SafeString(marked(options.fn(this).trim()));
});

//source
Handlebars.registerHelper('source', function(options) {
  var out = '<pre class="prettyprint linenums">' + (Handlebars.Utils.escapeExpression(options.fn(this))).trim() + '</pre>';
  return new Handlebars.SafeString(out);
});

//since
Handlebars.registerHelper('since', function() {
    if(this.since) {
       return new Handlebars.SafeString('<div style="text-align: left"><span style="font-size: 0.8em" class="muted">since '+ this.since +'</span></div>');
    }
});

var TraitsEditor = require('./traits-editor');
var PackageTemplate = require('../tpl/package.hbs');

var NotesComponent = React.createFactory(require('../components/notes'));

var Handlebars = require('handlebars');
Handlebars.registerHelper('normalize', function (v) {
    v = Number(v);
    if (v % 1024 === 0) {
        return _.str.sprintf('%d GB', v / 1024);
    }

    return _.str.sprintf('%d MB', v);
});

Handlebars.registerHelper('ifeq', function (a, b, options) {
    if (a == b) { return options.fn(this); }
    return options.inverse(this);
});

Handlebars.registerHelper('ifnoteq', function (a, b, options) {
    if (a != b) { return options.fn(this); }
    return options.inverse(this);
});


var PackageVersions = Backbone.Marionette.CompositeView.extend({
    template: require('../tpl/package-versions.hbs'),
    attributes: {
        'id': 'package-versions'
    },
    itemView: Backbone.Marionette.ItemView.extend({

return options.inverse(this);
	});
	Handlebars.registerHelper('getAvatar', function(options,size) {
		var path;
			if(_.has(options,'profileImageGId')){
				if(_.isUndefined(size)) 
					path = "service/content/multimedia/image/"+options.profileImageGId;
				else
					path = "service/content/multimedia/image/"+options.profileImageGId+"/small";
			}else{
				path = "styles/images/s-avatar.png";
			}
		return path;
	});

	Handlebars.registerHelper('ifCond', function (v1, operator, v2, options) {

		switch (operator) {
			case '==':
				return (v1 == v2) ? options.fn(this) : options.inverse(this);
			break;
			case '===':
				return (v1 === v2) ? options.fn(this) : options.inverse(this);
			break;
			case '<':
				return (v1 < v2) ? options.fn(this) : options.inverse(this);
			break;
			case '<=':
				return (v1 <= v2) ? options.fn(this) : options.inverse(this);
			break;
			case '>':
				return (v1 > v2) ? options.fn(this) : options.inverse(this);