office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/core/impl.js

@@ -0,0 +1,25 @@
+import { error } from '../util/log.js';
+
+// Implementation of exported APIs. For example registerMap, getMap.
+// The implementations will be registered when installing the component.
+// Avoid these code being bundled to the core module.
+var implsStore = {};
+// TODO Type
+function registerImpl(name, impl) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (implsStore[name]) {
+      error("Already has an implementation of " + name + ".");
+    }
+  }
+  implsStore[name] = impl;
+}
+function getImpl(name) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (!implsStore[name]) {
+      error("Implementation of " + name + " doesn't exists.");
+    }
+  }
+  return implsStore[name];
+}
+
+export { getImpl, registerImpl };

package/esm/node_modules/echarts/lib/core/lifecycle.js

@@ -0,0 +1,5 @@
+import Eventful from '../../../zrender/lib/core/Eventful.js';
+
+var lifecycle = new Eventful();
+
+export { lifecycle as default };

package/esm/node_modules/echarts/lib/core/locale.js

@@ -0,0 +1,47 @@
+import Model from '../model/Model.js';
+import env from '../../../zrender/lib/core/env.js';
+import langEN from '../i18n/langEN.js';
+import langZH from '../i18n/langZH.js';
+import { isString, clone, merge } from '../../../zrender/lib/core/util.js';
+
+var LOCALE_ZH = 'ZH';
+var LOCALE_EN = 'EN';
+var DEFAULT_LOCALE = LOCALE_EN;
+var localeStorage = {};
+var localeModels = {};
+var SYSTEM_LANG = !env.domSupported ? DEFAULT_LOCALE : function () {
+  var langStr = ( /* eslint-disable-next-line */
+  document.documentElement.lang || navigator.language || navigator.browserLanguage || DEFAULT_LOCALE).toUpperCase();
+  return langStr.indexOf(LOCALE_ZH) > -1 ? LOCALE_ZH : DEFAULT_LOCALE;
+}();
+function registerLocale(locale, localeObj) {
+  locale = locale.toUpperCase();
+  localeModels[locale] = new Model(localeObj);
+  localeStorage[locale] = localeObj;
+}
+// export function getLocale(locale: string) {
+//     return localeStorage[locale];
+// }
+function createLocaleObject(locale) {
+  if (isString(locale)) {
+    var localeObj = localeStorage[locale.toUpperCase()] || {};
+    if (locale === LOCALE_ZH || locale === LOCALE_EN) {
+      return clone(localeObj);
+    } else {
+      return merge(clone(localeObj), clone(localeStorage[DEFAULT_LOCALE]), false);
+    }
+  } else {
+    return merge(clone(locale), clone(localeStorage[DEFAULT_LOCALE]), false);
+  }
+}
+function getLocaleModel(lang) {
+  return localeModels[lang];
+}
+function getDefaultLocaleModel() {
+  return localeModels[DEFAULT_LOCALE];
+}
+// Default locale
+registerLocale(LOCALE_EN, langEN);
+registerLocale(LOCALE_ZH, langZH);
+
+export { SYSTEM_LANG, createLocaleObject, getDefaultLocaleModel, getLocaleModel, registerLocale };

package/esm/node_modules/echarts/lib/core/task.js

@@ -0,0 +1,303 @@
+import { assert, isArray } from '../../../zrender/lib/core/util.js';
+
+/**
+ * @param {Object} define
+ * @return See the return of `createTask`.
+ */
+function createTask(define) {
+  return new Task(define);
+}
+var Task = /** @class */function () {
+  function Task(define) {
+    define = define || {};
+    this._reset = define.reset;
+    this._plan = define.plan;
+    this._count = define.count;
+    this._onDirty = define.onDirty;
+    this._dirty = true;
+  }
+  /**
+   * @param step Specified step.
+   * @param skip Skip customer perform call.
+   * @param modBy Sampling window size.
+   * @param modDataCount Sampling count.
+   * @return whether unfinished.
+   */
+  Task.prototype.perform = function (performArgs) {
+    var upTask = this._upstream;
+    var skip = performArgs && performArgs.skip;
+    // TODO some refactor.
+    // Pull data. Must pull data each time, because context.data
+    // may be updated by Series.setData.
+    if (this._dirty && upTask) {
+      var context = this.context;
+      context.data = context.outputData = upTask.context.outputData;
+    }
+    if (this.__pipeline) {
+      this.__pipeline.currentTask = this;
+    }
+    var planResult;
+    if (this._plan && !skip) {
+      planResult = this._plan(this.context);
+    }
+    // Support sharding by mod, which changes the render sequence and makes the rendered graphic
+    // elements uniformed distributed when progress, especially when moving or zooming.
+    var lastModBy = normalizeModBy(this._modBy);
+    var lastModDataCount = this._modDataCount || 0;
+    var modBy = normalizeModBy(performArgs && performArgs.modBy);
+    var modDataCount = performArgs && performArgs.modDataCount || 0;
+    if (lastModBy !== modBy || lastModDataCount !== modDataCount) {
+      planResult = 'reset';
+    }
+    function normalizeModBy(val) {
+      !(val >= 1) && (val = 1); // jshint ignore:line
+      return val;
+    }
+    var forceFirstProgress;
+    if (this._dirty || planResult === 'reset') {
+      this._dirty = false;
+      forceFirstProgress = this._doReset(skip);
+    }
+    this._modBy = modBy;
+    this._modDataCount = modDataCount;
+    var step = performArgs && performArgs.step;
+    if (upTask) {
+      if (process.env.NODE_ENV !== 'production') {
+        assert(upTask._outputDueEnd != null);
+      }
+      this._dueEnd = upTask._outputDueEnd;
+    }
+    // DataTask or overallTask
+    else {
+      if (process.env.NODE_ENV !== 'production') {
+        assert(!this._progress || this._count);
+      }
+      this._dueEnd = this._count ? this._count(this.context) : Infinity;
+    }
+    // Note: Stubs, that its host overall task let it has progress, has progress.
+    // If no progress, pass index from upstream to downstream each time plan called.
+    if (this._progress) {
+      var start = this._dueIndex;
+      var end = Math.min(step != null ? this._dueIndex + step : Infinity, this._dueEnd);
+      if (!skip && (forceFirstProgress || start < end)) {
+        var progress = this._progress;
+        if (isArray(progress)) {
+          for (var i = 0; i < progress.length; i++) {
+            this._doProgress(progress[i], start, end, modBy, modDataCount);
+          }
+        } else {
+          this._doProgress(progress, start, end, modBy, modDataCount);
+        }
+      }
+      this._dueIndex = end;
+      // If no `outputDueEnd`, assume that output data and
+      // input data is the same, so use `dueIndex` as `outputDueEnd`.
+      var outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : end;
+      if (process.env.NODE_ENV !== 'production') {
+        // ??? Can not rollback.
+        assert(outputDueEnd >= this._outputDueEnd);
+      }
+      this._outputDueEnd = outputDueEnd;
+    } else {
+      // (1) Some overall task has no progress.
+      // (2) Stubs, that its host overall task do not let it has progress, has no progress.
+      // This should always be performed so it can be passed to downstream.
+      this._dueIndex = this._outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : this._dueEnd;
+    }
+    return this.unfinished();
+  };
+  Task.prototype.dirty = function () {
+    this._dirty = true;
+    this._onDirty && this._onDirty(this.context);
+  };
+  Task.prototype._doProgress = function (progress, start, end, modBy, modDataCount) {
+    iterator.reset(start, end, modBy, modDataCount);
+    this._callingProgress = progress;
+    this._callingProgress({
+      start: start,
+      end: end,
+      count: end - start,
+      next: iterator.next
+    }, this.context);
+  };
+  Task.prototype._doReset = function (skip) {
+    this._dueIndex = this._outputDueEnd = this._dueEnd = 0;
+    this._settedOutputEnd = null;
+    var progress;
+    var forceFirstProgress;
+    if (!skip && this._reset) {
+      progress = this._reset(this.context);
+      if (progress && progress.progress) {
+        forceFirstProgress = progress.forceFirstProgress;
+        progress = progress.progress;
+      }
+      // To simplify no progress checking, array must has item.
+      if (isArray(progress) && !progress.length) {
+        progress = null;
+      }
+    }
+    this._progress = progress;
+    this._modBy = this._modDataCount = null;
+    var downstream = this._downstream;
+    downstream && downstream.dirty();
+    return forceFirstProgress;
+  };
+  Task.prototype.unfinished = function () {
+    return this._progress && this._dueIndex < this._dueEnd;
+  };
+  /**
+   * @param downTask The downstream task.
+   * @return The downstream task.
+   */
+  Task.prototype.pipe = function (downTask) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert(downTask && !downTask._disposed && downTask !== this);
+    }
+    // If already downstream, do not dirty downTask.
+    if (this._downstream !== downTask || this._dirty) {
+      this._downstream = downTask;
+      downTask._upstream = this;
+      downTask.dirty();
+    }
+  };
+  Task.prototype.dispose = function () {
+    if (this._disposed) {
+      return;
+    }
+    this._upstream && (this._upstream._downstream = null);
+    this._downstream && (this._downstream._upstream = null);
+    this._dirty = false;
+    this._disposed = true;
+  };
+  Task.prototype.getUpstream = function () {
+    return this._upstream;
+  };
+  Task.prototype.getDownstream = function () {
+    return this._downstream;
+  };
+  Task.prototype.setOutputEnd = function (end) {
+    // This only happens in dataTask, dataZoom, map, currently.
+    // where dataZoom do not set end each time, but only set
+    // when reset. So we should record the set end, in case
+    // that the stub of dataZoom perform again and earse the
+    // set end by upstream.
+    this._outputDueEnd = this._settedOutputEnd = end;
+  };
+  return Task;
+}();
+var iterator = function () {
+  var end;
+  var current;
+  var modBy;
+  var modDataCount;
+  var winCount;
+  var it = {
+    reset: function (s, e, sStep, sCount) {
+      current = s;
+      end = e;
+      modBy = sStep;
+      modDataCount = sCount;
+      winCount = Math.ceil(modDataCount / modBy);
+      it.next = modBy > 1 && modDataCount > 0 ? modNext : sequentialNext;
+    }
+  };
+  return it;
+  function sequentialNext() {
+    return current < end ? current++ : null;
+  }
+  function modNext() {
+    var dataIndex = current % winCount * modBy + Math.ceil(current / winCount);
+    var result = current >= end ? null : dataIndex < modDataCount ? dataIndex
+    // If modDataCount is smaller than data.count() (consider `appendData` case),
+    // Use normal linear rendering mode.
+    : current;
+    current++;
+    return result;
+  }
+}();
+// -----------------------------------------------------------------------------
+// For stream debug (Should be commented out after used!)
+// @usage: printTask(this, 'begin');
+// @usage: printTask(this, null, {someExtraProp});
+// @usage: Use `__idxInPipeline` as conditional breakpiont.
+//
+// window.printTask = function (task: any, prefix: string, extra: { [key: string]: unknown }): void {
+//     window.ecTaskUID == null && (window.ecTaskUID = 0);
+//     task.uidDebug == null && (task.uidDebug = `task_${window.ecTaskUID++}`);
+//     task.agent && task.agent.uidDebug == null && (task.agent.uidDebug = `task_${window.ecTaskUID++}`);
+//     let props = [];
+//     if (task.__pipeline) {
+//         let val = `${task.__idxInPipeline}/${task.__pipeline.tail.__idxInPipeline} ${task.agent ? '(stub)' : ''}`;
+//         props.push({text: '__idxInPipeline/total', value: val});
+//     } else {
+//         let stubCount = 0;
+//         task.agentStubMap.each(() => stubCount++);
+//         props.push({text: 'idx', value: `overall (stubs: ${stubCount})`});
+//     }
+//     props.push({text: 'uid', value: task.uidDebug});
+//     if (task.__pipeline) {
+//         props.push({text: 'pipelineId', value: task.__pipeline.id});
+//         task.agent && props.push(
+//             {text: 'stubFor', value: task.agent.uidDebug}
+//         );
+//     }
+//     props.push(
+//         {text: 'dirty', value: task._dirty},
+//         {text: 'dueIndex', value: task._dueIndex},
+//         {text: 'dueEnd', value: task._dueEnd},
+//         {text: 'outputDueEnd', value: task._outputDueEnd}
+//     );
+//     if (extra) {
+//         Object.keys(extra).forEach(key => {
+//             props.push({text: key, value: extra[key]});
+//         });
+//     }
+//     let args = ['color: blue'];
+//     let msg = `%c[${prefix || 'T'}] %c` + props.map(item => (
+//         args.push('color: green', 'color: red'),
+//         `${item.text}: %c${item.value}`
+//     )).join('%c, ');
+//     console.log.apply(console, [msg].concat(args));
+//     // console.log(this);
+// };
+// window.printPipeline = function (task: any, prefix: string) {
+//     const pipeline = task.__pipeline;
+//     let currTask = pipeline.head;
+//     while (currTask) {
+//         window.printTask(currTask, prefix);
+//         currTask = currTask._downstream;
+//     }
+// };
+// window.showChain = function (chainHeadTask) {
+//     var chain = [];
+//     var task = chainHeadTask;
+//     while (task) {
+//         chain.push({
+//             task: task,
+//             up: task._upstream,
+//             down: task._downstream,
+//             idxInPipeline: task.__idxInPipeline
+//         });
+//         task = task._downstream;
+//     }
+//     return chain;
+// };
+// window.findTaskInChain = function (task, chainHeadTask) {
+//     let chain = window.showChain(chainHeadTask);
+//     let result = [];
+//     for (let i = 0; i < chain.length; i++) {
+//         let chainItem = chain[i];
+//         if (chainItem.task === task) {
+//             result.push(i);
+//         }
+//     }
+//     return result;
+// };
+// window.printChainAEachInChainB = function (chainHeadTaskA, chainHeadTaskB) {
+//     let chainA = window.showChain(chainHeadTaskA);
+//     for (let i = 0; i < chainA.length; i++) {
+//         console.log('chainAIdx:', i, 'inChainB:', window.findTaskInChain(chainA[i].task, chainHeadTaskB));
+//     }
+// };
+
+export { Task, createTask };

package/esm/node_modules/echarts/lib/data/DataDiffer.js

@@ -0,0 +1,253 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+function dataIndexMapValueLength(valNumOrArrLengthMoreThan2) {
+  return valNumOrArrLengthMoreThan2 == null ? 0 : valNumOrArrLengthMoreThan2.length || 1;
+}
+function defaultKeyGetter(item) {
+  return item;
+}
+var DataDiffer = /** @class */function () {
+  /**
+   * @param context Can be visited by this.context in callback.
+   */
+  function DataDiffer(oldArr, newArr, oldKeyGetter, newKeyGetter, context,
+  // By default: 'oneToOne'.
+  diffMode) {
+    this._old = oldArr;
+    this._new = newArr;
+    this._oldKeyGetter = oldKeyGetter || defaultKeyGetter;
+    this._newKeyGetter = newKeyGetter || defaultKeyGetter;
+    // Visible in callback via `this.context`;
+    this.context = context;
+    this._diffModeMultiple = diffMode === 'multiple';
+  }
+  /**
+   * Callback function when add a data
+   */
+  DataDiffer.prototype.add = function (func) {
+    this._add = func;
+    return this;
+  };
+  /**
+   * Callback function when update a data
+   */
+  DataDiffer.prototype.update = function (func) {
+    this._update = func;
+    return this;
+  };
+  /**
+   * Callback function when update a data and only work in `cbMode: 'byKey'`.
+   */
+  DataDiffer.prototype.updateManyToOne = function (func) {
+    this._updateManyToOne = func;
+    return this;
+  };
+  /**
+   * Callback function when update a data and only work in `cbMode: 'byKey'`.
+   */
+  DataDiffer.prototype.updateOneToMany = function (func) {
+    this._updateOneToMany = func;
+    return this;
+  };
+  /**
+   * Callback function when update a data and only work in `cbMode: 'byKey'`.
+   */
+  DataDiffer.prototype.updateManyToMany = function (func) {
+    this._updateManyToMany = func;
+    return this;
+  };
+  /**
+   * Callback function when remove a data
+   */
+  DataDiffer.prototype.remove = function (func) {
+    this._remove = func;
+    return this;
+  };
+  DataDiffer.prototype.execute = function () {
+    this[this._diffModeMultiple ? '_executeMultiple' : '_executeOneToOne']();
+  };
+  DataDiffer.prototype._executeOneToOne = function () {
+    var oldArr = this._old;
+    var newArr = this._new;
+    var newDataIndexMap = {};
+    var oldDataKeyArr = new Array(oldArr.length);
+    var newDataKeyArr = new Array(newArr.length);
+    this._initIndexMap(oldArr, null, oldDataKeyArr, '_oldKeyGetter');
+    this._initIndexMap(newArr, newDataIndexMap, newDataKeyArr, '_newKeyGetter');
+    for (var i = 0; i < oldArr.length; i++) {
+      var oldKey = oldDataKeyArr[i];
+      var newIdxMapVal = newDataIndexMap[oldKey];
+      var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal);
+      // idx can never be empty array here. see 'set null' logic below.
+      if (newIdxMapValLen > 1) {
+        // Consider there is duplicate key (for example, use dataItem.name as key).
+        // We should make sure every item in newArr and oldArr can be visited.
+        var newIdx = newIdxMapVal.shift();
+        if (newIdxMapVal.length === 1) {
+          newDataIndexMap[oldKey] = newIdxMapVal[0];
+        }
+        this._update && this._update(newIdx, i);
+      } else if (newIdxMapValLen === 1) {
+        newDataIndexMap[oldKey] = null;
+        this._update && this._update(newIdxMapVal, i);
+      } else {
+        this._remove && this._remove(i);
+      }
+    }
+    this._performRestAdd(newDataKeyArr, newDataIndexMap);
+  };
+  /**
+   * For example, consider the case:
+   * oldData: [o0, o1, o2, o3, o4, o5, o6, o7],
+   * newData: [n0, n1, n2, n3, n4, n5, n6, n7, n8],
+   * Where:
+   *     o0, o1, n0 has key 'a' (many to one)
+   *     o5, n4, n5, n6 has key 'b' (one to many)
+   *     o2, n1 has key 'c' (one to one)
+   *     n2, n3 has key 'd' (add)
+   *     o3, o4 has key 'e' (remove)
+   *     o6, o7, n7, n8 has key 'f' (many to many, treated as add and remove)
+   * Then:
+   *     (The order of the following directives are not ensured.)
+   *     this._updateManyToOne(n0, [o0, o1]);
+   *     this._updateOneToMany([n4, n5, n6], o5);
+   *     this._update(n1, o2);
+   *     this._remove(o3);
+   *     this._remove(o4);
+   *     this._remove(o6);
+   *     this._remove(o7);
+   *     this._add(n2);
+   *     this._add(n3);
+   *     this._add(n7);
+   *     this._add(n8);
+   */
+  DataDiffer.prototype._executeMultiple = function () {
+    var oldArr = this._old;
+    var newArr = this._new;
+    var oldDataIndexMap = {};
+    var newDataIndexMap = {};
+    var oldDataKeyArr = [];
+    var newDataKeyArr = [];
+    this._initIndexMap(oldArr, oldDataIndexMap, oldDataKeyArr, '_oldKeyGetter');
+    this._initIndexMap(newArr, newDataIndexMap, newDataKeyArr, '_newKeyGetter');
+    for (var i = 0; i < oldDataKeyArr.length; i++) {
+      var oldKey = oldDataKeyArr[i];
+      var oldIdxMapVal = oldDataIndexMap[oldKey];
+      var newIdxMapVal = newDataIndexMap[oldKey];
+      var oldIdxMapValLen = dataIndexMapValueLength(oldIdxMapVal);
+      var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal);
+      if (oldIdxMapValLen > 1 && newIdxMapValLen === 1) {
+        this._updateManyToOne && this._updateManyToOne(newIdxMapVal, oldIdxMapVal);
+        newDataIndexMap[oldKey] = null;
+      } else if (oldIdxMapValLen === 1 && newIdxMapValLen > 1) {
+        this._updateOneToMany && this._updateOneToMany(newIdxMapVal, oldIdxMapVal);
+        newDataIndexMap[oldKey] = null;
+      } else if (oldIdxMapValLen === 1 && newIdxMapValLen === 1) {
+        this._update && this._update(newIdxMapVal, oldIdxMapVal);
+        newDataIndexMap[oldKey] = null;
+      } else if (oldIdxMapValLen > 1 && newIdxMapValLen > 1) {
+        this._updateManyToMany && this._updateManyToMany(newIdxMapVal, oldIdxMapVal);
+        newDataIndexMap[oldKey] = null;
+      } else if (oldIdxMapValLen > 1) {
+        for (var i_1 = 0; i_1 < oldIdxMapValLen; i_1++) {
+          this._remove && this._remove(oldIdxMapVal[i_1]);
+        }
+      } else {
+        this._remove && this._remove(oldIdxMapVal);
+      }
+    }
+    this._performRestAdd(newDataKeyArr, newDataIndexMap);
+  };
+  DataDiffer.prototype._performRestAdd = function (newDataKeyArr, newDataIndexMap) {
+    for (var i = 0; i < newDataKeyArr.length; i++) {
+      var newKey = newDataKeyArr[i];
+      var newIdxMapVal = newDataIndexMap[newKey];
+      var idxMapValLen = dataIndexMapValueLength(newIdxMapVal);
+      if (idxMapValLen > 1) {
+        for (var j = 0; j < idxMapValLen; j++) {
+          this._add && this._add(newIdxMapVal[j]);
+        }
+      } else if (idxMapValLen === 1) {
+        this._add && this._add(newIdxMapVal);
+      }
+      // Support both `newDataKeyArr` are duplication removed or not removed.
+      newDataIndexMap[newKey] = null;
+    }
+  };
+  DataDiffer.prototype._initIndexMap = function (arr,
+  // Can be null.
+  map,
+  // In 'byKey', the output `keyArr` is duplication removed.
+  // In 'byIndex', the output `keyArr` is not duplication removed and
+  //     its indices are accurately corresponding to `arr`.
+  keyArr, keyGetterName) {
+    var cbModeMultiple = this._diffModeMultiple;
+    for (var i = 0; i < arr.length; i++) {
+      // Add prefix to avoid conflict with Object.prototype.
+      var key = '_ec_' + this[keyGetterName](arr[i], i);
+      if (!cbModeMultiple) {
+        keyArr[i] = key;
+      }
+      if (!map) {
+        continue;
+      }
+      var idxMapVal = map[key];
+      var idxMapValLen = dataIndexMapValueLength(idxMapVal);
+      if (idxMapValLen === 0) {
+        // Simple optimize: in most cases, one index has one key,
+        // do not need array.
+        map[key] = i;
+        if (cbModeMultiple) {
+          keyArr.push(key);
+        }
+      } else if (idxMapValLen === 1) {
+        map[key] = [idxMapVal, i];
+      } else {
+        idxMapVal.push(i);
+      }
+    }
+  };
+  return DataDiffer;
+}();
+
+export { DataDiffer as default };