async transformBindings(container, input, raw, currentpath, generator, liveBindings) {
        let output = {
            imports: [],
            externalImports: [],
            exports: [],
            dynamicImports: [],
            externalDynamicImports: [],
            metaProperties: [],
            dynamicMappings: {},
            exportLiveBindings: []
        };
    
        generator.onESMEnter(input, currentpath, raw.ast);
    
        for (let i = 0; i < raw.imports.length; i++) {
            await resolveImport(container, input, output, raw.imports[i].node, currentpath, generator);
        }

        for (let i = 0; i < raw.exports.length; i++) {
            let { type, node } = raw.exports[i];
            
            if (type === 'default') {
                resolveDefaultExport(container, input, output, node, currentpath, generator);
                continue;
            }

            if (type === 'named') {
                await resolveNamedExport(container, input, output, node, currentpath, generator, liveBindings);
                continue;
            }

            if (type === 'all') {
                await resolveAllExport(container, input, output, node, currentpath, generator);
                continue;
            }
        }

        for (let i = 0; i < raw.dynamicImports.length; i++) {
            await resolveDynamicImport(container, input, output, raw.dynamicImports[i].node, currentpath, generator);
        }

        for (let i = 0; i < raw.metaProperties.length; i++) {
            resolveMetaProperty(container, input, output, raw.metaProperties[i].node, currentpath, generator);
        }
  
        if (!liveBindings && output.exportLiveBindings.length > 0) {
            walkSimpleLiveBindings(container, input, output, raw.ast.body, [], 0, generator, currentpath);
        }
    
        if (liveBindings === 'reference') {
            LiveBindingResolver(output.imports, raw.ast.body, generator, currentpath)
        }
    
        let { code, map } = generator.onESMLeave(input, currentpath, raw.ast);
        output.code = code;
        output.map = map;
    
        return output;
    }
@param {PluginContainer} container 
@param {string} input 
@param {string} currentpath 
@param {CodeGenerator} generator 
@param {Boolean|String} liveBindings
@return {Promise<Object>}