0xD34F

А почему оно не должно быть undefined? Кто вам обещал, что подобным образом можно достучаться до настроек редактора?

Для этого есть метод getContext: editor.getContext().options.imageUploadUrl.

const roots = arr.filter((n, i, a) => !a.some(m => m.id === n.root_id));

или

const roots = arr.filter(function(n) {
  return !this.has(n.root_id);
}, new Set(arr.map(n => n.id)));

str.replace(/([A-Z])\1{2,}/g, '$1$1')

$items2.height(i => $items1.eq(i).width());

if(sortedArr[i + 1] == sortedArr[i]) {
  results.push(sortedArr[i]);
}

Недостаточное условие. Если четыре нуля идут подряд - сколько раз после нуля можно найти равное ему значение? Правильно, три раза - после первого, второго и третьего. Надо ещё проверять, что предыдущий элемент не равен текущему:

const getDuplicates = arr => arr
  .slice()
  .sort()
  .reduce((acc, n, i, a) => (n === a[i + 1] && n !== a[i - 1] && acc.push(n), acc), []);

Но вообще, использовать сортировку не обязательно, есть и другие способы:

const getDuplicates = arr => Array
  .from(arr.reduce((acc, n) => acc.set(n, (acc.get(n) ?? 0) + 1), new Map))
  .reduce((acc, n) => (n[1] > 1 && acc.push(n[0]), acc), []);

const getDuplicates = arr => Object
  .entries(arr.reduce((acc, n) => (acc[n] = acc.hasOwnProperty(n), acc), {}))
  .filter(n => n[1])
  .map(n => +n[0]);

const getDuplicates = arr =>
  [...arr.reduce((acc, n) => (acc[+acc[0].has(n)].add(n), acc), [ new Set, new Set ])[1]];

const getDuplicates = arr =>
  [...new Set(arr.filter((n, i, a) => a.includes(n, i + 1)))];

const getDuplicates = arr => arr
  .filter((n, i, a) => i !== a.indexOf(n))
  .filter((n, i, a) => i === a.indexOf(n));

Object.keys(obj1).forEach(n => delete obj2[n]);

или, если надо собрать новый объект вместо изменения исходного:

Object.fromEntries(Object.entries(obj2).filter(n => !obj1.hasOwnProperty(n[0])))

const groupSubarrays = (arr, idKey, subarrKey) =>
  Object.values(arr.reduce((acc, n) => (
    (acc[n[idKey]] ??= { ...n, [subarrKey]: [] })[subarrKey].push(...n[subarrKey]),
    acc
  ), {}));


const result = groupSubarrays(arr, 'id', 'array1');

Прежде чем упрощать, следует исправить - тот код, что есть, выдаёт некорректные результаты, если среди элементов массива есть 0 (например, для [ -1, 0, 0.1, 2 ] выдаёт 2 вместо 0.1). В первой части условия следует вместо предыдущего элемента массива смотреть индекс текущего - единственным неподходящим является нулевой.

Если планируете получать единственное значение, то фильтрация плюс извлечение нулевого элемента результата избыточны - хватит метода find. Для подмены undefined на null вообще не нужно никаких проверок делать - с этим справится nullish coalescing. Так что вот:

const firstNonConsecutive = arr => arr.find((n, i, a) => i && a[i - 1] !== n - 1) ?? null;

Не надо никуда ничего сохранять:

arr.splice(0, arr.length, ...arr.map((n, i, a) => (a[i - 1] ?? 0) + (a[i + 1] ?? 0)));

const $links = $('.small a');
let currentIndex = null;

function setActiveImage(index) {
  currentIndex = (index + $links.length) % $links.length;
  $('.big img').attr('src', $links.eq(currentIndex).attr('href'));
  $('.photo').text(`${currentIndex + 1} / ${$links.length}`);
}

$links.click(e => (e.preventDefault(), setActiveImage($links.index(e.currentTarget))));
$('#prev').click(() => setActiveImage(currentIndex - 1));
$('#next').click(() => setActiveImage(currentIndex + 1));

setActiveImage(0);

const select = document.querySelector('select');
const reg = /^\d\d\. /;

Array.prototype.forEach.call(
  select,
  n => n.hidden = !reg.test(n.innerText)
);

// или

for (const n of select) {
  n.style.display = n.textContent.search(reg) ? 'none' : '';
}

const newData = data
  .reduce((acc, { type, ...n }) => (
    (acc[acc.length - 1]?.[0] !== type) && acc.push([ type, [] ]),
    acc[acc.length - 1][1].push(n),
    acc
  ), [])
  .map(([ type, children ]) => children.length > 1
    ? { type: `Section${type}`, children }
    : { type, ...children[0] }
  );

const count = str => [...str]
  .reduce((acc, n, i, a) => (
    a[i - 1] !== n && acc.push([ n, 0 ]),
    acc[acc.length - 1][1]++,
    acc
  ), [])
  .flat()
  .join('');

или

const count = str => str.replace(/(.)\1*/g, m => m[0] + m.length);

new Date(str.split(' ', 1)[0].split('.').reverse().join('-')).toLocaleString('ru-RU', {
  month: 'long',
  day: 'numeric',
})

const $checkbox = $('.form__chekbox');
const $cbAll = $checkbox.filter('.form__chekbox_all');
const $cb = $checkbox.not($cbAll);

$cbAll.change(e => $cb.prop('checked', false));

$cb.change(() => {
  const $checked = $cb.filter(':checked');
  const allChecked = $checked.length === $cb.length;
  $cbAll.prop('checked', !$checked.length || allChecked);
  $cb.prop('checked', (i, val) => allChecked ? false : val);
});

Потому что

new Date instanceof Object // true

Пора бы разобраться с основами js - какие там бывают типы данных, и в чём особенности работы с ними. В частности, как сравниваются объекты.

/(?=.*1)(?=.*2)(?=.*3)/.test(str)

или

[ 1, 2, 3 ].every(n => str.includes(n))

или

new Set(str.match(/[123]/g)).size === 3

Как можно дополнить мой код, чтобы он проверял то, что требуется?

Дополнить - никак. Надо переписать. К единице надо плюсовать не все результаты рекурсивных вызовов, а только один, наибольший.

И можно как-нибудь без объявления переменной n внутри функции?

Можно:

const getMaxDepth = arr =>
  Array.isArray(arr)
    ? 1 + Math.max(0, ...arr.map(getMaxDepth))
    : 0;


console.log(getMaxDepth([ 1, [ 2 ], [ [ 3 ] ], [ [ [ 4 ] ] ] ])); // 4
console.log(getMaxDepth([])); // 1
console.log(getMaxDepth(666)); // 0

const createArr = (source, maxLength) =>
  [...Array(1 + Math.random() * maxLength | 0)].map(() => source[Math.random() * source.length | 0]);


const [ arr1, arr2, arr3 ] = [...Array(3)].map(() => createArr(arr, 5));

Если элементы не должны повторяться, тогда так (исходный массив копируется и из него вырезаются случайные элементы):

const createArr = ([...source], maxLength) => Array.from(
  { length: Math.min(source.length, 1 + Math.random() * maxLength | 0) },
  () => source.splice(Math.random() * source.length | 0, 1)[0]
);

или, копируем исходный массив, перемешиваем копию, берём случайное количество элементов из начала:

function createArr(source, maxLength) {
  const arr = source.slice();

  for (let i = arr.length; --i > 0;) {
    const j = Math.random() * (i + 1) | 0;
    [ arr[j], arr[i] ] = [ arr[i], arr[j] ];
  }

  return arr.slice(0, 1 + Math.random() * maxLength | 0);
}

function createTable(rows, cols) {
  const maxLen = `${rows * cols}`.length;

  return [...Array(rows)]
    .map((n, i) => [...Array(cols)]
      .map((m, j) => `${cols * i + j + 1}`.padStart(maxLen, 0))
      .join(' '))
    .join('\n');
}

или

function createTable(rows, cols) {
  const zeroStr = Array(1 + Math.ceil(Math.log10(rows * cols + 1))).join(0);
  let result = '';

  for (let i = 0; i < rows; i++) {
    result += i ? '\n' : '';

    for (let j = 0; j < cols; j++) {
      result += (j ? ' ' : '') + (zeroStr + (cols * i + j + 1)).slice(-zeroStr.length);
    }
  }

  return result;
}