How to use the lru_map.LRUMap function in lru_map

const CACHE_SIZE         = 10000;
const DATE_FORMAT        = "DD MMM YYYY";
const LOCAL_TIME_FORMAT  = "DD MMM, YYYY [at] HH:mm:ss [Local Time]";
const SERVER_TIME_FORMAT = "DD MMM, YYYY [at] HH:mm:ss Z [Server Time]";
// the default timestamp format rendered by the server
const defaultFormat      = "YYYY-MM-DDTHH:mm:ssZ";

const format = _.memoize((time) => {
  return moment(time, defaultFormat).format(LOCAL_TIME_FORMAT);
});
format.cache = new LRUMap(CACHE_SIZE);

const formatInServerTime = _.memoize((time) => {
  return moment(time, defaultFormat).utcOffset(utcOffsetInMinutes).format(SERVER_TIME_FORMAT);
});
formatInServerTime.cache = new LRUMap(CACHE_SIZE);

const formatInDate = (time?: moment.MomentInput) => {
  return moment(time, defaultFormat).format(DATE_FORMAT);
};

const toDate = (time?: moment.MomentInput) => {
  return moment(time, defaultFormat).toDate();
};

export const timeFormatter = {
  format,
  toDate,
  formatInDate,
  formatInServerTime
};

const LRUMap = require('lru_map').LRUMap;
require("moment-duration-format");

const utcOffsetInMinutes = parseInt(CONSTANTS.SERVER_TIMEZONE_UTC_OFFSET) / 60000;
const CACHE_SIZE         = 10000;
const DATE_FORMAT        = 'DD MMM YYYY';
const LOCAL_TIME_FORMAT  = 'DD MMM, YYYY [at] HH:mm:ss [Local Time]';
const SERVER_TIME_FORMAT = 'DD MMM, YYYY [at] HH:mm:ss Z [Server Time]';
// the default timestamp format rendered by the server
const defaultFormat      = 'YYYY-MM-DDTHH:mm:ssZ';

const format = _.memoize((time) => {
  return moment(time, defaultFormat).format(LOCAL_TIME_FORMAT);
});
format.cache = new LRUMap(CACHE_SIZE);

const formatInServerTime = _.memoize((time) => {
  return moment(time, defaultFormat).utcOffset(utcOffsetInMinutes).format(SERVER_TIME_FORMAT);
});
formatInServerTime.cache = new LRUMap(CACHE_SIZE);

const formatInDate = (time) => {
  return moment(time, defaultFormat).format(DATE_FORMAT);
};

module.exports = {
  format,
  formatInDate,
  formatInServerTime
};

import {FieldMask} from '@liaison/model';
import LRUMapModule from 'lru_map';
const LRUMap = LRUMapModule.LRUMap; // Turn around an issue when bundling with Rollup

/* eslint-disable guard-for-in */

export class Cache {
  constructor(parent, {size}) {
    this._parent = parent;
    this._size = size;

    this._entries = new LRUMap(size);
    this._entries.shift = () => {
      // Delete indexes when an entry is evicted from the cache
      const entry = LRUMap.prototype.shift.call(this._entries);
      this._deleteIndexes(entry.indexedFields);
      return entry;
    };

constructor(
    private application: Application,
    private cacheSize = 1 << 16,
    private ttl = 1 << 18
  ) {
    this.cache = new LRUMap>>(this.cacheSize);
  }

constructor(size: number, evictCb: PathCacheEvictHandler | null) {
    this.evictCb = evictCb
    this.cache = new LRUMap(size)
  }

constructor (base: string, file: string, options: BaseDbOptions) {
    super(base, file, options);

    this._lruBranch = new LRUMap(defaults.LRU_BRANCH_COUNT);
    this._lruData = new LRUMap(defaults.LRU_DATA_COUNT);
  }

constructor (backing: BaseDb, itemCount: number = DEFAULT_ITEM_COUNT) {
    this.backing = backing;
    this.lru = new LRUMap(itemCount);
  }

const parsedText = JSON.parse(text.slice(21, -1))
    const userTags: AccountTagList = JSON.parse(parsedText)

    return Object.entries(userTags).map(([name, value]) => ({
      ...value,
      name
    }))
  }

  const usePageCache = createCacheHook(fetchPages, new LRUMap(20))
  const useUgoiraCache = createCacheHook(fetchUgoira, new LRUMap(1))
  const useIllustCache = createCacheHook(fetchIllust, new LRUMap(20))
  const useUserCache = createCacheHook(fetchUser, new LRUMap(20))
  const useBookmarkCache = createCacheHook(
    fetchBookmarkForm,
    new LRUMap(1),
    true
  )

  return {
    token,
    yourId,
    isSelf,
    usePageCache,
    fetchImage,
    useUgoiraCache,
    useIllustCache,
    likeBy,
    bookmarkBy,
    useUserCache,
    followUser,
    useBookmarkCache

constructor(private application: Application, cacheSize = defaultCacheSize) {
    this.cache = new LRUMap>(cacheSize);
  }

constructor() {
        this.eventCache = new LRUMap(100);
        this.commandCache = new LRUMap(100);
        this.messageCache = new LRUMap(100);
    }