dfws-ve-resume-models 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,5 +1,5 @@
 /*!
- * dfws-ve-resume-models.js v0.1.2
+ * dfws-ve-resume-models.js v0.1.4
  * (c) 2024-2025 
  * Released under the MIT License in iflytek.
  */
@@ -11,69 +11,54 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.dfwsResume = factory());
 })(this, (function () { 'use strict';
 
-  function _arrayLikeToArray$1(r, a) {
-    (null == a || a > r.length) && (a = r.length);
-    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-    return n;
+  function _arrayLikeToArray$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
   }
 
-  function _arrayWithoutHoles(r) {
-    if (Array.isArray(r)) return _arrayLikeToArray$1(r);
+  function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray$1(arr);
   }
 
-  function _iterableToArray(r) {
-    if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+  function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
   }
 
-  function _unsupportedIterableToArray$1(r, a) {
-    if (r) {
-      if ("string" == typeof r) return _arrayLikeToArray$1(r, a);
-      var t = {}.toString.call(r).slice(8, -1);
-      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$1(r, a) : void 0;
-    }
+  function _unsupportedIterableToArray$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen);
   }
 
   function _nonIterableSpread() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
 
-  function _toConsumableArray(r) {
-    return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray$1(r) || _nonIterableSpread();
-  }
-
-  function _typeof$1(o) {
-    "@babel/helpers - typeof";
-
-    return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-      return typeof o;
-    } : function (o) {
-      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-    }, _typeof$1(o);
+  function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread();
   }
 
-  function toPrimitive(t, r) {
-    if ("object" != _typeof$1(t) || !t) return t;
-    var e = t[Symbol.toPrimitive];
-    if (void 0 !== e) {
-      var i = e.call(t, r || "default");
-      if ("object" != _typeof$1(i)) return i;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
     }
-    return ("string" === r ? String : Number)(t);
-  }
 
-  function toPropertyKey(t) {
-    var i = toPrimitive(t, "string");
-    return "symbol" == _typeof$1(i) ? i : i + "";
-  }
-
-  function _defineProperty(e, r, t) {
-    return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-      value: t,
-      enumerable: !0,
-      configurable: !0,
-      writable: !0
-    }) : e[r] = t, e;
+    return obj;
   }
 
   var mapStateToProps$f = function mapStateToProps(state) {
@@ -84,324 +69,375 @@
 
   var regeneratorRuntime$1 = {exports: {}};
 
-  var _typeof = {exports: {}};
+  var _typeof$1 = {exports: {}};
 
   (function (module) {
-  function _typeof(o) {
+  function _typeof(obj) {
     "@babel/helpers - typeof";
 
-    return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-      return typeof o;
-    } : function (o) {
-      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o);
+    return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+      return typeof obj;
+    } : function (obj) {
+      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
   }
+
   module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  }(_typeof));
+  }(_typeof$1));
 
   (function (module) {
-  var _typeof$1 = _typeof.exports["default"];
+  var _typeof = _typeof$1.exports["default"];
+
   function _regeneratorRuntime() {
+    /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
     module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
-      return e;
+      return exports;
     }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-    var t,
-      e = {},
-      r = Object.prototype,
-      n = r.hasOwnProperty,
-      o = Object.defineProperty || function (t, e, r) {
-        t[e] = r.value;
-      },
-      i = "function" == typeof Symbol ? Symbol : {},
-      a = i.iterator || "@@iterator",
-      c = i.asyncIterator || "@@asyncIterator",
-      u = i.toStringTag || "@@toStringTag";
-    function define(t, e, r) {
-      return Object.defineProperty(t, e, {
-        value: r,
+    var exports = {},
+        Op = Object.prototype,
+        hasOwn = Op.hasOwnProperty,
+        $Symbol = "function" == typeof Symbol ? Symbol : {},
+        iteratorSymbol = $Symbol.iterator || "@@iterator",
+        asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+        toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+    function define(obj, key, value) {
+      return Object.defineProperty(obj, key, {
+        value: value,
         enumerable: !0,
         configurable: !0,
         writable: !0
-      }), t[e];
+      }), obj[key];
     }
+
     try {
       define({}, "");
-    } catch (t) {
-      define = function define(t, e, r) {
-        return t[e] = r;
+    } catch (err) {
+      define = function define(obj, key, value) {
+        return obj[key] = value;
       };
     }
-    function wrap(t, e, r, n) {
-      var i = e && e.prototype instanceof Generator ? e : Generator,
-        a = Object.create(i.prototype),
-        c = new Context(n || []);
-      return o(a, "_invoke", {
-        value: makeInvokeMethod(t, r, c)
-      }), a;
+
+    function wrap(innerFn, outerFn, self, tryLocsList) {
+      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+          generator = Object.create(protoGenerator.prototype),
+          context = new Context(tryLocsList || []);
+      return generator._invoke = function (innerFn, self, context) {
+        var state = "suspendedStart";
+        return function (method, arg) {
+          if ("executing" === state) throw new Error("Generator is already running");
+
+          if ("completed" === state) {
+            if ("throw" === method) throw arg;
+            return doneResult();
+          }
+
+          for (context.method = method, context.arg = arg;;) {
+            var delegate = context.delegate;
+
+            if (delegate) {
+              var delegateResult = maybeInvokeDelegate(delegate, context);
+
+              if (delegateResult) {
+                if (delegateResult === ContinueSentinel) continue;
+                return delegateResult;
+              }
+            }
+
+            if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+              if ("suspendedStart" === state) throw state = "completed", context.arg;
+              context.dispatchException(context.arg);
+            } else "return" === context.method && context.abrupt("return", context.arg);
+            state = "executing";
+            var record = tryCatch(innerFn, self, context);
+
+            if ("normal" === record.type) {
+              if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+              return {
+                value: record.arg,
+                done: context.done
+              };
+            }
+
+            "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+          }
+        };
+      }(innerFn, self, context), generator;
     }
-    function tryCatch(t, e, r) {
+
+    function tryCatch(fn, obj, arg) {
       try {
         return {
           type: "normal",
-          arg: t.call(e, r)
+          arg: fn.call(obj, arg)
         };
-      } catch (t) {
+      } catch (err) {
         return {
           type: "throw",
-          arg: t
+          arg: err
         };
       }
     }
-    e.wrap = wrap;
-    var h = "suspendedStart",
-      l = "suspendedYield",
-      f = "executing",
-      s = "completed",
-      y = {};
+
+    exports.wrap = wrap;
+    var ContinueSentinel = {};
+
     function Generator() {}
+
     function GeneratorFunction() {}
+
     function GeneratorFunctionPrototype() {}
-    var p = {};
-    define(p, a, function () {
+
+    var IteratorPrototype = {};
+    define(IteratorPrototype, iteratorSymbol, function () {
       return this;
     });
-    var d = Object.getPrototypeOf,
-      v = d && d(d(values([])));
-    v && v !== r && n.call(v, a) && (p = v);
-    var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
-    function defineIteratorMethods(t) {
-      ["next", "throw", "return"].forEach(function (e) {
-        define(t, e, function (t) {
-          return this._invoke(e, t);
+    var getProto = Object.getPrototypeOf,
+        NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+    NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+    var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+
+    function defineIteratorMethods(prototype) {
+      ["next", "throw", "return"].forEach(function (method) {
+        define(prototype, method, function (arg) {
+          return this._invoke(method, arg);
         });
       });
     }
-    function AsyncIterator(t, e) {
-      function invoke(r, o, i, a) {
-        var c = tryCatch(t[r], t, o);
-        if ("throw" !== c.type) {
-          var u = c.arg,
-            h = u.value;
-          return h && "object" == _typeof$1(h) && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
-            invoke("next", t, i, a);
-          }, function (t) {
-            invoke("throw", t, i, a);
-          }) : e.resolve(h).then(function (t) {
-            u.value = t, i(u);
-          }, function (t) {
-            return invoke("throw", t, i, a);
+
+    function AsyncIterator(generator, PromiseImpl) {
+      function invoke(method, arg, resolve, reject) {
+        var record = tryCatch(generator[method], generator, arg);
+
+        if ("throw" !== record.type) {
+          var result = record.arg,
+              value = result.value;
+          return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+            invoke("next", value, resolve, reject);
+          }, function (err) {
+            invoke("throw", err, resolve, reject);
+          }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+            result.value = unwrapped, resolve(result);
+          }, function (error) {
+            return invoke("throw", error, resolve, reject);
           });
         }
-        a(c.arg);
+
+        reject(record.arg);
       }
-      var r;
-      o(this, "_invoke", {
-        value: function value(t, n) {
-          function callInvokeWithMethodAndArg() {
-            return new e(function (e, r) {
-              invoke(t, n, e, r);
-            });
-          }
-          return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-        }
-      });
-    }
-    function makeInvokeMethod(e, r, n) {
-      var o = h;
-      return function (i, a) {
-        if (o === f) throw Error("Generator is already running");
-        if (o === s) {
-          if ("throw" === i) throw a;
-          return {
-            value: t,
-            done: !0
-          };
-        }
-        for (n.method = i, n.arg = a;;) {
-          var c = n.delegate;
-          if (c) {
-            var u = maybeInvokeDelegate(c, n);
-            if (u) {
-              if (u === y) continue;
-              return u;
-            }
-          }
-          if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
-            if (o === h) throw o = s, n.arg;
-            n.dispatchException(n.arg);
-          } else "return" === n.method && n.abrupt("return", n.arg);
-          o = f;
-          var p = tryCatch(e, r, n);
-          if ("normal" === p.type) {
-            if (o = n.done ? s : l, p.arg === y) continue;
-            return {
-              value: p.arg,
-              done: n.done
-            };
-          }
-          "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+
+      var previousPromise;
+
+      this._invoke = function (method, arg) {
+        function callInvokeWithMethodAndArg() {
+          return new PromiseImpl(function (resolve, reject) {
+            invoke(method, arg, resolve, reject);
+          });
         }
+
+        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
       };
     }
-    function maybeInvokeDelegate(e, r) {
-      var n = r.method,
-        o = e.iterator[n];
-      if (o === t) return r.delegate = null, "throw" === n && e.iterator["return"] && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
-      var i = tryCatch(o, e.iterator, r.arg);
-      if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
-      var a = i.arg;
-      return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+
+    function maybeInvokeDelegate(delegate, context) {
+      var method = delegate.iterator[context.method];
+
+      if (undefined === method) {
+        if (context.delegate = null, "throw" === context.method) {
+          if (delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
+          context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+        }
+
+        return ContinueSentinel;
+      }
+
+      var record = tryCatch(method, delegate.iterator, context.arg);
+      if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+      var info = record.arg;
+      return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
     }
-    function pushTryEntry(t) {
-      var e = {
-        tryLoc: t[0]
+
+    function pushTryEntry(locs) {
+      var entry = {
+        tryLoc: locs[0]
       };
-      1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+      1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
     }
-    function resetTryEntry(t) {
-      var e = t.completion || {};
-      e.type = "normal", delete e.arg, t.completion = e;
+
+    function resetTryEntry(entry) {
+      var record = entry.completion || {};
+      record.type = "normal", delete record.arg, entry.completion = record;
     }
-    function Context(t) {
+
+    function Context(tryLocsList) {
       this.tryEntries = [{
         tryLoc: "root"
-      }], t.forEach(pushTryEntry, this), this.reset(!0);
+      }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
     }
-    function values(e) {
-      if (e || "" === e) {
-        var r = e[a];
-        if (r) return r.call(e);
-        if ("function" == typeof e.next) return e;
-        if (!isNaN(e.length)) {
-          var o = -1,
-            i = function next() {
-              for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
-              return next.value = t, next.done = !0, next;
-            };
-          return i.next = i;
+
+    function values(iterable) {
+      if (iterable) {
+        var iteratorMethod = iterable[iteratorSymbol];
+        if (iteratorMethod) return iteratorMethod.call(iterable);
+        if ("function" == typeof iterable.next) return iterable;
+
+        if (!isNaN(iterable.length)) {
+          var i = -1,
+              next = function next() {
+            for (; ++i < iterable.length;) {
+              if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+            }
+
+            return next.value = undefined, next.done = !0, next;
+          };
+
+          return next.next = next;
         }
       }
-      throw new TypeError(_typeof$1(e) + " is not iterable");
+
+      return {
+        next: doneResult
+      };
     }
-    return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
-      value: GeneratorFunctionPrototype,
-      configurable: !0
-    }), o(GeneratorFunctionPrototype, "constructor", {
-      value: GeneratorFunction,
-      configurable: !0
-    }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
-      var e = "function" == typeof t && t.constructor;
-      return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
-    }, e.mark = function (t) {
-      return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
-    }, e.awrap = function (t) {
+
+    function doneResult() {
       return {
-        __await: t
+        value: undefined,
+        done: !0
       };
-    }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+    }
+
+    return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+      var ctor = "function" == typeof genFun && genFun.constructor;
+      return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+    }, exports.mark = function (genFun) {
+      return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+    }, exports.awrap = function (arg) {
+      return {
+        __await: arg
+      };
+    }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
       return this;
-    }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
-      void 0 === i && (i = Promise);
-      var a = new AsyncIterator(wrap(t, r, n, o), i);
-      return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
-        return t.done ? t.value : a.next();
+    }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+      void 0 === PromiseImpl && (PromiseImpl = Promise);
+      var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+      return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+        return result.done ? result.value : iter.next();
       });
-    }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+    }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
       return this;
-    }), define(g, "toString", function () {
+    }), define(Gp, "toString", function () {
       return "[object Generator]";
-    }), e.keys = function (t) {
-      var e = Object(t),
-        r = [];
-      for (var n in e) r.push(n);
-      return r.reverse(), function next() {
-        for (; r.length;) {
-          var t = r.pop();
-          if (t in e) return next.value = t, next.done = !1, next;
+    }), exports.keys = function (object) {
+      var keys = [];
+
+      for (var key in object) {
+        keys.push(key);
+      }
+
+      return keys.reverse(), function next() {
+        for (; keys.length;) {
+          var key = keys.pop();
+          if (key in object) return next.value = key, next.done = !1, next;
         }
+
         return next.done = !0, next;
       };
-    }, e.values = values, Context.prototype = {
+    }, exports.values = values, Context.prototype = {
       constructor: Context,
-      reset: function reset(e) {
-        if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+      reset: function reset(skipTempReset) {
+        if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) {
+          "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+        }
       },
       stop: function stop() {
         this.done = !0;
-        var t = this.tryEntries[0].completion;
-        if ("throw" === t.type) throw t.arg;
+        var rootRecord = this.tryEntries[0].completion;
+        if ("throw" === rootRecord.type) throw rootRecord.arg;
         return this.rval;
       },
-      dispatchException: function dispatchException(e) {
-        if (this.done) throw e;
-        var r = this;
-        function handle(n, o) {
-          return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+      dispatchException: function dispatchException(exception) {
+        if (this.done) throw exception;
+        var context = this;
+
+        function handle(loc, caught) {
+          return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
         }
-        for (var o = this.tryEntries.length - 1; o >= 0; --o) {
-          var i = this.tryEntries[o],
-            a = i.completion;
-          if ("root" === i.tryLoc) return handle("end");
-          if (i.tryLoc <= this.prev) {
-            var c = n.call(i, "catchLoc"),
-              u = n.call(i, "finallyLoc");
-            if (c && u) {
-              if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
-              if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-            } else if (c) {
-              if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i],
+              record = entry.completion;
+          if ("root" === entry.tryLoc) return handle("end");
+
+          if (entry.tryLoc <= this.prev) {
+            var hasCatch = hasOwn.call(entry, "catchLoc"),
+                hasFinally = hasOwn.call(entry, "finallyLoc");
+
+            if (hasCatch && hasFinally) {
+              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+            } else if (hasCatch) {
+              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
             } else {
-              if (!u) throw Error("try statement without catch or finally");
-              if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+              if (!hasFinally) throw new Error("try statement without catch or finally");
+              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
             }
           }
         }
       },
-      abrupt: function abrupt(t, e) {
-        for (var r = this.tryEntries.length - 1; r >= 0; --r) {
-          var o = this.tryEntries[r];
-          if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
-            var i = o;
+      abrupt: function abrupt(type, arg) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+
+          if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+            var finallyEntry = entry;
             break;
           }
         }
-        i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
-        var a = i ? i.completion : {};
-        return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
-      },
-      complete: function complete(t, e) {
-        if ("throw" === t.type) throw t.arg;
-        return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
-      },
-      finish: function finish(t) {
-        for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-          var r = this.tryEntries[e];
-          if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+
+        finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+        var record = finallyEntry ? finallyEntry.completion : {};
+        return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+      },
+      complete: function complete(record, afterLoc) {
+        if ("throw" === record.type) throw record.arg;
+        return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+      },
+      finish: function finish(finallyLoc) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
         }
       },
-      "catch": function _catch(t) {
-        for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-          var r = this.tryEntries[e];
-          if (r.tryLoc === t) {
-            var n = r.completion;
-            if ("throw" === n.type) {
-              var o = n.arg;
-              resetTryEntry(r);
+      "catch": function _catch(tryLoc) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+
+          if (entry.tryLoc === tryLoc) {
+            var record = entry.completion;
+
+            if ("throw" === record.type) {
+              var thrown = record.arg;
+              resetTryEntry(entry);
             }
-            return o;
+
+            return thrown;
           }
         }
-        throw Error("illegal catch attempt");
+
+        throw new Error("illegal catch attempt");
       },
-      delegateYield: function delegateYield(e, r, n) {
+      delegateYield: function delegateYield(iterable, resultName, nextLoc) {
         return this.delegate = {
-          iterator: values(e),
-          resultName: r,
-          nextLoc: n
-        }, "next" === this.method && (this.arg = t), y;
+          iterator: values(iterable),
+          resultName: resultName,
+          nextLoc: nextLoc
+        }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
       }
-    }, e;
+    }, exports;
   }
+
   module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;
   }(regeneratorRuntime$1));
 
@@ -421,28 +457,38 @@
     }
   }
 
-  function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
-      var i = n[a](c),
-        u = i.value;
-    } catch (n) {
-      return void e(n);
+      var info = gen[key](arg);
+      var value = info.value;
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    if (info.done) {
+      resolve(value);
+    } else {
+      Promise.resolve(value).then(_next, _throw);
     }
-    i.done ? t(u) : Promise.resolve(u).then(r, o);
   }
-  function _asyncToGenerator(n) {
+
+  function _asyncToGenerator(fn) {
     return function () {
-      var t = this,
-        e = arguments;
-      return new Promise(function (r, o) {
-        var a = n.apply(t, e);
-        function _next(n) {
-          asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      var self = this,
+          args = arguments;
+      return new Promise(function (resolve, reject) {
+        var gen = fn.apply(self, args);
+
+        function _next(value) {
+          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
         }
-        function _throw(n) {
-          asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+
+        function _throw(err) {
+          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
         }
-        _next(void 0);
+
+        _next(undefined);
       });
     };
   }
@@ -456,12 +502,11 @@
   };
 
   var host = isWeapp ? 'https://xcx.veryeast.cn' : isWeb ? '/ve.resume' : ''; // 判断终端环境
-  var nowTime = new Date().getTime();
 
   // 公共接口
   var API_PUBLIC = {
     version: {
-      url: "https://dfws-file.veimg.cn/dict/version/list.json?t=".concat(nowTime.toString()),
+      url: "".concat(host, "/share-interface/v3/system/version/list"),
       method: 'GET',
       name: "版本信息"
     },
@@ -512,6 +557,12 @@
       name: '简历-基本信息-设置'
     },
     // 简历-基本信息-设置
+    set_ihma: {
+      url: "".concat(host, "/go/resume/v1/base/ihma"),
+      method: "PUT",
+      name: '简历-基本信息-设置IHMA'
+    },
+    // 简历-基本信息-设置IHMA
 
     get_intention: {
       url: "".concat(host, "/go/resume/v1/intention"),
@@ -841,7 +892,19 @@
       url: "".concat(host, "/go/resume/v1/all/parse/pc"),
       method: "POST",
       name: 'pc端-简历解析'
-    } // pc端-简历解析
+    },
+    // pc端-简历解析
+    set_micro_resume_base: {
+      url: "".concat(host, "/go/resume/v1/micro/pc/base"),
+      method: "POST",
+      name: 'pc端-保存微简历[第一步]'
+    },
+    // pc端-保存微简历[第一步]
+    set_micro_resume_more: {
+      url: "".concat(host, "/go/resume/v1/micro/pc/more"),
+      method: "POST",
+      name: 'pc端-保存微简历[第二步]'
+    } // pc端-保存微简历[第二步]
   };
 
   // 用户SSO
@@ -2039,6 +2102,7 @@
   function queryAddTrainingExp() {
     return _queryAddTrainingExp.apply(this, arguments);
   }
+  // 简历-基本信息-设置IHMA
   function _queryAddTrainingExp() {
     _queryAddTrainingExp = _asyncToGenerator(/*#__PURE__*/regenerator.mark(function _callee45() {
       var payload,
@@ -2060,6 +2124,30 @@
     }));
     return _queryAddTrainingExp.apply(this, arguments);
   }
+  function querySetIhmaStatus() {
+    return _querySetIhmaStatus.apply(this, arguments);
+  }
+  function _querySetIhmaStatus() {
+    _querySetIhmaStatus = _asyncToGenerator(/*#__PURE__*/regenerator.mark(function _callee46() {
+      var payload,
+        _API_RESUME$set_ihma,
+        url,
+        method,
+        _args46 = arguments;
+      return regenerator.wrap(function _callee46$(_context46) {
+        while (1) switch (_context46.prev = _context46.next) {
+          case 0:
+            payload = _args46.length > 0 && _args46[0] !== undefined ? _args46[0] : {};
+            _API_RESUME$set_ihma = API_RESUME.set_ihma, url = _API_RESUME$set_ihma.url, method = _API_RESUME$set_ihma.method;
+            return _context46.abrupt("return", request(url, payload, method));
+          case 3:
+          case "end":
+            return _context46.stop();
+        }
+      }, _callee46);
+    }));
+    return _querySetIhmaStatus.apply(this, arguments);
+  }
 
   // 删除简历职业风采
   function querySetAllInfo() {
@@ -2321,6 +2409,8 @@
   function queryAddUploadResume() {
     return _queryAddUploadResume.apply(this, arguments);
   }
+
+  //简历-保存微简历【第一步】
   function _queryAddUploadResume() {
     _queryAddUploadResume = _asyncToGenerator(/*#__PURE__*/regenerator.mark(function _callee11() {
       var payload,
@@ -2342,6 +2432,56 @@
     }));
     return _queryAddUploadResume.apply(this, arguments);
   }
+  function querySetMicroResumeBase() {
+    return _querySetMicroResumeBase.apply(this, arguments);
+  }
+
+  //简历-保存微简历【第二步】
+  function _querySetMicroResumeBase() {
+    _querySetMicroResumeBase = _asyncToGenerator(/*#__PURE__*/regenerator.mark(function _callee12() {
+      var payload,
+        _API_PC_RESUME$set_mi,
+        url,
+        method,
+        _args12 = arguments;
+      return regenerator.wrap(function _callee12$(_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
+          case 0:
+            payload = _args12.length > 0 && _args12[0] !== undefined ? _args12[0] : {};
+            _API_PC_RESUME$set_mi = API_PC_RESUME.set_micro_resume_base, url = _API_PC_RESUME$set_mi.url, method = _API_PC_RESUME$set_mi.method;
+            return _context12.abrupt("return", request(url, payload, method));
+          case 3:
+          case "end":
+            return _context12.stop();
+        }
+      }, _callee12);
+    }));
+    return _querySetMicroResumeBase.apply(this, arguments);
+  }
+  function querySetMicroResumeMore() {
+    return _querySetMicroResumeMore.apply(this, arguments);
+  }
+  function _querySetMicroResumeMore() {
+    _querySetMicroResumeMore = _asyncToGenerator(/*#__PURE__*/regenerator.mark(function _callee13() {
+      var payload,
+        _API_PC_RESUME$set_mi2,
+        url,
+        method,
+        _args13 = arguments;
+      return regenerator.wrap(function _callee13$(_context13) {
+        while (1) switch (_context13.prev = _context13.next) {
+          case 0:
+            payload = _args13.length > 0 && _args13[0] !== undefined ? _args13[0] : {};
+            _API_PC_RESUME$set_mi2 = API_PC_RESUME.set_micro_resume_more, url = _API_PC_RESUME$set_mi2.url, method = _API_PC_RESUME$set_mi2.method;
+            return _context13.abrupt("return", request(url, payload, method));
+          case 3:
+          case "end":
+            return _context13.stop();
+        }
+      }, _callee13);
+    }));
+    return _querySetMicroResumeMore.apply(this, arguments);
+  }
   var pc = {
     querySetAllInfo: querySetAllInfo,
     queryGetAllInfo: queryGetAllInfo,
@@ -2353,7 +2493,9 @@
     queryGetEdu: queryGetEdu,
     querySetEdu: querySetEdu,
     queryAddEdu: queryAddEdu,
-    queryAddUploadResume: queryAddUploadResume
+    queryAddUploadResume: queryAddUploadResume,
+    querySetMicroResumeBase: querySetMicroResumeBase,
+    querySetMicroResumeMore: querySetMicroResumeMore
   };
 
   function ownKeys$f(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
@@ -2606,13 +2748,34 @@
             }
           }, _callee7);
         })();
+      },
+      // 设置是否显示先之教育证书
+      setIhma: function setIhma(action, _ref8) {
+        var call = _ref8.call;
+        return /*#__PURE__*/regenerator.mark(function _callee8() {
+          var payload, response;
+          return regenerator.wrap(function _callee8$(_context8) {
+            while (1) switch (_context8.prev = _context8.next) {
+              case 0:
+                payload = action.payload;
+                _context8.next = 3;
+                return call(querySetIhmaStatus, payload);
+              case 3:
+                response = _context8.sent;
+                return _context8.abrupt("return", response);
+              case 5:
+              case "end":
+                return _context8.stop();
+            }
+          }, _callee8);
+        })();
       }
     },
     reducers: {
       save: function save() {
         var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-        var _ref8 = arguments.length > 1 ? arguments[1] : undefined,
-          payload = _ref8.payload;
+        var _ref9 = arguments.length > 1 ? arguments[1] : undefined,
+          payload = _ref9.payload;
         return _objectSpread$f(_objectSpread$f({}, state), payload);
       }
     }
@@ -2665,6 +2828,13 @@
         return dispatch({
           type: 'resume/fetchPcGetBase'
         });
+      },
+      // 设置是否显示先之教育证书
+      setIhma: function setIhma(params) {
+        return dispatch({
+          type: 'resume/setIhma',
+          payload: params
+        });
       }
     };
   };
@@ -4322,44 +4492,56 @@
     return _getArea.apply(this, arguments);
   }
 
-  function _arrayWithHoles(r) {
-    if (Array.isArray(r)) return r;
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+      return typeof obj;
+    } : function (obj) {
+      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    }, _typeof(obj);
   }
 
-  function _iterableToArrayLimit(r, l) {
-    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-    if (null != t) {
-      var e,
-        n,
-        i,
-        u,
-        a = [],
-        f = !0,
-        o = !1;
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+
+  function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+
+    var _s, _e;
+
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
       try {
-        if (i = (t = t.call(r)).next, 0 === l) {
-          if (Object(t) !== t) return;
-          f = !1;
-        } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-      } catch (r) {
-        o = !0, n = r;
+        if (!_n && _i["return"] != null) _i["return"]();
       } finally {
-        try {
-          if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
-        } finally {
-          if (o) throw n;
-        }
+        if (_d) throw _e;
       }
-      return a;
     }
+
+    return _arr;
   }
 
   function _nonIterableRest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
 
-  function _slicedToArray(r, e) {
-    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray$1(r, e) || _nonIterableRest();
+  function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest();
   }
 
   var generateTypeState = function generateTypeState(type) {
@@ -4368,7 +4550,7 @@
       var _ref2 = _slicedToArray(_ref, 2),
         key = _ref2[0],
         value = _ref2[1];
-      entries.push(_defineProperty({}, key, _typeof$1(value)));
+      entries.push(_defineProperty({}, key, _typeof(value)));
     });
     return entries;
   };
@@ -4381,13 +4563,13 @@
       var _ref4 = _slicedToArray(_ref3, 2),
         key = _ref4[0],
         value = _ref4[1];
-      entries.push(_defineProperty({}, key, typeof value == 'function' ? needsParameters(value.prototype.constructor) : _typeof$1(value)));
+      entries.push(_defineProperty({}, key, typeof value == 'function' ? needsParameters(value.prototype.constructor) : _typeof(value)));
     });
     return entries;
   };
   var baseClone = function baseClone(value, customizer, CLONE_DEEP, stack) {
     // 处理不同类型的数据
-    switch (_typeof$1(value)) {
+    switch (_typeof(value)) {
       case 'undefined':
       case 'null':
         return value;
@@ -4433,7 +4615,7 @@
     return result;
   };
   var isObjectLike = function isObjectLike(value) {
-    return value != null && _typeof$1(value) == 'object';
+    return value != null && _typeof(value) == 'object';
   };
   var getPrototype = function getPrototype(value) {
     var prototype = Object.getPrototypeOf(value);
@@ -4663,7 +4845,7 @@
                 response = _context2.sent;
                 if (!(response.status && response.status === 2)) {
                   if (callback) {
-                    callback(response);
+                    callback(response.data);
                   }
                 }
               case 5:
@@ -5205,13 +5387,63 @@
             }
           }, _callee4);
         })();
+      },
+      // pc微简历【第一步】
+      savePcBase: function savePcBase(action, _ref5) {
+        var call = _ref5.call;
+        return /*#__PURE__*/regenerator.mark(function _callee5() {
+          var payload, response;
+          return regenerator.wrap(function _callee5$(_context5) {
+            while (1) switch (_context5.prev = _context5.next) {
+              case 0:
+                payload = action.payload;
+                _context5.next = 3;
+                return call(pc.querySetMicroResumeBase, payload);
+              case 3:
+                response = _context5.sent;
+                if (!(response.status && response.status === 1)) {
+                  _context5.next = 6;
+                  break;
+                }
+                return _context5.abrupt("return", response);
+              case 6:
+              case "end":
+                return _context5.stop();
+            }
+          }, _callee5);
+        })();
+      },
+      // pc微简历【第二步】
+      savePcMore: function savePcMore(action, _ref6) {
+        var call = _ref6.call;
+        return /*#__PURE__*/regenerator.mark(function _callee6() {
+          var payload, response;
+          return regenerator.wrap(function _callee6$(_context6) {
+            while (1) switch (_context6.prev = _context6.next) {
+              case 0:
+                payload = action.payload;
+                _context6.next = 3;
+                return call(pc.querySetMicroResumeMore, payload);
+              case 3:
+                response = _context6.sent;
+                if (!(response.status && response.status === 1)) {
+                  _context6.next = 6;
+                  break;
+                }
+                return _context6.abrupt("return", response);
+              case 6:
+              case "end":
+                return _context6.stop();
+            }
+          }, _callee6);
+        })();
       }
     },
     reducers: {
       save: function save() {
         var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-        var _ref5 = arguments.length > 1 ? arguments[1] : undefined,
-          payload = _ref5.payload;
+        var _ref7 = arguments.length > 1 ? arguments[1] : undefined,
+          payload = _ref7.payload;
         return _objectSpread$6({
           state: state
         }, payload);
@@ -5262,6 +5494,20 @@
         return dispatch({
           type: 'micro/clearSave'
         });
+      },
+      // 保存微简历[第一步]
+      savePcBase: function savePcBase(params) {
+        return dispatch({
+          type: 'micro/savePcBase',
+          payload: params
+        });
+      },
+      // 保存微简历[第二步]
+      savePcMore: function savePcMore(params) {
+        return dispatch({
+          type: 'micro/savePcMore',
+          payload: params
+        });
       }
     };
   };