0xD34F

const names = new Set(objects.map(n => n.name));
strings.forEach(n => (names.has(n) || objects.push({ name: n })));

new Set(strings).forEach(function(n) {
  if (!this.has(n)) {
    objects.push({ name: n });
  }
}, new Set(objects.map(n => n.name)));

// или

for (const name of strings) {
  if (objects.every(n => n.name !== name)) {
    objects[objects.length] = { name };
  }
}

// или

objects.splice(0, objects.length, ...strings.reduce(
  (acc, n) => acc.set(n, acc.get(n) ?? { name: n }),
  new Map(objects.map(n => [ n.name, n ]))
).values());

str.split(RegExp(`(?:^|\\s)${word}(?:\\s|$)`)).join(`\n${word}\n`)

const punct = '.,!?;:"\'”“';
const numStrWithPunctEnd = 3;
const arr = str.split('\n');
const index = arr.findIndex(function(n, i, a) {
  return this.every(m => punct.includes(a[i + m]?.slice(-1)));
}, [...Array(numStrWithPunctEnd).keys()]);
const result = index !== -1 ? arr.slice(index).join('\n') : str;

const obj = {
  a: 69,
  b: 187,
  c: 666,
};

const proxy = new Proxy(obj, {
  set(target, key, val) {
    console.log('свойство', key, 'изменило своё значение с', target[key], 'на', val);
    target[key] = val;
    return true;
  },
});

const index = 1;
const count = 2;
const value = 'hello, world!!';

arr.splice(index, count, ...Array(count).fill(value));

// или, splice использовать необязательно
for (let i = count; i-- > 0; arr[index + i] = value) ;

const fixCount = Math.max(0, Math.min(count, arr.length - index));

function getDates(startStr, length) {
  const date = new Date(startStr.split('.').reverse().join('-'));
  const day = date.getDate();
  date.setDate(0);

  return Array.from({ length }, () => {
    date.setMonth(date.getMonth() + 2, 0);
    date.setDate(Math.min(date.getDate(), day));

    return date.toLocaleDateString('ru-RU', {
      year: 'numeric',
      month: '2-digit',
      day: '2-digit',
    });
  });
}

const lines = data.split('\n').map(n => n.replace(/X\S+/, 'hello, world!!'));

document.body.addEventListener('click', e => {
  document.querySelectorAll('details[open]').forEach(n => {
    n.open = n === e.target.parentNode;
  });
});

function createTree({
  data,
  idKey = 'id',
  parentKey = 'parentId',
  childrenKey = 'children',
}) {
  const tree = Object.fromEntries(data.map(n => [ n[idKey], { ...n, [childrenKey]: [] } ]));
  return Object.values(tree).filter(n => !tree[n[parentKey]]?.[childrenKey].push(n));
}


const result = createTree({
  data: components,
  childrenKey: 'components',
});

что делаю не так?

document.querySelectorAll('.panel').forEach(n => n.addEventListener('click', onClick));

function onClick() {
  const panel = this.closest('tr').nextElementSibling;
  const isActive = !panel.classList.contains('active');
  panel.classList.toggle('active', isActive);
  this.classList.toggle('changing-icon', isActive);
}

мне нужен не сам ответ

function findOutlier(integers) {
  const [ p0, p1, p2 ] = integers.slice(0, 3).map(n => n & 1);
  return p0 === p1
    ? integers.find(n => (n & 1) !== p0)
    : integers[+(p0 === p2)];
}

const findOutlier = arr => arr
  .reduce((acc, n) => (acc[n & 1].push(n), acc), [ [], [] ])
  .find(n => n.length === 1)
  .pop();

const findOutlier = arr => arr
  .sort((a, b) => (a & 1) - (b & 1))
  .at(-((arr[0] & 1) === (arr[1] & 1)));

function getFilterByCount(arr, filterFn, key) {
  const getKey = key instanceof Function ? key : key == null ? n => n : n => n[key];
  const count = arr.reduce((acc, n) => acc.set(getKey(n), -~acc.get(getKey(n))), new Map);
  return n => !!filterFn(count.get(getKey(n)));
}

const filterByCount = (...args) => args[0].filter(getFilterByCount(...args));


const newArr = filterByCount(arr, count => count > 1, 'props1');

function deleteByCount(arr, filterFn, key) {
  let numDeleted = 0;

  arr.forEach(function(n, i, a) {
    a[i - numDeleted] = n;
    numDeleted += this(n);
  }, getFilterByCount(arr, filterFn, key));

  arr.length -= numDeleted;
}


deleteByCount(arr, count => count < 2, n => n.props1);

for(var i = 0; i < tabss.children.length;i++); {
        tabss.children[i].classList.add('active')
}

const createTreeFromNestedSets = arr => [...arr]
  .sort((a, b) => a.left - b.left)
  .reduce((acc, n) => {
    while (acc.at(-1).at(-1).right < n.left) {
      acc.pop();
    }

    if (acc.at(-1).at(-1).right > n.left) {
      acc.push(acc.at(-1).at(-1).children);
    }

    acc.at(-1).push({ ...n, children: [] });

    return acc;
  }, [ [ { left: -Infinity, right: Infinity, children: [] } ] ])
  [0][0].children;

const createTreeHTML = (arr, nodeTemplate) =>
  Array.isArray(arr) && arr.length
    ? `<ul>${arr.map(n => `
         <li>
           ${nodeTemplate(n)}
           ${createTreeHTML(n.children, nodeTemplate)}
         </li>`).join('')}
       </ul>`
    : '';

containerElement.insertAdjacentHTML('beforeend', createTreeHTML(
  createTreeFromNestedSets(data),
  item => `<input data-id="${item.id}" type="checkbox">${item.name}`
));

function getDates(startStr, endStr) {
  const startDate = new Date(startStr.split('.').reverse().join('-'));
  const endDate = new Date(endStr.split('.').reverse().join('-'));
  const dates = [];

  for (; startDate <= endDate; startDate.setDate(startDate.getDate() + 1)) {
    dates.push(startDate.toLocaleDateString('ru-RU', {
      year: 'numeric',
      month: '2-digit',
      day: '2-digit',
    }));
  }

  return dates;
}

const inputs = [...document.querySelectorAll('.input')];
inputs.forEach(n => n.addEventListener('input', onInput));

function onInput({ target: t }) {
  if (t.value.length === t.maxLength) {
    t.nextElementSibling?.focus();
  }

  if (inputs.every(n => n.value.length === n.maxLength)) {
    // здесь дёргаете свою функцию
  }
}

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());