Дмитрий Беляев

HTML ищет обработчики в только глобальной области видимости.
Хранить что-либо в глобальной области видимости - чревато проблемами.
webpack изолирует область видимости модулей в замыканиях дабы таких проблем не возникало.

Навешивайте обработчики через JS, например как показал Yorido Satoshi

const arr = ['utmTerm=java', 'utmTerm=javascript', 'utmTerm=swift'];
const res = arr.reduce((acc, item) => {
    const [key, value] = item.split('=', 2);
    (acc[key] ??= []).push(value);
    return acc;
}, {});
console.log(res);

Можно записать объект в свойство prototype временной функции и наследоваться от нее:

function fromPrototype(proto) {
    function F() {}
    F.protoype = proto;
    return F;
}

const obj = {
    _sayHi() {
        console.log(`Hello, my name is ${this.name}!`);
    },
};

class Person extends fromPrototype(obj) {
    constructor(name, age) {
        this.name = name;
        this.age = age;
      
       if (this.age < 0 ) {
            this.age = 0;
        }
    }
}

Проблема вот тут:

const remove = this.on(events

Метод on у Вас ничего не возвращает, соответственно в remove будет undefined, функции там взяться неоткуда.
Переменной events нет в скоупе данного метода, очевидно имелась в виду eventName

А вообще, вместо массива колбэков для события лучше использовать Set, так метод off будет работать за O(1), а не за O(n) как сейчас.

В методе once можно подписываться на событие через метод on, и отписываться через метод off при его наступлении (так например делает EventEmitter из node.js). Но стоит учесть момент, что off должен работать и для once событий, а у Вас будет записан колбэк созданный в once, а не тот, что передал пользователь. Вообще проще хранить 2 коллекции: для многоразовых для одноразовых событий, ну или параметризовать колбэки (тогда лучше хранить их в Map, где ключи - колбэки, а значения - их параметры).

Ну и еще обратите внимание, что у Вас в методах emit и once колбэк пользователя вызывается по разному:
callback.apply(this, args) и callback.call(null, args)

https://www.electronjs.org/

Мне нужно из: [null] получить просто []

Если таких null много в вперемешку с полезными значениями, то можно отфильтровать:arr = arr.filter(el => el !== null);

Потому, что undefined в js - это специальное значение, суть которого быть значением по умолчанию для неинициализированных переменных.
То есть инициализация переменной значением undefined - это все равно, что инициализация значением по умолчанию.
Когда Вы в сигнатуре функции пишете b = 10 - это означает, что инициализируй b значением 10 если там инициализация по умолчанию (undefined).

С итерируемыми объектами работают только циклы for-of и for-await-of.

В современном JS есть следующие виды циклов:

1. while - цикл с условием

// где condition - это некоторое выражение, которое можно скастовать к boolean
while (condition) {
}

Данный цикл выполняется, пока условие condition истинно.

2. do-while - цикл с постусловием

do {
} while (condition);

Данный цикл выполняется как минимум 1 раз, условие condition проверяется после тела цикла и если оно истинно - запускается следующая итерация.

3. for - цикл с инициализацией, условием и финальным выражением

for (init; condition; final_expression) {
}

// основное применение - это цикл со счетчиком, но в целом мы не ограничены в применении
for (let i = 0; i < 10; ++i) {
}

Перед циклом выполняется init, который может быть выражением или оператором объявления переменных (var, let, const). Перед каждой итерацией проверяется условие condition, пока это условие истинно - цикл будет выполняться. После каждой итерации выполняется final_expression.

4. for-in - цикл по ключам объекта

// где object - это некоторое выражение, которое можно скастовать к типу object
for (const key in object) {
}

Данный цикл перебирает все перечислимые ключи самого объекта и всех объектов из его цепочки прототипов. Может работать медленно, а ключи из прототипа обычно не требуются, поэтому данный цикл не рекомендуется использовать.

5. for-of - цикл по итерируемым объектам

// где iterable - это некоторый объект с методом Symbol.iterator
for (const value_variable of iterable) {
}

Перед итерацией создает итератор вызывая iterable[Symbol.iterator](), перед каждой итерацией дергает метод next у итератора, работает пока в возвращаемом из метода next объекте поле done не станет true, подставляет поле value в переменную value_variable. Цикл в примере выше можно реализовать в виде обычного for:

{
  const iter = [1, 2, 3][Symbol.iterator]();
  for (let {done, value} = iter.next(); !done; ({done, value} = iter.next())) {
    const value_variable = value;
    {
      // тело исходного цикла
    }
  }
}

6. for-await-of - цикл по асинхронно итерируемым объектам

// где iterable - это некоторый объект с методом Symbol.asyncIterator или методом Symbol.iterator
for await (const value_variable of iterable) {
}

Перед итерацией создает итератор, одним из следующих способов:
Если в объекте iterable есть метод Symbol.asyncIterator - то вызывает его.
В противном случае вызывает метод Symbol.iterator.
В остальном работает как for-of, с той разницей, что дополнительно применяет оператор await к значению итератора и в value_variable попадает то, что вернул данный await.

То что у Вас в примере - это вообще не валидный JS.
Можно с объектами:

const fields = {
     'Алтайский край': {
          'Барнаул': {}
          'Рубцовск': {}
     },
     'Новосибирская область': {
           'Новосибирск': {}
     },
};
console.log(JSON.stringify(fields));