0xD34F

str.replace(/.*\./, '.')
// или
str.split(/(?=\.)/).pop()
// или
str.match(/\.?[^.]+$/)[0]
// или
str.slice(str.lastIndexOf('.'))
// или
[...str].reduce((acc, n) => n === '.' ? n : acc + n, '')

document.querySelector('table').addEventListener('input', e => {
  const tr = e.target.closest('tr');
  const price = parseInt(tr.querySelector('.price').innerText);
  const value = e.target.value;

  tr.querySelector('.item_result').innerText = value * price;
});

function groupNames(arr) {
  const tree = Object.fromEntries(arr.map(n => [ n.categoryId, { ...n, children: [] } ]));
  const values = Object.values(tree);
  const getNames = ({ name, children }) => children.length
    ? children.reduce((acc, n) => (
        acc.push(...getNames(n).map(m => [ name, ...m ])),
        acc
      ), [])
    : [ [ name ] ];

  values.forEach(n => tree[n.parentCategoryId]?.children.push(n));

  return values
    .filter(n => !n.parentCategoryId)
    .flatMap(n => getNames(n).map(n => n.join(' - ')));
}

$('.button').click(function() {
  const val = +$('.value').text((i, text) => +text + 1).text();

  $('.item')
    .removeClass('xxx')
    .filter((i, el) => +$(el).text() <= val)
    .sort((a, b) => $(a).text() - $(b).text())
    .last()
    .addClass('xxx');
});

document.querySelector('.button').addEventListener('click', () => {
  const val = ++document.querySelector('.value').innerText;
  const items = Array.from(document.querySelectorAll('.item'), n => [ n, +n.innerText ]);
  const max = items.reduce((max, n) => n[1] <= val && n[1] > max ? n[1] : max, -Infinity);
  items.forEach(n => n[0].classList.toggle('xxx', n[1] === max));
});

const findPath = (arr, id) =>
  (Array.isArray(arr) ? arr : []).reduce((found, n) => {
    if (!found) {
      found = n.category.categoryId === id
        ? []
        : findPath(n.children, id);

      if (found) {
        found.unshift(n.category);
      }
    }

    return found;
  }, null);

[...str].reduce((acc, n) => acc + (n === '1'), 0)

// или

str.match(/1/g)?.length ?? 0

// или

str.split('').filter(n => n === '1').length

// или

str.replace(/[^1]/g, '').length

// или

eval(Array.from(str, n => +(n === '1')).join('+')) || 0

const parseValue = str => {
  const values = str.match(/[^\s,]+/g) || [ null ];
  return values.length > 1 ? values : values[0];
};

const parseStyleStr = str =>
  str.split(';').reduce((acc, n) => {
    const [ k, v ] = n.split(':').map(n => n.trim());
    if (k && v) {
      const f = [...v.matchAll(/([\w]+?)\((.+?)\)/g)];
      acc[k] = f.length
        ? Object.fromEntries(f.map(n => [ n[1], parseValue(n[2]) ]))
        : parseValue(v);
    }

    return acc;
  }, {});

Хорошо бы если на чистом css

но и js тоже можно

document.addEventListener('click', ({ target: { tagName, parentNode: p } }) => {
  if (tagName === 'SUMMARY') {
    document.querySelectorAll('details').forEach(n => n.open = n.open && n === p);
  }
});

// или

const summaries = document.querySelectorAll('summary');
const details = Array.from(summaries, n => n.parentNode);
const onClick = e => details.forEach(n => n.open = n.open && n === e.target.parentNode);
summaries.forEach(n => n.addEventListener('click', onClick));

const obj = arr.find(n => n.id === newObj.id);
if (obj) {
  obj.counter++;
} else {
  arr.push({ ...newObj, counter: 1 });
}

Object.values(arr1.reduce((acc, { user_id: id, ...n }) => {
  Object.entries(n).forEach(([ k, v ]) => acc[id][k] = (acc[id][k] || 0) + v);
  return acc;
}, Object.fromEntries(arr2.map(n => [ n.id, {...n} ]))))

[...arr1.reduce((acc, { user_id: id, ...n }) => {
  const obj = acc.get(id);
  Object.entries(n).forEach(([ k, v ]) => obj[k] = (obj[k] || 0) + v);
  return acc;
}, new Map(arr2.map(n => [ n.id, {...n} ]))).values()]

arr2.map(function(n) {
  return this[n.id];
}, arr1.reduce((acc, { user_id: id, ...n }) => (
  Object.keys(n).forEach(k => acc[id][k] = (acc[id][k] || 0) + n[k]),
  acc
), Object.fromEntries(arr2.map(n => [ n.id, {...n} ]))))

const getReversedPaths = (arr, path = []) =>
  arr.reduce((acc, { childItems, ...item }) => {
    path.push(item);

    if (childItems) {
      acc.push(...getReversedPaths(childItems, path));
    } else {
      acc.push(path.length > 1
        ? path.map(({ packingLevel }, i, a) => ({ ...a[a.length - i - 1], packingLevel }))
        : [ path[0] ]
      );
    }

    path.pop();

    return acc;
  }, []);

const reverseThere = arr =>
  getReversedPaths(arr).map(n =>
    n.reduceRight((child, parent) => ({ ...parent, childItems: [ child ] }))
  );

const reverseBackAgain = arr =>
  (function createTree(arr) {
    return Object.values(arr.reduce((acc, [ head, ...tail ]) => {
      if (tail.length) {
        (acc[head.name] = acc[head.name] || { ...head, childItems: [] }).childItems.push(tail);
      } else {
        acc[head.name] = head;
      }

      return acc;
    }, {})).map(n => (n.childItems && (n.childItems = createTree(n.childItems)), n));
  })(getReversedPaths(arr));

const newArr2 = arr2.filter(n => arr1.includes(n.name));

// или

const newArr2 = arr2.filter(function(n) {
  return this.has(n.name);
}, new Set(arr1));

// или

const obj2 = Object.fromEntries(arr2.map(n => [ n.name, n ]));
const newArr2 = arr1.reduce((acc, n) => ((n = obj2[n]) && acc.push(n), acc), []);

let numDeleted = 0;

for (let i = 0; i < arr2.length; i++) {
  arr2[i - numDeleted] = arr2[i];
  numDeleted += !arr1.includes(arr2[i].name);
}

arr2.length -= numDeleted;

// или

for (let i = arr2.length; i--;) {
  if (!arr1.includes(arr2[i].name)) {
    arr2.splice(i, 1);
  }
}

// или

arr2.reduceRight((_, n, i, a) => arr1.includes(n.name) || a.splice(i, 1), null);

// или

arr2.splice(0, arr2.length, ...arr2.filter(n => arr1.includes(n.name)));

<select>
  <option value="" hidden>здесь ваше описание</option>
  ...

select.innerHTML = '<option value="" hidden>...</option>' + select.innerHTML;

select.insertAdjacentHTML('afterbegin', '<option value="" hidden>...</option>');

const option = document.createElement('option');
option.value = '';
option.hidden = true;
option.innerText = '...';
select.prepend(option);

const option = new Option('...', '');
option.style.display = 'none';
select.insertBefore(option, select.firstElementChild);

document.querySelector('.map__filters').addEventListener('change', function() {
  const values = Array.from(
    this.querySelectorAll('.map__checkbox:checked'),
    n => n.value
  );

  const filtered = values.length
    ? data.filter(n => values.every(m => n.features.includes(m)))
    : [];

  document.querySelector('#items').innerHTML = filtered
    .map(n => `<div>${JSON.stringify(n, null, 2)}</div>`)
    .join('');
});

function filter(obj, key, f) {
  const keys = Object.keys(obj);

  return (obj[key] || []).reduce((acc, n, i) => (
    f(n) && keys.forEach(k => acc[k].push(obj[k][i])),
    acc
  ), keys.reduce((acc, k) => (acc[k] = [], acc), {}));
}


const result = filter(obj, 'years', n => 2012 <= n && n <= 2014);

function filter(obj, f) {
  const keys = Object.keys(obj);
  const length = keys.length && obj[keys[0]].length;
  const result = Object.fromEntries(keys.map(k => [ k, [] ]));

  for (let i = 0; i < length; i++) {
    if (f(i, obj)) {
      keys.forEach(k => result[k].push(obj[k][i]));
    }
  }

  return result;
}


const result = filter(obj, (i, { years: { [i]: n } }) => 2012 <= n && n <= 2014);

- .dropdown__block.open {
+ .dropdown.open .dropdown__block {

const containerSelector = '.dropdown';
const buttonSelector = `${containerSelector} .dropdown__toggler`;
const activeClass = 'open';


// jquery, как вы и хотели
$(document).on('click', ({ target: t }) => {
  const $container = $(t).closest(containerSelector);
  const $button = $(t).closest(buttonSelector);

  if ($button.length) {
    $container.toggleClass(activeClass);
  }

  $(containerSelector).not($container).removeClass(activeClass);
});

// или, к чёрту jquery
document.addEventListener('click', ({ target: t }) => {
  const container = t.closest(containerSelector);
  const button = t.closest(buttonSelector);

  if (button) {
    container.classList.toggle(activeClass);
  }

  document.querySelectorAll(containerSelector).forEach(n => {
    if (n !== container) {
      n.classList.remove(activeClass);
    }
  });
});

.hidden {
  display: none;
}

const itemSelector = '.item-service';
const className = 'hidden';

function toggleUntilNextItem(el) {
  while ((el = el.nextElementSibling) && !el.matches(itemSelector)) {
    el.classList.toggle(className);
  }
}

document.querySelectorAll(itemSelector).forEach(function(n) {
  n.addEventListener('click', this);
}, e => toggleUntilNextItem(e.currentTarget));

// или

document.addEventListener('click', e => {
  const item = e.target.closest(itemSelector);
  if (item) {
    toggleUntilNextItem(item);
  }
});