How to use the tslib.__param function in tslib

let binding;
            const expr = runtime_1.ensureExpression(this.parser, instruction.from, 2048 /* Interpolation */);
            if (expr.isMulti) {
                binding = runtime_1.applyBindingBehavior(new runtime_1.MultiInterpolationBinding(this.observerLocator, expr, next, 'textContent', runtime_1.BindingMode.toView, context), expr, context);
            }
            else {
                binding = runtime_1.applyBindingBehavior(new runtime_1.InterpolationBinding(expr.firstExpression, expr, next, 'textContent', runtime_1.BindingMode.toView, this.observerLocator, context, true), expr, context);
            }
            runtime_1.addBinding(renderable, binding);
        }
    };
    TextBindingRenderer = tslib_1.__decorate([
        runtime_1.instructionRenderer("ha" /* textBinding */)
        /** @internal */
        ,
        tslib_1.__param(0, runtime_1.IExpressionParser),
        tslib_1.__param(1, runtime_1.IObserverLocator),
        tslib_1.__metadata("design:paramtypes", [Object, Object])
    ], TextBindingRenderer);
    exports.TextBindingRenderer = TextBindingRenderer;
    let ListenerBindingRenderer = 
    /** @internal */
    class ListenerBindingRenderer {
        constructor(parser, eventManager) {
            this.parser = parser;
            this.eventManager = eventManager;
        }
        render(flags, dom, context, renderable, target, instruction) {
            // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
            const expr = runtime_1.ensureExpression(this.parser, instruction.from, 80 /* IsEventCommand */ | (instruction.strategy + 6 /* DelegationStrategyDelta */));
            const binding = runtime_1.applyBindingBehavior(new listener_1.Listener(dom, instruction.to, instruction.strategy, expr, target, instruction.preventDefault, this.eventManager, context), expr, context);
            runtime_1.addBinding(renderable, binding);

}
        this.elapsedFrames = 0;
        const tracked = this.tracked;
        const len = tracked.length;
        let current;
        let i = 0;
        for (; i < len; ++i) {
            current = tracked[i];
            if (current.isDirty()) {
                current.flush(256 /* fromTick */);
            }
        }
    }
};
DirtyChecker = __decorate([
    __param(0, IScheduler)
], DirtyChecker);
export { DirtyChecker };
let DirtyCheckProperty = class DirtyCheckProperty {
    constructor(dirtyChecker, obj, propertyKey) {
        this.dirtyChecker = dirtyChecker;
        this.obj = obj;
        this.propertyKey = propertyKey;
    }
    isDirty() {
        return this.oldValue !== this.obj[this.propertyKey];
    }
    flush(flags) {
        const oldValue = this.oldValue;
        const newValue = this.obj[this.propertyKey];
        this.callSubscribers(newValue, oldValue, flags | 16 /* updateTargetInstance */);
        this.oldValue = newValue;

mc.on(eventName, callback);
            return function () {
                mc.off(eventName, callback);
                // destroy mc to prevent memory leak
                if (typeof mc.destroy === 'function') {
                    mc.destroy();
                }
            };
        });
    };
    HammerGesturesPlugin.prototype.isCustomEvent = function (eventName) { return this._config.events.indexOf(eventName) > -1; };
    HammerGesturesPlugin = __decorate([
        Injectable(),
        __param(0, Inject(DOCUMENT$1)),
        __param(1, Inject(HAMMER_GESTURE_CONFIG)),
        __param(3, Optional()), __param(3, Inject(HAMMER_LOADER)),
        __metadata("design:paramtypes", [Object, HammerGestureConfig, ɵConsole, Object])
    ], HammerGesturesPlugin);
    return HammerGesturesPlugin;
}(EventManagerPlugin));

runBeforeAttach(locator = this.locator) {
        return this.run(3 /* beforeAttach */, locator);
    }
    run(slot, locator = this.locator) {
        const tasks = locator.getAll(IStartTask)
            .filter(startTask => startTask.slot === slot)
            .map(startTask => startTask.resolveTask())
            .filter(task => !task.done);
        if (tasks.length === 0) {
            return LifecycleTask.done;
        }
        return new AggregateTerminalTask(tasks);
    }
};
StartTaskManager = __decorate([
    __param(0, IServiceLocator)
], StartTaskManager);
export { StartTaskManager };
export class PromiseTask {
    constructor(promise, next, context, ...args) {
        this.done = false;
        this.hasStarted = false;
        this.isCancelled = false;
        this.promise = promise.then(value => {
            if (this.isCancelled === true) {
                return;
            }
            this.hasStarted = true;
            if (next !== null) {
                const nextResult = next.call(context, value, ...args);
                if (nextResult === void 0) {
                    this.done = true;

return createElement(this.dom, subject, this.properties, this.$controller.projector === void 0
            ? PLATFORM.emptyArray
            : this.$controller.projector.children).createView(this.$controller.context);
    }
};
__decorate([
    bindable,
    __metadata("design:type", Object)
], Compose.prototype, "subject", void 0);
__decorate([
    bindable({ mode: BindingMode.fromView }),
    __metadata("design:type", Boolean)
], Compose.prototype, "composing", void 0);
Compose = __decorate([
    customElement({ name: 'au-compose', template: null, containerless: true }),
    __param(0, IDOM),
    __param(1, ITargetedInstruction),
    __metadata("design:paramtypes", [Object, Object])
], Compose);
export { Compose };
function isController(subject) {
    return 'lockScope' in subject;
}
//# sourceMappingURL=compose.js.map

}
    beforeAttach(flags) {
        this.view.attach(flags);
    }
    beforeDetach(flags) {
        this.view.detach(flags);
    }
    beforeUnbind(flags) {
        const task = this.view.unbind(flags);
        this.view.parent = void 0;
        return task;
    }
};
Replaceable = __decorate([
    templateController('replaceable'),
    __param(0, IViewFactory),
    __param(1, IRenderLocation),
    __metadata("design:paramtypes", [Object, Object])
], Replaceable);
export { Replaceable };
//# sourceMappingURL=replaceable.js.map

* @returns The reconfigured `BrowserModule` to import into the app's root `AppModule`.
     */
    BrowserModule.withServerTransition = function (params) {
        return {
            ngModule: BrowserModule_1,
            providers: [
                { provide: APP_ID, useValue: params.appId },
                { provide: TRANSITION_ID, useExisting: APP_ID },
                SERVER_TRANSITION_PROVIDERS,
            ],
        };
    };
    var BrowserModule_1;
    BrowserModule = BrowserModule_1 = tslib_1.__decorate([
        NgModule({ providers: BROWSER_MODULE_PROVIDERS, exports: [CommonModule, ApplicationModule] }),
        tslib_1.__param(0, Optional()), tslib_1.__param(0, SkipSelf()), tslib_1.__param(0, Inject(BrowserModule_1)),
        tslib_1.__metadata("design:paramtypes", [Object])
    ], BrowserModule);
    return BrowserModule;
}());
export { BrowserModule };

tslib_1.__decorate([
        Input('name'),
        tslib_1.__metadata("design:type", String)
    ], TdNavigationDrawerComponent.prototype, "name", void 0);
    tslib_1.__decorate([
        Input('email'),
        tslib_1.__metadata("design:type", String)
    ], TdNavigationDrawerComponent.prototype, "email", void 0);
    TdNavigationDrawerComponent = tslib_1.__decorate([
        Component({
            selector: 'td-navigation-drawer',
            styles: [":host { width: 100%; } :host .td-navigation-drawer-content.ng-animating, :host .td-navigation-drawer-menu-content.ng-animating { overflow: hidden; } :host mat-toolbar { padding: 16px; } :host mat-toolbar.td-toolbar-background { background-repeat: no-repeat; background-size: cover; } :host mat-toolbar.td-nagivation-drawer-toolbar { -webkit-box-orient: vertical; -webkit-box-direction: normal; -ms-flex-direction: column; flex-direction: column; height: auto !important; display: block !important; } :host mat-toolbar .td-navigation-drawer-toolbar-content { -webkit-box-orient: horizontal; -webkit-box-direction: normal; -ms-flex-direction: row; flex-direction: row; -webkit-box-sizing: border-box; box-sizing: border-box; display: -webkit-box; display: -ms-flexbox; display: flex; -webkit-box-align: center; -ms-flex-align: center; align-items: center; -ms-flex-line-pack: center; align-content: center; max-width: 100%; -webkit-box-pack: start; -ms-flex-pack: start; justify-content: start; } :host mat-toolbar .td-navigation-drawer-menu-toggle { -webkit-box-orient: horizontal; -webkit-box-direction: normal; -ms-flex-direction: row; flex-direction: row; -webkit-box-sizing: border-box; box-sizing: border-box; display: -webkit-box; display: -ms-flexbox; display: flex; } :host mat-toolbar .td-navigation-drawer-menu-toggle .td-navigation-drawer-label { -webkit-box-flex: 1; -ms-flex: 1; flex: 1; } :host mat-toolbar .td-navigation-drawer-menu-toggle .td-navigation-drawer-menu-button { height: 24px; line-height: 24px; width: 24px; } :host > div { overflow: hidden; } /*# sourceMappingURL=navigation-drawer.component.css.map */ "],
            template: "   <div class="\&quot;td-navigation-drawer-toolbar-content\&quot;"> {{icon}}  <span class="\&quot;td-navigation-drawer-title\&quot;">{{sidenavTitle}}</span> </div> <div class="\&quot;td-navigation-drawer-name\&quot;">{{name}}</div> <div href="" class="\&quot;td-navigation-drawer-menu-toggle\&quot;"> <span class="\&quot;td-navigation-drawer-label\&quot;">{{email || name}}</span> <button class="\&quot;td-navigation-drawer-menu-button\&quot;"> arrow_drop_down arrow_drop_up </button> </div>   <div class="\&quot;td-navigation-drawer-content\&quot;">  </div> <div class="\&quot;td-navigation-drawer-menu-content\&quot;">  </div> ",
            animations: [TdCollapseAnimation()],
        }),
        tslib_1.__param(0, Inject(forwardRef(function () { return TdLayoutComponent; }))),
        tslib_1.__param(1, Optional()),
        tslib_1.__metadata("design:paramtypes", [TdLayoutComponent,
            Router,
            DomSanitizer])
    ], TdNavigationDrawerComponent);
    return TdNavigationDrawerComponent;
}());
export { TdNavigationDrawerComponent };

tslib_1.__metadata("design:paramtypes", [Object])
    ], RouterLink.prototype, "routerLink", null);
    tslib_1.__decorate([
        Input(),
        tslib_1.__metadata("design:type", Boolean),
        tslib_1.__metadata("design:paramtypes", [Boolean])
    ], RouterLink.prototype, "preserveQueryParams", null);
    tslib_1.__decorate([
        HostListener('click'),
        tslib_1.__metadata("design:type", Function),
        tslib_1.__metadata("design:paramtypes", []),
        tslib_1.__metadata("design:returntype", Boolean)
    ], RouterLink.prototype, "onClick", null);
    RouterLink = tslib_1.__decorate([
        Directive({ selector: ':not(a)[routerLink]' }),
        tslib_1.__param(2, Attribute('tabindex')),
        tslib_1.__metadata("design:paramtypes", [Router, ActivatedRoute, String, Renderer2, ElementRef])
    ], RouterLink);
    return RouterLink;
}());
export { RouterLink };

};
    ReducerManager.prototype.updateReducers = function (featureKeys) {
        this.next(this.reducerFactory(this.reducers, this.initialState));
        this.dispatcher.next({
            type: UPDATE,
            features: featureKeys,
        });
    };
    ReducerManager.prototype.ngOnDestroy = function () {
        this.complete();
    };
    ReducerManager = __decorate([
        Injectable(),
        __param(1, Inject(INITIAL_STATE)),
        __param(2, Inject(INITIAL_REDUCERS)),
        __param(3, Inject(REDUCER_FACTORY)),
        __metadata("design:paramtypes", [ReducerManagerDispatcher, Object, Object, Function])
    ], ReducerManager);
    return ReducerManager;
}(BehaviorSubject));
var REDUCER_MANAGER_PROVIDERS = [