How to use the immutable.OrderedSet.of function in immutable

private updateEventListeners(dom: HTMLElement, prev: EventListeners, next: EventListeners) {
        const prevKeys = Object.keys(prev);
        const nextKeys = Object.keys(next);
        const allKeys: string[] = OrderedSet
            .of(...nextKeys.concat(prevKeys))
            .toJS();

        // Find listeners to add / remove with order preservation
        type Diff = {
            event: string,
            toAdd: EventListener[],
            toRemove: EventListener[],
        };
        const diff: Diff[] = allKeys.map((event: string) => {
            const prevListeners: EventListener[] = prev[event] || [];
            const nextListeners: EventListener[] = next[event] || [];
            let diffStart;
            for (diffStart = 0; diffStart < Math.min(prevListeners.length, nextListeners.length); diffStart++) {
                if (prevListeners[diffStart] !== nextListeners[diffStart]) {
                    break;

if (typeof action.uid !== 'string') return state
  const uid: string = action.uid
  const oldValue = state[uid]
  const newValue = decoratedClient(oldValue, action)
  if (oldValue === newValue) return state
  return {
    ...state,
    [uid]: newValue,
    ids  : idsReducer(state.ids, uid)
  }
}

const unitIDS = map((unit: MessageUnit) => /*:: toUID( */ unit.id /*:: ) */)

const lastMessagesImm: ActReducer> =
makeReducer(OrderedSet.of(/*:: uidFake */))
  .on(API.TASK.DONE, (state, payload): OrderedSet => state
    .concat(unitIDS(payload))
    .slice(-100))

const message: ActReducer> =
makeReducer(OrderedMap([]))
  .on(NET.SEND, (state, payload): OrderedMap => state
    .set(payload.message.msg_id, payload.message))

const messagePending: ActReducer> =
makeReducer(OrderedSet.of(/*:: '' */))
  .on(NET.SEND,
      (state, { message }): OrderedSet => state
        .add(message.msg_id)
        .concat(...(message.inner || []))
  )

  loaders: () => OrderedSet.of(),
  overrideLoader: (values, env, target, paths, key) => values,

plugins: () =>
    OrderedSet.of(
      "caseSensitivePathsPlugin",
      "watchMissingNodeModulesPlugin",
      "noEmitOnErrorsPlugin",
      "definePlugin",
      "namedModulesPlugin",
      "namedChunksPlugin",
      "statsPlugin"
    ),
  loaders: () => OrderedSet.of(),

*
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @format
 * @flow strict-local
 * @emails oncall+draft_js
 */

'use strict';

const {OrderedSet} = require('immutable');

module.exports = {
  BOLD: (OrderedSet.of('BOLD'): OrderedSet),
  BOLD_ITALIC: (OrderedSet.of('BOLD', 'ITALIC'): OrderedSet),
  BOLD_ITALIC_UNDERLINE: (OrderedSet.of(
    'BOLD',
    'ITALIC',
    'UNDERLINE',
  ): OrderedSet),
  BOLD_UNDERLINE: (OrderedSet.of('BOLD', 'UNDERLINE'): OrderedSet),
  CODE: (OrderedSet.of('CODE'): OrderedSet),
  ITALIC: (OrderedSet.of('ITALIC'): OrderedSet),
  ITALIC_UNDERLINE: (OrderedSet.of('ITALIC', 'UNDERLINE'): OrderedSet),
  NONE: (OrderedSet(): OrderedSet),
  STRIKETHROUGH: (OrderedSet.of('STRIKETHROUGH'): OrderedSet),
  UNDERLINE: (OrderedSet.of('UNDERLINE'): OrderedSet),
};

const broilerplate = (env, target, paths, overrides) => {
  let features = OrderedSet.of(
    "babelFeature",
    "babelMinifyFeature",
    "basicDevelopmentFeature",
    "basicOptimizationFeature",
    "clientRenderFeature",
    "serverRenderFeature",
    "codeSplittingFeature",
    "manifestFeature",
    "pekkisHybridCssFeature",
    "assetFeature"
  );

  let loaders = OrderedSet.of();
  let plugins = OrderedSet.of();

  const broilerplate = {
    addPlugin: plugin => {
      plugins = plugins.add(plugin);
      return broilerplate;
    },

    removePlugin: plugin => {
      plugins = plugins.filterNot(p => p === plugin);
      return broilerplate;
    },

    addLoader: loader => {
      loaders = loaders.add(loader);
      return broilerplate;
    },

  loaders: () => OrderedSet.of("postcssLoader", "externalcssLoader"),
  overrideLoader: (values, env, target, paths, key) => {

plugins: () =>
    OrderedSet.of("occurrenceOrderPlugin", "moduleConcatenationPlugin"),
  loaders: () => OrderedSet.of(),

*/

'use strict';

const {OrderedSet} = require('immutable');

module.exports = {
  BOLD: (OrderedSet.of('BOLD'): OrderedSet),
  BOLD_ITALIC: (OrderedSet.of('BOLD', 'ITALIC'): OrderedSet),
  BOLD_ITALIC_UNDERLINE: (OrderedSet.of(
    'BOLD',
    'ITALIC',
    'UNDERLINE',
  ): OrderedSet),
  BOLD_UNDERLINE: (OrderedSet.of('BOLD', 'UNDERLINE'): OrderedSet),
  CODE: (OrderedSet.of('CODE'): OrderedSet),
  ITALIC: (OrderedSet.of('ITALIC'): OrderedSet),
  ITALIC_UNDERLINE: (OrderedSet.of('ITALIC', 'UNDERLINE'): OrderedSet),
  NONE: (OrderedSet(): OrderedSet),
  STRIKETHROUGH: (OrderedSet.of('STRIKETHROUGH'): OrderedSet),
  UNDERLINE: (OrderedSet.of('UNDERLINE'): OrderedSet),
};

'use strict';

const {OrderedSet} = require('immutable');

module.exports = {
  BOLD: (OrderedSet.of('BOLD'): OrderedSet),
  BOLD_ITALIC: (OrderedSet.of('BOLD', 'ITALIC'): OrderedSet),
  BOLD_ITALIC_UNDERLINE: (OrderedSet.of(
    'BOLD',
    'ITALIC',
    'UNDERLINE',
  ): OrderedSet),
  BOLD_UNDERLINE: (OrderedSet.of('BOLD', 'UNDERLINE'): OrderedSet),
  CODE: (OrderedSet.of('CODE'): OrderedSet),
  ITALIC: (OrderedSet.of('ITALIC'): OrderedSet),
  ITALIC_UNDERLINE: (OrderedSet.of('ITALIC', 'UNDERLINE'): OrderedSet),
  NONE: (OrderedSet(): OrderedSet),
  STRIKETHROUGH: (OrderedSet.of('STRIKETHROUGH'): OrderedSet),
  UNDERLINE: (OrderedSet.of('UNDERLINE'): OrderedSet),
};