@newview/file-ui 1.1.14 → 1.1.15

package/dist/file-ui.js

@@ -6,11 +6,10 @@ var __publicField = (obj, key, value) => {
 };
 import { BaseInstance } from "@newview/base-vue";
 import { defineComponent, ref, watch, resolveComponent, openBlock, createElementBlock, Fragment, createVNode, withCtx, createElementVNode, reactive, renderList, createBlock, createSlots, normalizeClass, withModifiers, createCommentVNode, toDisplayString, createTextVNode, pushScopeId, popScopeId, onMounted, onBeforeUnmount, nextTick, h, watchEffect, normalizeStyle, withDirectives, vShow, vModelText } from "vue";
-import { QueryWrapper } from "@newview/infrastructure";
+import { QueryWrapper, storageInfo } from "@newview/infrastructure";
 import { OSSFileApi, FileApi, UploadApi, FileInfoApi } from "@newview/fileservice-api";
-import { loadDictionaryData } from "@newview/basics-ui";
-import { DataStructureApi, StructureInstanceApi } from "@newview/basics-api";
-import linq from "linq";
+import { DictionaryDetailApi, DataStructureApi, StructureInstanceApi } from "@newview/basics-api";
+import { utilities } from "@newview/tools";
 const propDefine$6 = {
   modelValue: {
     // 是否显示
@@ -15468,6 +15467,21 @@ function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
   }, 8, ["onlyView", "formItems", "formModel"]);
 }
 const ComFormUp = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["render", _sfc_render$3]]);
+const dictionaryDetailApi = new DictionaryDetailApi();
+const loadDictionaryData = async (optionCode, source, iViewOptions, platformId) => {
+  if (!source) {
+    source = [];
+  }
+  if (utilities.isNull(platformId)) {
+    platformId = storageInfo.getCurrentPlatform().Id;
+  }
+  const res = utilities.parseApiResult(await dictionaryDetailApi.getOptions(platformId, optionCode));
+  if (iViewOptions) {
+    source.splice(0, 0, ...utilities.arrayHelper.parseIViewOptions(res, "DetailInfor", "DetailValue"));
+    return source;
+  }
+  return res;
+};
 const propDefine$2 = {
   code: {
     // 字典码
@@ -15547,6 +15561,2663 @@ function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
   }, 8, ["disabled", "modelValue", "onOnChange"]);
 }
 const NvDicSelect = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$2]]);
+var Functions = {
+  Identity: function(x) {
+    return x;
+  },
+  True: function() {
+    return true;
+  },
+  Blank: function() {
+  }
+};
+var Types = {
+  Boolean: "boolean",
+  Number: "number",
+  String: "string",
+  Object: typeof {},
+  Undefined: "undefined",
+  Function: "function"
+};
+var funcCache = { "": Functions.Identity };
+var Utils = {
+  createLambda: function(expression) {
+    if (expression == null)
+      return Functions.Identity;
+    if (typeof expression === Types.String) {
+      let f = funcCache[expression];
+      if (f != null) {
+        return f;
+      }
+      if (expression.indexOf("=>") === -1) {
+        const regexp = new RegExp("[$]+", "g");
+        let maxLength = 0;
+        let match;
+        while ((match = regexp.exec(expression)) != null) {
+          if (match[0].length > maxLength) {
+            maxLength = match[0].length;
+          }
+        }
+        const argArray = [];
+        for (let i = 1; i <= maxLength; i++) {
+          let dollar = "";
+          for (let j = 0; j < i; j++) {
+            dollar += "$";
+          }
+          argArray.push(dollar);
+        }
+        const args = argArray.join(",");
+        f = new Function(args, "return " + expression);
+        funcCache[expression] = f;
+        return f;
+      } else {
+        const expr = expression.match(/^[(\s]*([^()]*?)[)\s]*=>(.*)/);
+        f = new Function(expr[1], expr[2].match(/\breturn\b/) ? expr[2] : "return " + expr[2]);
+        funcCache[expression] = f;
+        return f;
+      }
+    }
+    return expression;
+  },
+  defineProperty: function(target, methodName, value) {
+    Object.defineProperty(target, methodName, {
+      enumerable: false,
+      configurable: true,
+      writable: true,
+      value
+    });
+  },
+  compare: function(a, b) {
+    return a === b ? 0 : a > b ? 1 : -1;
+  },
+  dispose: function(obj) {
+    if (obj != null)
+      obj.dispose();
+  },
+  hasNativeIteratorSupport: function() {
+    return typeof Symbol !== "undefined" && typeof Symbol.iterator !== "undefined";
+  }
+};
+var State = { Before: 0, Running: 1, After: 2 };
+var IEnumerator = function(initialize, tryGetNext, dispose) {
+  var yielder = new Yielder();
+  var state = State.Before;
+  this.current = yielder.current;
+  this.moveNext = function() {
+    try {
+      switch (state) {
+        case State.Before:
+          state = State.Running;
+          initialize();
+        case State.Running:
+          if (tryGetNext.apply(yielder)) {
+            return true;
+          } else {
+            this.dispose();
+            return false;
+          }
+        case State.After:
+          return false;
+      }
+    } catch (e) {
+      this.dispose();
+      throw e;
+    }
+  };
+  this.dispose = function() {
+    if (state != State.Running)
+      return;
+    try {
+      dispose();
+    } finally {
+      state = State.After;
+    }
+  };
+};
+var Yielder = function() {
+  var current = null;
+  this.current = function() {
+    return current;
+  };
+  this.yieldReturn = function(value) {
+    current = value;
+    return true;
+  };
+  this.yieldBreak = function() {
+    return false;
+  };
+};
+var Enumerable = function(getEnumerator) {
+  this.getEnumerator = getEnumerator;
+};
+Enumerable.Utils = {};
+Enumerable.Utils.createLambda = function(expression) {
+  return Utils.createLambda(expression);
+};
+Enumerable.Utils.createEnumerable = function(getEnumerator) {
+  return new Enumerable(getEnumerator);
+};
+Enumerable.Utils.createEnumerator = function(initialize, tryGetNext, dispose) {
+  return new IEnumerator(initialize, tryGetNext, dispose);
+};
+Enumerable.Utils.extendTo = function(type) {
+  var typeProto = type.prototype;
+  var enumerableProto;
+  if (type === Array) {
+    enumerableProto = ArrayEnumerable.prototype;
+    Utils.defineProperty(typeProto, "getSource", function() {
+      return this;
+    });
+  } else {
+    enumerableProto = Enumerable.prototype;
+    Utils.defineProperty(typeProto, "getEnumerator", function() {
+      return Enumerable.from(this).getEnumerator();
+    });
+  }
+  for (let methodName in enumerableProto) {
+    const func = enumerableProto[methodName];
+    if (typeProto[methodName] == func)
+      continue;
+    if (typeProto[methodName] != null) {
+      methodName = methodName + "ByLinq";
+      if (typeProto[methodName] == func)
+        continue;
+    }
+    if (func instanceof Function) {
+      Utils.defineProperty(typeProto, methodName, func);
+    }
+  }
+};
+Enumerable.Utils.recallFrom = function(type) {
+  var typeProto = type.prototype;
+  var enumerableProto;
+  if (type === Array) {
+    enumerableProto = ArrayEnumerable.prototype;
+    delete typeProto.getSource;
+  } else {
+    enumerableProto = Enumerable.prototype;
+    delete typeProto.getEnumerator;
+  }
+  for (const methodName in enumerableProto) {
+    const func = enumerableProto[methodName];
+    if (typeProto[methodName + "ByLinq"]) {
+      delete typeProto[methodName + "ByLinq"];
+    } else if (typeProto[methodName] == func && func instanceof Function) {
+      delete typeProto[methodName];
+    }
+  }
+};
+Enumerable.choice = function() {
+  var args = arguments;
+  return new Enumerable(function() {
+    return new IEnumerator(
+      function() {
+        args = args[0] instanceof Array ? args[0] : args[0].getEnumerator != null ? args[0].toArray() : args;
+      },
+      function() {
+        return this.yieldReturn(args[Math.floor(Math.random() * args.length)]);
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.cycle = function() {
+  var args = arguments;
+  return new Enumerable(function() {
+    var index = 0;
+    return new IEnumerator(
+      function() {
+        args = args[0] instanceof Array ? args[0] : args[0].getEnumerator != null ? args[0].toArray() : args;
+      },
+      function() {
+        if (index >= args.length)
+          index = 0;
+        return this.yieldReturn(args[index++]);
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.empty = function() {
+  return new Enumerable(function() {
+    return new IEnumerator(
+      Functions.Blank,
+      function() {
+        return false;
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.from = function(obj) {
+  if (obj == null) {
+    return Enumerable.empty();
+  }
+  if (obj instanceof Enumerable) {
+    return obj;
+  }
+  if (typeof obj == Types.Number || typeof obj == Types.Boolean) {
+    return Enumerable.repeat(obj, 1);
+  }
+  if (typeof obj == Types.String) {
+    return new Enumerable(function() {
+      var index = 0;
+      return new IEnumerator(
+        Functions.Blank,
+        function() {
+          return index < obj.length ? this.yieldReturn(obj.charAt(index++)) : false;
+        },
+        Functions.Blank
+      );
+    });
+  }
+  if (typeof obj != Types.Function) {
+    if (typeof obj.length == Types.Number) {
+      return new ArrayEnumerable(obj);
+    }
+    if (typeof Symbol !== "undefined" && typeof obj[Symbol.iterator] !== "undefined") {
+      return new Enumerable(function() {
+        return new IEnumerator(
+          Functions.Blank,
+          function() {
+            var next = obj.next();
+            return next.done ? false : this.yieldReturn(next.value);
+          },
+          Functions.Blank
+        );
+      });
+    }
+  }
+  return new Enumerable(function() {
+    var array = [];
+    var index = 0;
+    return new IEnumerator(
+      function() {
+        for (const key in obj) {
+          const value = obj[key];
+          if (!(value instanceof Function) && Object.prototype.hasOwnProperty.call(obj, key)) {
+            array.push({ key, value });
+          }
+        }
+      },
+      function() {
+        return index < array.length ? this.yieldReturn(array[index++]) : false;
+      },
+      Functions.Blank
+    );
+  });
+}, Enumerable.make = function(element) {
+  return Enumerable.repeat(element, 1);
+};
+Enumerable.matches = function(input, pattern, flags) {
+  if (flags == null)
+    flags = "";
+  if (pattern instanceof RegExp) {
+    flags += pattern.ignoreCase ? "i" : "";
+    flags += pattern.multiline ? "m" : "";
+    pattern = pattern.source;
+  }
+  if (flags.indexOf("g") === -1)
+    flags += "g";
+  return new Enumerable(function() {
+    var regex;
+    return new IEnumerator(
+      function() {
+        regex = new RegExp(pattern, flags);
+      },
+      function() {
+        var match = regex.exec(input);
+        return match ? this.yieldReturn(match) : false;
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.range = function(start, count, step) {
+  if (step == null)
+    step = 1;
+  return new Enumerable(function() {
+    var value;
+    var index = 0;
+    return new IEnumerator(
+      function() {
+        value = start - step;
+      },
+      function() {
+        return index++ < count ? this.yieldReturn(value += step) : this.yieldBreak();
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.rangeDown = function(start, count, step) {
+  if (step == null)
+    step = 1;
+  return new Enumerable(function() {
+    var value;
+    var index = 0;
+    return new IEnumerator(
+      function() {
+        value = start + step;
+      },
+      function() {
+        return index++ < count ? this.yieldReturn(value -= step) : this.yieldBreak();
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.rangeTo = function(start, to, step) {
+  if (step == null)
+    step = 1;
+  if (start < to) {
+    return new Enumerable(function() {
+      var value;
+      return new IEnumerator(
+        function() {
+          value = start - step;
+        },
+        function() {
+          var next = value += step;
+          return next <= to ? this.yieldReturn(next) : this.yieldBreak();
+        },
+        Functions.Blank
+      );
+    });
+  } else {
+    return new Enumerable(function() {
+      var value;
+      return new IEnumerator(
+        function() {
+          value = start + step;
+        },
+        function() {
+          var next = value -= step;
+          return next >= to ? this.yieldReturn(next) : this.yieldBreak();
+        },
+        Functions.Blank
+      );
+    });
+  }
+};
+Enumerable.repeat = function(element, count) {
+  if (count != null)
+    return Enumerable.repeat(element).take(count);
+  return new Enumerable(function() {
+    return new IEnumerator(
+      Functions.Blank,
+      function() {
+        return this.yieldReturn(element);
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.repeatWithFinalize = function(initializer, finalizer) {
+  initializer = Utils.createLambda(initializer);
+  finalizer = Utils.createLambda(finalizer);
+  return new Enumerable(function() {
+    var element;
+    return new IEnumerator(
+      function() {
+        element = initializer();
+      },
+      function() {
+        return this.yieldReturn(element);
+      },
+      function() {
+        if (element != null) {
+          finalizer(element);
+          element = null;
+        }
+      }
+    );
+  });
+};
+Enumerable.generate = function(func, count) {
+  if (count != null)
+    return Enumerable.generate(func).take(count);
+  func = Utils.createLambda(func);
+  return new Enumerable(function() {
+    return new IEnumerator(
+      Functions.Blank,
+      function() {
+        return this.yieldReturn(func());
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.toInfinity = function(start, step) {
+  if (start == null)
+    start = 0;
+  if (step == null)
+    step = 1;
+  return new Enumerable(function() {
+    var value;
+    return new IEnumerator(
+      function() {
+        value = start - step;
+      },
+      function() {
+        return this.yieldReturn(value += step);
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.toNegativeInfinity = function(start, step) {
+  if (start == null)
+    start = 0;
+  if (step == null)
+    step = 1;
+  return new Enumerable(function() {
+    var value;
+    return new IEnumerator(
+      function() {
+        value = start + step;
+      },
+      function() {
+        return this.yieldReturn(value -= step);
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.unfold = function(seed, func) {
+  func = Utils.createLambda(func);
+  return new Enumerable(function() {
+    var isFirst = true;
+    var value;
+    return new IEnumerator(
+      Functions.Blank,
+      function() {
+        if (isFirst) {
+          isFirst = false;
+          value = seed;
+          return this.yieldReturn(value);
+        }
+        value = func(value);
+        return this.yieldReturn(value);
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.defer = function(enumerableFactory) {
+  return new Enumerable(function() {
+    var enumerator;
+    return new IEnumerator(
+      function() {
+        enumerator = Enumerable.from(enumerableFactory()).getEnumerator();
+      },
+      function() {
+        return enumerator.moveNext() ? this.yieldReturn(enumerator.current()) : this.yieldBreak();
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.traverseBreadthFirst = function(func, resultSelector) {
+  var source = this;
+  func = Utils.createLambda(func);
+  resultSelector = Utils.createLambda(resultSelector);
+  return new Enumerable(function() {
+    var enumerator;
+    var nestLevel = 0;
+    var buffer = [];
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        while (true) {
+          if (enumerator.moveNext()) {
+            buffer.push(enumerator.current());
+            return this.yieldReturn(resultSelector(enumerator.current(), nestLevel));
+          }
+          const next = Enumerable.from(buffer).selectMany(function(x) {
+            return func(x);
+          });
+          if (!next.any()) {
+            return false;
+          } else {
+            nestLevel++;
+            buffer = [];
+            Utils.dispose(enumerator);
+            enumerator = next.getEnumerator();
+          }
+        }
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.traverseDepthFirst = function(func, resultSelector) {
+  var source = this;
+  func = Utils.createLambda(func);
+  resultSelector = Utils.createLambda(resultSelector);
+  return new Enumerable(function() {
+    var enumeratorStack = [];
+    var enumerator;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        while (true) {
+          if (enumerator.moveNext()) {
+            const value = resultSelector(enumerator.current(), enumeratorStack.length);
+            enumeratorStack.push(enumerator);
+            enumerator = Enumerable.from(func(enumerator.current())).getEnumerator();
+            return this.yieldReturn(value);
+          }
+          if (enumeratorStack.length <= 0)
+            return false;
+          Utils.dispose(enumerator);
+          enumerator = enumeratorStack.pop();
+        }
+      },
+      function() {
+        try {
+          Utils.dispose(enumerator);
+        } finally {
+          Enumerable.from(enumeratorStack).forEach(function(s) {
+            s.dispose();
+          });
+        }
+      }
+    );
+  });
+};
+Enumerable.prototype.flatten = function() {
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    var middleEnumerator = null;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        while (true) {
+          if (middleEnumerator != null) {
+            if (middleEnumerator.moveNext()) {
+              return this.yieldReturn(middleEnumerator.current());
+            } else {
+              middleEnumerator = null;
+            }
+          }
+          if (enumerator.moveNext()) {
+            if (enumerator.current() instanceof Array) {
+              Utils.dispose(middleEnumerator);
+              middleEnumerator = Enumerable.from(enumerator.current()).selectMany(Functions.Identity).flatten().getEnumerator();
+              continue;
+            } else {
+              return this.yieldReturn(enumerator.current());
+            }
+          }
+          return false;
+        }
+      },
+      function() {
+        try {
+          Utils.dispose(enumerator);
+        } finally {
+          Utils.dispose(middleEnumerator);
+        }
+      }
+    );
+  });
+};
+Enumerable.prototype.pairwise = function(selector) {
+  var source = this;
+  selector = Utils.createLambda(selector);
+  return new Enumerable(function() {
+    var enumerator;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+        enumerator.moveNext();
+      },
+      function() {
+        var prev = enumerator.current();
+        return enumerator.moveNext() ? this.yieldReturn(selector(prev, enumerator.current())) : false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.scan = function(seed, func) {
+  var isUseSeed;
+  if (func == null) {
+    func = Utils.createLambda(seed);
+    isUseSeed = false;
+  } else {
+    func = Utils.createLambda(func);
+    isUseSeed = true;
+  }
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    var value;
+    var isFirst = true;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        if (isFirst) {
+          isFirst = false;
+          if (!isUseSeed) {
+            if (enumerator.moveNext()) {
+              return this.yieldReturn(value = enumerator.current());
+            }
+          } else {
+            return this.yieldReturn(value = seed);
+          }
+        }
+        return enumerator.moveNext() ? this.yieldReturn(value = func(value, enumerator.current())) : false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.select = function(selector) {
+  selector = Utils.createLambda(selector);
+  if (selector.length <= 1) {
+    return new WhereSelectEnumerable(this, null, selector);
+  } else {
+    var source = this;
+    return new Enumerable(function() {
+      var enumerator;
+      var index = 0;
+      return new IEnumerator(
+        function() {
+          enumerator = source.getEnumerator();
+        },
+        function() {
+          return enumerator.moveNext() ? this.yieldReturn(selector(enumerator.current(), index++)) : false;
+        },
+        function() {
+          Utils.dispose(enumerator);
+        }
+      );
+    });
+  }
+};
+Enumerable.prototype.selectMany = function(collectionSelector, resultSelector) {
+  var source = this;
+  collectionSelector = Utils.createLambda(collectionSelector);
+  if (resultSelector == null)
+    resultSelector = function(a, b) {
+      return b;
+    };
+  resultSelector = Utils.createLambda(resultSelector);
+  return new Enumerable(function() {
+    var enumerator;
+    var middleEnumerator = void 0;
+    var index = 0;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        if (middleEnumerator === void 0) {
+          if (!enumerator.moveNext())
+            return false;
+        }
+        do {
+          if (middleEnumerator == null) {
+            const middleSeq = collectionSelector(enumerator.current(), index++);
+            middleEnumerator = Enumerable.from(middleSeq).getEnumerator();
+          }
+          if (middleEnumerator.moveNext()) {
+            return this.yieldReturn(resultSelector(enumerator.current(), middleEnumerator.current()));
+          }
+          Utils.dispose(middleEnumerator);
+          middleEnumerator = null;
+        } while (enumerator.moveNext());
+        return false;
+      },
+      function() {
+        try {
+          Utils.dispose(enumerator);
+        } finally {
+          Utils.dispose(middleEnumerator);
+        }
+      }
+    );
+  });
+};
+Enumerable.prototype.where = function(predicate) {
+  predicate = Utils.createLambda(predicate);
+  if (predicate.length <= 1) {
+    return new WhereEnumerable(this, predicate);
+  } else {
+    var source = this;
+    return new Enumerable(function() {
+      var enumerator;
+      var index = 0;
+      return new IEnumerator(
+        function() {
+          enumerator = source.getEnumerator();
+        },
+        function() {
+          while (enumerator.moveNext()) {
+            if (predicate(enumerator.current(), index++)) {
+              return this.yieldReturn(enumerator.current());
+            }
+          }
+          return false;
+        },
+        function() {
+          Utils.dispose(enumerator);
+        }
+      );
+    });
+  }
+};
+Enumerable.prototype.choose = function(selector) {
+  selector = Utils.createLambda(selector);
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    var index = 0;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        while (enumerator.moveNext()) {
+          const result = selector(enumerator.current(), index++);
+          if (result != null) {
+            return this.yieldReturn(result);
+          }
+        }
+        return this.yieldBreak();
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.ofType = function(type) {
+  var typeName;
+  switch (type) {
+    case Number:
+      typeName = Types.Number;
+      break;
+    case String:
+      typeName = Types.String;
+      break;
+    case Boolean:
+      typeName = Types.Boolean;
+      break;
+    case Function:
+      typeName = Types.Function;
+      break;
+    default:
+      typeName = null;
+      break;
+  }
+  return typeName === null ? this.where(function(x) {
+    return x instanceof type;
+  }) : this.where(function(x) {
+    return typeof x === typeName;
+  });
+};
+Enumerable.prototype.zip = function() {
+  var args = arguments;
+  var selector = Utils.createLambda(arguments[arguments.length - 1]);
+  var source = this;
+  if (arguments.length == 2) {
+    const second = arguments[0];
+    return new Enumerable(function() {
+      var firstEnumerator;
+      var secondEnumerator;
+      var index = 0;
+      return new IEnumerator(
+        function() {
+          firstEnumerator = source.getEnumerator();
+          secondEnumerator = Enumerable.from(second).getEnumerator();
+        },
+        function() {
+          if (firstEnumerator.moveNext() && secondEnumerator.moveNext()) {
+            return this.yieldReturn(selector(firstEnumerator.current(), secondEnumerator.current(), index++));
+          }
+          return false;
+        },
+        function() {
+          try {
+            Utils.dispose(firstEnumerator);
+          } finally {
+            Utils.dispose(secondEnumerator);
+          }
+        }
+      );
+    });
+  } else {
+    return new Enumerable(function() {
+      var enumerators;
+      var index = 0;
+      return new IEnumerator(
+        function() {
+          var array = Enumerable.make(source).concat(Enumerable.from(args).takeExceptLast().select(Enumerable.from)).select(function(x) {
+            return x.getEnumerator();
+          }).toArray();
+          enumerators = Enumerable.from(array);
+        },
+        function() {
+          if (enumerators.all(function(x) {
+            return x.moveNext();
+          })) {
+            const array = enumerators.select(function(x) {
+              return x.current();
+            }).toArray();
+            array.push(index++);
+            return this.yieldReturn(selector.apply(null, array));
+          } else {
+            return this.yieldBreak();
+          }
+        },
+        function() {
+          Enumerable.from(enumerators).forEach(Utils.dispose);
+        }
+      );
+    });
+  }
+};
+Enumerable.prototype.merge = function() {
+  var args = arguments;
+  var source = this;
+  return new Enumerable(function() {
+    var enumerators;
+    var index = -1;
+    return new IEnumerator(
+      function() {
+        enumerators = Enumerable.make(source).concat(Enumerable.from(args).select(Enumerable.from)).select(function(x) {
+          return x.getEnumerator();
+        }).toArray();
+      },
+      function() {
+        while (enumerators.length > 0) {
+          index = index >= enumerators.length - 1 ? 0 : index + 1;
+          const enumerator = enumerators[index];
+          if (enumerator.moveNext()) {
+            return this.yieldReturn(enumerator.current());
+          } else {
+            enumerator.dispose();
+            enumerators.splice(index--, 1);
+          }
+        }
+        return this.yieldBreak();
+      },
+      function() {
+        Enumerable.from(enumerators).forEach(Utils.dispose);
+      }
+    );
+  });
+};
+Enumerable.prototype.join = function(inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {
+  outerKeySelector = Utils.createLambda(outerKeySelector);
+  innerKeySelector = Utils.createLambda(innerKeySelector);
+  resultSelector = Utils.createLambda(resultSelector);
+  compareSelector = Utils.createLambda(compareSelector);
+  var source = this;
+  return new Enumerable(function() {
+    var outerEnumerator;
+    var lookup;
+    var innerElements = null;
+    var innerCount = 0;
+    return new IEnumerator(
+      function() {
+        outerEnumerator = source.getEnumerator();
+        lookup = Enumerable.from(inner).toLookup(innerKeySelector, Functions.Identity, compareSelector);
+      },
+      function() {
+        while (true) {
+          if (innerElements != null) {
+            let innerElement = innerElements[innerCount++];
+            if (innerElement !== void 0) {
+              return this.yieldReturn(resultSelector(outerEnumerator.current(), innerElement));
+            }
+            innerElement = null;
+            innerCount = 0;
+          }
+          if (outerEnumerator.moveNext()) {
+            const key = outerKeySelector(outerEnumerator.current());
+            innerElements = lookup.get(key).toArray();
+          } else {
+            return false;
+          }
+        }
+      },
+      function() {
+        Utils.dispose(outerEnumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.leftJoin = function(inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {
+  outerKeySelector = Utils.createLambda(outerKeySelector);
+  innerKeySelector = Utils.createLambda(innerKeySelector);
+  resultSelector = Utils.createLambda(resultSelector);
+  compareSelector = Utils.createLambda(compareSelector);
+  var source = this;
+  return new Enumerable(function() {
+    var outerEnumerator;
+    var lookup;
+    var innerElements = null;
+    var innerCount = 0;
+    return new IEnumerator(
+      function() {
+        outerEnumerator = source.getEnumerator();
+        lookup = Enumerable.from(inner).toLookup(innerKeySelector, Functions.Identity, compareSelector);
+      },
+      function() {
+        while (true) {
+          if (innerElements != null) {
+            let innerElement = innerElements[innerCount++];
+            if (innerElement !== void 0) {
+              return this.yieldReturn(resultSelector(outerEnumerator.current(), innerElement));
+            }
+            innerElement = null;
+            innerCount = 0;
+          }
+          if (outerEnumerator.moveNext()) {
+            const key = outerKeySelector(outerEnumerator.current());
+            innerElements = lookup.get(key).toArray();
+            if (innerElements == null || innerElements.length == 0) {
+              return this.yieldReturn(resultSelector(outerEnumerator.current(), null));
+            }
+          } else {
+            return false;
+          }
+        }
+      },
+      function() {
+        Utils.dispose(outerEnumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.groupJoin = function(inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {
+  outerKeySelector = Utils.createLambda(outerKeySelector);
+  innerKeySelector = Utils.createLambda(innerKeySelector);
+  resultSelector = Utils.createLambda(resultSelector);
+  compareSelector = Utils.createLambda(compareSelector);
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator = source.getEnumerator();
+    var lookup = null;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+        lookup = Enumerable.from(inner).toLookup(innerKeySelector, Functions.Identity, compareSelector);
+      },
+      function() {
+        if (enumerator.moveNext()) {
+          const innerElement = lookup.get(outerKeySelector(enumerator.current()));
+          return this.yieldReturn(resultSelector(enumerator.current(), innerElement));
+        }
+        return false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.all = function(predicate) {
+  predicate = Utils.createLambda(predicate);
+  var result = true;
+  this.forEach(function(x) {
+    if (!predicate(x)) {
+      result = false;
+      return false;
+    }
+  });
+  return result;
+};
+Enumerable.prototype.any = function(predicate) {
+  predicate = Utils.createLambda(predicate);
+  var enumerator = this.getEnumerator();
+  try {
+    if (arguments.length == 0)
+      return enumerator.moveNext();
+    while (enumerator.moveNext()) {
+      if (predicate(enumerator.current()))
+        return true;
+    }
+    return false;
+  } finally {
+    Utils.dispose(enumerator);
+  }
+};
+Enumerable.prototype.isEmpty = function() {
+  return !this.any();
+};
+Enumerable.prototype.concat = function() {
+  var source = this;
+  if (arguments.length == 1) {
+    const second = arguments[0];
+    return new Enumerable(function() {
+      var firstEnumerator;
+      var secondEnumerator;
+      return new IEnumerator(
+        function() {
+          firstEnumerator = source.getEnumerator();
+        },
+        function() {
+          if (secondEnumerator == null) {
+            if (firstEnumerator.moveNext())
+              return this.yieldReturn(firstEnumerator.current());
+            secondEnumerator = Enumerable.from(second).getEnumerator();
+          }
+          if (secondEnumerator.moveNext())
+            return this.yieldReturn(secondEnumerator.current());
+          return false;
+        },
+        function() {
+          try {
+            Utils.dispose(firstEnumerator);
+          } finally {
+            Utils.dispose(secondEnumerator);
+          }
+        }
+      );
+    });
+  } else {
+    const args = arguments;
+    return new Enumerable(function() {
+      var enumerators;
+      return new IEnumerator(
+        function() {
+          enumerators = Enumerable.make(source).concat(Enumerable.from(args).select(Enumerable.from)).select(function(x) {
+            return x.getEnumerator();
+          }).toArray();
+        },
+        function() {
+          while (enumerators.length > 0) {
+            const enumerator = enumerators[0];
+            if (enumerator.moveNext()) {
+              return this.yieldReturn(enumerator.current());
+            } else {
+              enumerator.dispose();
+              enumerators.splice(0, 1);
+            }
+          }
+          return this.yieldBreak();
+        },
+        function() {
+          Enumerable.from(enumerators).forEach(Utils.dispose);
+        }
+      );
+    });
+  }
+};
+Enumerable.prototype.insert = function(index, second) {
+  var source = this;
+  return new Enumerable(function() {
+    var firstEnumerator;
+    var secondEnumerator;
+    var count = 0;
+    var isEnumerated = false;
+    return new IEnumerator(
+      function() {
+        firstEnumerator = source.getEnumerator();
+        secondEnumerator = Enumerable.from(second).getEnumerator();
+      },
+      function() {
+        if (count == index && secondEnumerator.moveNext()) {
+          isEnumerated = true;
+          return this.yieldReturn(secondEnumerator.current());
+        }
+        if (firstEnumerator.moveNext()) {
+          count++;
+          return this.yieldReturn(firstEnumerator.current());
+        }
+        if (!isEnumerated && secondEnumerator.moveNext()) {
+          return this.yieldReturn(secondEnumerator.current());
+        }
+        return false;
+      },
+      function() {
+        try {
+          Utils.dispose(firstEnumerator);
+        } finally {
+          Utils.dispose(secondEnumerator);
+        }
+      }
+    );
+  });
+};
+Enumerable.prototype.alternate = function(alternateValueOrSequence) {
+  var source = this;
+  return new Enumerable(function() {
+    var buffer;
+    var enumerator;
+    var alternateSequence;
+    var alternateEnumerator;
+    return new IEnumerator(
+      function() {
+        if (alternateValueOrSequence instanceof Array || alternateValueOrSequence.getEnumerator != null) {
+          alternateSequence = Enumerable.from(Enumerable.from(alternateValueOrSequence).toArray());
+        } else {
+          alternateSequence = Enumerable.make(alternateValueOrSequence);
+        }
+        enumerator = source.getEnumerator();
+        if (enumerator.moveNext())
+          buffer = enumerator.current();
+      },
+      function() {
+        while (true) {
+          if (alternateEnumerator != null) {
+            if (alternateEnumerator.moveNext()) {
+              return this.yieldReturn(alternateEnumerator.current());
+            } else {
+              alternateEnumerator = null;
+            }
+          }
+          if (buffer == null && enumerator.moveNext()) {
+            buffer = enumerator.current();
+            alternateEnumerator = alternateSequence.getEnumerator();
+            continue;
+          } else if (buffer != null) {
+            const retVal = buffer;
+            buffer = null;
+            return this.yieldReturn(retVal);
+          }
+          return this.yieldBreak();
+        }
+      },
+      function() {
+        try {
+          Utils.dispose(enumerator);
+        } finally {
+          Utils.dispose(alternateEnumerator);
+        }
+      }
+    );
+  });
+};
+Enumerable.prototype.contains = function(value, compareSelector) {
+  compareSelector = Utils.createLambda(compareSelector);
+  var enumerator = this.getEnumerator();
+  try {
+    while (enumerator.moveNext()) {
+      if (compareSelector(enumerator.current()) === value)
+        return true;
+    }
+    return false;
+  } finally {
+    Utils.dispose(enumerator);
+  }
+};
+Enumerable.prototype.defaultIfEmpty = function(defaultValue) {
+  var source = this;
+  if (defaultValue === void 0)
+    defaultValue = null;
+  return new Enumerable(function() {
+    var enumerator;
+    var isFirst = true;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        if (enumerator.moveNext()) {
+          isFirst = false;
+          return this.yieldReturn(enumerator.current());
+        } else if (isFirst) {
+          isFirst = false;
+          return this.yieldReturn(defaultValue);
+        }
+        return false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.distinct = function(compareSelector) {
+  return this.except(Enumerable.empty(), compareSelector);
+};
+Enumerable.prototype.distinctUntilChanged = function(compareSelector) {
+  compareSelector = Utils.createLambda(compareSelector);
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    var compareKey;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        while (enumerator.moveNext()) {
+          const key = compareSelector(enumerator.current());
+          if (compareKey === key) {
+            continue;
+          }
+          compareKey = key;
+          return this.yieldReturn(enumerator.current());
+        }
+        return this.yieldBreak();
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.except = function(second, compareSelector) {
+  compareSelector = Utils.createLambda(compareSelector);
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    var keys;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+        keys = new Dictionary(compareSelector);
+        Enumerable.from(second).forEach(function(key) {
+          keys.add(key);
+        });
+      },
+      function() {
+        while (enumerator.moveNext()) {
+          const current = enumerator.current();
+          if (!keys.contains(current)) {
+            keys.add(current);
+            return this.yieldReturn(current);
+          }
+        }
+        return false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.intersect = function(second, compareSelector) {
+  compareSelector = Utils.createLambda(compareSelector);
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    var keys;
+    var outs;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+        keys = new Dictionary(compareSelector);
+        Enumerable.from(second).forEach(function(key) {
+          keys.add(key);
+        });
+        outs = new Dictionary(compareSelector);
+      },
+      function() {
+        while (enumerator.moveNext()) {
+          const current = enumerator.current();
+          if (!outs.contains(current) && keys.contains(current)) {
+            outs.add(current);
+            return this.yieldReturn(current);
+          }
+        }
+        return false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.sequenceEqual = function(second, compareSelector) {
+  compareSelector = Utils.createLambda(compareSelector);
+  var firstEnumerator = this.getEnumerator();
+  try {
+    const secondEnumerator = Enumerable.from(second).getEnumerator();
+    try {
+      while (firstEnumerator.moveNext()) {
+        if (!secondEnumerator.moveNext() || compareSelector(firstEnumerator.current()) !== compareSelector(secondEnumerator.current())) {
+          return false;
+        }
+      }
+      if (secondEnumerator.moveNext())
+        return false;
+      return true;
+    } finally {
+      Utils.dispose(secondEnumerator);
+    }
+  } finally {
+    Utils.dispose(firstEnumerator);
+  }
+};
+Enumerable.prototype.union = function(second, compareSelector) {
+  compareSelector = Utils.createLambda(compareSelector);
+  var source = this;
+  return new Enumerable(function() {
+    var firstEnumerator;
+    var secondEnumerator;
+    var keys;
+    return new IEnumerator(
+      function() {
+        firstEnumerator = source.getEnumerator();
+        keys = new Dictionary(compareSelector);
+      },
+      function() {
+        var current;
+        if (secondEnumerator === void 0) {
+          while (firstEnumerator.moveNext()) {
+            current = firstEnumerator.current();
+            if (!keys.contains(current)) {
+              keys.add(current);
+              return this.yieldReturn(current);
+            }
+          }
+          secondEnumerator = Enumerable.from(second).getEnumerator();
+        }
+        while (secondEnumerator.moveNext()) {
+          current = secondEnumerator.current();
+          if (!keys.contains(current)) {
+            keys.add(current);
+            return this.yieldReturn(current);
+          }
+        }
+        return false;
+      },
+      function() {
+        try {
+          Utils.dispose(firstEnumerator);
+        } finally {
+          Utils.dispose(secondEnumerator);
+        }
+      }
+    );
+  });
+};
+Enumerable.prototype.orderBy = function(keySelector, comparer) {
+  return new OrderedEnumerable(this, keySelector, comparer, false);
+};
+Enumerable.prototype.orderByDescending = function(keySelector, comparer) {
+  return new OrderedEnumerable(this, keySelector, comparer, true);
+};
+Enumerable.prototype.reverse = function() {
+  var source = this;
+  return new Enumerable(function() {
+    var buffer;
+    var index;
+    return new IEnumerator(
+      function() {
+        buffer = source.toArray();
+        index = buffer.length;
+      },
+      function() {
+        return index > 0 ? this.yieldReturn(buffer[--index]) : false;
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.prototype.shuffle = function() {
+  var source = this;
+  return new Enumerable(function() {
+    var buffer;
+    return new IEnumerator(
+      function() {
+        buffer = source.toArray();
+      },
+      function() {
+        if (buffer.length > 0) {
+          const i = Math.floor(Math.random() * buffer.length);
+          return this.yieldReturn(buffer.splice(i, 1)[0]);
+        }
+        return false;
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.prototype.weightedSample = function(weightSelector) {
+  weightSelector = Utils.createLambda(weightSelector);
+  var source = this;
+  return new Enumerable(function() {
+    var sortedByBound;
+    var totalWeight = 0;
+    return new IEnumerator(
+      function() {
+        sortedByBound = source.choose(function(x) {
+          var weight = weightSelector(x);
+          if (weight <= 0)
+            return null;
+          totalWeight += weight;
+          return { value: x, bound: totalWeight };
+        }).toArray();
+      },
+      function() {
+        if (sortedByBound.length > 0) {
+          const draw = Math.floor(Math.random() * totalWeight) + 1;
+          let lower = -1;
+          let upper = sortedByBound.length;
+          while (upper - lower > 1) {
+            const index = Math.floor((lower + upper) / 2);
+            if (sortedByBound[index].bound >= draw) {
+              upper = index;
+            } else {
+              lower = index;
+            }
+          }
+          return this.yieldReturn(sortedByBound[upper].value);
+        }
+        return this.yieldBreak();
+      },
+      Functions.Blank
+    );
+  });
+};
+Enumerable.prototype.groupBy = function(keySelector, elementSelector, resultSelector, compareSelector) {
+  var source = this;
+  keySelector = Utils.createLambda(keySelector);
+  elementSelector = Utils.createLambda(elementSelector);
+  if (resultSelector != null)
+    resultSelector = Utils.createLambda(resultSelector);
+  compareSelector = Utils.createLambda(compareSelector);
+  return new Enumerable(function() {
+    var enumerator;
+    return new IEnumerator(
+      function() {
+        enumerator = source.toLookup(keySelector, elementSelector, compareSelector).toEnumerable().getEnumerator();
+      },
+      function() {
+        while (enumerator.moveNext()) {
+          return resultSelector == null ? this.yieldReturn(enumerator.current()) : this.yieldReturn(resultSelector(enumerator.current().key(), enumerator.current()));
+        }
+        return false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.partitionBy = function(keySelector, elementSelector, resultSelector, compareSelector) {
+  var source = this;
+  keySelector = Utils.createLambda(keySelector);
+  elementSelector = Utils.createLambda(elementSelector);
+  compareSelector = Utils.createLambda(compareSelector);
+  var hasResultSelector;
+  if (resultSelector == null) {
+    hasResultSelector = false;
+    resultSelector = function(key, group) {
+      return new Grouping(key, group);
+    };
+  } else {
+    hasResultSelector = true;
+    resultSelector = Utils.createLambda(resultSelector);
+  }
+  return new Enumerable(function() {
+    var enumerator;
+    var key;
+    var compareKey;
+    var group = [];
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+        if (enumerator.moveNext()) {
+          key = keySelector(enumerator.current());
+          compareKey = compareSelector(key);
+          group.push(elementSelector(enumerator.current()));
+        }
+      },
+      function() {
+        var hasNext;
+        while ((hasNext = enumerator.moveNext()) == true) {
+          if (compareKey === compareSelector(keySelector(enumerator.current()))) {
+            group.push(elementSelector(enumerator.current()));
+          } else
+            break;
+        }
+        if (group.length > 0) {
+          const result = hasResultSelector ? resultSelector(key, Enumerable.from(group)) : resultSelector(key, group);
+          if (hasNext) {
+            key = keySelector(enumerator.current());
+            compareKey = compareSelector(key);
+            group = [elementSelector(enumerator.current())];
+          } else
+            group = [];
+          return this.yieldReturn(result);
+        }
+        return false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.buffer = function(count) {
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        var array = [];
+        var index = 0;
+        while (enumerator.moveNext()) {
+          array.push(enumerator.current());
+          if (++index >= count)
+            return this.yieldReturn(array);
+        }
+        if (array.length > 0)
+          return this.yieldReturn(array);
+        return false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.aggregate = function(seed, func, resultSelector) {
+  resultSelector = Utils.createLambda(resultSelector);
+  return resultSelector(this.scan(seed, func, resultSelector).last());
+};
+Enumerable.prototype.average = function(selector) {
+  selector = Utils.createLambda(selector);
+  var sum = 0;
+  var count = 0;
+  this.forEach(function(x) {
+    sum += selector(x);
+    ++count;
+  });
+  return sum / count;
+};
+Enumerable.prototype.count = function(predicate) {
+  predicate = predicate == null ? Functions.True : Utils.createLambda(predicate);
+  var count = 0;
+  this.forEach(function(x, i) {
+    if (predicate(x, i))
+      ++count;
+  });
+  return count;
+};
+Enumerable.prototype.max = function(selector) {
+  if (selector == null)
+    selector = Functions.Identity;
+  return this.select(selector).aggregate(function(a, b) {
+    return a > b ? a : b;
+  });
+};
+Enumerable.prototype.min = function(selector) {
+  if (selector == null)
+    selector = Functions.Identity;
+  return this.select(selector).aggregate(function(a, b) {
+    return a < b ? a : b;
+  });
+};
+Enumerable.prototype.maxBy = function(keySelector) {
+  keySelector = Utils.createLambda(keySelector);
+  return this.aggregate(function(a, b) {
+    return keySelector(a) > keySelector(b) ? a : b;
+  });
+};
+Enumerable.prototype.minBy = function(keySelector) {
+  keySelector = Utils.createLambda(keySelector);
+  return this.aggregate(function(a, b) {
+    return keySelector(a) < keySelector(b) ? a : b;
+  });
+};
+Enumerable.prototype.sum = function(selector) {
+  if (selector == null)
+    selector = Functions.Identity;
+  return this.select(selector).aggregate(0, function(a, b) {
+    return a + b;
+  });
+};
+Enumerable.prototype.elementAt = function(index) {
+  var value;
+  var found = false;
+  this.forEach(function(x, i) {
+    if (i == index) {
+      value = x;
+      found = true;
+      return false;
+    }
+  });
+  if (!found)
+    throw new Error("index is less than 0 or greater than or equal to the number of elements in source.");
+  return value;
+};
+Enumerable.prototype.elementAtOrDefault = function(index, defaultValue) {
+  if (defaultValue === void 0)
+    defaultValue = null;
+  var value;
+  var found = false;
+  this.forEach(function(x, i) {
+    if (i == index) {
+      value = x;
+      found = true;
+      return false;
+    }
+  });
+  return !found ? defaultValue : value;
+};
+Enumerable.prototype.first = function(predicate) {
+  if (predicate != null)
+    return this.where(predicate).first();
+  var value;
+  var found = false;
+  this.forEach(function(x) {
+    value = x;
+    found = true;
+    return false;
+  });
+  if (!found)
+    throw new Error("first:No element satisfies the condition.");
+  return value;
+};
+Enumerable.prototype.firstOrDefault = function(predicate, defaultValue) {
+  if (predicate !== void 0) {
+    if (typeof predicate === Types.Function || typeof Utils.createLambda(predicate) === Types.Function) {
+      return this.where(predicate).firstOrDefault(void 0, defaultValue);
+    }
+    defaultValue = predicate;
+  }
+  var value;
+  var found = false;
+  this.forEach(function(x) {
+    value = x;
+    found = true;
+    return false;
+  });
+  return !found ? defaultValue : value;
+};
+Enumerable.prototype.last = function(predicate) {
+  if (predicate != null)
+    return this.where(predicate).last();
+  var value;
+  var found = false;
+  this.forEach(function(x) {
+    found = true;
+    value = x;
+  });
+  if (!found)
+    throw new Error("last:No element satisfies the condition.");
+  return value;
+};
+Enumerable.prototype.lastOrDefault = function(predicate, defaultValue) {
+  if (predicate !== void 0) {
+    if (typeof predicate === Types.Function || typeof Utils.createLambda(predicate) === Types.Function) {
+      return this.where(predicate).lastOrDefault(void 0, defaultValue);
+    }
+    defaultValue = predicate;
+  }
+  var value;
+  var found = false;
+  this.forEach(function(x) {
+    found = true;
+    value = x;
+  });
+  return !found ? defaultValue : value;
+};
+Enumerable.prototype.single = function(predicate) {
+  if (predicate != null)
+    return this.where(predicate).single();
+  var value;
+  var found = false;
+  this.forEach(function(x) {
+    if (!found) {
+      found = true;
+      value = x;
+    } else
+      throw new Error("single:sequence contains more than one element.");
+  });
+  if (!found)
+    throw new Error("single:No element satisfies the condition.");
+  return value;
+};
+Enumerable.prototype.singleOrDefault = function(predicate, defaultValue) {
+  if (defaultValue === void 0)
+    defaultValue = null;
+  if (predicate != null)
+    return this.where(predicate).singleOrDefault(null, defaultValue);
+  var value;
+  var found = false;
+  this.forEach(function(x) {
+    if (!found) {
+      found = true;
+      value = x;
+    } else
+      throw new Error("single:sequence contains more than one element.");
+  });
+  return !found ? defaultValue : value;
+};
+Enumerable.prototype.skip = function(count) {
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    var index = 0;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+        while (index++ < count && enumerator.moveNext()) {
+        }
+      },
+      function() {
+        return enumerator.moveNext() ? this.yieldReturn(enumerator.current()) : false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.skipWhile = function(predicate) {
+  predicate = Utils.createLambda(predicate);
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    var index = 0;
+    var isSkipEnd = false;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        while (!isSkipEnd) {
+          if (enumerator.moveNext()) {
+            if (!predicate(enumerator.current(), index++)) {
+              isSkipEnd = true;
+              return this.yieldReturn(enumerator.current());
+            }
+            continue;
+          } else
+            return false;
+        }
+        return enumerator.moveNext() ? this.yieldReturn(enumerator.current()) : false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.take = function(count) {
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    var index = 0;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        return index++ < count && enumerator.moveNext() ? this.yieldReturn(enumerator.current()) : false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.takeWhile = function(predicate) {
+  predicate = Utils.createLambda(predicate);
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    var index = 0;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        return enumerator.moveNext() && predicate(enumerator.current(), index++) ? this.yieldReturn(enumerator.current()) : false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.takeExceptLast = function(count) {
+  if (count == null)
+    count = 1;
+  var source = this;
+  return new Enumerable(function() {
+    if (count <= 0)
+      return source.getEnumerator();
+    var enumerator;
+    var q = [];
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        while (enumerator.moveNext()) {
+          if (q.length == count) {
+            q.push(enumerator.current());
+            return this.yieldReturn(q.shift());
+          }
+          q.push(enumerator.current());
+        }
+        return false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.takeFromLast = function(count) {
+  if (count <= 0 || count == null)
+    return Enumerable.empty();
+  var source = this;
+  return new Enumerable(function() {
+    var sourceEnumerator;
+    var enumerator;
+    var q = [];
+    return new IEnumerator(
+      function() {
+        sourceEnumerator = source.getEnumerator();
+      },
+      function() {
+        while (sourceEnumerator.moveNext()) {
+          if (q.length == count)
+            q.shift();
+          q.push(sourceEnumerator.current());
+        }
+        if (enumerator == null) {
+          enumerator = Enumerable.from(q).getEnumerator();
+        }
+        return enumerator.moveNext() ? this.yieldReturn(enumerator.current()) : false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.indexOf = function(item) {
+  var found = null;
+  if (typeof item === Types.Function) {
+    this.forEach(function(x, i) {
+      if (item(x, i)) {
+        found = i;
+        return false;
+      }
+    });
+  } else {
+    this.forEach(function(x, i) {
+      if (x === item) {
+        found = i;
+        return false;
+      }
+    });
+  }
+  return found !== null ? found : -1;
+};
+Enumerable.prototype.lastIndexOf = function(item) {
+  var result = -1;
+  if (typeof item === Types.Function) {
+    this.forEach(function(x, i) {
+      if (item(x, i))
+        result = i;
+    });
+  } else {
+    this.forEach(function(x, i) {
+      if (x === item)
+        result = i;
+    });
+  }
+  return result;
+};
+Enumerable.prototype.cast = function() {
+  return this;
+};
+Enumerable.prototype.asEnumerable = function() {
+  return Enumerable.from(this);
+};
+Enumerable.prototype.toArray = function() {
+  var array = [];
+  this.forEach(function(x) {
+    array.push(x);
+  });
+  return array;
+};
+Enumerable.prototype.toLookup = function(keySelector, elementSelector, compareSelector) {
+  keySelector = Utils.createLambda(keySelector);
+  elementSelector = Utils.createLambda(elementSelector);
+  compareSelector = Utils.createLambda(compareSelector);
+  var dict = new Dictionary(compareSelector);
+  this.forEach(function(x) {
+    var key = keySelector(x);
+    var element = elementSelector(x);
+    var array = dict.get(key);
+    if (array !== void 0)
+      array.push(element);
+    else
+      dict.add(key, [element]);
+  });
+  return new Lookup(dict);
+};
+Enumerable.prototype.toObject = function(keySelector, elementSelector) {
+  keySelector = Utils.createLambda(keySelector);
+  elementSelector = Utils.createLambda(elementSelector);
+  var obj = {};
+  this.forEach(function(x) {
+    obj[keySelector(x)] = elementSelector(x);
+  });
+  return obj;
+};
+Enumerable.prototype.toDictionary = function(keySelector, elementSelector, compareSelector) {
+  keySelector = Utils.createLambda(keySelector);
+  elementSelector = Utils.createLambda(elementSelector);
+  compareSelector = Utils.createLambda(compareSelector);
+  var dict = new Dictionary(compareSelector);
+  this.forEach(function(x) {
+    dict.add(keySelector(x), elementSelector(x));
+  });
+  return dict;
+};
+Enumerable.prototype.toJSONString = function(replacer, space) {
+  if (typeof JSON === Types.Undefined || JSON.stringify == null) {
+    throw new Error("toJSONString can't find JSON.stringify. This works native JSON support Browser or include json2.js");
+  }
+  return JSON.stringify(this.toArray(), replacer, space);
+};
+Enumerable.prototype.toJoinedString = function(separator, selector) {
+  if (separator == null)
+    separator = "";
+  if (selector == null)
+    selector = Functions.Identity;
+  return this.select(selector).toArray().join(separator);
+};
+Enumerable.prototype.doAction = function(action) {
+  var source = this;
+  action = Utils.createLambda(action);
+  return new Enumerable(function() {
+    var enumerator;
+    var index = 0;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        if (enumerator.moveNext()) {
+          action(enumerator.current(), index++);
+          return this.yieldReturn(enumerator.current());
+        }
+        return false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.forEach = function(action) {
+  action = Utils.createLambda(action);
+  var index = 0;
+  var enumerator = this.getEnumerator();
+  try {
+    while (enumerator.moveNext()) {
+      if (action(enumerator.current(), index++) === false)
+        break;
+    }
+  } finally {
+    Utils.dispose(enumerator);
+  }
+};
+Enumerable.prototype.force = function() {
+  var enumerator = this.getEnumerator();
+  try {
+    while (enumerator.moveNext()) {
+    }
+  } finally {
+    Utils.dispose(enumerator);
+  }
+};
+Enumerable.prototype.letBind = function(func) {
+  func = Utils.createLambda(func);
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    return new IEnumerator(
+      function() {
+        enumerator = Enumerable.from(func(source)).getEnumerator();
+      },
+      function() {
+        return enumerator.moveNext() ? this.yieldReturn(enumerator.current()) : false;
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.share = function() {
+  var source = this;
+  var sharedEnumerator;
+  var disposed = false;
+  return new DisposableEnumerable(function() {
+    return new IEnumerator(
+      function() {
+        if (sharedEnumerator == null) {
+          sharedEnumerator = source.getEnumerator();
+        }
+      },
+      function() {
+        if (disposed)
+          throw new Error("enumerator is disposed");
+        return sharedEnumerator.moveNext() ? this.yieldReturn(sharedEnumerator.current()) : false;
+      },
+      Functions.Blank
+    );
+  }, function() {
+    disposed = true;
+    Utils.dispose(sharedEnumerator);
+  });
+};
+Enumerable.prototype.memoize = function() {
+  var source = this;
+  var cache;
+  var enumerator;
+  var disposed = false;
+  return new DisposableEnumerable(function() {
+    var index = -1;
+    return new IEnumerator(
+      function() {
+        if (enumerator == null) {
+          enumerator = source.getEnumerator();
+          cache = [];
+        }
+      },
+      function() {
+        if (disposed)
+          throw new Error("enumerator is disposed");
+        index++;
+        if (cache.length <= index) {
+          return enumerator.moveNext() ? this.yieldReturn(cache[index] = enumerator.current()) : false;
+        }
+        return this.yieldReturn(cache[index]);
+      },
+      Functions.Blank
+    );
+  }, function() {
+    disposed = true;
+    Utils.dispose(enumerator);
+    cache = null;
+  });
+};
+if (Utils.hasNativeIteratorSupport()) {
+  Enumerable.prototype[Symbol.iterator] = function() {
+    return {
+      enumerator: this.getEnumerator(),
+      next: function() {
+        if (this.enumerator.moveNext()) {
+          return {
+            done: false,
+            value: this.enumerator.current()
+          };
+        } else {
+          return { done: true };
+        }
+      }
+    };
+  };
+}
+Enumerable.prototype.catchError = function(handler) {
+  handler = Utils.createLambda(handler);
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        try {
+          return enumerator.moveNext() ? this.yieldReturn(enumerator.current()) : false;
+        } catch (e) {
+          handler(e);
+          return false;
+        }
+      },
+      function() {
+        Utils.dispose(enumerator);
+      }
+    );
+  });
+};
+Enumerable.prototype.finallyAction = function(finallyAction) {
+  finallyAction = Utils.createLambda(finallyAction);
+  var source = this;
+  return new Enumerable(function() {
+    var enumerator;
+    return new IEnumerator(
+      function() {
+        enumerator = source.getEnumerator();
+      },
+      function() {
+        return enumerator.moveNext() ? this.yieldReturn(enumerator.current()) : false;
+      },
+      function() {
+        try {
+          Utils.dispose(enumerator);
+        } finally {
+          finallyAction();
+        }
+      }
+    );
+  });
+};
+Enumerable.prototype.log = function(selector) {
+  selector = Utils.createLambda(selector);
+  return this.doAction(function(item) {
+    if (typeof console !== Types.Undefined) {
+      console.log(selector(item));
+    }
+  });
+};
+Enumerable.prototype.trace = function(message, selector) {
+  if (message == null)
+    message = "Trace";
+  selector = Utils.createLambda(selector);
+  return this.doAction(function(item) {
+    if (typeof console !== Types.Undefined) {
+      console.log(message, selector(item));
+    }
+  });
+};
+var OrderedEnumerable = function(source, keySelector, comparer, descending, parent) {
+  this.source = source;
+  this.keySelector = Utils.createLambda(keySelector);
+  this.descending = descending;
+  this.parent = parent;
+  if (comparer)
+    this.comparer = Utils.createLambda(comparer);
+};
+OrderedEnumerable.prototype = new Enumerable();
+OrderedEnumerable.prototype.createOrderedEnumerable = function(keySelector, comparer, descending) {
+  return new OrderedEnumerable(this.source, keySelector, comparer, descending, this);
+};
+OrderedEnumerable.prototype.thenBy = function(keySelector, comparer) {
+  return this.createOrderedEnumerable(keySelector, comparer, false);
+};
+OrderedEnumerable.prototype.thenByDescending = function(keySelector, comparer) {
+  return this.createOrderedEnumerable(keySelector, comparer, true);
+};
+OrderedEnumerable.prototype.getEnumerator = function() {
+  var self2 = this;
+  var buffer;
+  var indexes;
+  var index = 0;
+  return new IEnumerator(
+    function() {
+      buffer = [];
+      indexes = [];
+      self2.source.forEach(function(item, index2) {
+        buffer.push(item);
+        indexes.push(index2);
+      });
+      var sortContext = SortContext.create(self2, null);
+      sortContext.GenerateKeys(buffer);
+      indexes.sort(function(a, b) {
+        return sortContext.compare(a, b);
+      });
+    },
+    function() {
+      return index < indexes.length ? this.yieldReturn(buffer[indexes[index++]]) : false;
+    },
+    Functions.Blank
+  );
+};
+var SortContext = function(keySelector, comparer, descending, child) {
+  this.keySelector = keySelector;
+  this.descending = descending;
+  this.child = child;
+  this.comparer = comparer;
+  this.keys = null;
+};
+SortContext.create = function(orderedEnumerable, currentContext) {
+  var context = new SortContext(
+    orderedEnumerable.keySelector,
+    orderedEnumerable.comparer,
+    orderedEnumerable.descending,
+    currentContext
+  );
+  if (orderedEnumerable.parent != null)
+    return SortContext.create(orderedEnumerable.parent, context);
+  return context;
+};
+SortContext.prototype.GenerateKeys = function(source) {
+  var len = source.length;
+  var keySelector = this.keySelector;
+  var keys = new Array(len);
+  for (let i = 0; i < len; i++)
+    keys[i] = keySelector(source[i]);
+  this.keys = keys;
+  if (this.child != null)
+    this.child.GenerateKeys(source);
+};
+SortContext.prototype.compare = function(index1, index2) {
+  var comparison = this.comparer ? this.comparer(this.keys[index1], this.keys[index2]) : Utils.compare(this.keys[index1], this.keys[index2]);
+  if (comparison == 0) {
+    if (this.child != null)
+      return this.child.compare(index1, index2);
+    return Utils.compare(index1, index2);
+  }
+  return this.descending ? -comparison : comparison;
+};
+var DisposableEnumerable = function(getEnumerator, dispose) {
+  this.dispose = dispose;
+  Enumerable.call(this, getEnumerator);
+};
+DisposableEnumerable.prototype = new Enumerable();
+var ArrayEnumerable = function(source) {
+  this.getSource = function() {
+    return source;
+  };
+};
+ArrayEnumerable.prototype = new Enumerable();
+ArrayEnumerable.prototype.any = function(predicate) {
+  return predicate == null ? this.getSource().length > 0 : Enumerable.prototype.any.apply(this, arguments);
+};
+ArrayEnumerable.prototype.count = function(predicate) {
+  return predicate == null ? this.getSource().length : Enumerable.prototype.count.apply(this, arguments);
+};
+ArrayEnumerable.prototype.elementAt = function(index) {
+  var source = this.getSource();
+  return 0 <= index && index < source.length ? source[index] : Enumerable.prototype.elementAt.apply(this, arguments);
+};
+ArrayEnumerable.prototype.elementAtOrDefault = function(index, defaultValue) {
+  if (defaultValue === void 0)
+    defaultValue = null;
+  var source = this.getSource();
+  return 0 <= index && index < source.length ? source[index] : defaultValue;
+};
+ArrayEnumerable.prototype.first = function(predicate) {
+  var source = this.getSource();
+  return predicate == null && source.length > 0 ? source[0] : Enumerable.prototype.first.apply(this, arguments);
+};
+ArrayEnumerable.prototype.firstOrDefault = function(predicate, defaultValue) {
+  if (predicate !== void 0) {
+    return Enumerable.prototype.firstOrDefault.apply(this, arguments);
+  }
+  defaultValue = predicate;
+  var source = this.getSource();
+  return source.length > 0 ? source[0] : defaultValue;
+};
+ArrayEnumerable.prototype.last = function(predicate) {
+  var source = this.getSource();
+  return predicate == null && source.length > 0 ? source[source.length - 1] : Enumerable.prototype.last.apply(this, arguments);
+};
+ArrayEnumerable.prototype.lastOrDefault = function(predicate, defaultValue) {
+  if (predicate !== void 0) {
+    return Enumerable.prototype.lastOrDefault.apply(this, arguments);
+  }
+  defaultValue = predicate;
+  var source = this.getSource();
+  return source.length > 0 ? source[source.length - 1] : defaultValue;
+};
+ArrayEnumerable.prototype.skip = function(count) {
+  var source = this.getSource();
+  return new Enumerable(function() {
+    var index;
+    return new IEnumerator(
+      function() {
+        index = count < 0 ? 0 : count;
+      },
+      function() {
+        return index < source.length ? this.yieldReturn(source[index++]) : false;
+      },
+      Functions.Blank
+    );
+  });
+};
+ArrayEnumerable.prototype.takeExceptLast = function(count) {
+  if (count == null)
+    count = 1;
+  return this.take(this.getSource().length - count);
+};
+ArrayEnumerable.prototype.takeFromLast = function(count) {
+  return this.skip(this.getSource().length - count);
+};
+ArrayEnumerable.prototype.reverse = function() {
+  var source = this.getSource();
+  return new Enumerable(function() {
+    var index;
+    return new IEnumerator(
+      function() {
+        index = source.length;
+      },
+      function() {
+        return index > 0 ? this.yieldReturn(source[--index]) : false;
+      },
+      Functions.Blank
+    );
+  });
+};
+ArrayEnumerable.prototype.sequenceEqual = function(second, compareSelector) {
+  if ((second instanceof ArrayEnumerable || second instanceof Array) && compareSelector == null && Enumerable.from(second).count() != this.count()) {
+    return false;
+  }
+  return Enumerable.prototype.sequenceEqual.apply(this, arguments);
+};
+ArrayEnumerable.prototype.toJoinedString = function(separator, selector) {
+  var source = this.getSource();
+  if (selector != null || !(source instanceof Array)) {
+    return Enumerable.prototype.toJoinedString.apply(this, arguments);
+  }
+  if (separator == null)
+    separator = "";
+  return source.join(separator);
+};
+ArrayEnumerable.prototype.getEnumerator = function() {
+  var source = this.getSource();
+  var index = -1;
+  return {
+    current: function() {
+      return source[index];
+    },
+    moveNext: function() {
+      return ++index < source.length;
+    },
+    dispose: Functions.Blank
+  };
+};
+var WhereEnumerable = function(source, predicate) {
+  this.prevSource = source;
+  this.prevPredicate = predicate;
+};
+WhereEnumerable.prototype = new Enumerable();
+WhereEnumerable.prototype.where = function(predicate) {
+  predicate = Utils.createLambda(predicate);
+  if (predicate.length <= 1) {
+    const prevPredicate = this.prevPredicate;
+    const composedPredicate = function(x) {
+      return prevPredicate(x) && predicate(x);
+    };
+    return new WhereEnumerable(this.prevSource, composedPredicate);
+  } else {
+    return Enumerable.prototype.where.call(this, predicate);
+  }
+};
+WhereEnumerable.prototype.select = function(selector) {
+  selector = Utils.createLambda(selector);
+  return selector.length <= 1 ? new WhereSelectEnumerable(this.prevSource, this.prevPredicate, selector) : Enumerable.prototype.select.call(this, selector);
+};
+WhereEnumerable.prototype.getEnumerator = function() {
+  var predicate = this.prevPredicate;
+  var source = this.prevSource;
+  var enumerator;
+  return new IEnumerator(
+    function() {
+      enumerator = source.getEnumerator();
+    },
+    function() {
+      while (enumerator.moveNext()) {
+        if (predicate(enumerator.current())) {
+          return this.yieldReturn(enumerator.current());
+        }
+      }
+      return false;
+    },
+    function() {
+      Utils.dispose(enumerator);
+    }
+  );
+};
+var WhereSelectEnumerable = function(source, predicate, selector) {
+  this.prevSource = source;
+  this.prevPredicate = predicate;
+  this.prevSelector = selector;
+};
+WhereSelectEnumerable.prototype = new Enumerable();
+WhereSelectEnumerable.prototype.where = function(predicate) {
+  predicate = Utils.createLambda(predicate);
+  return predicate.length <= 1 ? new WhereEnumerable(this, predicate) : Enumerable.prototype.where.call(this, predicate);
+};
+WhereSelectEnumerable.prototype.select = function(selector) {
+  selector = Utils.createLambda(selector);
+  if (selector.length <= 1) {
+    const prevSelector = this.prevSelector;
+    const composedSelector = function(x) {
+      return selector(prevSelector(x));
+    };
+    return new WhereSelectEnumerable(this.prevSource, this.prevPredicate, composedSelector);
+  } else {
+    return Enumerable.prototype.select.call(this, selector);
+  }
+};
+WhereSelectEnumerable.prototype.getEnumerator = function() {
+  var predicate = this.prevPredicate;
+  var selector = this.prevSelector;
+  var source = this.prevSource;
+  var enumerator;
+  return new IEnumerator(
+    function() {
+      enumerator = source.getEnumerator();
+    },
+    function() {
+      while (enumerator.moveNext()) {
+        if (predicate == null || predicate(enumerator.current())) {
+          return this.yieldReturn(selector(enumerator.current()));
+        }
+      }
+      return false;
+    },
+    function() {
+      Utils.dispose(enumerator);
+    }
+  );
+};
+var Dictionary = function() {
+  var callHasOwnProperty = function(target, key) {
+    return Object.prototype.hasOwnProperty.call(target, key);
+  };
+  var computeHashCode = function(obj) {
+    if (obj === null)
+      return "null";
+    if (obj === void 0)
+      return "undefined";
+    return typeof obj.toString === Types.Function ? obj.toString() : Object.prototype.toString.call(obj);
+  };
+  var HashEntry = function(key, value) {
+    this.key = key;
+    this.value = value;
+    this.prev = null;
+    this.next = null;
+  };
+  var EntryList = function() {
+    this.first = null;
+    this.last = null;
+  };
+  EntryList.prototype = {
+    addLast: function(entry) {
+      if (this.last != null) {
+        this.last.next = entry;
+        entry.prev = this.last;
+        this.last = entry;
+      } else
+        this.first = this.last = entry;
+    },
+    replace: function(entry, newEntry) {
+      if (entry.prev != null) {
+        entry.prev.next = newEntry;
+        newEntry.prev = entry.prev;
+      } else
+        this.first = newEntry;
+      if (entry.next != null) {
+        entry.next.prev = newEntry;
+        newEntry.next = entry.next;
+      } else
+        this.last = newEntry;
+    },
+    remove: function(entry) {
+      if (entry.prev != null)
+        entry.prev.next = entry.next;
+      else
+        this.first = entry.next;
+      if (entry.next != null)
+        entry.next.prev = entry.prev;
+      else
+        this.last = entry.prev;
+    }
+  };
+  var Dictionary2 = function(compareSelector) {
+    this.countField = 0;
+    this.entryList = new EntryList();
+    this.buckets = {};
+    this.compareSelector = compareSelector == null ? Functions.Identity : compareSelector;
+  };
+  Dictionary2.prototype = {
+    add: function(key, value) {
+      var compareKey = this.compareSelector(key);
+      var hash = computeHashCode(compareKey);
+      var entry = new HashEntry(key, value);
+      if (callHasOwnProperty(this.buckets, hash)) {
+        const array = this.buckets[hash];
+        for (let i = 0; i < array.length; i++) {
+          if (this.compareSelector(array[i].key) === compareKey) {
+            this.entryList.replace(array[i], entry);
+            array[i] = entry;
+            return;
+          }
+        }
+        array.push(entry);
+      } else {
+        this.buckets[hash] = [entry];
+      }
+      this.countField++;
+      this.entryList.addLast(entry);
+    },
+    get: function(key) {
+      var compareKey = this.compareSelector(key);
+      var hash = computeHashCode(compareKey);
+      if (!callHasOwnProperty(this.buckets, hash))
+        return void 0;
+      var array = this.buckets[hash];
+      for (let i = 0; i < array.length; i++) {
+        const entry = array[i];
+        if (this.compareSelector(entry.key) === compareKey)
+          return entry.value;
+      }
+      return void 0;
+    },
+    set: function(key, value) {
+      var compareKey = this.compareSelector(key);
+      var hash = computeHashCode(compareKey);
+      if (callHasOwnProperty(this.buckets, hash)) {
+        const array = this.buckets[hash];
+        for (let i = 0; i < array.length; i++) {
+          if (this.compareSelector(array[i].key) === compareKey) {
+            const newEntry = new HashEntry(key, value);
+            this.entryList.replace(array[i], newEntry);
+            array[i] = newEntry;
+            return true;
+          }
+        }
+      }
+      return false;
+    },
+    contains: function(key) {
+      var compareKey = this.compareSelector(key);
+      var hash = computeHashCode(compareKey);
+      if (!callHasOwnProperty(this.buckets, hash))
+        return false;
+      var array = this.buckets[hash];
+      for (let i = 0; i < array.length; i++) {
+        if (this.compareSelector(array[i].key) === compareKey)
+          return true;
+      }
+      return false;
+    },
+    clear: function() {
+      this.countField = 0;
+      this.buckets = {};
+      this.entryList = new EntryList();
+    },
+    remove: function(key) {
+      var compareKey = this.compareSelector(key);
+      var hash = computeHashCode(compareKey);
+      if (!callHasOwnProperty(this.buckets, hash))
+        return;
+      var array = this.buckets[hash];
+      for (let i = 0; i < array.length; i++) {
+        if (this.compareSelector(array[i].key) === compareKey) {
+          this.entryList.remove(array[i]);
+          array.splice(i, 1);
+          if (array.length == 0)
+            delete this.buckets[hash];
+          this.countField--;
+          return;
+        }
+      }
+    },
+    count: function() {
+      return this.countField;
+    },
+    toEnumerable: function() {
+      var self2 = this;
+      return new Enumerable(function() {
+        var currentEntry;
+        return new IEnumerator(
+          function() {
+            currentEntry = self2.entryList.first;
+          },
+          function() {
+            if (currentEntry != null) {
+              const result = { key: currentEntry.key, value: currentEntry.value };
+              currentEntry = currentEntry.next;
+              return this.yieldReturn(result);
+            }
+            return false;
+          },
+          Functions.Blank
+        );
+      });
+    }
+  };
+  return Dictionary2;
+}();
+var Lookup = function(dictionary) {
+  this.count = function() {
+    return dictionary.count();
+  };
+  this.get = function(key) {
+    return Enumerable.from(dictionary.get(key));
+  };
+  this.contains = function(key) {
+    return dictionary.contains(key);
+  };
+  this.toEnumerable = function() {
+    return dictionary.toEnumerable().select(function(kvp) {
+      return new Grouping(kvp.key, kvp.value);
+    });
+  };
+};
+var Grouping = function(groupKey, elements) {
+  this.key = function() {
+    return groupKey;
+  };
+  ArrayEnumerable.call(this, elements);
+};
+Grouping.prototype = new ArrayEnumerable();
 const propDefine$1 = {
   // modelValue:{
   //     // 平台Id
@@ -15606,7 +18277,7 @@ class StructureTypeSelectInstance extends BaseInstance {
         this.activeTypeItem.value = item;
       }
       if (this.structrueTypeLevGroup.value.find((e) => e["level"] == level)) {
-        let index = linq.from(this.structrueTypeLevGroup.value).indexOf((e) => e["level"] == level);
+        let index = Enumerable.from(this.structrueTypeLevGroup.value).indexOf((e) => e["level"] == level);
         this.structrueTypeLevGroup.value[index] = item;
         this.structrueTypeLevGroup.value.splice(index + 1, this.structrueTypeLevGroup.value.length);
       } else {
@@ -15628,14 +18299,14 @@ class StructureTypeSelectInstance extends BaseInstance {
       if (state) {
         this.StructureTypeCheckData.value.push(item);
       } else {
-        let index = linq.from(this.StructureTypeCheckData.value).indexOf((e) => e["value"] == item.value);
+        let index = Enumerable.from(this.StructureTypeCheckData.value).indexOf((e) => e["value"] == item.value);
         this.StructureTypeCheckData.value.splice(index, 1);
       }
       this.doSelectedAfterFun();
     });
     __publicField(this, "removeStructureType", (item) => {
       this.changeTreeItem(this.StructureTypeData.value, item.value, "checked", false);
-      let index = linq.from(this.StructureTypeCheckData.value).indexOf((e) => e["value"] == item.value);
+      let index = Enumerable.from(this.StructureTypeCheckData.value).indexOf((e) => e["value"] == item.value);
       this.StructureTypeCheckData.value.splice(index, 1);
     });
     __publicField(this, "poptipVisChange", () => {
@@ -15678,7 +18349,7 @@ class StructureTypeSelectInstance extends BaseInstance {
       this.searchTypeList.value = [];
     });
     __publicField(this, "toCheckSearchType", (item, state) => {
-      let index = linq.from(this.StructureTypeCheckData.value).indexOf((e) => e["value"] == item.value);
+      let index = Enumerable.from(this.StructureTypeCheckData.value).indexOf((e) => e["value"] == item.value);
       if (state || index >= 0) {
         this.StructureTypeCheckData.value.push({ value: item.Id, label: item.NodeName, parentPath: item.parentPath });
         this.changeTreeItem(this.StructureTypeData.value, item.Id, "checked", true);
@@ -15764,7 +18435,7 @@ class StructureTypeSelectInstance extends BaseInstance {
       obj.value = e[value];
       obj.label = e[label];
       obj.parentPath = JSON.parse(JSON.stringify(parentPath2));
-      let index = linq.from(this.StructureTypeDataAll).indexOf((x) => x["Id"] == obj.value);
+      let index = Enumerable.from(this.StructureTypeDataAll).indexOf((x) => x["Id"] == obj.value);
       this.StructureTypeDataAll[index].parentPath = obj.parentPath;
       obj.level = obj.parentPath.length + 1;
       if (this.props.multiple) {
@@ -16139,7 +18810,7 @@ class StructureSelectInstance extends BaseInstance {
      */
     __publicField(this, "removeStructureInstance", (item) => {
       item.checked = false;
-      let index = linq.from(this.StructureInstanceCheckData.value).indexOf((e) => e["Id"] == item.Id);
+      let index = Enumerable.from(this.StructureInstanceCheckData.value).indexOf((e) => e["Id"] == item.Id);
       this.StructureInstanceCheckData.value.splice(index, 1);
       this.treeChStateChange(this.StructureInstanceData.value);
       this.doSelectedAfterFun();
@@ -16153,7 +18824,7 @@ class StructureSelectInstance extends BaseInstance {
    */
   async loadNodeTypeAndUnitData() {
     let res = this.utilities.parseApiResult(await this.structureInstanceApi.getEntities(new QueryWrapper().select(["Id", "NodeTypeName", "NodeType", "NodeName"]).eq("PId", 0)));
-    this.TypeGroupData.value = linq.from(res).groupBy((e) => e["NodeTypeName"]).select((e) => {
+    this.TypeGroupData.value = Enumerable.from(res).groupBy((e) => e["NodeTypeName"]).select((e) => {
       return {
         NodeTypeName: e.key(),
         UnitData: e.getSource()