function main(workbook: ExcelScript.Workbook) {
let hojas = workbook.getWorksheets();
let encab: string[][] = [['Fechas', 'País', 'Producto', 'Unidades']];
  console.log ('num columnas ' + encab[0].length);
  console.log('num filas ' + encab.length);

let arrFin:string[][] = [];   //array 2D - dos dimensiones
    //bucle por todas las hojas del libro
  hojas.forEach(hoja  => {
    let tablas=hoja.getTables();  //identificamos las tablas de cada hoja
    //bucle por las tablas
    tablas.forEach(tbl => {
      //trabajamos con todos los datos de la tabla (sin encabiezados ni fila totales)
      let colsUds=tbl.getRangeBetweenHeaderAndTotal().getValues();
      
      //filtramos solo los registros cuyo valoe en Unidades > 50 (columna 4 = 3 en base cero)
      //el resultado es otra ARRAY
      //let filtrado = colsUds.every( valor => valor[3] < 50); //alternativa a .filter
      let filtrado = colsUds.filter( valor => valor[3] > 50);
      
      //anexamos-agregamos cada nueva array a las anteriores
      arrFin = [].concat(arrFin,filtrado);
    })
  });

console.log (encab);
console.log (arrFin);
//devuelvo la matriz filtrada a la hoja REsultado
let rdo=workbook.getWorksheet("Resultado")
rdo.getRange("A1:D1").setValues(encab);
rdo.getRange("A2:D" + (arrFin.length+1)).setValues(arrFin);
};

function main(workbook: ExcelScript.Workbook) {
  let tWb=workbook;
  let hoja = tWb.getWorksheet("Tablas");
  //creamos nuestra tabla...
  let ejemtabla: ExcelScript.Table =  hoja.addTable("A1:D1", true /*con encabezados*/);

  //le damos nombre
  ejemtabla.setName("Mi_Tabla");

  //incorporamos lso títulos de los campos
  ejemtabla.getHeaderRowRange().setValues([["Fecha", "Producto", "Unidades", "Importe"]]);

  //añadimos un conjunto de filas
  ejemtabla.addRows(null /*agrega un conjunto de filas al final de la tabla*/, 
  [
    ["1/1/2023", "Pdto A", 103, "123.45"],
    ["2/15/2023", "Pdto B", 22, "987.65"],
    ["5/21/2023", "Pdto C", 12, "654.02"]
  ]);

  //Añado una nueva columna___________________________________________
  //indicamos posición de la nueva columna - null para añadirla al final
  //después una matriz que incluya posiciones para encabezados y filas
  //y por úlitmo el título para el campo/columna
  ejemtabla.addColumn(4,["","1","5","6"],"Descuento")

  //Inserto una única fila nueva en la primera posición_________________
  //indicamos la posicón de la fila a insertar
  //y luego el vector-matriz de datos
  ejemtabla.addRow(0,["09/13/2023","Pdto DD",13,"111.11","9"])

  //recuperamos los distintos elementos_________________________________
  //el encabezado
  let encab=ejemtabla.getHeaderRowRange().getValues()
  console.log(encab)

  //el nombre de la tabla
  let nombre=ejemtabla.getName()
  console.log(nombre)

  //el rango que ocupa toda la tabla
  let rngTabla=ejemtabla.getRange().getAddressLocal()
  console.log(rngTabla)

  //el número de filas de la tabla
  let numfilas=ejemtabla.getRowCount()
  console.log(numfilas)

  //recuperamos una matriz con el contenido solo de la parte de datos
  //sin encabezado ni fila de totales
  let databody=ejemtabla.getRangeBetweenHeaderAndTotal().getValues()
  console.log(databody)

  //redimensionamos el tamaño de la tabla, 
  //dos columnas y tres filas mas
  ejemtabla.resize(ejemtabla.getRange().getResizedRange(3, 2).getAddressLocal())
  console.log(ejemtabla.getRange().getAddressLocal())

  //eliminamos la fila 5 y 6___________________________________________
  ejemtabla.deleteRowsAt(4,2)

  //eliminamos la tabla____________________________________________
  ejemtabla.delete()
}

function main(workbook: ExcelScript.Workbook) {
  let tWb = workbook;
  let hoja = tWb.getWorksheet("Tablas");
  //definimos una variable que corresponda con nuestra tabla...
  let ejemtabla: ExcelScript.Table = hoja.getTables()[0];
  console.log (ejemtabla.getName());

  //defino una variable de la 'Importe'
  let col:ExcelScript.TableColumn = ejemtabla.getColumnByName('Importe');

  //recuperamos la posición de la columna
  let posicion=col.getId();
  console.log(posicion);

  //Cambiamos el nombre de la columna
  col.setName("Importe_EUR");

  //Obtenemos el rango, como string, de celdas correspondiente a la columna
  let rango=col.getRangeBetweenHeaderAndTotal().getAddressLocal();
  console.log(rango);

  //O bien como Array de valores
  let arrCol=col.getRangeBetweenHeaderAndTotal().getValues();
  console.log(arrCol);

  //podríamos tambien eliminar la columna identificada
  //col.delete ()
}  

let
    lstNombres={"TblES","TblDE","TblIT"},
    lstNuevosNombres={"Date","Units","Amount"},

    //generamos una tabla de null, que será la 'semilla' de List.Accumulate
    tblINI=#table(lstNuevosNombres,{List.Repeat({null}, List.Count(lstNuevosNombres))}),

    //recorremos los nombres de las tablas
    anexado=List.Accumulate(
            lstNombres,     //elementos a recorrer
            tblINI,         // semilla o inicio de la secuencia
            (state,current)=> let
                //paso clave para trasnformar texto como Tabla
                tabla="#""" & Expression.Identifier(current) & """",

                tbl=[MiTabla= Expression.Evaluate(tabla,#shared)],
                TablaMedia=tbl[MiTabla],    //Obtengo una Tabla a partir de un elemento texto

                //Tranformaciones una vez convertido el texto a tabla_____________
                //selecciono campos según TblLANG
                lang=Text.End(current,2),
                tsl=Table.SelectRows(TblLANG, each List.Contains(lstNuevosNombres,[UK])),
                lstCampos=Table.Column(tsl, lang),
                //preparo lista 'zippeada' para renombrar columnas
                zip=List.Zip({lstCampos,lstNuevosNombres}),
                TblRenombroCOLS=Table.RenameColumns(TablaMedia,zip),
                //y acabo seleccionando solo las columnas requeridas
                TablaCOLS=Table.SelectColumns(TblRenombroCOLS,lstNuevosNombres),
                //incorporo una nueva col con el país..
                TablaFinal=Table.AddColumn(TablaCOLS, "Country", each lang)
            in 
                Table.Combine({state,TablaFinal})
    )
in
    anexado

...
    //paso clave para trasnformar texto como Tabla
	tabla="#""" & Expression.Identifier(current) & """",

	tbl=[MiTabla= Expression.Evaluate(tabla,#shared)],
	TablaMedia=tbl[MiTabla],    //Obtengo una Tabla a partir de un elemento texto
                ...

let
    Origen = Excel.CurrentWorkbook(){[Name="Tabla1"]}[Content],
 
    lstTipos={"Tipo_1","Tipo_2","Tipo_3"},
    lstCamposCrear={"BI4","BI10","BI21"},
    lstPorc={0.04,0.10,0.21,0.00},
    
    //definimos el límite con un valor
    Contador=List.Count(lstCamposCrear),

    //creamos una función recursiva que recorra cada fila/registro
    RepartoBases=(TablaTemp as table, n as number)=> 
            let TablaFinal=Table.AddColumn(
                TablaTemp, //trabajamos siempre sobre la tabla modificada
                lstCamposCrear{n},  //asignamos un nombre de columna asociada a las listas previas
                each let rw=_ in    //sobre el registro que representa cada fila
                                    //aplicamos ciertas transformaciones
                                    //que nos permiten obtener el dato de la columna buscada,,,
                   try List.Sum(List.Select( 
                            List.Transform(lstTipos, 
                                each 
                                let 
                                    i=Text.End(_,1)
                                in 
                                    if Record.FieldOrDefault(rw,_)=lstPorc{n} then 
                                            Record.FieldOrDefault(rw,"Base_" & i) 
                                    else 0),
                        each _<>0))
                    otherwise 0)
        in 
            //controlamos la finalización del proceso cuando lleguemos al último reemplazamiento
            if n+1=Contador then TablaFinal // terminamos
                else @RepartoBases(TablaFinal,n+1),   // mantenemos el ciclo de sustitución
            
    //aplicamos nuestra función recursiva anterior sobre la Tabla Original
    Resultado=RepartoBases(Origen, 0)

in
    Resultado

let
    //cargamos los datos..
    Origen = Excel.CurrentWorkbook(){[Name="TblFechas"]}[Content],
    //añadimos una columna con el cálculo deseado
    ToC=Table.AddColumn(Origen,
            "Extrae_Fecha",
            each 
                let
                    //Limpiamos de caracteres no deseados nuestras cadenas de texto
                    //Usamos Text.Select para detrerminar qué caracteres permanecen
                    txt=Text.Select(Text.From([col1]),{"0".."9","/","-",".","|"," "}),
                    //separamos el texto resultante por un separador que se repite en el ejemplo
                    //dependerá de la cadena de texto...
                    partes=Text.Split(txt,"|"),

                    //realizamos una selección de las partes obtenidas
                    //pero solo cuando concurran dos condiciones:
                    //1-que el texto resultante tenga más de 8 caracteres
                    //      (suponemos que cuanlquier fecha, al menos, tiene
                    //          un patrón dd/mm/aa
                    //          o bien dd/mm/aaaa - con 10 caracteres)
                    //2-otra condición es que la parte de texto a analizar tendrá dos veces el separador de fecha
                    //      (alguno de los habituales: . / -
                    selecc=Text.Trim(
                            List.Select(partes, 
                                each 
                                    List.Count(Text.ToList(_))>=8 and 
                                    List.Count(List.PositionOfAny(Text.ToList(_),{".","/","-"},Occurrence.All))=2){0}),

                    //Una última criba donde permanece la primera 'subparte'
                    tb=Text.BeforeDelimiter(selecc," "),
                    calc=if tb="" then selecc else tb
                in 
                    //finalmente aplicamos la conversión de la fecha
                    // aplicando la 'cultura' de fecha en español
                    try Date.FromText(calc,[Culture="es-ES"]) otherwise null)[[Extrae_Fecha]]
in
    ToC

let
    Origen = Excel.CurrentWorkbook(){[Name="ndtest"]}[Content],
    //creamos nuestro propio cálculo agregado
    //que nos indicará en qué columnas existe el texto 'Total' en cualquiera de sus formas
    TP = Table.Profile(Origen, 
                { {"contiene", 
                    each Type.Is(_, type any), 
                    each let col=_ ,
                        rdo=List.AnyTrue( List.Transform(col, each Text.Contains(_,"Total", Comparer.OrdinalIgnoreCase)))
                    in 
                        try rdo otherwise false }  }) [[Column],[contiene]],

    //filtramos para obtener únicamente las columnas donde
    //nuestro cálculo sea cierto
    ColsTOTAL = Table.SelectRows(TP, each ([contiene] = true))[Column],

    //Seleccionamos dichas columnas con el texto buscado
    TablaTOTAL=Table.SelectColumns(Origen,ColsTOTAL)
in
    TablaTOTAL

...
    { {"contiene", 
        each Type.Is(_, type any), 
        each let col=_ ,
                 rdo=List.AnyTrue( List.Transform(col, each Text.Contains(_,"Total", Comparer.OrdinalIgnoreCase)))
              in 
                 try rdo otherwise false }  }
    ...

let
    Origen = Excel.CurrentWorkbook(){[Name="ndtest"]}[Content],
    //Obtenemos estadísticas de la tabla
    //pero solo nos quedamos con tres aspectos relevantes:
    //Column: nombre de la columna
    //Count: número de filas de la columna
    //NullCount: número de elementos nulos/vacíos en la columna
    TP = Table.Profile(Origen)[[Column],[Count],[NullCount]],

    //filtramos para obtener únicamente las columnas donde
    //el número de vacíos/nulos es igual al total de elementos
    //i.e., cuando  TODOS son nulos/vacíos
    ColsVacias = Table.SelectRows(TP, each ([NullCount] = [Count]))[Column],

    //eliminamos dichas columnas con todos los elementos nulos
    //es decir, las columnas sin datos
    TablaLimpia=Table.RemoveColumns(Origen,ColsVacias)
in
    TablaLimpia

let
    usuario=NombresUSER[Name]{0},
    rutalocal=NombresUSER[Folder Path]{0},

    //accedemos al contenido de la carpeta de Users
    Origen = Folder.Contents(rutalocal),
    Origen2=Origen, //truco para 'evitar' el paso oculto de Navegación
    //Vamos al contenido de la carpeta con nuestro nombre de usuario
    Nombre = Origen2{[Name=usuario]}[Content],
    //y navegamos por fin a la carpeta de OneDrive
    // OJOOOO, personaliza el nombre de tu carpeta!!!
    OneDrive = Nombre{[Name="OneDrive - excelforo"]}[Content]
in
    OneDrive

let
    //empleando los datos obtenidos en la consulta previa
    usuario=NombresUSER[Name]{0},
    //componemos nuestra ruta URL
    rutaWeb="https://ircalcerrada-my.sharepoint.com/personal/" & usuario & "_excelforo_com/",

    //https://ircalcerrada-my.sharepoint.com/personal/excelforo_excelforo_com/Documents
    //accedemos al contenido de la carpeta de SharePoint/OneDrive
    Origen = SharePoint.Contents(rutaWeb, [ApiVersion=15]),
    //y a la carpeta que nos interese...
    Origen2=Origen{[Name="Documents"]}[Content]
in
    Origen2

let
    //de la lista de letras de la A a la Z
    //concatenado con la carpeta \Users\ donde encontraremos todos los usuarios 
    //del equipo
    //verificamos cuáles existen, eliminado el resto....
    Origen=List.RemoveNulls(
            List.Transform({"A".."Z"}, 
                each 
                    let 
                    tbl=Folder.Contents(_ & ":\Users\"),
                    check=if (try tbl{0} otherwise null)<>null then tbl else null
                    in 
                    check)),

    //La lista resultante de unidades existentes con ese Carpeta
    //la convertimos en Tabla
    ConvertidoTablaRecords = Table.FromColumns({Origen},{"Registros"}),
    //y las combinamos en una única Tabla para facilitar el trabajo
    ListaContenidos = Table.Combine(ConvertidoTablaRecords[Registros]),

    Origen2=ListaContenidos,
    //Expandimos la columna de Atributos en busca de ciertas características
    //que hacen únicos a nuestros usuarios
    ExpandeAttributes = Table.ExpandRecordColumn(Origen2, 
            "Attributes", 
            {"Kind", "ReadOnly", "Hidden"}, 
            {"Kind", "ReadOnly", "Hidden"}),
    //filtramos y mostramos dos columnas importantes: Nombre del usuario y unidad de la raiz
    FiltrosTRUE_FALSE = Table.SelectRows(ExpandeAttributes, each ([Kind] = "Folder") and ([Hidden] = false) and ([ReadOnly] = false))[[Name],[Folder Path]]
in
    FiltrosTRUE_FALSE

let
    Origen = Excel.CurrentWorkbook(){[Name="TblVENTAS"]}[Content]
in
    Origen

let
      Origen = Excel.CurrentWorkbook(){[Name="TblVENTAS"]}[Content],
    TipoCambiado = Table.TransformColumnTypes(Origen,{{"Fechas", type date}, {"Artículo", type text}, {"Unidades", Int64.Type}}),
    NombreMes = Table.TransformColumns(TipoCambiado, {{"Fechas", each Date.MonthName(_), type text}}),
    Agrupacion = Table.Group(NombreMes, {"Fechas", "Artículo"}, {{"Acum_Uds", each List.Sum([Unidades]), type nullable number}})
    in
    Agrupacion

[
      Origen = Excel.CurrentWorkbook(){[Name="TblVENTAS"]}[Content],
    TipoCambiado = Table.TransformColumnTypes(Origen,{{"Fechas", type date}, {"Artículo", type text}, {"Unidades", Int64.Type}}),
    NombreMes = Table.TransformColumns(TipoCambiado, {{"Fechas", each Date.MonthName(_), type text}}),
    Agrupacion = Table.Group(NombreMes, {"Fechas", "Artículo"}, {{"Acum_Uds", each List.Sum([Unidades]), type nullable number}})
    ]

let
    //obtenemos el campo 'Agrupacion' del Record 'VENTAS'
    Origen = VENTAS[Agrupacion],

    //para conbinar el contenido de ese campo (una tabla) con una segunda tabla (TblPRECIOS)
    CombinoPRECIOS = Table.NestedJoin(Origen, {"Artículo"}, PRECIOS, {"Pdto"}, "PRECIOS", JoinKind.LeftOuter),
    //y finalizar expandiendo un valor
    ExpandePRECIOS = Table.ExpandTableColumn(CombinoPRECIOS, "PRECIOS", {"Precio"}, {"Precio"})
in
    ExpandePRECIOS

let
    //obtenemos el campo 'Agrupacion' del Record 'VENTAS'
    Origen = VENTAS[Agrupacion],

    //para conbinar el contenido de ese campo (una tabla) con una segunda tabla (TblPRECIOS)
    CombinoPRECIOS = Table.NestedJoin(Origen, {"Artículo"}, PRECIOS, {"Pdto"}, "PRECIOS", JoinKind.LeftOuter),
    //y finalizar expandiendo un valor
    ExpandePRECIOS = Table.ExpandTableColumn(CombinoPRECIOS, "PRECIOS", {"Precio"}, {"Precio"}),

    //Incorporamos al REcord VENTAS un nuevo campo que contiene la Tabla previa
    NuevoRecord= VENTAS & [ExpandePRECIOS=ExpandePRECIOS]
in
    NuevoRecord

let
    //obtenemos el campo 'Agrupacion' del Record 'VENTAS'
    Origen = VENTAS[Agrupacion],

    //para conbinar el contenido de ese campo (una tabla) con una segunda tabla (TblPRECIOS)
    CombinoPRECIOS = Table.NestedJoin(Origen, {"Artículo"}, PRECIOS, {"Pdto"}, "PRECIOS", JoinKind.LeftOuter),
    //y finalizar expandiendo un valor
    ExpandePRECIOS = Table.ExpandTableColumn(CombinoPRECIOS, "PRECIOS", {"Precio"}, {"Precio"}),

    //Incorporamos al REcord VENTAS un nuevo campo que contiene la Tabla previa
    NuevoRecord= VENTAS & [ExpandePRECIOS=ExpandePRECIOS],

    //Del nuevo registro creado, recuperamos uno de sus campos
    //recuerda que el contenido, en este caso, son Tablas
    //Y de esa tabla seleccionamos dos de sus columnas
    Seleccion = NuevoRecord[ExpandePRECIOS][[Artículo],[Precio]]
in
    Seleccion

=LET(rDatos;$B$5:$D$17;
fechas;INDICE(rDatos;0;1); Pais;INDICE(rDatos;0;2);Importes;INDICE(rDatos;0;3);
desde;MIN(fechas);hasta;MAX(fechas);
rFechasN;SECUENCIA(hasta-desde+1;;desde;1);
rPaisN;BYROW(rFechasN;LAMBDA(vFecha;BUSCARX(vFecha;fechas;Pais;"")));
rImporteN;BYROW(rFechasN;LAMBDA(vFecha;BUSCARX(vFecha;fechas;Importes;"")));
APILARH(rFechasN;rPaisN;rImporteN))

...
   rDatos;$B$5:$D$17;
fechas;INDICE(rDatos;0;1); Pais;INDICE(rDatos;0;2);Importes;INDICE(rDatos;0;3);
desde;MIN(fechas);hasta;MAX(fechas);
...

...
    rFechasN;SECUENCIA(hasta-desde+1;;desde;1);
    ...

...
    rPaisN;BYROW(rFechasN;LAMBDA(vFecha;BUSCARX(vFecha;fechas;Pais;"")));
rImporteN;BYROW(rFechasN;LAMBDA(vFecha;BUSCARX(vFecha;fechas;Importes;"")));
    ...

...
    APILARH(rFechasN;rPaisN;rImporteN))

=LET(rDatos;$B$5:$D$17;
fechas;INDICE(rDatos;0;1);
desde;MIN(fechas);hasta;MAX(fechas);
rFechasN;SECUENCIA(hasta-desde+1;;desde;1);
nFilas;FILAS(rFechasN);nCols;COLUMNAS(rDatos);
rDatosN;ARCHIVOMAKEARRAY(nFilas;nCols;LAMBDA(f;c;SI(c>1;BUSCARX(INDICE(rFechasN;f);fechas;INDICE(rDatos;0;c);"");INDICE(rFechasN;f))));
rDatosN)

...
   rDatos;$B$5:$D$17;
fechas;INDICE(rDatos;0;1);
desde;MIN(fechas);hasta;MAX(fechas);
rFechasN;SECUENCIA(hasta-desde+1;;desde;1);
nFilas;FILAS(rFechasN);nCols;COLUMNAS(rDatos);
...

...rDatosN;ARCHIVOMAKEARRAY(nFilas;nCols;LAMBDA(f;c;SI(c>1;BUSCARX(INDICE(rFechasN;f);fechas;INDICE(rDatos;0;c);"");INDICE(rFechasN;f))))

  =LET(rDatos;$B$5:$D$17;
fechas;INDICE(rDatos;0;1);
desde;MIN(fechas);hasta;MAX(fechas);
rFechasN;SECUENCIA(hasta-desde+1;;desde;1);
rNOCoincidentes;LET(criterio;BYROW(rFechasN;LAMBDA(vFecha;NO(SI.ERROR(COINCIDIR(vFecha;fechas;0)>0;FALSO))));FILTRAR(rFechasN;criterio));
ORDENAR(SI.ERROR(APILARV(rDatos;rNOCoincidentes);"")))

...
   rDatos;$B$5:$D$17;
fechas;INDICE(rDatos;0;1);
desde;MIN(fechas);hasta;MAX(fechas);
rFechasN;SECUENCIA(hasta-desde+1;;desde;1);
...

... rNOCoincidentes;LET(criterio;BYROW(rFechasN;LAMBDA(vFecha;NO(SI.ERROR(COINCIDIR(vFecha;fechas;0)>0;FALSO))));FILTRAR(rFechasN;criterio));...

let
    Origen = Excel.CurrentWorkbook(){[Name="Tabla1"]}[Content],
    //Uso de la sintaxis Each _
    //donde _ corresponde a cada registro de la tabla 'Origen'
    //y como sobre cualquier Record, podemos llamar a cualquiera de sus campos
    Test1=Table.AddColumn(
                Origen,
                "Prueba1", 
                each _[Unidades] * _ [Precio Unitario]),

    //Uso alternativo de Funciones
    //Declaro una variable, con el nombre 'registro'
    //Y para facilitar la lectura empleo let...in..
    //asignando valor a dos elementos 'uds' y 'pz'
    // a partir de la variable anterior
    // para finalmente devolver el producto de ambos
    Test2=Table.AddColumn(
                Test1,
                "Prueba2", 
                (registro)=> 
                    let 
                        uds=registro[Unidades],
                        pz=registro[Precio Unitario]
                    in 
                        uds * pz )

in
    Test2

let
    Origen = Excel.CurrentWorkbook(){[Name="Tabla1"]}[Content],
    //Empleando la sintaxis de funciones
    //obtendremos el producto de cada producto por el precio máximo de cualquier venta de nuestra tabla
    Test3=Table.AddColumn(
                Origen,
                "Prueba3", 
                (registro)=> 
                    let 
                        uds=registro[Unidades],
                        pz=List.Max(Origen[Precio Unitario])
                    in 
                        uds * pz ),

    //DOBLE Each_ DOBLE Función
    //En este caso existe un doble recorrido
    //en su parte más profunda recorremos y seleccionamos aquellos registros que cumplan una condición
    //sobre un elemento del recorrido de los registros del bucle principal
    Test4=Table.AddColumn(
                Test3,
                "Prueba4", 
                (registro)=> 
                    let 
                        uds=registro[Unidades],
                        //art=registro[Artículo],
                        pz=List.Max(Table.SelectRows(
                                        Test3, 
                                        (seleccion)=> seleccion[Artículo]=registro[Artículo])[Precio Unitario])
                                        //(seleccion)=> seleccion[Artículo]=art)[Precio Unitario])
                    in 
                        uds * pz )
in
    Test4

let
    Origen = Excel.CurrentWorkbook(){[Name="TblDATOS"]}[Content],

    //Opción 1
    //Doble condicional para controlar los nulos en las columnas implicadas
    CondicionalEstandar=Table.AddColumn(
                    Origen,
                    "Densidad1", 
                    each if [Km2]=null then 0 else 
                        if [Habitantes]=null then 0 else [Habitantes]/[Km2]),
    
    //Opción 2
    //Usando el operador de fusión para en caso de devolver nulo
    //cambiarlo por 0
    Coalesce=Table.AddColumn(
                CondicionalEstandar,
                "Densidad2",
                each [Habitantes]/[Km2]??0 )
in
    Coalesce

let
    Origen = Excel.CurrentWorkbook(){[Name="TblDATOS"]}[Content],

    CondicionalEstandar = Table.AddColumn(
                Origen, 
                "UltimoDatoPIB_2021_2022_v1", 
                each if [PIB_2022]<>null then [PIB_2022] else 
                    if [PIB_2021]<>null then [PIB_2021] else 0),

     Coalesce=Table.AddColumn(
                CondicionalEstandar,
                "UltimoDatoPIB_2021_2022_v2",
                each [PIB_2022]??[PIB_2021]??0)

in
    Coalesce

let
    Origen = Excel.CurrentWorkbook(){[Name="TblDATOS"]}[Content],
    //elementos de la columna REgión en forma de lista
    ListaColumna=Origen[Región]
in
    ListaColumna

let
    Origen = Excel.CurrentWorkbook(){[Name="TblDATOS"]}[Content],
    //elementos de la columna REgión en forma de tabla
    //OJO con el doble corchete
    TablaColumna=Origen[[Región]]
in
    TablaColumna

let
    Origen = Excel.CurrentWorkbook(){[Name="TblDATOS"]}[Content],
    //elementos de la columna REgión en forma de tabla
    //OJO con el doble corchete
    TablaColumna=Origen[[Ciudad],[Habitantes]]
in
    TablaColumna

let
    Origen = Excel.CurrentWorkbook(){[Name="TblDATOS"]}[Content],
    //elementos de la columna REgión en forma de tabla
    //OJO con el doble corchete
    TablaColumna=Origen[[Ciudad],[Habitantes],[Provincia]]?
in
    TablaColumna

let
    Origen = AlternativaClasica,

    //TransformRows nos permite Elegir Columnas, renombrarlas, y a un tiempo aplicar algún tipo de transformación!!
    Transformacion=Table.TransformRows(Origen, 
            each [Fechas=Date.From([Fechas]),   //convertimos las FEchas 
                B = [Unidades]*2,               //doblamos las Unidades
                País=Text.End([Name],2)] ),     //Eliminamos el prefijo de cada texto

    //convertimos la lista de registros que no retorna TransformRows en Tabla
    ATabla=Table.FromRecords(Transformacion)
in
    ATabla

let
    //recuperamos todas las tablas del libro actual que empiecen con 'Tbl"
    Origen = Table.SelectRows( Excel.CurrentWorkbook(), each Text.StartsWith([Name],"Tbl")),

    //aplicamos la trasnformación a la columna de Contenido 'Content'
    Transformacion= Table.TransformColumns(Origen,
            {{"Content", each
                let
                    pos= List.PositionOf(Origen[Content], _),   //identifico el número de fila
                    nombre=Origen[Name]{pos},                   //recupero el Nombre desde el campo 'Name'
                    ordeno=Table.Sort(_, {"Fechas"}),           //ordeno cada tabla por Fechas
                    //y añado a cada tabla un campo nuevo con el nombre anterior
                    AddCol=Table.AddColumn(ordeno, "País", each nombre)
                in
                    AddCol }}),

    //acabamos Combinando (anexando) las distintas tablas de la columna 'Content'
    Consolidado=Table.Combine(Transformacion[Content])
in
    Consolidado

let
    Origen = Table.SelectRows( Excel.CurrentWorkbook(), each Text.StartsWith([Name],"Tbl")),
    ExpandeContent = Table.ExpandTableColumn(Origen, "Content", 
                        {"Fechas", "Artículos", "Unidades"}, 
                        {"Fechas", "Artículos", "Unidades"})
in
    ExpandeContent

=LET(datos;$B$3:$D$19;
    datos_ordenados; ORDENAR(datos; 1; 1);
    fechas;INDICE(datos_ordenados;0;1);
    importes;INDICE(datos_ordenados;0;3);
    convertido;UNICOS(MES(fechas));
    acumulado; MAP(SECUENCIA(FILAS(convertido));
    LAMBDA(fila;  SUMAPRODUCTO(importes*( MES(fechas)=INDICE(convertido;fila;1)))));
    rdo;APILARH(convertido;acumulado);
    
    variacion; MAP(SECUENCIA(FILAS(rdo)); LAMBDA(fila2;
    SI( Y(INDICE(rdo; fila2; 1)=INDICE(rdo; fila2-1; 1)+1);
    (INDICE(rdo; fila2; 2) / INDICE(rdo; fila2-1;2)  )- 1;         "")  )  );
    APILARH(TEXTO(FECHA(2022;EXCLUIR(rdo;;-1);1);"mmm");variacion) )

=LET(datos;$B$3:$D$19;
    datos_ordenados; ORDENAR(datos; 1; 1);
    fechas;INDICE(datos_ordenados;0;1);
    importes;INDICE(datos_ordenados;0;3);
    convertido;UNICOS(MES(fechas));...

...
    acumulado; MAP(SECUENCIA(FILAS(convertido));
    LAMBDA(fila;  SUMAPRODUCTO(importes*( MES(fechas)=INDICE(convertido;fila;1)))));
    ...

...
    rdo;APILARH(convertido;acumulado);
    ...

...
    variacion; MAP(SECUENCIA(FILAS(rdo)); LAMBDA(fila2;
    SI( Y(INDICE(rdo; fila2; 1)=INDICE(rdo; fila2-1; 1)+1);
    (INDICE(rdo; fila2; 2) / INDICE(rdo; fila2-1;2)  )- 1;         "")  )  );
    ...

...
    APILARH(TEXTO(FECHA(2022;EXCLUIR(rdo;;-1);1);"mmm");variacion)
    ...

let
    Origen = Folder.Files("E:\excelforo\TEST_CARPETAS\"),
    DATOS = Table.Buffer(Origen),
    
    //Tabla creada adrede para añadir filas coincidentes
    TablaRecupera=#table({"Folder Path","Name"},{{"",""}}),

    CreamosTabla=List.Accumulate(
                        TblCRITERIA[Criterios_Búsqueda],    //Lista conceptos a buscar
                        TablaRecupera,  //Inicio
                        (acum,concepto_buscado)=>
                            let
                                //buscamos cada concepto
                                TablaRdo=Table.SelectColumns(
                                        Table.SelectRows(DATOS, each Text.Contains([Name], Text.From(concepto_buscado))),
                                        {"Folder Path","Name"}),
                                //Lo incorporamos a los registros anteriores...
                                AddDato=Table.Combine({acum, TablaRdo})
                            in 
                                AddDato ),
    //Quitamos los registros/filas vacías...                            
    QuitaBlanco = Table.SelectRows(CreamosTabla, each not List.IsEmpty(List.RemoveMatchingItems(Record.FieldValues(_), {"", null})))
    

in
    QuitaBlanco

let
    //Nuestra lista de elementos a combinar dos a dos
    Lista={"A","B","C","D","E","F"},
    
    //para generar las combinaciones posibles
    //excluyendo la de dos elementos iguales
    Combinaciones = List.TransformMany(
                    Lista,
                    (dos)=> Lista,
                    (uno, dos)=> let orden=List.Sort({uno,dos}) in 
                            if orden{0}=orden{1} then null else orden{0} & " | " & orden{1} ),
    
    //List.Distinc se encarga de eliminar combinaciones repetidas...
    SinRepeticion=List.Distinct(List.RemoveNulls(Combinaciones))
in
    SinRepeticion

let
    //Lista con las tablas a trabajar
    LstTablas={Tabla1,Tabla2,Tabla3,Tabla4,Tabla5},

    //aplicamos List.Sort para ordenar nuestras tablas
    LstOrdenada=List.Sort(LstTablas, (x, y) => Value.Compare(List.Min(x[Fecha]),List.Min(y[Fecha]) )),
    
    //Proceso que acumula registros de las distintas tablas
    //cuando los registros cumplan una condición
    //que su fecha sea posterior a la del acumulado anterior
    Combinada= List.Accumulate(
                LstOrdenada,      //lista que recorremos
                LstOrdenada{0},   //inicio 
                (acum,tbl)=>    //transformación a aplicar
                    let 
                        Fmax=List.Max(acum[Fecha]),
                        rdo=Table.Combine({acum,Table.SelectRows(tbl, each [Fecha]>Fmax)})
                    in rdo)
in
    Combinada

...
    //aplicamos List.Sort para ordenar nuestras tablas
    LstOrdenada=List.Sort(LstTablas, (x, y) => Value.Compare(List.Min(x[Fecha]),List.Min(y[Fecha]) )),
    ...

let
    //Lista con las tablas a trabajar
    LstTablas={Tabla1,Tabla2,Tabla3},

    //Proceso que acumula registros de las distintas tablas
    //cuando los registros cumplan una condición
    //que su fecha sea posterior a la del acumulado anterior
    Combinada= List.Accumulate(
                LstTablas,      //lista que recorremos
                LstTablas{0},   //inicio 
                (acum,tbl)=>    //transformación a aplicar
                    let 
                        Fmax=List.Max(acum[Fecha]),
                        rdo=Table.Combine({acum,Table.SelectRows(tbl, each [Fecha]>Fmax)})
                    in rdo)
in
    Combinada