How to use the raptor-util.inherit function in raptor-util

},

    getFileOutputStream: function(file) {
        return fs.createWriteStream(file, {encoding: 'utf8'});
    },
    
    setUrlBuilder: function(urlBuilder) {
        this.urlBuilder = urlBuilder;
    },
    
    getUrlBuilder: function() {
        return this.urlBuilder;
    }
};

require('raptor-util').inherit(FileWriter, Writer);

module.exports = FileWriter;

var test = this.getProperty('test');
        if (!test) {
            this.addError('"test" attribute is required for ' + this.toString() + ' tag.');
        }
        var ifCode = 'if (' + test + ')';
        if (!this.firstWhen) {
            template.line('else ' + ifCode + ' {');
        } else {
            template.statement(ifCode + ' {');
        }
        template.indent(function () {
            this.generateCodeForChildren(template);
        }, this).line('}');
    }
};
require('raptor-util').inherit(WhenNode, require('../../compiler').Node);
module.exports = WhenNode;

ElseNode.$super.call(this, 'c-else');
    if (props) {
        this.setProperties(props);
    }
}
ElseNode.prototype = {
    doGenerateCode: function (template) {
        if (this.valid == null) {
            return;    //Don't generate code for an invalid else
        }
        template.line('else {').indent(function () {
            this.generateCodeForChildren(template);
        }, this).line('}');
    }
};
require('raptor-util').inherit(ElseNode, require('../../compiler').ElementNode);
module.exports = ElseNode;

'use strict';
function ScriptletNode(code) {
    ScriptletNode.$super.call(this, 'scriptlet');
    this.code = code;
}
ScriptletNode.prototype = {
    doGenerateCode: function (template) {
        if (this.code) {
            template.code(this.code);
        }
    },
    toString: function () {
        return '{%' + this.code + '%}';
    }
};
require('raptor-util').inherit(ScriptletNode, require('../../compiler').Node);
module.exports = ScriptletNode;

OtherwiseNode.$super.call(this);
    if (props) {
        this.setProperties(props);
    }
}
OtherwiseNode.prototype = {
    doGenerateCode: function (template) {
        template.line('else {').indent(function () {
            this.generateCodeForChildren(template);
        }, this).line('}');
    },
    toString: function () {
        return '';
    }
};
require('raptor-util').inherit(OtherwiseNode, require('../../compiler').Node);
module.exports = OtherwiseNode;

var value = this.getProperty('value');
        if (!varName) {
            this.addError('"var" attribute is required');
        } else if (!varNameRegExp.test(varName)) {
            this.addError('Invalid variable name of "' + varName + '"');
            varName = null;
        }
        if (!value) {
            this.addError('"value" attribute is required');
        }
        if (varName) {
            template.statement(varName + '=' + value + ';');
        }
    }
};
require('raptor-util').inherit(AssignNode, require('../../compiler').Node);
module.exports = AssignNode;

},

    toString: function() {
        var lines = [];
        for (var k in this.dependencyToBundleMapping) {
            if (this.dependencyToBundleMapping.hasOwnProperty(k)) {
                var targetBundle = this.dependencyToBundleMapping[k].bundle;
                lines.push(k + ' --> ' + targetBundle.toString());
            }
        }

        return lines.join('\n');
    }
};

require('raptor-util').inherit(BundleMappings, EventEmitter);

module.exports = BundleMappings;

} else {
            this.fork();
        }
    },

    start: function(port) {
        this.port = port;
        this.restart();
    },

    isStarted: function() {
        return this.state === 'started';
    }
};

require('raptor-util').inherit(Launcher, EventEmitter);

module.exports = Launcher;

}
        });

        return promise;
    },

    buildResourceCacheKey(cacheKey, lassoContext) {
        if (this.impl.buildResourceCacheKey) {
            return this.impl.buildResourceCacheKey(cacheKey, lassoContext);
        } else {
            return cacheKey;
        }
    }
};

require('raptor-util').inherit(Writer, EventEmitter);

module.exports = Writer;

_this.emit('modified', {
                        type: event,
                        path: path
                    });
                });
            });
    }

    this.start = start;
}

Watcher.prototype = {
};

require('raptor-util').inherit(Watcher, EventEmitter);

module.exports = Watcher;