let
    f=(x)=>Table.AddRankColumn(x,"Ранг",{"Штуки",1}),
    from=Excel.CurrentWorkbook(){[Name="Таблица1"]}[Content],
    gr=Table.Combine(Table.Group(from,"Клиент",{"tmp",f})[tmp])
in
    gr

let
    f=(x)=>((a)=>Table.Sort(Table.AddRankColumn(a,"Ранг",{"Штуки",1}),"ind"))
            (Table.AddIndexColumn(x,"ind",0,1)),
    from=Excel.CurrentWorkbook(){[Name="Таблица3"]}[Content],
    gr=Table.RemoveColumns(Table.Combine(Table.Group(from,"Клиент",{"tmp",f})[tmp]),"ind")
in
    gr

let
    f=(x)=>[Показания одометра на начало=List.Min(x[Показания одометра на начало]),
            Показания одометра на конец=List.Max(x[Показания одометра на конец]),
            Пробег=#"Показания одометра на конец"-#"Показания одометра на начало" ],
    from=Excel.Workbook(File.Contents(fParam("Path")),true){[Name="Лист1"]}[Data],
    add=Table.AddColumn(from,"Месяц",(x)=>Date.MonthName(x[Дата])),
    gr=Table.Group(add,{"Месяц","Номер "},{"tmp",f}),
    nms=Record.FieldNames(gr[tmp]{0}),
    exp=Table.ExpandRecordColumn(gr, "tmp",nms)
in
    exp

let
    from = Excel.CurrentWorkbook(){[Name="Таблица13"]}[Content],
    gr=Table.Group(from,"Дата",{{"Товар",(x)=>Text.Combine(List.Distinct(x[Товар])," ")},
                                {"Цена",(x)=>x[Цена]}}),
    to=Table.SplitColumn(gr,"Цена",(x)=>x)
in
   to

let
    f=(x)=>List.FirstN(x,2)&{[
    a=if x{5}<>null and not Text.Contains(x{2},x{5},Comparer.OrdinalIgnoreCase) then x{2} &" Part Number: " & x{5} else x{2},
    b = if x{3}<>null and x{3}<>"Not applicable" then  a &"#(lf)" & "Manufacturer: " &x{3} else a,
    c=if x{4}<>null then b &"#(lf)" & "Certification requirements:" & "#(lf)" & 
    Text.Combine(List.Transform(Text.Split(x{4},","),(x)=>"- "&Text.Trim(x)&";"),"#(lf)")  else b
][c]},
    Источник = Excel.CurrentWorkbook(){[Name="Таблица1"]}[Content],
    textype = Table.TransformColumnTypes(Источник, List.Transform(Table.ColumnNames(Источник), each {_, type text})),
    toList=Table.ToList( textype,f),
    to= Table.FromList(toList,(x)=>x,List.FirstN(Table.ColumnNames(textype),3))
in
    to

let
    f=(x)=>((a)=>Table.Skip(Table.RenameColumns(x,a)))
    (List.Zip({Table.ColumnNames(x),List.FirstN(Table.ColumnNames(x),2)&List.Skip(Record.ToList(x{0}),2)})),
    file=Excel.Workbook(File.Contents(fParam("Path"))),
    sel_row=Table.SelectRows(file,(x)=>Text.Contains(x[Item],"Таблица") and x[Kind]="Table" and not Text.Contains(x[Name],"Сводная")),
    from=Table.Combine(List.Transform(sel_row[Data],f)),
    nms=List.Select(Table.ColumnNames(from),(x)=>not Text.Contains(x,"Всего")),
    sort=List.FirstN(nms,2)&List.Sort(List.Skip(nms,2),(x)=>Value.FromText(x)),
    tr=Table.TransformColumns(Table.SelectColumns(from,sort),{},(x)=>x??0),
    add=Table.AddColumn(tr,"Всего",(x)=>List.Sum(List.Skip(Record.ToList(x),2)))
in
    add

AlienSx, я сейчас здесь только ради Вас, не уходите, я пишу Вам, я под впечатлением...)  

let
    g=(x)=>List.Sum(Table.Column(Table.SelectRows(x,(i)=>Record.Field(i,nms{1})="03.01"),nms{2})),
    h=(x)=>Value.FromText(Text.Combine(List.LastN(Splitter.SplitTextByDelimiter(" ")(x),2)," ")),
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    from=f("data"), 
    start=Value.FromText(f("start")[Start]{0}),
    end=Value.FromText(f("start")[End]{0}),
    nms=Table.ColumnNames(from),
    gr=Table.Group(from,nms{0},{"Сумма",g},GroupKind.Local,(s,c)=>Number.From(c<>null)),
    tr=Table.TransformColumns(gr,{nms{0},h}),
    sel=List.Sum(Table.SelectRows(tr,(x)=>Record.Field(x,nms{0})>=start and Record.Field(x,nms{0})<=end)[Сумма])
in
    sel

let
    g=(y)=>[a=Table.AddColumn(y,"с",(i)=>List.Generate(()=>i[аренда с],
                                     (x)=>x<=i[аренда по],
                                     (x)=>Date.AddDays(x,1),
                                     (x)=>x)),
            b=Table.FillDown(Table.Sort(rate&Table.ExpandListColumn(a,"с"),"с"),{nms{2}}),
            c=List.Sum(Table.Column(Table.SelectRows(b,(x)=>x[аренда с]<>null),nms{2}))][c],      
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    rate=Table.TransformColumnTypes(f("rate"),{{"с", type date}, {"по", type date}}), 
    per=Table.TransformColumnTypes(f("period"),{{"с", type date}, {"по", type date}}),
    ren = Table.RenameColumns(per,{{"с", "аренда с"}, {"по", "аренда по"}}),
    nms=Table.ColumnNames(rate),
    gr=Table.Group(ren,{"аренда с","аренда по"},{"Стоимость аренды, руб. без НДС",g})[[#"Стоимость аренды, руб. без НДС"]]  
in
    gr

let
    f=(s,c)=>Number.From(Value.FromText(Text.Start(Text.From(c),18)) is number),
    g=(x)=>[b=Table.Max(Table.Sort(Table.Skip(x,(y)=>not Value.Is(y[data],type date)),"data"),"data"),
            c=List.FirstN(x[data],2)&{Record.Field(b,"data"),Record.Field(b,"price")}][c],
    from=Excel.CurrentWorkbook(){[Name="table1"]}[Content],
    tr=Table.TransformColumns(from,{"data",(x)=>if x is datetime or Text.Contains(x,".20") then Date.From(x) else x}),
    gr=Table.Group(tr,"data",{"tmp",g},GroupKind.Local,f),
    //tb=Table.FromList(gr[tmp],(x)=>x,{"Номер изделия", "Наименование","Дата","Цена"})
    tb=#table(type table [Номер изделия=Text.Type,Наименование=Text.Type,Дата=Date.Type,Цена=Number.Type],gr[tmp])
in
    tb

//на Лист "Параметры" прописать путь к файлу
let
    from=Csv.Document(File.Contents(fParam("Path")),null,";",null,1251)[Column2],
    ind={1,3,24,23,30,38,37,10,9,14,15},
    nms=List.Transform(ind,(x)=>"B"&Text.From(x+1)),
    lst=Table.FromColumns(List.Transform(ind,(x)=>{from{x}}),nms)
in
   lst

let
   f=(x)=>((a)=>if a is text then Expression.Evaluate(a)??"пусто" else a??"пусто")
          (List.Last(List.RemoveNulls(List.Alternate(Record.ToList(x),1,1,1)))),
   from = Excel.CurrentWorkbook(){[Name="Таблица1"]}[Content],
   add = Table.AddColumn(from,"Value",f)[[Value]]
in
   add

let
    from =Excel.Workbook(File.Contents(fParam("Path"))){[Name="Лист_1"]}[Data],
    tr=Table.TransformColumns(from,{"Column1",(x)=>Text.From(x)??""}),
    add=Table.AddColumn(tr,"МЭС",(x)=>if Text.Contains(x[Column1],"МЭС") or Text.Contains(x[Column1],"Итог") then x[Column1] else null),
    to=Table.PromoteHeaders(Table.CombineColumns(Table.FillDown(add,{"МЭС"}),{"МЭС","Column1"},(x)=>x{0}??x{1},"МЭС"))
in
    to

Function CurrentRegion(ws As Worksheet, stCell As Range) As Range
    Dim Rng As Range
    Dim lRow&, lCol&

    lRow = ws.Cells(ws.Rows.Count, stCell.Column).End(xlUp).Row
    lCol = ws.Cells(stCell.Row, ws.Columns.Count).End(xlToLeft).Column

    Set Rng = ws.Range(stCell, ws.Cells(lRow, lCol))
    Set CurrentRegion = Rng
End Function

Sub SelectColumns()
    Dim ws As Worksheet
    Dim col As Range, cell As Range, sel As Range, Rng As Range, stCell As Range
    
    Set ws = ThisWorkbook.Sheets("Sheet1")
    Set stCell = ws.Range("B2")   'стартовая ячейка (первая заполненная)

    Set Rng = CurrentRegion(ws, stCell)
    MsgBox "Диапазон с данными" & Rng.Address, vbInformation
    
    For Each col In Rng.Columns
        For Each cell In col.Cells
            If IsEmpty(cell.Value) Then
                If sel Is Nothing Then
                    Set sel = col
                Else
                    Set sel = Union(sel, col)
                End If
                Exit For
            End If
        Next cell
    Next col
    
    If Not sel Is Nothing Then
        sel.Select
    Else
        MsgBox "Нет столбцов с пустыми ячейками", vbInformation
    End If
End Sub

let
    f=(c,v)=>Number.From(Text.Split(c,"-"){0}<>Text.Split(v,"-"){0}),
    g=(x)=>List.Sum(x[#"Сумма итого, руб"]),
    from=Excel.Workbook(File.Contents(fParam("Path"))){[Name="Начисления"]}[Data],
    skip=Table.PromoteHeaders(Table.Skip(from)),
    gr=Table.Group(Table.Sort(skip,"ID начисления"),"ID начисления",{"Сумма",g},GroupKind.Local,f)
in
    gr

let
    from =Excel.Workbook(File.Contents(fParam("Path")),true){[Name="Total"]}[Data],
    lst=List.Buffer(Table.ToList(from,(x)=>x)),
    max=List.Max(from[level]),
    gen=List.Generate(()=>[i=0,j=lst{i},r={j{1}}&List.Repeat({null},max-j{0})&List.Skip(j,2)],
        (x)=>x[i]<List.Count(lst),
        (x)=>[i=x[i]+1,j=lst{i},r=List.FirstN(x[r],j{0}-1)&{j{1}}&List.Repeat({null},max-j{0})&List.Skip(j,2)],
        (x)=>x[r]),
    nms=List.Transform({1..max},(x)=>"Name_"&Text.From(x))&List.Skip(Table.ColumnNames(from),2),
    to=Table.FromList(gen,(x)=>x,nms)
in
    to

let
    f=(x)=>Expression.Evaluate(Text.Combine(List.Transform(Record.ToList(x),Text.From))),
    from = Excel.CurrentWorkbook(){[Name="table1"]}[Content],
    add=Table.AddColumn(from,"результат",f)
in
    add

let
    f=(x)=>[ls=List.Buffer(List.Skip(x)),
            a=List.PositionOfAny(ls,sp,Occurrence.First,(c,v)=>Text.Contains(Text.Lower(c),v)),
            b=if a=-1 then {} else List.Skip(List.FirstN(ls,(w)=>not Text.Contains(Text.Lower(w),"нет")),a),
            b1=List.Transform(b,(x)=>if List.Contains(num,x,(c,v)=>Text.Contains(v,c)) then Text.Combine(Text.Split(x," "),"||") else x),
            c={Text.Combine(b1,"||")}&x][c],
    from = Excel.CurrentWorkbook(){[Name="data"]}[Content],
    num=List.Buffer({"0".."9"}),sp=List.Buffer({"высота","ширина","длина"}),
    tr=Table.TransformColumns(from,{},(x)=>if x=null then "" else f_txtTrim(x)),
    to=Table.FromList(Table.ToList(tr,f),(x)=>x,{"Высота/Ширина/Длина"}&Table.ColumnNames(from))
in
    to

let
    f=(x)=>[lst=List.Buffer(List.Skip(Record.ToList(x))),num=List.Buffer({"0".."9"}),sp=List.Buffer({"Высота","Ширина","Длина"}),
            a=List.PositionOfAny(lst,sp,Occurrence.First,(c,v)=>Text.Contains(Text.Proper(c),v)),
            b=if a=-1 then {} else List.Skip(List.FirstN(lst,(w)=>not Text.Contains(Text.Proper(w),"Нет")),a),
            b1=List.Transform(b,(x)=>if List.Contains(num,x,(c,v)=>Text.Contains(v,c)) then Text.Combine(Text.Split(x," "),"||") else x),
            c=Text.Combine(b1,"||")][c],
    from = Excel.CurrentWorkbook(){[Name="data"]}[Content],
    tr=Table.TransformColumns(from,{},(x)=>if x=null then "" else f_txtTrim(x)),
    add=Table.AddColumn(tr,"Высота/Ширина/Длина",f),
    to = Table.ReorderColumns(add,{"Высота/Ширина/Длина"}&Table.ColumnNames(from))
in
    to

let
    f=(x)=>[lst=Record.ToList(x),
            a=List.PositionOfAny(lst,{"Высота","Ширина","Длина"},Occurrence.First,(c,v)=>Text.Contains(Text.Proper(c),v)),
            b=if a=-1 then {} else List.Skip(List.FirstN(lst,(w)=>not Text.Contains(Text.Proper(w),"Нет")),a),
            c=Text.Combine(b,"||")][c],
    from = Excel.CurrentWorkbook(){[Name="data"]}[Content],
    tr=Table.TransformColumns(from,{},(x)=>if x=null then "" else f_txtTrim(x)),
    add=Table.AddColumn(tr,"Высота/Ширина/Длина",f)
in
    add

let
    f=(x)=>[a=List.Transform(x,(w)=>Text.Split(w,"#(lf)")),
            b=List.Accumulate(a,{{}},(s,c)=>List.TransformMany(s,(i)=>c,(i,j)=>i&{j}))][b],
    from = Excel.CurrentWorkbook(){[Name="table1"]}[Content],
    nms=Table.ColumnNames(from),
    com=Table.CombineColumns(from,{"Column2","Column3","Column4"},f,"tmp"),
    exp=Table.ExpandListColumn(com, "tmp"),
    to=Table.SplitColumn(exp,"tmp",(x)=>x,{"Column2","Column3","Column4"})
in
    to