0xD34F

const blockSelector = '.block';
const buttonSelector = `${blockSelector} .block__close`;

Делегирование, назначаем обработчик один раз:

document.addEventListener('click', e => {
  const block = e.target.closest(buttonSelector)?.closest(blockSelector);
  block?.parentNode.removeChild(block);
});

Назначаем обработчик каждой кнопке индивидуально:

document.querySelectorAll(buttonSelector).forEach(function(n) {
  n.addEventListener('click', this);
}, e => e.currentTarget.closest(blockSelector).remove());

не затрагивая строчку sort

users.sort((a,b) => a- b);

Значит, надо научить объекты представлять себя в виде числа.

Добавьте им

valueOf() {
  return this.age;
},

Или, замените toString на

[Symbol.toPrimitive](hint) {
  return hint === 'number'
    ? this.age
    : `${this.name} is ${this.age} y.o.`;
},

const svgEl = document.createElementNS('http://www.w3.org/2000/svg', 'svg');

Так, NS, хорошо.

const pathEl = document.createElement('path');

Плохо.

const group = (arr, ...keys) =>
  arr.reduce(((key, acc, n) => (
    (keys.reduce((obj, k) => obj[n[k]] ??= {}, acc)[n[key]] ??= []).push(n),
    acc
  )).bind(null, keys.pop()), {});

const grouped = group(arr, 'order', 'user_id', 'stream_id', 'currency_id');

или

function group(data, keys) {
  const result = {};

  for (const n of data) {
    const objKeys = [].concat(keys(n));
    const arrKey = objKeys.pop();
    (objKeys.reduce((obj, k) => obj[k] ??= {}, result)[arrKey] ??= []).push(n);
  }

  return result;
}

// ваш случай
group(arr, n => [ n.order, n.user_id, n.stream_id, n.currency_id ])

// а вообще, группировать можно не только массивы; количество признаков группировки
// может отличаться для различных элементов; сами признаки и имена групп не обязаны совпадать
// с какими-либо свойствами элементов, а могут являться производными от них значениями
group('12+345-!aщСxE_VЖg', n => {
  const low = n.toLowerCase();
  return (
    low !== n.toUpperCase() ? [ 'буквы', n === low ? 'строчные' : 'заглавные' ] :
    Number.isInteger(+n)    ? [ 'цифры', (n & 1)   ? 'нечётные' :    'чётные' ] :
                              'другое'
  );
})

Рекурсия есть:

const find = (data, test) =>
  test(data)
    ? data
    : data === Object(data)
      ? Object.values(data).reduce((found, n) =>
          found !== null ? found : find(n, test)
        , null)
      : null;

Рекурсии нет:

function find(data, test) {
  for (const stack = [ data ]; stack.length;) {
    const n = stack.pop();
    if (test(n)) {
      return n;
    } else if (n instanceof Object) {
      stack.push(...Object.values(n).reverse());
    }
  }

  return null;
}

Ищем: const obj = find(fractal, n => n?.id === id);.

Будем использовать стек. В начале стек содержит единственное значение - то, которое передано в функцию. Цикл крутится до тех пор, пока стек не окажется пуст. На каждой итерации извлекаем значение из стека, если число - плюсуем к результату, если объект - добавляем значения его свойств в стек.

function sum(data) {
  let result = 0;

  for (const stack = [ data ]; stack.length;) {
    const n = stack.pop();
    stack.push(...(n instanceof Object ? Object.values(n) : []));
    result += typeof n === 'number' ? n : 0;
  }

  return result;
}

Добавить в options interpolateNulls: true.

Элемент и его сосед:

const el = вам виднее, откуда он берётся;
const prev = el.previousElementSibling;

Меняем местами:

el.after(prev);

// или

el.insertAdjacentElement('afterend', prev);

// или

el.parentNode.insertBefore(el, prev);

// или

el.replaceWith(el, prev);

<label>
  Город:
  <select id="city"></select>
</label>
<label>
  Линия:
  <select id="line"></select>
</label>
<label>
  Станция:
  <select id="station"></select>
</label>

fetch('https://api.hh.ru/metro/').then(r => r.json()).then(subwayData => {
  const city = document.querySelector('#city');
  const line = document.querySelector('#line');
  const station = document.querySelector('#station');

  const getLines = () => subwayData[city.value].lines;
  const update = (el, data) => {
    el.replaceChildren(...data.map((n, i) => new Option(n.name, i)));
    el.dispatchEvent(new Event('change'));
  };

  city.addEventListener('change', () => update(line, getLines()));
  line.addEventListener('change', () => update(station, getLines()[line.value].stations));

  update(city, subwayData);
});

.inputmask('aa\\|9999',

выводит не совсем то что мне надо

Вместо array.length надо крутить цикл до array.length - n + 1.

А вообще, цикл в явном виде не нужен:

const bullshitChunks = (arr, chunkSize) =>
  Array.from(
    { length: arr.length + 1 - chunkSize },
    (_, i) => arr.slice(i, i + chunkSize)
  );


console.log(bullshitChunks([ 1, 2, 3, 4, 5, 6, 7 ], 4));
console.log(bullshitChunks('abcdefg', 5));

(products.find(n => n.product.id === newProduct.id) ??
(products[products.length] = {
  product: { ...newProduct },
  count: 0,
})).count++;

Что если в carIds присутствуют такие значения, которых нет среди id в cars?

Если получать undefined для вас окей, тогда

const result = carIds.map(n => cars.find(m => m.id === n));

Если нет, то вместо отсутствующих объектов можно подставлять какое-нибудь дефолтное значение:

const result = carIds.map(function(n) {
  return this[n] ?? 'объект не найден';
}, Object.fromEntries(cars.map(n => [ n.id, n ])));

Или, есть вариант для несуществующих id ничего не получать:

const carsMap = new Map(cars.map(n => [ n.id, n ]));
const result = carIds.reduce((acc, n) => (
  (n = carsMap.get(n)) && acc.push(n),
  acc
), []);

const selectors = [ '.addservice', '.addprice' ];
const data = Array.from(
  document.querySelectorAll('.addserviceBlock'),
  n => selectors.map(m => n.querySelector(m).value)
);

Заголовки, элемент меню и классы для его пунктов:

const headers = document.querySelectorAll('section > h2');
const menu = document.querySelector('вам виднее, что тут должно быть');
const className = 'inner__menu anchor-js';

Собираем разметку:

const menuHTML = Array.from(headers, n =>
  `<a class="${className}" href="#${n.parentNode.id}">${n.innerText}</a>`
).join('');

// можем добавить новое содержимое, не трогая то, что уже есть
menu.insertAdjacentHTML('beforeend', menuHTML);
// или новый контент перезапишет существующий
menu.innerHTML = menuHTML;

Или создаём элементы напрямую:

const menuElements = Array.from(headers, n =>
  Object.assign(document.createElement('a'), {
    className,
    href: `#${n.parentNode.id}`,
    text: n.textContent,
  })
);

// добавляем
menu.append(...menuElements);
// перезаписываем
menu.replaceChildren(...menuElements);

const wrapper = document.createElement('div');
const start = block.querySelector('.start');
for (let el; !(el = start.nextElementSibling).matches('.end'); wrapper.appendChild(el)) ;
start.insertAdjacentElement('afterend', wrapper);

или

const wrapper = document.createElement('div');
const children = [...block.children];
const iStart = children.findIndex(n => n.classList.contains('start'));
const iEnd = children.findIndex(n => n.classList.contains('end'));
wrapper.append(...children.slice(iStart + 1, iEnd));
children[iStart].after(wrapper);

data.reduce((acc, { unique, id, count, name }) => (
  ((acc[unique] ??= { count })[id] ??= []).push(name),
  acc
), {})

Кого хотим достать: const key = 'TicketNumber';.

Достаём:

const val = str.match(RegExp(`(?<=[?;]${key}=)[^;#]*`))?.[0];

// или

const val = new URL(str.replaceAll(';', '&')).searchParams.get(key);

// или

const val = Object.fromEntries(str
  .split('?')
  .pop()
  .split('#')
  .shift()
  .split(';')
  .map(n => n.split('='))
)[key];

function chunked(str, numChunks) {
  const chunkSize = Math.ceil(str.length / numChunks);
  return Array.from(
    { length: numChunks },
    (_, i) => str.slice(i * chunkSize, (i + 1) * chunkSize)
  );
}

UPD. В комментариях докладывают:

неаккуратненько как-то:
chunked('test', 3) // [ "te", "st", "" ]

Это поправимо. Наверное. Размер куска округляем вниз. Есть два варианта:

Первый - закидываем остаток в последний кусок:

const chunked = (str, numChunks) =>
  Array.from(
    { length: numChunks },
    function(_, i) {
      return str.slice(this(i), i < ~-numChunks ? this(-~i) : str.length);
    },
    i => i * (Math.max(1, str.length / numChunks | 0))
  );

Второй - раскидываем по одному дополнительному элементу в те куски, что идут первыми:

function chunked(str, numChunks) {
  const chunkSize = str.length / numChunks | 0;
  const numLooseItems = str.length % numChunks;
  const chunkIndex = i => i * chunkSize + Math.min(i, numLooseItems);

  return Array.from(
    { length: numChunks },
    (_, i) => str.slice(chunkIndex(i), chunkIndex(-~i))
  );
}