0xD34F

const openSelector = '[data-target]';
const closeSelector = '.modal__close';
const modalSelector = '.modal';
const activeClass = 'modal--active';

document.addEventListener('click', ({ target: t }) => {
  const open = t.closest(openSelector);
  if (open) {
    document.querySelector(`#${open.dataset.target}`).classList.add(activeClass);
  } else {
    t.closest(closeSelector)?.closest(modalSelector).classList.remove(activeClass);
  }
});

const onClick = (selector, handler) => document
  .querySelectorAll(selector)
  .forEach(n => n.addEventListener('click', handler));

onClick(openSelector, ({ currentTarget: { dataset: { target } } }) => {
  document.querySelector(`#${target}`).classList.add(activeClass);
});

onClick(closeSelector, e => {
  e.currentTarget.closest(modalSelector).classList.remove(activeClass);
});

const obj = {
  val: 1,
  valueOf() {
    return this.val ^= 1;
  },
};

// или

const obj = {
  val: '1',
  toString() {
    return this.val = '1'.slice(this.val.length);
  },
};

// или

const obj = {
  val: true,
  [Symbol.toPrimitive]() {
    return this.val = !this.val;
  },
};

console.log(obj == false, obj == true); // true true
console.log(...Array.from({ length: 5 }, () => +obj)); // 0 1 0 1 0

function mustStay(n) {
  for (const m of arr2) {
    if (m.content.insuranceType === n.value) {
      return false;
    }
  }

  return true;
}

// или

const mustStay = n => arr2.every(m => m.content.insuranceType !== n.value);

// или

const mustStay = function(n) {
  return !this.has(n.value);
}.bind(new Set(arr2.map(n => n.content.insuranceType)));

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

// или

arr1.splice(0, arr1.length, ...arr1.filter(mustStay));

// или

let numDeleted = 0;

for (const [ i, n ] of arr1.entries()) {
  arr1[i - numDeleted] = n;
  numDeleted += !mustStay(n);
}

arr1.length -= numDeleted;

const steps = [ /* ... */ ];
let currentStep = 0;

const quizQuestion = document.querySelector('.quiz__question');
const quizAnswers = document.querySelector('.quiz__answers');

const prevBtn = document.querySelector('.quiz__button_prev');
const nextBtn = document.querySelector('.quiz__button_next');

prevBtn.addEventListener('click', () => nextStep(-1));
nextBtn.addEventListener('click', () => nextStep(+1));

function nextStep(stepChange) {
  currentStep = Math.max(0, Math.min(steps.length - 1, currentStep + stepChange));

  prevBtn.disabled = currentStep === 0;
  nextBtn.disabled = currentStep === steps.length - 1;
  
  quizQuestion.innerHTML = steps[currentStep].question;
  quizAnswers.innerHTML = steps[currentStep].answers.map(n => `<li>${n}</li>`).join('');
}

nextStep(0);

<v-data-table
  :headers="mainTableHeaders"
  :items="mainTableItems"
  item-key="mainTableItemKey"
  show-expand
>
  <template #expanded-item="{ headers, item }">
    <td :colspan="headers.length">
      <v-data-table
        :headers="nestedTableHeaders"
        :items="item.nestedTableItems"
      ></v-data-table>
    </td>
  </template>
</v-data-table>

при клике на строчку

methods: {
  onRowClick(item, row) {
    row.expand(!row.isExpanded);
  },
  ...

<v-data-table
  @click:row="onRowClick"
  ...

class DB {
  info = null;
  ...

const Episodes = observer(() => {
  useEffect(() => {
    ...
  }, [ DB.info ]);
  ...

<div data-filter="service">
  <div class="sign">Streaming service</div>
  <div class="item">Netflix</div>
  <div class="item">HBO Max</div>
  <div class="item">Hulu</div>
</div>
<div data-filter="genre">
  <div class="sign">Movie genre</div>
  <div class="item">Comedy</div>
  <div class="item">Action</div>
  <div class="item">Horror</div>
  <div class="item">Drama</div>
  <div class="item">Fantasy</div>
</div>

<li class="card" data-service="Netflix" data-genre="Comedy">

const cardSelector = '.card';
const hiddenCardClass = 'hidden';
const filterSelector = '[data-filter]';
const filterItemSelector = `${filterSelector} .item`;
const activeFilterItemClass = 'item_active';

document.querySelector('.filters').addEventListener('click', e => {
  const item = e.target.closest(filterItemSelector);
  if (!item) {
    return;
  }

  item.closest(filterSelector).querySelectorAll(filterItemSelector).forEach(n => {
    n.classList[n === item ? 'toggle' : 'remove'](activeFilterItemClass);
  });

  const values = Array.from(
    e.currentTarget.querySelectorAll(`.${activeFilterItemClass}`),
    n => [ n.closest(filterSelector).dataset.filter, n.innerText ]
  );

  document.querySelectorAll(cardSelector).forEach(n => {
    n.classList.toggle(hiddenCardClass, values.some(m => n.dataset[m[0]] !== m[1]));
  });
});

setup() {
    let isActive = false
    return {
        isActive
    }
},

methods: {
  onClick({ target: t }) {
    if (
      t.classList.contains('v-messages__message') &&
      t.closest('.v-messages.error--text')
    ) {
      // ну да, кликнули по сообщению об ошибке
    }
  },
},

Такое вообще возможно?

$items = array_combine(
  array_column($arr2['entries'], 'name_item'),
  $arr2['entries']
);

$keys = [ 'price_item', 'image_item' ];

foreach ($arr1 as $n) {
  foreach ($keys as $k) {
    $n[$k] = $items[$n[0]][$k];
  }

  $arr3[] = $n;
}

function updateValue(el) {
  el.value = el.value, из которого удалено всё, кроме цифр;
  el.dispatchEvent(new Event('input'));
  el.value = форматированное значение el.value;
}

function onInput(e) {
  if (e.isTrusted) {
    updateValue(e.target);
  }
}

Vue.directive('number', {
  bind(el) {
    el.addEventListener('input', onInput);
    updateValue(el);
  },
  update(el) {
    updateValue(el);
  },
  unbind(el) {
    el.removeEventListener('input', onInput);
  },
});

с минимальным количеством действий

return getValue(objectValus[prop], property);

const getValue = (obj, key) => Object
  .values(obj ?? {})
  .reduce((found, n) => found ?? getValue(n, key), obj?.[key]);

<div className={css.inputList}>
  {checkedList.map(n => (
    <div className={css.field} key={n}>
      <p>{n}:</p>
      <Input />
    </div>
  ))}
</div>

const total = results.reduce((acc, n) => acc + n.counts, 0);
const resultsObj = Object.fromEntries(results.map(n => [ n.id, n.counts ]));
const usersWithResults = users.map(n => ({
  ...n,
  result: (resultsObj[n.id] ?? 0) / total * 100,
}));

function solve(arr) {
  const last = arr.reduce((acc, n, i) => (acc[n] = i, acc), {});
  return arr.filter((n, i) => last[n] === i);
}