@vunk/form 1.1.21 → 1.1.24

package/components/esri-input-geojson/index.js

@@ -0,0 +1,1526 @@
+import { openBlock, createElementBlock, createElementVNode, defineComponent, resolveComponent, createBlock, withCtx, createVNode, createCommentVNode, provide, renderSlot, shallowRef, computed, onMounted, ref, mergeProps, toHandlers, withDirectives, vShow } from 'vue';
+import { _VkfInputCtx, VkfInput } from '@vunk/form/components/input';
+import { EMPTY_FEATURE_COLLECTION } from '@vumap/core/shared/static';
+import { bindPropsFactory, onEmitsFactory } from '@vunk/core/shared/utils-vue';
+import { ElButton, ElIcon, ElButtonGroup, ElUpload, ElMessage } from 'element-plus';
+import { VaTdtBasemap, VaMapView, VaSketch, VaGraphicsLayer } from '@vuesri/core';
+import MapView from '@arcgis/core/views/MapView';
+import SceneView from '@arcgis/core/views/SceneView';
+import { VkAsyncTeleport } from '@vunk/core';
+import Graphic from '@arcgis/core/Graphic';
+import { useComputedReadonly } from '@vunk/form/composables';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues({}, _VkfInputCtx.props), {
+  readonly: {
+    type: Boolean,
+    default: void 0
+  },
+  view: {
+    type: Object
+  },
+  editTypes: {
+    type: [Array, String],
+    default: () => "polygon"
+  },
+  viewModelActiveFillSymbol: {
+    type: Object,
+    default: () => ({
+      type: "simple-fill",
+      color: [0, 0, 0, 0],
+      style: "solid",
+      outline: {
+        color: [255, 0, 0, 1],
+        width: 2,
+        style: "dash"
+      }
+    })
+  },
+  viewModelActiveLineSymbol: null,
+  viewModelActivePointSymbol: null,
+  modelValue: {
+    type: Object,
+    default: () => EMPTY_FEATURE_COLLECTION
+  },
+  multiple: {
+    type: Boolean,
+    default: true
+  },
+  mapTo: {
+    type: [Object, String],
+    default: void 0
+  },
+  skipSave: {
+    type: Boolean,
+    default: false
+  },
+  showMap: {
+    type: Boolean,
+    default: false
+  },
+  dialogEdit: {
+    type: Boolean,
+    default: true
+  },
+  dialogEditFullscreen: {
+    type: Boolean,
+    default: true
+  },
+  dialogEditTitle: {
+    type: String,
+    default: "\u7ED8\u5236\u56FE\u6591"
+  }
+});
+bindPropsFactory(props);
+const emits = __spreadProps(__spreadValues({}, _VkfInputCtx.emits), {
+  "update:modelValue": (e) => e
+});
+onEmitsFactory(emits);
+
+var EDIT_TYPE = /* @__PURE__ */ ((EDIT_TYPE2) => {
+  EDIT_TYPE2["POINT"] = "point";
+  EDIT_TYPE2["POLYGON"] = "polygon";
+  EDIT_TYPE2["LINE_STRING"] = "line_string";
+  return EDIT_TYPE2;
+})(EDIT_TYPE || {});
+const EDIT_TYPE_OPTIONS = [
+  {
+    label: "\u70B9",
+    value: "point" /* POINT */,
+    availableCreatureTools: ["point"]
+  },
+  {
+    label: "\u7EBF",
+    value: "line_string" /* LINE_STRING */,
+    availableCreatureTools: ["polyline"]
+  },
+  {
+    label: "\u9762",
+    value: "polygon" /* POLYGON */,
+    availableCreatureTools: ["polygon", "circle", "rectangle"]
+  }
+];
+const EDIT_TYPE_REFLECT = EDIT_TYPE_OPTIONS.reduce((acc, cur) => {
+  acc[cur.value] = cur;
+  return acc;
+}, {});
+
+/*! Element Plus Icons Vue v2.1.0 */
+
+// unplugin-vue:/plugin-vue/export-helper
+var export_helper_default = (sfc, props) => {
+  let target = sfc.__vccOpts || sfc;
+  for (let [key, val] of props)
+    target[key] = val;
+  return target;
+};
+
+// unplugin-vue:/home/runner/work/element-plus-icons/element-plus-icons/packages/vue/src/components/document-checked.vue?vue&type=script&lang.ts
+var document_checked_vue_vue_type_script_lang_default = {
+  name: "DocumentChecked"
+};
+var _hoisted_186 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 1024 1024"
+}, _hoisted_286 = /* @__PURE__ */ createElementVNode(
+  "path",
+  {
+    fill: "currentColor",
+    d: "M805.504 320 640 154.496V320h165.504zM832 384H576V128H192v768h640V384zM160 64h480l256 256v608a32 32 0 0 1-32 32H160a32 32 0 0 1-32-32V96a32 32 0 0 1 32-32zm318.4 582.144 180.992-180.992L704.64 510.4 478.4 736.64 320 578.304l45.248-45.312L478.4 646.144z"
+  },
+  null,
+  -1
+  /* HOISTED */
+), _hoisted_385 = [
+  _hoisted_286
+];
+function _sfc_render86(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_186, _hoisted_385);
+}
+var document_checked_default = /* @__PURE__ */ export_helper_default(document_checked_vue_vue_type_script_lang_default, [["render", _sfc_render86], ["__file", "document-checked.vue"]]);
+
+// unplugin-vue:/home/runner/work/element-plus-icons/element-plus-icons/packages/vue/src/components/edit.vue?vue&type=script&lang.ts
+var edit_vue_vue_type_script_lang_default = {
+  name: "Edit"
+};
+var _hoisted_194 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 1024 1024"
+}, _hoisted_294 = /* @__PURE__ */ createElementVNode(
+  "path",
+  {
+    fill: "currentColor",
+    d: "M832 512a32 32 0 1 1 64 0v352a32 32 0 0 1-32 32H160a32 32 0 0 1-32-32V160a32 32 0 0 1 32-32h352a32 32 0 0 1 0 64H192v640h640V512z"
+  },
+  null,
+  -1
+  /* HOISTED */
+), _hoisted_393 = /* @__PURE__ */ createElementVNode(
+  "path",
+  {
+    fill: "currentColor",
+    d: "m469.952 554.24 52.8-7.552L847.104 222.4a32 32 0 1 0-45.248-45.248L477.44 501.44l-7.552 52.8zm422.4-422.4a96 96 0 0 1 0 135.808l-331.84 331.84a32 32 0 0 1-18.112 9.088L436.8 623.68a32 32 0 0 1-36.224-36.224l15.104-105.6a32 32 0 0 1 9.024-18.112l331.904-331.84a96 96 0 0 1 135.744 0z"
+  },
+  null,
+  -1
+  /* HOISTED */
+), _hoisted_431 = [
+  _hoisted_294,
+  _hoisted_393
+];
+function _sfc_render94(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_194, _hoisted_431);
+}
+var edit_default = /* @__PURE__ */ export_helper_default(edit_vue_vue_type_script_lang_default, [["render", _sfc_render94], ["__file", "edit.vue"]]);
+
+// unplugin-vue:/home/runner/work/element-plus-icons/element-plus-icons/packages/vue/src/components/upload.vue?vue&type=script&lang.ts
+var upload_vue_vue_type_script_lang_default = {
+  name: "Upload"
+};
+var _hoisted_1275 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 1024 1024"
+}, _hoisted_2275 = /* @__PURE__ */ createElementVNode(
+  "path",
+  {
+    fill: "currentColor",
+    d: "M160 832h704a32 32 0 1 1 0 64H160a32 32 0 1 1 0-64zm384-578.304V704h-64V247.296L237.248 490.048 192 444.8 508.8 128l316.8 316.8-45.312 45.248L544 253.696z"
+  },
+  null,
+  -1
+  /* HOISTED */
+), _hoisted_3274 = [
+  _hoisted_2275
+];
+function _sfc_render275(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", _hoisted_1275, _hoisted_3274);
+}
+var upload_default = /* @__PURE__ */ export_helper_default(upload_vue_vue_type_script_lang_default, [["render", _sfc_render275], ["__file", "upload.vue"]]);
+
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const _sfc_main$2 = defineComponent({
+  components: {
+    ElButton,
+    ElIcon,
+    ElButtonGroup,
+    Upload: upload_default,
+    Edit: edit_default,
+    ElUpload
+  },
+  props: {
+    disabled: Boolean,
+    dialog: Boolean,
+    upload: {
+      type: Boolean,
+      default: true
+    }
+  },
+  emits: {
+    upload: (e) => e,
+    edit: null
+  },
+  methods: {
+    getFile(file) {
+      this.$emit("upload", file);
+    },
+    uploadClick(e) {
+      const target = e.target.querySelector("input[type=file]");
+      if (!target)
+        return;
+      target.click();
+    }
+  }
+});
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_Upload = resolveComponent("Upload");
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_ElUpload = resolveComponent("ElUpload");
+  const _component_Edit = resolveComponent("Edit");
+  const _component_ElButton = resolveComponent("ElButton");
+  const _component_ElButtonGroup = resolveComponent("ElButtonGroup");
+  return openBlock(), createBlock(_component_ElButtonGroup, null, {
+    default: withCtx(() => [
+      _ctx.upload ? (openBlock(), createBlock(_component_ElUpload, {
+        key: 0,
+        class: "el-button el-button--default vkf-esri-input-geojson__upload",
+        action: "",
+        accept: "file",
+        multiple: false,
+        "show-file-list": false,
+        "auto-upload": false,
+        "on-change": _ctx.getFile,
+        disabled: _ctx.disabled,
+        onClick: _ctx.uploadClick
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_ElIcon, { color: "var(--el-color-primary)" }, {
+            default: withCtx(() => [
+              createVNode(_component_Upload)
+            ]),
+            _: 1
+          }, 8, ["color"])
+        ]),
+        _: 1
+      }, 8, ["on-change", "disabled", "onClick"])) : createCommentVNode("v-if", true),
+      _ctx.dialog ? (openBlock(), createBlock(_component_ElButton, {
+        key: 1,
+        onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("edit")),
+        disabled: _ctx.disabled
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_ElIcon, { color: "var(--el-color-primary)" }, {
+            default: withCtx(() => [
+              createVNode(_component_Edit)
+            ]),
+            _: 1
+          }, 8, ["color"])
+        ]),
+        _: 1
+      }, 8, ["disabled"])) : createCommentVNode("v-if", true)
+    ]),
+    _: 1
+  });
+}
+var AppendVue = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["render", _sfc_render$2], ["__file", "append.vue"]]);
+
+const _sfc_main$1 = defineComponent({
+  components: {
+    VaTdtBasemap,
+    VaMapView
+  },
+  props: {
+    view: {
+      type: Object
+    }
+  },
+  setup(props) {
+    if (props.view) {
+      provide("vaView", props.view);
+      if (props.view instanceof MapView) {
+        provide("vaMapView", props.view);
+      }
+      if (props.view instanceof SceneView) {
+        provide("vaSceneView", props.view);
+      }
+    }
+    return {};
+  }
+});
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VaTdtBasemap = resolveComponent("VaTdtBasemap");
+  const _component_VaMapView = resolveComponent("VaMapView");
+  return !_ctx.view ? (openBlock(), createBlock(_component_VaMapView, { key: 0 }, {
+    default: withCtx(() => [
+      createVNode(_component_VaTdtBasemap),
+      renderSlot(_ctx.$slots, "default")
+    ]),
+    _: 3
+  })) : renderSlot(_ctx.$slots, "default", { key: 1 });
+}
+var ViewerVue = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render$1], ["__file", "viewer.vue"]]);
+
+function array_cancel() {
+  this._array = null;
+  return Promise.resolve();
+}
+
+function array_read() {
+  var array = this._array;
+  this._array = null;
+  return Promise.resolve(array ? {done: false, value: array} : {done: true, value: undefined});
+}
+
+function array(array) {
+  return new ArraySource(array instanceof Uint8Array ? array : new Uint8Array(array));
+}
+
+function ArraySource(array) {
+  this._array = array;
+}
+
+ArraySource.prototype.read = array_read;
+ArraySource.prototype.cancel = array_cancel;
+
+function fetchPath(url) {
+  return fetch(url).then(function(response) {
+    return response.body && response.body.getReader
+        ? response.body.getReader()
+        : response.arrayBuffer().then(array);
+  });
+}
+
+function requestPath(url) {
+  return new Promise(function(resolve, reject) {
+    var request = new XMLHttpRequest;
+    request.responseType = "arraybuffer";
+    request.onload = function() { resolve(array(request.response)); };
+    request.onerror = reject;
+    request.ontimeout = reject;
+    request.open("GET", url, true);
+    request.send();
+  });
+}
+
+function path(path) {
+  return (typeof fetch === "function" ? fetchPath : requestPath)(path);
+}
+
+function stream(source) {
+  return typeof source.read === "function" ? source : source.getReader();
+}
+
+var empty = new Uint8Array(0);
+
+function slice_cancel() {
+  return this._source.cancel();
+}
+
+function concat$1(a, b) {
+  if (!a.length) return b;
+  if (!b.length) return a;
+  var c = new Uint8Array(a.length + b.length);
+  c.set(a);
+  c.set(b, a.length);
+  return c;
+}
+
+function slice_read() {
+  var that = this, array = that._array.subarray(that._index);
+  return that._source.read().then(function(result) {
+    that._array = empty;
+    that._index = 0;
+    return result.done ? (array.length > 0
+        ? {done: false, value: array}
+        : {done: true, value: undefined})
+        : {done: false, value: concat$1(array, result.value)};
+  });
+}
+
+function slice_slice(length) {
+  if ((length |= 0) < 0) throw new Error("invalid length");
+  var that = this, index = this._array.length - this._index;
+
+  // If the request fits within the remaining buffer, resolve it immediately.
+  if (this._index + length <= this._array.length) {
+    return Promise.resolve(this._array.subarray(this._index, this._index += length));
+  }
+
+  // Otherwise, read chunks repeatedly until the request is fulfilled.
+  var array = new Uint8Array(length);
+  array.set(this._array.subarray(this._index));
+  return (function read() {
+    return that._source.read().then(function(result) {
+
+      // When done, it’s possible the request wasn’t fully fullfilled!
+      // If so, the pre-allocated array is too big and needs slicing.
+      if (result.done) {
+        that._array = empty;
+        that._index = 0;
+        return index > 0 ? array.subarray(0, index) : null;
+      }
+
+      // If this chunk fulfills the request, return the resulting array.
+      if (index + result.value.length >= length) {
+        that._array = result.value;
+        that._index = length - index;
+        array.set(result.value.subarray(0, length - index), index);
+        return array;
+      }
+
+      // Otherwise copy this chunk into the array, then read the next chunk.
+      array.set(result.value, index);
+      index += result.value.length;
+      return read();
+    });
+  })();
+}
+
+function slice(source) {
+  return typeof source.slice === "function" ? source :
+      new SliceSource(typeof source.read === "function" ? source
+          : source.getReader());
+}
+
+function SliceSource(source) {
+  this._source = source;
+  this._array = empty;
+  this._index = 0;
+}
+
+SliceSource.prototype.read = slice_read;
+SliceSource.prototype.slice = slice_slice;
+SliceSource.prototype.cancel = slice_cancel;
+
+function dbf_cancel() {
+  return this._source.cancel();
+}
+
+function readBoolean(value) {
+  return /^[nf]$/i.test(value) ? false
+      : /^[yt]$/i.test(value) ? true
+      : null;
+}
+
+function readDate(value) {
+  return new Date(+value.substring(0, 4), value.substring(4, 6) - 1, +value.substring(6, 8));
+}
+
+function readNumber(value) {
+  return !(value = value.trim()) || isNaN(value = +value) ? null : value;
+}
+
+function readString(value) {
+  return value.trim() || null;
+}
+
+var types$1 = {
+  B: readNumber,
+  C: readString,
+  D: readDate,
+  F: readNumber,
+  L: readBoolean,
+  M: readNumber,
+  N: readNumber
+};
+
+function dbf_read() {
+  var that = this, i = 1;
+  return that._source.slice(that._recordLength).then(function(value) {
+    return value && (value[0] !== 0x1a) ? {done: false, value: that._fields.reduce(function(p, f) {
+      p[f.name] = types$1[f.type](that._decode(value.subarray(i, i += f.length)));
+      return p;
+    }, {})} : {done: true, value: undefined};
+  });
+}
+
+function view(array) {
+  return new DataView(array.buffer, array.byteOffset, array.byteLength);
+}
+
+function dbf(source, decoder) {
+  source = slice(source);
+  return source.slice(32).then(function(array) {
+    var head = view(array);
+    return source.slice(head.getUint16(8, true) - 32).then(function(array) {
+      return new Dbf(source, decoder, head, view(array));
+    });
+  });
+}
+
+function Dbf(source, decoder, head, body) {
+  this._source = source;
+  this._decode = decoder.decode.bind(decoder);
+  this._recordLength = head.getUint16(10, true);
+  this._fields = [];
+  for (var n = 0; body.getUint8(n) !== 0x0d; n += 32) {
+    for (var j = 0; j < 11; ++j) if (body.getUint8(n + j) === 0) break;
+    this._fields.push({
+      name: this._decode(new Uint8Array(body.buffer, body.byteOffset + n, j)),
+      type: String.fromCharCode(body.getUint8(n + 11)),
+      length: body.getUint8(n + 16)
+    });
+  }
+}
+
+var prototype$2 = Dbf.prototype;
+prototype$2.read = dbf_read;
+prototype$2.cancel = dbf_cancel;
+
+function cancel() {
+  return this._source.cancel();
+}
+
+function parseMultiPoint(record) {
+  var i = 40, j, n = record.getInt32(36, true), coordinates = new Array(n);
+  for (j = 0; j < n; ++j, i += 16) coordinates[j] = [record.getFloat64(i, true), record.getFloat64(i + 8, true)];
+  return {type: "MultiPoint", coordinates: coordinates};
+}
+
+function parseNull() {
+  return null;
+}
+
+function parsePoint(record) {
+  return {type: "Point", coordinates: [record.getFloat64(4, true), record.getFloat64(12, true)]};
+}
+
+function parsePolygon(record) {
+  var i = 44, j, n = record.getInt32(36, true), m = record.getInt32(40, true), parts = new Array(n), points = new Array(m), polygons = [], holes = [];
+  for (j = 0; j < n; ++j, i += 4) parts[j] = record.getInt32(i, true);
+  for (j = 0; j < m; ++j, i += 16) points[j] = [record.getFloat64(i, true), record.getFloat64(i + 8, true)];
+
+  parts.forEach(function(i, j) {
+    var ring = points.slice(i, parts[j + 1]);
+    if (ringClockwise(ring)) polygons.push([ring]);
+    else holes.push(ring);
+  });
+
+  holes.forEach(function(hole) {
+    polygons.some(function(polygon) {
+      if (ringContainsSome(polygon[0], hole)) {
+        polygon.push(hole);
+        return true;
+      }
+    }) || polygons.push([hole]);
+  });
+
+  return polygons.length === 1
+      ? {type: "Polygon", coordinates: polygons[0]}
+      : {type: "MultiPolygon", coordinates: polygons};
+}
+function ringClockwise(ring) {
+  if ((n = ring.length) < 4) return false;
+  var i = 0, n, area = ring[n - 1][1] * ring[0][0] - ring[n - 1][0] * ring[0][1];
+  while (++i < n) area += ring[i - 1][1] * ring[i][0] - ring[i - 1][0] * ring[i][1];
+  return area >= 0;
+}
+
+function ringContainsSome(ring, hole) {
+  var i = -1, n = hole.length, c;
+  while (++i < n) {
+    if (c = ringContains(ring, hole[i])) {
+      return c > 0;
+    }
+  }
+  return false;
+}
+
+function ringContains(ring, point) {
+  var x = point[0], y = point[1], contains = -1;
+  for (var i = 0, n = ring.length, j = n - 1; i < n; j = i++) {
+    var pi = ring[i], xi = pi[0], yi = pi[1],
+        pj = ring[j], xj = pj[0], yj = pj[1];
+    if (segmentContains(pi, pj, point)) {
+      return 0;
+    }
+    if (((yi > y) !== (yj > y)) && ((x < (xj - xi) * (y - yi) / (yj - yi) + xi))) {
+      contains = -contains;
+    }
+  }
+  return contains;
+}
+
+function segmentContains(p0, p1, p2) {
+  var x20 = p2[0] - p0[0], y20 = p2[1] - p0[1];
+  if (x20 === 0 && y20 === 0) return true;
+  var x10 = p1[0] - p0[0], y10 = p1[1] - p0[1];
+  if (x10 === 0 && y10 === 0) return false;
+  var t = (x20 * x10 + y20 * y10) / (x10 * x10 + y10 * y10);
+  return t < 0 || t > 1 ? false : t === 0 || t === 1 ? true : t * x10 === x20 && t * y10 === y20;
+}
+
+function parsePolyLine(record) {
+  var i = 44, j, n = record.getInt32(36, true), m = record.getInt32(40, true), parts = new Array(n), points = new Array(m);
+  for (j = 0; j < n; ++j, i += 4) parts[j] = record.getInt32(i, true);
+  for (j = 0; j < m; ++j, i += 16) points[j] = [record.getFloat64(i, true), record.getFloat64(i + 8, true)];
+  return n === 1
+      ? {type: "LineString", coordinates: points}
+      : {type: "MultiLineString", coordinates: parts.map(function(i, j) { return points.slice(i, parts[j + 1]); })};
+}
+
+function concat(a, b) {
+  var ab = new Uint8Array(a.length + b.length);
+  ab.set(a, 0);
+  ab.set(b, a.length);
+  return ab;
+}
+
+function shp_read() {
+  var that = this;
+  ++that._index;
+  return that._source.slice(12).then(function(array) {
+    if (array == null) return {done: true, value: undefined};
+    var header = view(array);
+
+    // If the record starts with an invalid shape type (see #36), scan ahead in
+    // four-byte increments to find the next valid record, identified by the
+    // expected index, a non-empty content length and a valid shape type.
+    function skip() {
+      return that._source.slice(4).then(function(chunk) {
+        if (chunk == null) return {done: true, value: undefined};
+        header = view(array = concat(array.slice(4), chunk));
+        return header.getInt32(0, false) !== that._index ? skip() : read();
+      });
+    }
+
+    // All records should have at least four bytes (for the record shape type),
+    // so an invalid content length indicates corruption.
+    function read() {
+      var length = header.getInt32(4, false) * 2 - 4, type = header.getInt32(8, true);
+      return length < 0 || (type && type !== that._type) ? skip() : that._source.slice(length).then(function(chunk) {
+        return {done: false, value: type ? that._parse(view(concat(array.slice(8), chunk))) : null};
+      });
+    }
+
+    return read();
+  });
+}
+
+var parsers = {
+  0: parseNull,
+  1: parsePoint,
+  3: parsePolyLine,
+  5: parsePolygon,
+  8: parseMultiPoint,
+  11: parsePoint, // PointZ
+  13: parsePolyLine, // PolyLineZ
+  15: parsePolygon, // PolygonZ
+  18: parseMultiPoint, // MultiPointZ
+  21: parsePoint, // PointM
+  23: parsePolyLine, // PolyLineM
+  25: parsePolygon, // PolygonM
+  28: parseMultiPoint // MultiPointM
+};
+
+function shp(source) {
+  source = slice(source);
+  return source.slice(100).then(function(array) {
+    return new Shp(source, view(array));
+  });
+}
+function Shp(source, header) {
+  var type = header.getInt32(32, true);
+  if (!(type in parsers)) throw new Error("unsupported shape type: " + type);
+  this._source = source;
+  this._type = type;
+  this._index = 0;
+  this._parse = parsers[type];
+  this.bbox = [header.getFloat64(36, true), header.getFloat64(44, true), header.getFloat64(52, true), header.getFloat64(60, true)];
+}
+
+var prototype$1 = Shp.prototype;
+prototype$1.read = shp_read;
+prototype$1.cancel = cancel;
+
+function noop() {}
+
+function shapefile_cancel() {
+  return Promise.all([
+    this._dbf && this._dbf.cancel(),
+    this._shp.cancel()
+  ]).then(noop);
+}
+
+function shapefile_read() {
+  var that = this;
+  return Promise.all([
+    that._dbf ? that._dbf.read() : {value: {}},
+    that._shp.read()
+  ]).then(function(results) {
+    var dbf = results[0], shp = results[1];
+    return shp.done ? shp : {
+      done: false,
+      value: {
+        type: "Feature",
+        properties: dbf.value,
+        geometry: shp.value
+      }
+    };
+  });
+}
+
+function shapefile(shpSource, dbfSource, decoder) {
+  return Promise.all([
+    shp(shpSource),
+    dbfSource && dbf(dbfSource, decoder)
+  ]).then(function(sources) {
+    return new Shapefile(sources[0], sources[1]);
+  });
+}
+
+function Shapefile(shp, dbf) {
+  this._shp = shp;
+  this._dbf = dbf;
+  this.bbox = shp.bbox;
+}
+
+var prototype = Shapefile.prototype;
+prototype.read = shapefile_read;
+prototype.cancel = shapefile_cancel;
+
+function open(shp, dbf, options) {
+  if (typeof dbf === "string") {
+    if (!/\.dbf$/.test(dbf)) dbf += ".dbf";
+    dbf = path(dbf);
+  } else if (dbf instanceof ArrayBuffer || dbf instanceof Uint8Array) {
+    dbf = array(dbf);
+  } else if (dbf != null) {
+    dbf = stream(dbf);
+  }
+  if (typeof shp === "string") {
+    if (!/\.shp$/.test(shp)) shp += ".shp";
+    if (dbf === undefined) dbf = path(shp.substring(0, shp.length - 4) + ".dbf").catch(function() {});
+    shp = path(shp);
+  } else if (shp instanceof ArrayBuffer || shp instanceof Uint8Array) {
+    shp = array(shp);
+  } else {
+    shp = stream(shp);
+  }
+  return Promise.all([shp, dbf]).then(function(sources) {
+    var shp = sources[0], dbf = sources[1], encoding = "windows-1252";
+    if (options && options.encoding != null) encoding = options.encoding;
+    return shapefile(shp, dbf, dbf && new TextDecoder(encoding));
+  });
+}
+
+const shpToGeojson = (file) => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsArrayBuffer(file);
+    const data = {
+      type: "FeatureCollection",
+      features: []
+    };
+    reader.onload = function() {
+      open(this.result).then((source) => source.read().then(
+        function log(result) {
+          if (!result.done) {
+            data.features.push(result.value);
+            source.read().then(log);
+          } else {
+            if (result.value) {
+              data.features.push(result.value);
+            }
+            resolve(data);
+          }
+        }
+      )).catch(reject);
+    };
+  });
+};
+
+const toGeojson = (file) => {
+  const actions = {
+    shp: shpToGeojson
+  };
+  return new Promise((resolve, reject) => {
+    const suffix = file.name.split(".").pop();
+    if (suffix && actions[suffix]) {
+      resolve(actions[suffix](file));
+    } else {
+      reject(new Error(`Can't resolve the .${suffix} file`));
+    }
+  });
+};
+
+/* @preserve
+* @terraformer/arcgis - v2.1.1 - MIT
+* Copyright (c) 2012-2022 Environmental Systems Research Institute, Inc.
+* Tue Aug 02 2022 14:23:48 GMT-0700 (Pacific Daylight Time)
+*/
+/* Copyright (c) 2012-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+var edgeIntersectsEdge = function edgeIntersectsEdge(a1, a2, b1, b2) {
+  var uaT = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]);
+  var ubT = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]);
+  var uB = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]);
+
+  if (uB !== 0) {
+    var ua = uaT / uB;
+    var ub = ubT / uB;
+
+    if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {
+      return true;
+    }
+  }
+
+  return false;
+};
+var coordinatesContainPoint = function coordinatesContainPoint(coordinates, point) {
+  var contains = false;
+
+  for (var i = -1, l = coordinates.length, j = l - 1; ++i < l; j = i) {
+    if ((coordinates[i][1] <= point[1] && point[1] < coordinates[j][1] || coordinates[j][1] <= point[1] && point[1] < coordinates[i][1]) && point[0] < (coordinates[j][0] - coordinates[i][0]) * (point[1] - coordinates[i][1]) / (coordinates[j][1] - coordinates[i][1]) + coordinates[i][0]) {
+      contains = !contains;
+    }
+  }
+
+  return contains;
+};
+var pointsEqual = function pointsEqual(a, b) {
+  for (var i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+var arrayIntersectsArray = function arrayIntersectsArray(a, b) {
+  for (var i = 0; i < a.length - 1; i++) {
+    for (var j = 0; j < b.length - 1; j++) {
+      if (edgeIntersectsEdge(a[i], a[i + 1], b[j], b[j + 1])) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+/* Copyright (c) 2012-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+var closeRing = function closeRing(coordinates) {
+  if (!pointsEqual(coordinates[0], coordinates[coordinates.length - 1])) {
+    coordinates.push(coordinates[0]);
+  }
+
+  return coordinates;
+}; // determine if polygon ring coordinates are clockwise. clockwise signifies outer ring, counter-clockwise an inner ring
+// or hole. this logic was found at http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-
+// points-are-in-clockwise-order
+
+var ringIsClockwise = function ringIsClockwise(ringToTest) {
+  var total = 0;
+  var i = 0;
+  var rLength = ringToTest.length;
+  var pt1 = ringToTest[i];
+  var pt2;
+
+  for (i; i < rLength - 1; i++) {
+    pt2 = ringToTest[i + 1];
+    total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1]);
+    pt1 = pt2;
+  }
+
+  return total >= 0;
+}; // This function ensures that rings are oriented in the right directions
+// from http://jsperf.com/cloning-an-object/2
+
+var shallowClone = function shallowClone(obj) {
+  var target = {};
+
+  for (var i in obj) {
+    // both arcgis attributes and geojson props are just hardcoded keys
+    if (obj.hasOwnProperty(i)) {
+      // eslint-disable-line no-prototype-builtins
+      target[i] = obj[i];
+    }
+  }
+
+  return target;
+};
+
+/* Copyright (c) 2012-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+var coordinatesContainCoordinates = function coordinatesContainCoordinates(outer, inner) {
+  var intersects = arrayIntersectsArray(outer, inner);
+  var contains = coordinatesContainPoint(outer, inner[0]);
+
+  if (!intersects && contains) {
+    return true;
+  }
+
+  return false;
+}; // do any polygons in this array contain any other polygons in this array?
+// used for checking for holes in arcgis rings
+
+
+var convertRingsToGeoJSON = function convertRingsToGeoJSON(rings) {
+  var outerRings = [];
+  var holes = [];
+  var x; // iterator
+
+  var outerRing; // current outer ring being evaluated
+
+  var hole; // current hole being evaluated
+  // for each ring
+
+  for (var r = 0; r < rings.length; r++) {
+    var ring = closeRing(rings[r].slice(0));
+
+    if (ring.length < 4) {
+      continue;
+    } // is this ring an outer ring? is it clockwise?
+
+
+    if (ringIsClockwise(ring)) {
+      var polygon = [ring.slice().reverse()]; // wind outer rings counterclockwise for RFC 7946 compliance
+
+      outerRings.push(polygon); // push to outer rings
+    } else {
+      holes.push(ring.slice().reverse()); // wind inner rings clockwise for RFC 7946 compliance
+    }
+  }
+
+  var uncontainedHoles = []; // while there are holes left...
+
+  while (holes.length) {
+    // pop a hole off out stack
+    hole = holes.pop(); // loop over all outer rings and see if they contain our hole.
+
+    var contained = false;
+
+    for (x = outerRings.length - 1; x >= 0; x--) {
+      outerRing = outerRings[x][0];
+
+      if (coordinatesContainCoordinates(outerRing, hole)) {
+        // the hole is contained push it into our polygon
+        outerRings[x].push(hole);
+        contained = true;
+        break;
+      }
+    } // ring is not contained in any outer ring
+    // sometimes this happens https://github.com/Esri/esri-leaflet/issues/320
+
+
+    if (!contained) {
+      uncontainedHoles.push(hole);
+    }
+  } // if we couldn't match any holes using contains we can try intersects...
+
+
+  while (uncontainedHoles.length) {
+    // pop a hole off out stack
+    hole = uncontainedHoles.pop(); // loop over all outer rings and see if any intersect our hole.
+
+    var intersects = false;
+
+    for (x = outerRings.length - 1; x >= 0; x--) {
+      outerRing = outerRings[x][0];
+
+      if (arrayIntersectsArray(outerRing, hole)) {
+        // the hole is contained push it into our polygon
+        outerRings[x].push(hole);
+        intersects = true;
+        break;
+      }
+    }
+
+    if (!intersects) {
+      outerRings.push([hole.reverse()]);
+    }
+  }
+
+  if (outerRings.length === 1) {
+    return {
+      type: 'Polygon',
+      coordinates: outerRings[0]
+    };
+  } else {
+    return {
+      type: 'MultiPolygon',
+      coordinates: outerRings
+    };
+  }
+};
+
+var getId = function getId(attributes, idAttribute) {
+  var keys = idAttribute ? [idAttribute, 'OBJECTID', 'FID'] : ['OBJECTID', 'FID'];
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+
+    if (key in attributes && (typeof attributes[key] === 'string' || typeof attributes[key] === 'number')) {
+      return attributes[key];
+    }
+  }
+
+  throw Error('No valid id attribute found');
+};
+
+var arcgisToGeoJSON = function arcgisToGeoJSON(arcgis, idAttribute) {
+  var geojson = {};
+
+  if (arcgis.features) {
+    geojson.type = 'FeatureCollection';
+    geojson.features = [];
+
+    for (var i = 0; i < arcgis.features.length; i++) {
+      geojson.features.push(arcgisToGeoJSON(arcgis.features[i], idAttribute));
+    }
+  }
+
+  if (typeof arcgis.x === 'number' && typeof arcgis.y === 'number') {
+    geojson.type = 'Point';
+    geojson.coordinates = [arcgis.x, arcgis.y];
+
+    if (typeof arcgis.z === 'number') {
+      geojson.coordinates.push(arcgis.z);
+    }
+  }
+
+  if (arcgis.points) {
+    geojson.type = 'MultiPoint';
+    geojson.coordinates = arcgis.points.slice(0);
+  }
+
+  if (arcgis.paths) {
+    if (arcgis.paths.length === 1) {
+      geojson.type = 'LineString';
+      geojson.coordinates = arcgis.paths[0].slice(0);
+    } else {
+      geojson.type = 'MultiLineString';
+      geojson.coordinates = arcgis.paths.slice(0);
+    }
+  }
+
+  if (arcgis.rings) {
+    geojson = convertRingsToGeoJSON(arcgis.rings.slice(0));
+  }
+
+  if (typeof arcgis.xmin === 'number' && typeof arcgis.ymin === 'number' && typeof arcgis.xmax === 'number' && typeof arcgis.ymax === 'number') {
+    geojson.type = 'Polygon';
+    geojson.coordinates = [[[arcgis.xmax, arcgis.ymax], [arcgis.xmin, arcgis.ymax], [arcgis.xmin, arcgis.ymin], [arcgis.xmax, arcgis.ymin], [arcgis.xmax, arcgis.ymax]]];
+  }
+
+  if (arcgis.geometry || arcgis.attributes) {
+    geojson.type = 'Feature';
+    geojson.geometry = arcgis.geometry ? arcgisToGeoJSON(arcgis.geometry) : null;
+    geojson.properties = arcgis.attributes ? shallowClone(arcgis.attributes) : null;
+
+    if (arcgis.attributes) {
+      try {
+        geojson.id = getId(arcgis.attributes, idAttribute);
+      } catch (err) {// don't set an id
+      }
+    }
+  } // if no valid geometry was encountered
+
+
+  if (JSON.stringify(geojson.geometry) === JSON.stringify({})) {
+    geojson.geometry = null;
+  }
+
+  if (arcgis.spatialReference && arcgis.spatialReference.wkid && arcgis.spatialReference.wkid !== 4326) {
+    console.warn('Object converted in non-standard crs - ' + JSON.stringify(arcgis.spatialReference));
+  }
+
+  return geojson;
+};
+
+/* Copyright (c) 2012-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+// outer rings are clockwise, holes are counterclockwise
+// used for converting GeoJSON Polygons to ArcGIS Polygons
+
+var orientRings = function orientRings(poly) {
+  var output = [];
+  var polygon = poly.slice(0);
+  var outerRing = closeRing(polygon.shift().slice(0));
+
+  if (outerRing.length >= 4) {
+    if (!ringIsClockwise(outerRing)) {
+      outerRing.reverse();
+    }
+
+    output.push(outerRing);
+
+    for (var i = 0; i < polygon.length; i++) {
+      var hole = closeRing(polygon[i].slice(0));
+
+      if (hole.length >= 4) {
+        if (ringIsClockwise(hole)) {
+          hole.reverse();
+        }
+
+        output.push(hole);
+      }
+    }
+  }
+
+  return output;
+}; // This function flattens holes in multipolygons to one array of polygons
+// used for converting GeoJSON Polygons to ArcGIS Polygons
+
+
+var flattenMultiPolygonRings = function flattenMultiPolygonRings(rings) {
+  var output = [];
+
+  for (var i = 0; i < rings.length; i++) {
+    var polygon = orientRings(rings[i]);
+
+    for (var x = polygon.length - 1; x >= 0; x--) {
+      var ring = polygon[x].slice(0);
+      output.push(ring);
+    }
+  }
+
+  return output;
+};
+
+var geojsonToArcGIS = function geojsonToArcGIS(geojson, idAttribute) {
+  idAttribute = idAttribute || 'OBJECTID';
+  var spatialReference = {
+    wkid: 4326
+  };
+  var result = {};
+  var i;
+
+  switch (geojson.type) {
+    case 'Point':
+      result.x = geojson.coordinates[0];
+      result.y = geojson.coordinates[1];
+
+      if (geojson.coordinates[2] != null) {
+        result.z = geojson.coordinates[2];
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'MultiPoint':
+      result.points = geojson.coordinates.slice(0);
+
+      if (geojson.coordinates[0][2] != null) {
+        result.hasZ = true;
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'LineString':
+      result.paths = [geojson.coordinates.slice(0)];
+
+      if (geojson.coordinates[0][2] != null) {
+        result.hasZ = true;
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'MultiLineString':
+      result.paths = geojson.coordinates.slice(0);
+
+      if (geojson.coordinates[0][0][2] != null) {
+        result.hasZ = true;
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'Polygon':
+      result.rings = orientRings(geojson.coordinates.slice(0));
+
+      if (geojson.coordinates[0][0][2] != null) {
+        result.hasZ = true;
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'MultiPolygon':
+      result.rings = flattenMultiPolygonRings(geojson.coordinates.slice(0));
+
+      if (geojson.coordinates[0][0][0][2] != null) {
+        result.hasZ = true;
+      }
+
+      result.spatialReference = spatialReference;
+      break;
+
+    case 'Feature':
+      if (geojson.geometry) {
+        result.geometry = geojsonToArcGIS(geojson.geometry, idAttribute);
+      }
+
+      result.attributes = geojson.properties ? shallowClone(geojson.properties) : {};
+
+      if (geojson.id) {
+        result.attributes[idAttribute] = geojson.id;
+      }
+
+      break;
+
+    case 'FeatureCollection':
+      result = [];
+
+      for (i = 0; i < geojson.features.length; i++) {
+        result.push(geojsonToArcGIS(geojson.features[i], idAttribute));
+      }
+
+      break;
+
+    case 'GeometryCollection':
+      result = [];
+
+      for (i = 0; i < geojson.geometries.length; i++) {
+        result.push(geojsonToArcGIS(geojson.geometries[i], idAttribute));
+      }
+
+      break;
+  }
+
+  return result;
+};
+
+var _sfc_main = defineComponent({
+  name: "VkfEsriInputGeojson",
+  components: {
+    VkfInput,
+    VaSketch,
+    ViewerVue,
+    VkAsyncTeleport,
+    DocumentChecked: document_checked_default,
+    VaGraphicsLayer
+  },
+  emits,
+  props,
+  setup(props2, {
+    emit
+  }) {
+    const inputBindProps = _VkfInputCtx.createBindProps(props2, ["inputSlots", "readonly", "modelValue"]);
+    const inputOnEmits = _VkfInputCtx.createOnEmits(emit, ["update:modelValue"]);
+    const readonly = useComputedReadonly(props2);
+    const sketchRef = shallowRef();
+    const shetchPanel = computed(() => {
+      var _a;
+      const container = (_a = sketchRef.value) == null ? void 0 : _a.container;
+      return container == null ? void 0 : container.querySelector(".esri-sketch__panel");
+    });
+    const sketchLoad = async (e) => {
+      await e.sketch.when();
+      sketchRef.value = e.sketch;
+    };
+    const availableCreatureTools = computed(() => {
+      if (Array.isArray(props2.editTypes)) {
+        return props2.editTypes.reduce((pre, cur) => {
+          return pre.concat(EDIT_TYPE_REFLECT[cur].availableCreatureTools);
+        }, []);
+      } else {
+        return EDIT_TYPE_REFLECT[props2.editTypes].availableCreatureTools;
+      }
+    });
+    const sketchValue = shallowRef([]);
+    uSketchValue();
+    const handleUpdateSketchValue = (e) => {
+      sketchValue.value = e;
+      if (props2.skipSave) {
+        u();
+      }
+    };
+    const normalMapRef = shallowRef();
+    const dialogMapRef = shallowRef();
+    const mapTo = shallowRef();
+    onMounted(() => {
+      mapTo.value = normalMapRef.value;
+    });
+    const dialogShow = ref(false);
+    const dialogOnOpen = async () => {
+      mapTo.value = dialogMapRef.value;
+    };
+    const dialogOnClose = async () => {
+      mapTo.value = normalMapRef.value;
+    };
+    const doSave = () => {
+      u();
+      ElMessage({
+        message: "\u4FDD\u5B58\u6210\u529F",
+        type: "success"
+      });
+      dialogShow.value = false;
+    };
+    const append = () => createVNode(AppendVue, {
+      "dialog": props2.dialogEdit,
+      "upload": !readonly.value,
+      "disabled": props2.disabled,
+      "onUpload": onUpload,
+      "onEdit": onEdit
+    }, null);
+    async function onUpload(e) {
+      if (!e.raw)
+        return;
+      toGeojson(e.raw).then((res) => {
+        emit("update:modelValue", res);
+      }).then(uSketchValue).then(() => {
+        ElMessage.success("\u4E0A\u4F20\u6210\u529F");
+      }).then(async () => {
+        var _a;
+        const view = (_a = sketchRef.value) == null ? void 0 : _a.view;
+        if (!view)
+          return;
+        await view.when();
+        view.goTo(sketchValue.value);
+      });
+    }
+    function onEdit() {
+      dialogShow.value = true;
+    }
+    function u() {
+      const features = sketchValue.value.map((item) => {
+        return arcgisToGeoJSON(item);
+      });
+      emit("update:modelValue", {
+        type: "FeatureCollection",
+        features
+      });
+    }
+    function uSketchValue() {
+      const esriData = geojsonToArcGIS(props2.modelValue);
+      const graphics = esriData.map((item) => {
+        const g = item.geometry;
+        if (g.rings) {
+          g.type = "polygon";
+          item.symbol = props2.viewModelActiveFillSymbol;
+        } else if (g.paths) {
+          g.type = "polyline";
+          item.symbol = props2.viewModelActiveLineSymbol;
+        } else if (g.x) {
+          g.type = "point";
+          item.symbol = props2.viewModelActivePointSymbol;
+        }
+        return new Graphic(item);
+      });
+      sketchValue.value = graphics;
+    }
+    return {
+      inputBindProps,
+      inputOnEmits,
+      append,
+      availableCreatureTools,
+      sketchValue,
+      handleUpdateSketchValue,
+      sketchRef,
+      sketchLoad,
+      shetchPanel,
+      dialogShow,
+      normalMapRef,
+      dialogMapRef,
+      dialogOnOpen,
+      dialogOnClose,
+      mapTo,
+      doSave,
+      readonly
+    };
+  }
+});
+
+const _hoisted_1 = { class: "vkf-form-item" };
+const _hoisted_2 = {
+  class: "vkf-esri-input-geojson__map",
+  ref: "normalMapRef"
+};
+const _hoisted_3 = {
+  ref: "dialogMapRef",
+  class: "vkf-esri-input-geojson-dialog__map"
+};
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkfInput = resolveComponent("VkfInput");
+  const _component_VaGraphicsLayer = resolveComponent("VaGraphicsLayer");
+  const _component_DocumentChecked = resolveComponent("DocumentChecked");
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_VkAsyncTeleport = resolveComponent("VkAsyncTeleport");
+  const _component_VaSketch = resolveComponent("VaSketch");
+  const _component_ViewerVue = resolveComponent("ViewerVue");
+  const _component_ElDialog = resolveComponent("ElDialog");
+
+  return (openBlock(), createElementBlock("div", _hoisted_1, [
+    createVNode(_component_VkfInput, mergeProps({
+      readonly: true,
+      modelValue: JSON.stringify(_ctx.modelValue)
+    }, _ctx.inputBindProps, toHandlers(_ctx.inputOnEmits), {
+      inputSlots: {
+        append: _ctx.append
+      }
+    }), null, 16 /* FULL_PROPS */, ["modelValue", "inputSlots"]),
+    createVNode(_component_VkAsyncTeleport, { to: _ctx.mapTo }, {
+      default: withCtx(() => [
+        createVNode(_component_ViewerVue, { view: _ctx.view }, {
+          default: withCtx(() => [
+            (_ctx.readonly)
+              ? (openBlock(), createBlock(_component_VaGraphicsLayer, {
+                  key: 0,
+                  graphics: _ctx.sketchValue
+                }, null, 8 /* PROPS */, ["graphics"]))
+              : (openBlock(), createBlock(_component_VaSketch, {
+                  key: 1,
+                  viewModelActiveFillSymbol: _ctx.viewModelActiveFillSymbol,
+                  viewModelActiveLineSymbol: _ctx.viewModelActiveLineSymbol,
+                  viewModelActivePointSymbol: _ctx.viewModelActivePointSymbol,
+                  multiple: _ctx.multiple,
+                  availableCreatureTools: _ctx.availableCreatureTools,
+                  modelValue: _ctx.sketchValue,
+                  "onUpdate:modelValue": _ctx.handleUpdateSketchValue,
+                  onLoad: _ctx.sketchLoad
+                }, {
+                  default: withCtx(() => [
+                    (!_ctx.skipSave && _ctx.shetchPanel)
+                      ? (openBlock(), createBlock(_component_VkAsyncTeleport, {
+                          key: 0,
+                          to: _ctx.shetchPanel
+                        }, {
+                          default: withCtx(() => [
+                            createVNode(_component_ElIcon, {
+                              class: "esri-sketch-ui-save esri-widget--button",
+                              onClick: _ctx.doSave
+                            }, {
+                              default: withCtx(() => [
+                                createVNode(_component_DocumentChecked)
+                              ]),
+                              _: 1 /* STABLE */
+                            }, 8 /* PROPS */, ["onClick"])
+                          ]),
+                          _: 1 /* STABLE */
+                        }, 8 /* PROPS */, ["to"]))
+                      : createCommentVNode("v-if", true)
+                  ]),
+                  _: 1 /* STABLE */
+                }, 8 /* PROPS */, ["viewModelActiveFillSymbol", "viewModelActiveLineSymbol", "viewModelActivePointSymbol", "multiple", "availableCreatureTools", "modelValue", "onUpdate:modelValue", "onLoad"]))
+          ]),
+          _: 1 /* STABLE */
+        }, 8 /* PROPS */, ["view"])
+      ]),
+      _: 1 /* STABLE */
+    }, 8 /* PROPS */, ["to"]),
+    withDirectives(createElementVNode("div", _hoisted_2, null, 512 /* NEED_PATCH */), [
+      [vShow, _ctx.showMap]
+    ]),
+    createVNode(_component_ElDialog, {
+      modelValue: _ctx.dialogShow,
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => ((_ctx.dialogShow) = $event)),
+      title: _ctx.dialogEditTitle,
+      fullscreen: _ctx.dialogEditFullscreen,
+      modalClass: "vkf-esri-input-geojson-dialog",
+      appendToBody: true,
+      onOpen: _ctx.dialogOnOpen,
+      onClose: _ctx.dialogOnClose,
+      closeOnClickModal: false,
+      draggable: true
+    }, {
+      default: withCtx(() => [
+        createElementVNode("div", _hoisted_3, null, 512 /* NEED_PATCH */)
+      ]),
+      _: 1 /* STABLE */
+    }, 8 /* PROPS */, ["modelValue", "title", "fullscreen", "onOpen", "onClose"])
+  ]))
+}
+var VkfEsriInputGeojson = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render],['__file',"index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfEsriInputGeojson.install = (app) => {
+  app.component(VkfEsriInputGeojson.name, VkfEsriInputGeojson);
+};
+
+export { EDIT_TYPE, EDIT_TYPE_OPTIONS, EDIT_TYPE_REFLECT, VkfEsriInputGeojson, types as __VkfEsriInputGeojson, VkfEsriInputGeojson as default };