/******/ (function() { // webpackBootstrap
/******/ 	"use strict";
/******/ 	var __webpack_modules__ = ({

/***/ 9219:
/***/ (function(__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) {


// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js + 4 modules
var objectSpread2 = __webpack_require__(5051);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.promise.js
var es_promise = __webpack_require__(3362);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.assign.js
var es_object_assign = __webpack_require__(9085);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.promise.finally.js
var es_promise_finally = __webpack_require__(9391);
;// external "Vue"
var external_Vue_namespaceObject = Vue;
var external_Vue_default = /*#__PURE__*/__webpack_require__.n(external_Vue_namespaceObject);
;// ./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./src/components/App/template.html?vue&type=template&id=1e79e03c&external
var render = function render() {
  var _vm = this,
    _c = _vm._self._c;
  return _c('trame-connect', {
    attrs: {
      "use-url": "",
      "forward-errors": ""
    }
  }, [_c('trame-template', {
    attrs: {
      "use-url": ""
    }
  })], 1);
};
var staticRenderFns = [];

;// ./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./src/components/Connect/template.html?vue&type=template&id=103a6579&external
var templatevue_type_template_id_103a6579_external_render = function render() {
  var _vm = this,
    _c = _vm._self._c;
  return _vm.ready ? _vm._t("default") : _vm._e();
};
var templatevue_type_template_id_103a6579_external_staticRenderFns = [];

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.push.js
var es_array_push = __webpack_require__(4114);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.constructor.js
var es_iterator_constructor = __webpack_require__(8111);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.for-each.js
var es_iterator_for_each = __webpack_require__(7588);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.map.js
var es_iterator_map = __webpack_require__(1701);
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom-collections.iterator.js
var web_dom_collections_iterator = __webpack_require__(2953);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.includes.js
var es_array_includes = __webpack_require__(4423);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.regexp.exec.js
var es_regexp_exec = __webpack_require__(7495);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.regexp.to-string.js
var es_regexp_to_string = __webpack_require__(8781);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.includes.js
var es_string_includes = __webpack_require__(1699);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.replace.js
var es_string_replace = __webpack_require__(5440);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.replace-all.js
var es_string_replace_all = __webpack_require__(9978);
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.url.js
var web_url = __webpack_require__(3296);
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.url.to-json.js
var web_url_to_json = __webpack_require__(7208);
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.url-search-params.js
var web_url_search_params = __webpack_require__(8408);
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.url-search-params.delete.js
var web_url_search_params_delete = __webpack_require__(4603);
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.url-search-params.has.js
var web_url_search_params_has = __webpack_require__(7566);
// EXTERNAL MODULE: ./node_modules/core-js/modules/web.url-search-params.size.js
var web_url_search_params_size = __webpack_require__(8721);
// EXTERNAL MODULE: ./node_modules/@kitware/vtk.js/Common/Core/URLExtract.js
var URLExtract = __webpack_require__(5952);
// EXTERNAL MODULE: ./node_modules/wslink/src/SmartConnect/index.js + 16 modules
var SmartConnect = __webpack_require__(672);
// EXTERNAL MODULE: ./node_modules/@kitware/vtk.js/IO/Core/WSLinkClient.js + 6 modules
var WSLinkClient = __webpack_require__(5934);
;// ./src/components/Connect/wslink/protocols/SyncView.js
/* harmony default export */ var SyncView = (session => ({
  getArray(hash, binary = true) {
    return session.call('viewport.geometry.array.get', [hash, binary]).then(res => {
      if (res.buffer) {
        return new Blob([res]);
      }
      return res;
    });
  },
  getViewState(viewId, newSubscription = false) {
    return session.call('viewport.geometry.view.get.state', [viewId, newSubscription]);
  },
  addViewObserver(viewId) {
    return session.call('viewport.geometry.view.observer.add', [viewId]);
  },
  removeViewObserver(viewId) {
    return session.call('viewport.geometry.view.observer.remove', [viewId]);
  },
  subscribeToViewChange(callback) {
    return session.subscribe('viewport.geometry.view.subscription', callback);
  },
  unsubscribe(subscription) {
    return session.unsubscribe(subscription);
  }
}));
(Object.getOwnPropertyDescriptor(SyncView, "name") || {}).writable || Object.defineProperty(SyncView, "name", { value: "default", configurable: true });
;// ./src/components/Connect/wslink/protocols/Trame.js
/* harmony default export */ var Trame = (session => ({
  lifeCycleUpdate(phaseName) {
    return session.call('trame.lifecycle.update', [phaseName]);
  },
  sendError(message) {
    return session.call('trame.error.client', [message]);
  },
  getState() {
    return session.call('trame.state.get', []);
  },
  trigger(name, args = [], kwargs = {}) {
    return session.call('trame.trigger', [name, args, kwargs]);
  },
  updateState(changes) {
    return session.call('trame.state.update', [changes]);
  },
  subscribeToStateUpdate(callback) {
    return session.subscribe('trame.state.topic', callback);
  },
  subscribeToActions(callback) {
    return session.subscribe('trame.actions.topic', callback);
  },
  unsubscribe(subscription) {
    return session.unsubscribe(subscription);
  }
}));
(Object.getOwnPropertyDescriptor(Trame, "name") || {}).writable || Object.defineProperty(Trame, "name", { value: "default", configurable: true });
;// ./src/components/Connect/wslink/protocols/index.js


/* harmony default export */ var protocols = ({
  SyncView: SyncView,
  Trame: Trame
});
;// ./src/components/Connect/wslink/index.js





















WSLinkClient/* default */.Ay.setSmartConnectClass(SmartConnect/* default */.Ay);
const WS_CLIENTS = {};
const WS_PROTOCOL = {
  'http:': 'ws:',
  'https:': 'wss:',
  'ws:': 'ws:',
  'wss:': 'wss:'
};
const NOT_BUSY_LIST = [
// *
'unsubscribe',
// SyncView
'subscribeToViewChange',
// Trame
'subscribeToStateUpdate', 'subscribeToActions', 'subscribeToViewChange'];
function configDecorator(config) {
  const outputConfig = (0,objectSpread2/* default */.A)({}, config);

  // Process sessionURL
  if (outputConfig.sessionURL) {
    let sessionURL = outputConfig.sessionURL.toLowerCase();
    const httpURL = window.location;

    // handle protocol mapping http(s) => ws(s)
    if (sessionURL.includes('use_')) {
      const wsURL = new URL(sessionURL);
      wsURL.protocol = WS_PROTOCOL[httpURL.protocol];
      sessionURL = wsURL.toString();
    }

    // handle variable replacement
    const use_mapping = {
      use_hostname: httpURL.hostname,
      use_host: httpURL.host
    };
    for (const [key, value] of Object.entries(use_mapping)) {
      sessionURL = sessionURL.replaceAll(key, value);
    }

    // update config
    outputConfig.sessionURL = sessionURL;
  }

  // Extract app-name from html
  outputConfig.application = document.querySelector('html').dataset.appName || outputConfig.application;
  const sessionManagerURL = document.querySelector('html').dataset.sessionManagerUrl || outputConfig.sessionManagerURL;
  if (sessionManagerURL) {
    outputConfig.sessionManagerURL = sessionManagerURL;
  }

  // Process arguments from URL
  if (outputConfig.useUrl) {
    return (0,objectSpread2/* default */.A)((0,objectSpread2/* default */.A)({}, outputConfig), URLExtract/* default */.A.extractURLParameters());
  }
  return outputConfig;
}
function createClient() {
  return WSLinkClient/* default.newInstance */.Ay.newInstance({
    protocols: protocols,
    configDecorator,
    notBusyList: NOT_BUSY_LIST
  });
}
function getClient(name) {
  var _WS_CLIENTS$name, _params$get;
  let client = (_WS_CLIENTS$name = WS_CLIENTS[name]) === null || _WS_CLIENTS$name === void 0 ? void 0 : _WS_CLIENTS$name.client;
  if (!client) {
    client = createClient();
    const subscriptions = [];
    const status = {
      type: 'created',
      message: 'Client connected...'
    };
    WS_CLIENTS[name] = {
      client,
      status,
      subscriptions
    };

    /* eslint-disable no-inner-declarations */
    function updateStatus(status) {
      WS_CLIENTS[name].status = status;
    }
    subscriptions.push(client.onConnectionError(httpReq => {
      var _httpReq$response;
      updateStatus({
        type: 'Connection error',
        message: httpReq === null || httpReq === void 0 || (_httpReq$response = httpReq.response) === null || _httpReq$response === void 0 ? void 0 : _httpReq$response.error
      });
    }));
    subscriptions.push(client.onConnectionClose(httpReq => {
      var _httpReq$response2;
      updateStatus({
        type: 'Connection closed',
        message: httpReq === null || httpReq === void 0 || (_httpReq$response2 = httpReq.response) === null || _httpReq$response2 === void 0 ? void 0 : _httpReq$response2.error
      });
    }));
  }

  // Remove any URL parameters once config generated
  const params = new URL(window.location).searchParams;
  const paramsToClean = ['sessionURL', 'sessionManagerURL', 'secret', 'application', 'remove'].concat(((_params$get = params.get('remove')) === null || _params$get === void 0 ? void 0 : _params$get.split(',')) || []);
  paramsToClean.forEach(v => params.delete(v));
  const cleanURL = `${window.location.pathname}${params.size ? '?' : ''}${params.toString()}${window.location.hash}`;
  window.history.replaceState({}, document.title, cleanURL);
  return client;
}
function resetClient(name) {
  WS_CLIENTS[name] = null;
}
function getStatus(name) {
  return WS_CLIENTS[name].status;
}
/* harmony default export */ var wslink = ({
  getClient,
  resetClient,
  getStatus,
  configDecorator
});
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.filter.js
var es_iterator_filter = __webpack_require__(2489);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.json.stringify.js
var es_json_stringify = __webpack_require__(3110);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.set.difference.v2.js
var es_set_difference_v2 = __webpack_require__(7642);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.set.intersection.v2.js
var es_set_intersection_v2 = __webpack_require__(8004);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.set.is-disjoint-from.v2.js
var es_set_is_disjoint_from_v2 = __webpack_require__(3853);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.set.is-subset-of.v2.js
var es_set_is_subset_of_v2 = __webpack_require__(5876);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.set.is-superset-of.v2.js
var es_set_is_superset_of_v2 = __webpack_require__(2475);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.set.symmetric-difference.v2.js
var es_set_symmetric_difference_v2 = __webpack_require__(5024);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.set.union.v2.js
var es_set_union_v2 = __webpack_require__(1698);
// EXTERNAL MODULE: ./node_modules/v-runtime-template/dist/v-runtime-template.es.js
var v_runtime_template_es = __webpack_require__(3996);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.sort.js
var es_array_sort = __webpack_require__(6910);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array-buffer.detached.js
var es_array_buffer_detached = __webpack_require__(6573);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array-buffer.transfer.js
var es_array_buffer_transfer = __webpack_require__(8100);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array-buffer.transfer-to-fixed-length.js
var es_array_buffer_transfer_to_fixed_length = __webpack_require__(7936);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.promise.all-settled.js
var es_promise_all_settled = __webpack_require__(6167);
;// ./src/components/Connect/trame/decorators.js









const CTX = {};
function compareDecorator(a, b) {
  return a.priority - b.priority;
}
function setAddAttachment(fn) {
  CTX.addAttachement = fn;
}
const fileHandler = {
  priority: 0,
  async decorate(value) {
    if (value === null || value === undefined) return value;
    if (value.constructor && value.constructor === File) {
      const {
        name,
        lastModified,
        size,
        type
      } = value;

      // Will be null in the event of an error on read, DataView otherwise
      let content = null;
      // Will be an error string if content failed to read, null otherwise
      let error = null;
      try {
        const arrayBuffer = await new Promise((resolve, reject) => {
          const reader = new FileReader();
          reader.addEventListener('loadend', () => {
            resolve(reader.result);
          });
          reader.addEventListener('error', () => {
            reject(reader.error);
          });
          reader.readAsArrayBuffer(value);
        });
        content = new DataView(arrayBuffer);
      } catch (e) {
        var _e$message;
        error = (_e$message = e === null || e === void 0 ? void 0 : e.message) !== null && _e$message !== void 0 ? _e$message : String(e);
      }
      return {
        name,
        lastModified,
        size,
        type,
        content,
        error,
        // used by server to prevent sending those fields back to JS
        _filter: ['content']
      };
    }
    return value;
  }
};
const fileListHandler = {
  priority: 0,
  async decorate(value) {
    if (value === null || value === undefined) return value;
    if (typeof value === 'string') {
      return value;
    }
    if (value.constructor && value.constructor === FileList || value.length) {
      const results = await Promise.allSettled(Array.from(value).map(file => fileHandler.decorate(file)));
      return results.map(result => result.value);
    }
    return value;
  }
};
const fileInObjectHandler = {
  priority: 0,
  async decorate(value) {
    if (value === null || value === undefined) return value;
    if (typeof value === 'string') {
      return value;
    }
    if (value.constructor && value.constructor === Object) {
      const newValue = {};
      const names = Object.keys(value);
      /* eslint-disable no-await-in-loop */
      for (let i = 0; i < names.length; i++) {
        const name = names[i];
        newValue[name] = value[name];
        newValue[name] = await fileListHandler.decorate(newValue[name]);
        newValue[name] = await fileHandler.decorate(newValue[name]);
      }
      /* eslint-enable no-await-in-loop */
      return newValue;
    }
    return value;
  }
};

// ----------------------------------------------------------------------------
// API
// ----------------------------------------------------------------------------

const STATE_DECORATORS = [fileHandler, fileListHandler, fileInObjectHandler];
function registerDecorator(decorator) {
  STATE_DECORATORS.push(decorator);
  STATE_DECORATORS.sort(compareDecorator);
}
async function decorate(value) {
  let result = value;
  /* eslint-disable no-await-in-loop */
  for (let i = 0; i < STATE_DECORATORS.length; i++) {
    if (result === null || result === undefined) {
      return result;
    }
    result = await STATE_DECORATORS[i].decorate(result);
  }
  /* eslint-enable no-await-in-loop */
  return result;
}
;// ./src/utils/vtk/index.js
const VTK_EVENT_KEYS = ['type', 'key', 'keyCode', 'controlKey', 'altKey', 'shiftKey', 'position', 'spinX', 'spinY', 'pixelX', 'pixelY'];
function vtk_event(e) {
  const result = {};
  for (let i = 0; i < VTK_EVENT_KEYS.length; i++) {
    const key = VTK_EVENT_KEYS[i];
    if (key in e) {
      result[key] = e[key];
    }
  }
  return result;
}
/* harmony default export */ var vtk = ({
  event: vtk_event
});
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.number.to-fixed.js
var es_number_to_fixed = __webpack_require__(9868);
;// ./src/utils/fmt/index.js

function number(value, units = [], steps = 1000, fixed = 2) {
  if (value === null) {
    return null;
  }
  for (let i = 0; i < units.length; i++) {
    const step = Array.isArray(steps) ? steps[i] : steps;
    const unit = units[i];
    if (value > step) {
      value /= step;
    } else {
      return `${value.toFixed(fixed)} ${unit}`;
    }
  }
  return `${value.toFixed(fixed)} ${steps[steps.length - 1]}`;
}
function bytes(v, fixed = 2) {
  return number(v, ['B', 'KB', 'MB', 'GB', 'TB', 'PB'], 1024, fixed);
}
/* harmony default export */ var fmt = ({
  number,
  bytes
});
;// ./src/utils/index.js













async function download(filename, contentOrPromise, type = 'application/octet-stream') {
  const content = await Promise.resolve(contentOrPromise);
  const blob = new Blob([content], {
    type
  });
  const url = URL.createObjectURL(blob);
  const anchor = document.createElement('a');
  anchor.setAttribute('href', url);
  anchor.setAttribute('download', filename);
  document.body.appendChild(anchor);
  anchor.click();
  document.body.removeChild(anchor);
  setTimeout(() => URL.revokeObjectURL(url), 1000);
}
function get(path, obj = window) {
  let current = obj;
  const steps = path.split('.');
  for (let i = 0; i < steps.length; i++) {
    current = current[steps[i]];
  }
  return current;
}
function safe(obj) {
  try {
    JSON.stringify(obj);
    return obj;
  } catch (e) {
    // We need to look into object
  }
  const safeObj = {};
  const keys = Object.keys(obj);
  for (let i = 0; i < keys.length; i++) {
    const key = keys[i];
    const value = obj[key];
    if (Array.isArray(value)) {
      safeObj[key] = value.map(safe);
    } else {
      try {
        JSON.stringify(value);
        safeObj[key] = value;
      } catch (e) {
        continue;
      }
    }
  }
  return safeObj;
}
function toNode(id, key, value) {
  const node = {
    id
  };
  const prefix = key ? `${key}: ` : '';
  if (Array.isArray(value)) {
    node.name = `${prefix}[]`;
    if (value.length) {
      node.children = [];
    }
    return node;
  }
  if (value === null || !value) {
    node.name = `${prefix}${value}`;
    return node;
  }
  if (typeof value === 'function') {
    node.name = `${prefix}function`;
    return node;
  }
  if (typeof value === 'object') {
    node.name = `${prefix}{}`;
    if (Object.keys(value).length) {
      node.children = [];
    }
    return node;
  }
  node.name = `${prefix}${value}`;
  return node;
}
function registerItem(container, id, key, value) {
  const node = toNode(id, key, value);
  container.push(node);
  if (node.children) {
    registerList(id, node.children, value);
  }
}
function registerList(parentId, container, obj) {
  if (Array.isArray(obj)) {
    const key = null;
    for (let i = 0; i < obj.length; i++) {
      registerItem(container, `${parentId}_${i}`, key, obj[i]);
    }
  } else {
    const keys = Object.keys(obj);
    for (let i = 0; i < keys.length; i++) {
      const key = keys[i];
      registerItem(container, `${parentId}_${i}`, key, obj[key]);
    }
  }
}
function tree(obj) {
  const result = [];
  registerList('', result, obj);
  return result;
}
/* harmony default export */ var utils = ({
  download,
  get,
  safe,
  tree,
  vtk: vtk,
  fmt: fmt
});
;// ./src/components/Connect/trame/state.js






















// ----------------------------------------------------------------------------
// Make utils global
// ----------------------------------------------------------------------------

const GLOBAL_STATE = {};
if (!window.trame) {
  window.trame = {};
}
if (!window.trame.utils) {
  window.trame.utils = utils;
}
if (!window.trame.state) {
  window.trame.state = GLOBAL_STATE;
}

// ----------------------------------------------------------------------------
// Helper functions for state reactivity handling
// ----------------------------------------------------------------------------
var LOADED_URLS = [];
function loadScript(url) {
  return new Promise(function (resolve, reject) {
    if (LOADED_URLS.indexOf(url) === -1) {
      LOADED_URLS.push(url);
      var newScriptTag = document.createElement('script');
      newScriptTag.type = 'text/javascript';
      newScriptTag.src = url;
      newScriptTag.onload = resolve;
      newScriptTag.onerror = reject;
      document.body.appendChild(newScriptTag);
    } else {
      resolve(false);
    }
  });
}
function loadScriptAsModule(url) {
  return new Promise(function (resolve, reject) {
    if (LOADED_URLS.indexOf(url) === -1) {
      LOADED_URLS.push(url);
      var newScriptTag = document.createElement('script');
      newScriptTag.type = 'module';
      newScriptTag.src = url;
      newScriptTag.onload = resolve;
      newScriptTag.onerror = reject;
      document.body.appendChild(newScriptTag);
    } else {
      resolve(false);
    }
  });
}
function loadCSS(url) {
  return new Promise(function (resolve, reject) {
    if (LOADED_URLS.indexOf(url) === -1) {
      LOADED_URLS.push(url);
      var newScriptTag = document.createElement('link');
      newScriptTag.rel = 'stylesheet';
      newScriptTag.href = url;
      newScriptTag.onload = resolve;
      newScriptTag.onerror = reject;
      document.head.appendChild(newScriptTag);
    } else {
      resolve(false);
    }
  });
}
function createStateTS(keys) {
  const dataForStateTS = {
    tts: 0
  };
  keys.forEach(name => {
    dataForStateTS[name] = 0;
  });
  return new (external_Vue_default())({
    data: dataForStateTS
  });
}

// ----------------------------------------------------------------------------

function monitorChanges(trame, stateTS) {
  function onChange(names) {
    for (let i = 0; i < names.length; i++) {
      stateTS[names[i]]++;
    }
  }
  trame.$on('stateChange', onChange);
  return () => {
    trame.$off('stateChange', onChange);
  };
}

// ----------------------------------------------------------------------------

function createComputed(trame, keys, stateTS) {
  const computed = {};
  keys.forEach(name => {
    computed[name] = {
      get() {
        stateTS[name];
        return trame.state.get(name);
      },
      set(v) {
        trame.state.set(name, v);
      }
    };
  });
  return computed;
}

// ----------------------------------------------------------------------------
// Initialisation helpers
//   1. trame__styles  : list of url to load as css
//   2. trame__scripts : list of url to load as scripts
//   3. trame__use     : list of vue plugins to load
//   4. trame__favicon : favicon
//   5. trame__title   : browser tab title
// ----------------------------------------------------------------------------

const GLOBAL_VUE_OPTIONS = {};
const VUE_USE_LOADED = {};
async function serialLoad(urls, loadFn) {
  for (let i = 0; i < urls.length; i++) {
    /* eslint-disable no-await-in-loop */
    await loadFn(urls[i]);
  }
}

// ----------------------------------------------------------------------------

function loadURLs(urls, loadFn) {
  const mainGroup = [];
  const serialGroups = {};
  for (let i = 0; i < urls.length; i++) {
    let container = mainGroup;
    let url = urls[i];
    if (Array.isArray(url)) {
      const groupName = url[1].serial;
      if (groupName) {
        if (!serialGroups[groupName]) {
          serialGroups[groupName] = [];
        }
        container = serialGroups[groupName];
      }
      [url] = url;
    }
    container.push(url);
  }
  const waitList = mainGroup.map(loadFn);
  const serialScripts = Object.values(serialGroups);
  for (let i = 0; i < serialScripts.length; i++) {
    waitList.push(serialLoad(serialScripts[i], loadFn));
  }
  return Promise.all(waitList);
}
async function handlePageUpdate(modifiedKeys, state, exclude = []) {
  const filterFn = v => !exclude.includes(v);
  if (modifiedKeys.includes('trame__styles')) {
    await loadURLs(state.trame__styles.filter(filterFn), loadCSS);
  }
  if (modifiedKeys.includes('trame__scripts')) {
    await loadURLs(state.trame__scripts.filter(filterFn), loadScript);
  }
  if (modifiedKeys.includes('trame__module_scripts')) {
    await loadURLs(state.trame__module_scripts.filter(filterFn), loadScriptAsModule);
  }
  if (modifiedKeys.includes('trame__vue_use')) {
    // utils.get(path, obj)
    state.trame__vue_use.forEach(libUseEntry => {
      let libKey = libUseEntry;
      let libOptions = {};
      if (Array.isArray(libUseEntry)) {
        [libKey, libOptions] = libUseEntry;
      }
      let lib = utils.get(libKey);

      // Invalid lib name
      if (!lib) {
        console.error(`Lookup error: Vue.use(${libKey}, ${JSON.stringify(libOptions)})`);
        return;
      }
      if (VUE_USE_LOADED[libKey] || exclude.includes(libKey)) {
        return;
      }
      VUE_USE_LOADED[libKey] = true;

      // Resolve "default" namespace if any
      if (lib.default) {
        lib = lib.default;
      }

      // Resolve "lib.install" requirement
      console.info(`Vue.use(${libKey}, ${JSON.stringify(libOptions)}) - ${!!lib} - install(${!!lib.install})`);
      if (lib.install) {
        external_Vue_default().use(lib, libOptions);
        if (lib.getOptions) {
          Object.assign(GLOBAL_VUE_OPTIONS, lib.getOptions());
        }
      } else {
        external_Vue_default().use({
          install: lib
        }, libOptions);
      }
    });
  }
  if (modifiedKeys.includes('trame__favicon') && state.trame__favicon) {
    document.querySelector('link[rel=icon]').href = state.trame__favicon;
  }
  if (modifiedKeys.includes('trame__title') && state.trame__title) {
    document.title = state.trame__title;
  }
}

// ----------------------------------------------------------------------------
// State helper
// ----------------------------------------------------------------------------

class TrameState {
  constructor(vueInstance, client = null, exclude = []) {
    this.name = 'Default trame application';
    this.vueInstance = vueInstance;
    this.client = (vueInstance === null || vueInstance === void 0 ? void 0 : vueInstance.client) || client;
    this.exclude = (vueInstance === null || vueInstance === void 0 ? void 0 : vueInstance.exclude) || exclude;
    this.subscriptions = [];
    this.state = {};
    this.keyTS = {};
    this.ts = 0;
    this.trameTemplateTS = 0;
    this.trameTemplate = {
      template: '<div>Too early for trame template</div>'
    };
    this.dirtyKeys = new Set();

    // bind decorator helper
    this.registerDecorator = registerDecorator;
    const updateFromServer = async serverState => {
      const updatedKeys = [];
      const allKeys = Object.keys(serverState);
      for (let i = 0; i < allKeys.length; i++) {
        var _value$_filter;
        let modified = true;
        const key = allKeys[i];
        const value = serverState[key];

        // Handle _filter field
        if (value !== null && value !== void 0 && (_value$_filter = value._filter) !== null && _value$_filter !== void 0 && _value$_filter.length) {
          modified = false;
          const prevValue = this.state[key];
          const objKeys = Object.keys(value);
          for (let j = 0; !modified && j < objKeys.length; j++) {
            const subKey = objKeys[j];
            if (subKey[0] === '_') {
              continue;
            }
            if (prevValue === undefined || prevValue[subKey] !== value[subKey]) {
              modified = true;
            }
          }
        }
        if (modified) {
          updatedKeys.push(key);
          this.state[key] = value;
        }
      }
      this.ts += 1;
      let newKeyCount = 0;
      for (let i = 0; i < updatedKeys.length; i++) {
        const key = updatedKeys[i];
        if (this.keyTS[key] === undefined) {
          newKeyCount++;
        }
        this.keyTS[key] = this.ts;
      }

      // Handle any page update (resource loading, vue plugins, title, favicon)
      await handlePageUpdate(updatedKeys, this.state, this.exclude);
      if (newKeyCount) {
        this.updateTrameTemplate();
        if (this.vueInstance) {
          this.vueInstance.$emit('trameTemplateChange', this.trameTemplateTS);
        }
      }
      if (this.vueInstance) {
        var _serverState$trame__r;
        this.vueInstance.$emit('stateChange', updatedKeys);

        // Setup router if available
        if (this.vueInstance.$router && serverState !== null && serverState !== void 0 && (_serverState$trame__r = serverState.trame__routes) !== null && _serverState$trame__r !== void 0 && _serverState$trame__r.length) {
          const router = this.vueInstance.$router;
          serverState.trame__routes.forEach(route => {
            router.addRoute(route);
          });
        }
      }
    };
    this.subscriptions.push(this.client.getRemote().Trame.subscribeToStateUpdate(([serverState]) => updateFromServer(serverState)));
    this.client.getRemote().Trame.getState().then(({
      state,
      name
    }) => {
      this.name = name;
      updateFromServer(state);
      if (vueInstance) {
        vueInstance.ready = true;
      }
    });

    // Keep it so we can call it on disconnect
    this._updateFromServer = updateFromServer;
  }
  updateTrameTemplate() {
    if (!this.vueInstance) {
      return;
    }
    this.trameTemplateTS += 1;
    const availableKeys = Object.keys(this.state);
    const stateTS = createStateTS(availableKeys);
    const unbindState = monitorChanges(this.vueInstance, stateTS);
    const computed = createComputed(this.vueInstance, availableKeys, stateTS);
    let refCount = 0;
    this.trameTemplate = {
      name: 'TrameTemplateInternal',
      inject: ['trame'],
      props: {
        templateName: {
          type: String,
          default: 'main'
        }
      },
      components: {
        VRuntimeTemplate: v_runtime_template_es/* default */.A
      },
      computed: (0,objectSpread2/* default */.A)((0,objectSpread2/* default */.A)({}, computed), {}, {
        contentTemplate() {
          const templateKey = `trame__template_${this.templateName}`;
          return this[templateKey] || `<div>No state variable for ${templateKey} with the following state.<br><pre>${JSON.stringify(this.trame.state.get(), null, 2)}</pre></div>`;
        },
        tts() {
          return stateTS.tts;
        },
        utils() {
          return utils;
        }
      }),
      watch: {
        contentTemplate() {
          setTimeout(() => stateTS.tts += 1, 10);
        }
      },
      methods: {
        set(key, value) {
          return this.trame.state.set(key, value);
        },
        get(key = null) {
          return this.trame.state.get(key);
        },
        setAll(obj) {
          return this.trame.state.update(obj);
        },
        flushState(...keys) {
          return this.trame.state.flush(...keys);
        },
        registerDecorator(...args) {
          return this.trame.state.registerDecorator(...args);
        },
        async trigger(name, args = [], kwargs = {}) {
          let decoratedArgs = [];
          const decoratedKwargs = {};
          if (args) {
            const decorateArgs = args.map(arg => decorate(arg));
            decoratedArgs = await Promise.all(decorateArgs);
          }
          if (kwargs) {
            const keys = [];
            const values = [];
            Object.entries(kwargs).forEach(entry => {
              keys.push(entry[0]);
              values.push(decorate(entry[1]));
            });
            const resolvedValues = await Promise.all(values);
            for (let i = 0; i < keys.length; i++) {
              decoratedKwargs[keys[i]] = resolvedValues[i];
            }
          }
          return await this.trame.client.getRemote().Trame.trigger(name, decoratedArgs, decoratedKwargs);
        },
        getRef(ref) {
          const {
            trameTemplateRootRef
          } = this.$refs;
          if (trameTemplateRootRef.$refs && trameTemplateRootRef.$refs[ref]) {
            return trameTemplateRootRef.$refs[ref];
          }
          return trameTemplateRootRef.$children[0].$refs[ref];
        },
        execAction(action) {
          const {
            ref,
            type
          } = action;
          const elem = this.getRef(ref);
          if (elem && type === 'method') {
            const {
              method,
              args
            } = action;
            elem[method](...args);
          }
          if (elem && type === 'property') {
            const {
              property,
              value
            } = action;
            elem[property] = value;
          }
        }
      },
      created() {
        refCount++;
        this.onActions = ([actions]) => {
          for (let i = 0; i < actions.length; i++) {
            this.execAction(actions[i]);
          }
        };
        this.clientSub = this.trame.client.getRemote().Trame.subscribeToActions(this.onActions);

        // Update global trame.state
        GLOBAL_STATE.set = (k, v) => this.set(k, v);
        GLOBAL_STATE.get = k => this.get(k);
        GLOBAL_STATE.setAll = obj => this.setAll(obj);
        GLOBAL_STATE.flushState = (...keys) => this.flushState(...keys);
        GLOBAL_STATE.registerDecorator = (...args) => this.registerDecorator(...args);
        GLOBAL_STATE.trigger = async (name, args = [], kwargs = {}) => this.trigger(name, args, kwargs);
      },
      beforeDestroy() {
        refCount--;
        if (refCount === 0) {
          unbindState();
        }
        this.trame.client.getRemote().Trame.unsubscribe(this.clientSub);
      },
      template: '<v-runtime-template ref="trameTemplateRootRef" :template="contentTemplate" />'
    };
  }
  delete() {
    while (this.subscriptions.length) {
      this.client.getRemote().Trame.unsubscribe(this.subscriptions.pop());
    }
  }
  get(key) {
    if (key === undefined) {
      return this.state;
    }
    return this.state[key];
  }
  getTimeStamp(key) {
    return this.keyTS[key] || 0;
  }
  async set(key, value) {
    // Prevent triggering change when same value is set
    if (this.state[key] === value) {
      return;
    }
    this.ts += 1;
    this.state[key] = value;
    this.keyTS[key] = this.ts;
    this.dirty(key);
    await this.flush();
  }
  async update(obj) {
    this.ts += 1;
    for (const [key, value] of Object.entries(obj)) {
      if (this.state[key] !== value) {
        this.state[key] = value;
        this.keyTS[key] = this.ts;
        this.dirty(key);
      }
    }
    await this.flush();
  }
  canDirty(name) {
    return !this.state.trame__client_only.includes(name);
  }
  dirty(...keys) {
    keys.forEach(key => {
      if (this.canDirty(key)) {
        this.dirtyKeys.add(key);
      }

      // Make sure client side is aware of that change...
      if (this.vueInstance) {
        this.vueInstance.$emit('stateChange', [key]);
      }
    });
  }
  async flush(...keys) {
    if (keys.length) {
      keys.forEach(key => {
        if (Array.isArray(key)) {
          this.dirty(...key);
        } else {
          this.dirty(key);
        }
      });
    }
    if (this.dirtyKeys.size && !this.client.isBusy()) {
      const waitOn = [];
      const keys = [];
      this.dirtyKeys.forEach(key => {
        waitOn.push(decorate(this.state[key]));
        keys.push(key);
      });
      this.dirtyKeys.clear();
      const values = await Promise.all(waitOn);
      const deltaState = keys.map((key, i) => ({
        key,
        value: values[i]
      }));
      await this.client.getRemote().Trame.updateState(deltaState);

      // Make sure we don't leave any pending update...
      if (this.dirtyKeys.size) {
        this.flush();
      }
    }

    // when connection died, the client is busy...
    if (this.vueInstance && !this.vueInstance.connected) {
      // Handle dynamic update once disconnected
      this._updateFromServer(this.state);
    }
  }
}
;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./src/components/Connect/script.js?vue&type=script&lang=js&external










/* harmony default export */ var scriptvue_type_script_lang_js_external = ({
  name: 'TrameConnect',
  props: {
    name: {
      type: String,
      default: 'TrameConnect'
    },
    config: {
      type: Object,
      default: () => ({
        application: 'trame'
      })
    },
    exclude: {
      type: Array,
      default: () => []
    },
    useUrl: {
      type: Boolean,
      default: false
    },
    forwardErrors: {
      type: Boolean,
      default: false
    }
  },
  data() {
    return {
      ready: false,
      connected: false,
      busy: 1,
      status: {
        type: 'created',
        message: 'Connecting...'
      }
    };
  },
  async created() {
    await this.connect();
  },
  beforeDestroy() {
    this.client.getRemote().Trame.lifeCycleUpdate('client_unmounted');
    while (this.subscriptions.length) {
      this.subscriptions.pop().unsubscribe();
    }
    if (this.state) {
      this.state.delete();
      this.state = null;
    }
  },
  methods: {
    reportError(message = 'Something unexpected happened...') {
      var _this$client;
      let templateName = 'trame__template_main';
      if (this.useUrl && URLExtract/* default */.A.extractURLParameters().ui) {
        templateName = `trame__template_${URLExtract/* default */.A.extractURLParameters().ui}`;
      }
      if (this !== null && this !== void 0 && (_this$client = this.client) !== null && _this$client !== void 0 && (_this$client = _this$client.getConfig()) !== null && _this$client !== void 0 && _this$client.reconnect) {
        this.state.set(templateName, `<trame-reconnect message="${message}"/>`);
      } else {
        this.state.set(templateName, `<trame-loading message="${message}"/>`);
      }
    },
    async connect() {
      if (this.connected) {
        return;
      }
      if (this.client) {
        this.previousConfig = this.client.getConfig();
        while (this.subscriptions.length) {
          this.subscriptions.pop().unsubscribe();
        }
        if (this.state) {
          this.state.delete();
          this.state = null;
        }
        wslink.resetClient(this.name);
      }
      this.subscriptions = [];
      this.client = wslink.getClient(this.name);

      // Monitor busy
      this.subscriptions.push(this.client.onBusyChange(count => {
        const emitBusyChange = !count !== !this.busy;
        this.busy = count;
        if (emitBusyChange && this.state) {
          this.state.set('trame__busy', count);
        }
        if (count === 0) {
          this.state.flush();
        }
        if (emitBusyChange) {
          this.$emit('busyChange', count);
        }
      }));

      // Connection Error/Close
      this.subscriptions.push(this.client.onConnectionError(httpReq => {
        var _httpReq$response, _httpReq$response2;
        this.connected = false;
        this.status = {
          type: 'Connection error',
          message: httpReq === null || httpReq === void 0 || (_httpReq$response = httpReq.response) === null || _httpReq$response === void 0 ? void 0 : _httpReq$response.error
        };
        this.reportError((httpReq === null || httpReq === void 0 || (_httpReq$response2 = httpReq.response) === null || _httpReq$response2 === void 0 ? void 0 : _httpReq$response2.error) || 'Connection error');
        this.$emit('statusChange', this.status);
      }));
      this.subscriptions.push(this.client.onConnectionClose(httpReq => {
        var _httpReq$response3, _httpReq$response4;
        this.connected = false;
        this.status = {
          type: 'Connection closed',
          message: httpReq === null || httpReq === void 0 || (_httpReq$response3 = httpReq.response) === null || _httpReq$response3 === void 0 ? void 0 : _httpReq$response3.error
        };
        this.reportError((httpReq === null || httpReq === void 0 || (_httpReq$response4 = httpReq.response) === null || _httpReq$response4 === void 0 ? void 0 : _httpReq$response4.error) || 'Connection closed');
        this.$emit('statusChange', this.status);
      }));

      // Connect if new client
      if (this.client.isConnected()) {
        this.status = wslink.getStatus(this.name);
        this.$emit('statusChange', this.status);
      } else {
        const config = this.previousConfig || wslink.configDecorator((0,objectSpread2/* default */.A)((0,objectSpread2/* default */.A)({}, this.config), {}, {
          useUrl: this.useUrl
        }));
        await this.client.connect(config);
        this.lastConfig = this.client.getConfig();
        setAddAttachment(this.client.getConnection().getSession().addAttachment);
        this.status = {
          type: 'Connected'
        };
      }
      this.connected = this.client.isConnected();
      this.busy = this.client.isBusy();
      this.$emit('statusChange', this.status);

      // Fill our trame instance with what make trame magical
      if (this.connected) {
        this.state = new TrameState(this);
      }

      // Attach lifecycles
      this.client.getRemote().Trame.lifeCycleUpdate('client_connected');
      window.addEventListener('beforeunload', () => this.client.getRemote().Trame.lifeCycleUpdate('client_exited'));

      // Forward JS errors to Python
      if (this.forwardErrors) {
        const _error = console.error;
        console.error = (...args) => {
          try {
            this.client.getRemote().Trame.sendError(args.join(' '));
          } catch (e) {
            _error(e);
          } finally {
            _error(...args);
          }
        };
        window.addEventListener('error', event => {
          console.error(`${event.type}: ${event.message}`);
        });
      }
    },
    async trigger(name, args = [], kwargs = {}) {
      let decoratedArgs = [];
      const decoratedKwargs = {};
      if (args) {
        const decorateArgs = args.map(arg => decorate(arg));
        decoratedArgs = await Promise.all(decorateArgs);
      }
      if (kwargs) {
        const keys = [];
        const values = [];
        Object.entries(kwargs).forEach(entry => {
          keys.push(entry[0]);
          values.push(decorate(entry[1]));
        });
        const resolvedValues = await Promise.all(values);
        for (let i = 0; i < keys.length; i++) {
          decoratedKwargs[keys[i]] = resolvedValues[i];
        }
      }
      return await this.client.getRemote().Trame.trigger(name, decoratedArgs, decoratedKwargs);
    }
  },
  provide() {
    return {
      trame: this
    };
  }
});
;// ./src/components/Connect/script.js?vue&type=script&lang=js&external
 /* harmony default export */ var Connect_scriptvue_type_script_lang_js_external = (scriptvue_type_script_lang_js_external); 
// EXTERNAL MODULE: ./node_modules/@vue/vue-loader-v15/lib/runtime/componentNormalizer.js
var componentNormalizer = __webpack_require__(1656);
;// ./src/components/Connect/index.vue





/* normalize component */
;
var component = (0,componentNormalizer/* default */.A)(
  Connect_scriptvue_type_script_lang_js_external,
  templatevue_type_template_id_103a6579_external_render,
  templatevue_type_template_id_103a6579_external_staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* harmony default export */ var Connect = (component.exports);
;// ./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./src/components/ServerTemplate/template.html?vue&type=template&id=17fc9d14&external
var templatevue_type_template_id_17fc9d14_external_render = function render() {
  var _vm = this,
    _c = _vm._self._c;
  return _c('trame-template-internal', {
    key: _vm.trameTemplateTS,
    attrs: {
      "templateName": _vm.tName
    }
  });
};
var templatevue_type_template_id_17fc9d14_external_staticRenderFns = [];

;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./src/components/ServerTemplate/script.js?vue&type=script&lang=js&external

/* harmony default export */ var ServerTemplate_scriptvue_type_script_lang_js_external = ({
  name: 'TrameServerTemplate',
  inject: ['trame'],
  props: {
    templateName: {
      type: String,
      default: 'main'
    },
    urlKey: {
      type: String,
      default: 'ui'
    },
    useUrl: {
      type: Boolean,
      default: false
    }
  },
  data() {
    return {
      trameTemplateTS: 0
    };
  },
  computed: {
    tName() {
      if (this.useUrl && URLExtract/* default */.A.extractURLParameters()[this.urlKey]) {
        return URLExtract/* default */.A.extractURLParameters()[this.urlKey];
      }
      return this.templateName;
    }
  },
  created() {
    this.onNewTemplate = () => {
      this.$options.components.trameTemplateInternal = this.trame.state.trameTemplate;
      this.trameTemplateTS = this.trame.state.trameTemplateTS;
    };
    this.trame.$on('trameTemplateChange', this.onNewTemplate);
    this.onNewTemplate();
  },
  beforeDestroy() {
    this.trame.$off('trameTemplateChange', this.onNewTemplate);
  }
});
;// ./src/components/ServerTemplate/script.js?vue&type=script&lang=js&external
 /* harmony default export */ var components_ServerTemplate_scriptvue_type_script_lang_js_external = (ServerTemplate_scriptvue_type_script_lang_js_external); 
;// ./src/components/ServerTemplate/index.vue





/* normalize component */
;
var ServerTemplate_component = (0,componentNormalizer/* default */.A)(
  components_ServerTemplate_scriptvue_type_script_lang_js_external,
  templatevue_type_template_id_17fc9d14_external_render,
  templatevue_type_template_id_17fc9d14_external_staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* harmony default export */ var ServerTemplate = (ServerTemplate_component.exports);
;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./src/components/App/script.js?vue&type=script&lang=js&external


/* harmony default export */ var App_scriptvue_type_script_lang_js_external = ({
  name: 'App',
  components: {
    TrameConnect: Connect,
    TrameServerTemplate: ServerTemplate
  }
});
;// ./src/components/App/script.js?vue&type=script&lang=js&external
 /* harmony default export */ var components_App_scriptvue_type_script_lang_js_external = (App_scriptvue_type_script_lang_js_external); 
;// ./src/components/App/index.vue





/* normalize component */
;
var App_component = (0,componentNormalizer/* default */.A)(
  components_App_scriptvue_type_script_lang_js_external,
  render,
  staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* harmony default export */ var App = (App_component.exports);
;// ./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./src/components/Loading/template.html?vue&type=template&id=40dc20fc&external
var templatevue_type_template_id_40dc20fc_external_render = function render() {
  var _vm = this,
    _c = _vm._self._c;
  return _c('div', {
    class: _vm.$style.container
  }, [_c('div', {
    class: _vm.$style.loader
  }), _c('div', {
    class: _vm.$style.message
  }, [_vm._v(_vm._s(_vm.message))])]);
};
var templatevue_type_template_id_40dc20fc_external_staticRenderFns = [];

;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./src/components/Loading/script.js?vue&type=script&lang=js&external
/* harmony default export */ var Loading_scriptvue_type_script_lang_js_external = ({
  name: 'Loading',
  props: {
    message: {
      type: String,
      default: 'Loading...'
    }
  }
});
;// ./src/components/Loading/script.js?vue&type=script&lang=js&external
 /* harmony default export */ var components_Loading_scriptvue_type_script_lang_js_external = (Loading_scriptvue_type_script_lang_js_external); 
;// ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-11.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-11.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-11.use[2]!./src/components/Loading/style.css?vue&type=style&index=0&prod&module=true&lang=css&external
// extracted by mini-css-extract-plugin
/* harmony default export */ var stylevue_type_style_index_0_prod_module_true_lang_css_external = ({"container":"style_container_VCsHx","loader":"style_loader_CNsNi","spin":"style_spin_BAaPb","message":"style_message_rmggO"});
;// ./src/components/Loading/style.css?vue&type=style&index=0&prod&module=true&lang=css&external
 
;// ./src/components/Loading/index.vue



;




function injectStyles (context) {
  
  this["$style"] = (stylevue_type_style_index_0_prod_module_true_lang_css_external.locals || stylevue_type_style_index_0_prod_module_true_lang_css_external)

}

/* normalize component */

var Loading_component = (0,componentNormalizer/* default */.A)(
  components_Loading_scriptvue_type_script_lang_js_external,
  templatevue_type_template_id_40dc20fc_external_render,
  templatevue_type_template_id_40dc20fc_external_staticRenderFns,
  false,
  injectStyles,
  null,
  null
  
)

/* harmony default export */ var Loading = (Loading_component.exports);
;// ./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./src/components/Reconnect/template.html?vue&type=template&id=77d4d01d&external
var templatevue_type_template_id_77d4d01d_external_render = function render() {
  var _vm = this,
    _c = _vm._self._c;
  return _c('div', {
    class: _vm.$style.container
  }, [_c('div', {
    class: _vm.$style.center
  }, [_c('div', {
    class: _vm.$style.button,
    on: {
      "click": _vm.reconnect
    }
  }, [_c('svg', {
    staticStyle: {
      "width": "24px"
    },
    attrs: {
      "xmlns": "http://www.w3.org/2000/svg",
      "viewBox": "0 0 24 24"
    }
  }, [_c('path', {
    attrs: {
      "d": "M4,1C2.89,1 2,1.89 2,3V7C2,8.11 2.89,9 4,9H1V11H13V9H10C11.11,9 12,8.11 12,7V3C12,1.89 11.11,1 10,1H4M4,3H10V7H4V3M14,13C12.89,13 12,13.89 12,15V19C12,20.11 12.89,21 14,21H11V23H23V21H20C21.11,21 22,20.11 22,19V15C22,13.89 21.11,13 20,13H14M3.88,13.46L2.46,14.88L4.59,17L2.46,19.12L3.88,20.54L6,18.41L8.12,20.54L9.54,19.12L7.41,17L9.54,14.88L8.12,13.46L6,15.59L3.88,13.46M14,15H20V19H14V15Z"
    }
  })]), _vm._v(" " + _vm._s(_vm.message) + " ")])])]);
};
var templatevue_type_template_id_77d4d01d_external_staticRenderFns = [];

;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./src/components/Reconnect/script.js?vue&type=script&lang=js&external
/* harmony default export */ var Reconnect_scriptvue_type_script_lang_js_external = ({
  name: 'Reconnect',
  props: {
    message: {
      type: String,
      default: 'Click to reconnect...'
    },
    maxRetry: {
      type: Number,
      default: 10
    },
    delay: {
      type: Number,
      default: 500
    }
  },
  methods: {
    async reconnect() {
      await this.trame.connect();
    },
    resetRetry() {
      if (this.interval) {
        clearInterval(this.interval);
        this.interval = null;
      }
    }
  },
  mounted() {
    var _this$trame;
    this.retryCount = 0;
    const reconnect = (_this$trame = this.trame) === null || _this$trame === void 0 || (_this$trame = _this$trame.client) === null || _this$trame === void 0 || (_this$trame = _this$trame.getConfig()) === null || _this$trame === void 0 ? void 0 : _this$trame.reconnect;
    if (reconnect) {
      console.log('reconnect', reconnect);
      if (reconnect === 'auto') {
        this.interval = setInterval(() => {
          if (this.retryCount++ < this.maxRetry) {
            this.reconnect();
          } else {
            this.resetRetry();
          }
        }, this.delay);
      }
    }
  },
  beforeDestroy() {
    this.resetRetry();
  },
  inject: ['trame']
});
;// ./src/components/Reconnect/script.js?vue&type=script&lang=js&external
 /* harmony default export */ var components_Reconnect_scriptvue_type_script_lang_js_external = (Reconnect_scriptvue_type_script_lang_js_external); 
;// ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-11.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-11.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-11.use[2]!./src/components/Reconnect/style.css?vue&type=style&index=0&prod&module=true&lang=css&external
// extracted by mini-css-extract-plugin
/* harmony default export */ var Reconnect_stylevue_type_style_index_0_prod_module_true_lang_css_external = ({"container":"style_container_n4xKQ","center":"style_center_xzh58","button":"style_button_kGhdk"});
;// ./src/components/Reconnect/style.css?vue&type=style&index=0&prod&module=true&lang=css&external
 
;// ./src/components/Reconnect/index.vue



;




function Reconnect_injectStyles (context) {
  
  this["$style"] = (Reconnect_stylevue_type_style_index_0_prod_module_true_lang_css_external.locals || Reconnect_stylevue_type_style_index_0_prod_module_true_lang_css_external)

}

/* normalize component */

var Reconnect_component = (0,componentNormalizer/* default */.A)(
  components_Reconnect_scriptvue_type_script_lang_js_external,
  templatevue_type_template_id_77d4d01d_external_render,
  templatevue_type_template_id_77d4d01d_external_staticRenderFns,
  false,
  Reconnect_injectStyles,
  null,
  null
  
)

/* harmony default export */ var Reconnect = (Reconnect_component.exports);
;// ./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./src/components/StateResolver/template.html?vue&type=template&id=3ce31e8c&external
var templatevue_type_template_id_3ce31e8c_external_render = function render() {
  var _vm = this,
    _c = _vm._self._c;
  return _vm._t("default", null, null, _vm.state);
};
var templatevue_type_template_id_3ce31e8c_external_staticRenderFns = [];

;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./src/components/StateResolver/script.js?vue&type=script&lang=js&external








function generateData(...keys) {
  const data = {};
  for (let i = 0; i < keys.length; i++) {
    data[keys[i]] = null;
  }
  return data;
}
function createStateListener(trame, dest, ...keys) {
  return names => {
    const {
      state
    } = trame;
    const changeNames = new Set(names);
    for (let i = 0; i < keys.length; i++) {
      const name = keys[i];
      if (changeNames.has(name)) {
        dest[name] = state.get(name);
      }
    }
  };
}
/* harmony default export */ var StateResolver_scriptvue_type_script_lang_js_external = ({
  inject: ['trame'],
  name: 'TrameStateResolver',
  props: {
    names: {
      type: Array,
      default: () => []
    }
  },
  data() {
    return generateData(...this.names);
  },
  computed: {
    state() {
      const filteredState = {
        trame: this.trame,
        set: (...args) => this.trame.state.set(...args)
      };
      for (let i = 0; i < this.names.length; i++) {
        const name = this.names[i];
        filteredState[name] = this[name];
      }
      return filteredState;
    }
  },
  created() {
    this.onStateChange = createStateListener(this.trame, this, ...this.names);
    this.trame.$on('stateChange', this.onStateChange);
    this.onStateChange(this.names);
  },
  beforeDestroy() {
    this.trame.$off('stateChange', this.onStateChange);
  },
  provide() {
    return {
      state: this
    };
  }
});
;// ./src/components/StateResolver/script.js?vue&type=script&lang=js&external
 /* harmony default export */ var components_StateResolver_scriptvue_type_script_lang_js_external = (StateResolver_scriptvue_type_script_lang_js_external); 
;// ./src/components/StateResolver/index.vue





/* normalize component */
;
var StateResolver_component = (0,componentNormalizer/* default */.A)(
  components_StateResolver_scriptvue_type_script_lang_js_external,
  templatevue_type_template_id_3ce31e8c_external_render,
  templatevue_type_template_id_3ce31e8c_external_staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* harmony default export */ var StateResolver = (StateResolver_component.exports);
;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./src/components/Style/script.js?vue&type=script&lang=js&external
let ID = 1;
function getNextId() {
  return `trame_style_elem_${ID++}`;
}
/* harmony default export */ var Style_scriptvue_type_script_lang_js_external = ({
  name: 'TrameStyle',
  props: {
    css: {
      type: String,
      default: ''
    }
  },
  watch: {
    css(cssContent) {
      this.updateStyle(cssContent);
    }
  },
  created() {
    this.elemId = getNextId();
    this.updateStyle(this.css);
  },
  beforeDestroy() {
    this.removeStyle();
  },
  methods: {
    updateStyle(cssContent) {
      let elem = document.querySelector(`#${this.elemId}`);
      if (cssContent) {
        if (!elem) {
          elem = document.createElement('style');
          elem.id = this.elemId;
          document.head.appendChild(elem);
        }
        elem.innerHTML = cssContent;
      } else {
        this.removeStyle();
      }
    },
    removeStyle() {
      const elem = document.querySelector(`#${this.elemId}`);
      if (elem) {
        elem.parentNode.removeChild(elem);
      }
    }
  }
});
;// ./src/components/Style/script.js?vue&type=script&lang=js&external
 /* harmony default export */ var components_Style_scriptvue_type_script_lang_js_external = (Style_scriptvue_type_script_lang_js_external); 
;// ./src/components/Style/index.vue
var Style_render, Style_staticRenderFns
;



/* normalize component */
;
var Style_component = (0,componentNormalizer/* default */.A)(
  components_Style_scriptvue_type_script_lang_js_external,
  Style_render,
  Style_staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* harmony default export */ var Style = (Style_component.exports);
;// ./src/components/TrameScript.js
const {
  unref
} = window.Vue;
let TrameScript_ID = 1;
function TrameScript_getNextId() {
  return `trame_script_elem_${TrameScript_ID++}`;
}
/* harmony default export */ var TrameScript = ({
  props: {
    script: {
      type: String,
      default: ''
    },
    module: {
      type: Boolean,
      default: false
    }
  },
  watch: {
    script(scriptContent) {
      this.updateContent(scriptContent);
    }
  },
  created() {
    this.elemId = TrameScript_getNextId();
    this.updateContent(this.script);
  },
  beforeUnmount() {
    this.removeScript();
  },
  methods: {
    updateContent(scriptContent) {
      scriptContent = unref(scriptContent);
      let elem = document.querySelector(`#${this.elemId}`);
      if (scriptContent) {
        if (!elem) {
          elem = document.createElement('script');
          elem.id = this.elemId;
          elem.type = this.module ? 'module' : 'text/javascript';
          document.head.appendChild(elem);
        }
        elem.innerHTML = scriptContent;
      } else {
        this.removeScript();
      }
    },
    removeScript() {
      const elem = document.querySelector(`#${this.elemId}`);
      if (elem) {
        elem.parentNode.removeChild(elem);
      }
    }
  },
  template: `<slot />`
});
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.json.parse.js
var es_json_parse = __webpack_require__(9112);
;// ./src/components/TrameDeepReactive.js




const {
  inject,
  reactive,
  onBeforeMount,
  onBeforeUnmount,
  watch
} = window.Vue;
/* harmony default export */ var TrameDeepReactive = ({
  props: ['name'],
  setup(props) {
    const trame = inject('trame');
    const value = reactive({});
    let trameStr = null;
    let refStr = null;
    function pushChange() {
      console.log('pushChange');
      refStr = JSON.stringify(value);
      if (refStr !== trameStr) {
        trame.state.set(props.name, JSON.parse(refStr));
      }
    }
    function fetchValue() {
      console.log('fetchValue');
      trameStr = JSON.stringify(trame.state.get(props.name));
      if (trameStr !== refStr) {
        Object.assign(value, JSON.parse(trameStr));
      }
    }
    function updateState(keys) {
      if (keys.includes(props.name)) {
        fetchValue();
      }
    }
    onBeforeMount(() => {
      trame.$on('stateChange', updateState);
      fetchValue();
    });
    onBeforeUnmount(() => {
      trame.$off('stateChange', updateState);
    });
    watch(value, pushChange);
    return {
      value
    };
  },
  template: '<slot :value="value"></slot>'
});
;// ./src/components/TrameExec.js
/* harmony default export */ var TrameExec = ({
  name: 'TrameExec',
  props: ['event'],
  methods: {
    exec(arg) {
      if (arg === undefined) {
        this.$emit('exec', this.event);
      } else {
        this.$emit('exec', arg);
      }
    }
  },
  template: `<slot />`
});
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.at.js
var es_array_at = __webpack_require__(8107);
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.at-alternative.js
var es_string_at_alternative = __webpack_require__(7357);
;// ./src/components/Getter.js




const {
  inject: Getter_inject,
  ref,
  onBeforeMount: Getter_onBeforeMount,
  onBeforeUnmount: Getter_onBeforeUnmount,
  watch: Getter_watch
} = window.Vue;
/* harmony default export */ var Getter = ({
  props: ['name'],
  setup(props) {
    const trame = Getter_inject('trame');
    const computedValue = ref(null);
    const computedName = ref(null);
    function updateNested(key, value) {
      const newData = JSON.parse(JSON.stringify(trame.state.get(props.name)));
      let current = newData;
      const steps = String(key).split('.');
      for (let i = 0; i < steps.length - 1; i++) {
        current = current[steps[i]];
      }
      current[steps.at(-1)] = value;
      trame.state.set(props.name, newData);
    }
    function update(value) {
      trame.state.set(props.name, value);
    }
    function updateState() {
      const newValue = trame.state.get(props.name);
      if (computedName.value !== props.name) {
        computedName.value = props.name;
      }
      if (newValue !== computedValue.value) {
        computedValue.value = newValue;
      }
    }
    Getter_watch(() => props.name, updateState);
    Getter_onBeforeMount(() => {
      trame.$on('stateChange', updateState);
      updateState();
    });
    Getter_onBeforeUnmount(() => {
      trame.$off('stateChange', updateState);
    });
    return {
      computedValue,
      computedName,
      updateNested,
      update
    };
  },
  template: '<slot :keyName="computedName" :update="update" :updateNested="updateNested" :value="computedValue"></slot>'
});
;// ./src/components/ClientStateChange.js
const {
  watch: ClientStateChange_watch,
  nextTick
} = window.Vue;
/* harmony default export */ var ClientStateChange = ({
  props: {
    value: {
      type: String
    },
    immediate: {
      type: Boolean,
      default: false
    },
    triggerChangeOnCreate: {
      type: Boolean,
      default: false
    }
  },
  emits: ['change'],
  setup(props, {
    emit
  }) {
    ClientStateChange_watch(() => props.value, v => {
      if (props.immediate) {
        emit('change', v);
      } else {
        nextTick(() => {
          emit('change', v);
        });
      }
    });
    if (props.triggerChangeOnCreate) {
      emit('change', props.value);
    }
  },
  template: `<slot />`
});
;// ./src/components/ClientTriggers.js
const {
  onMounted,
  onBeforeUnmount: ClientTriggers_onBeforeUnmount
} = window.Vue;
/* harmony default export */ var ClientTriggers = ({
  emits: ['mounted', 'created', 'beforeDestroy', 'beforeUnmount', 'exit'],
  setup(props, {
    emit,
    expose
  }) {
    function emitTopic(topic, event) {
      emit(topic, event);
    }
    onMounted(() => emit('mounted'));
    ClientTriggers_onBeforeUnmount(() => {
      emit('beforeDestroy');
      emit('beforeUnmount');
    });
    expose({
      emit: emitTopic
    });
    window.addEventListener('beforeunload', () => {
      emit('exit');
    });
    emit('created');
    return {
      emit: emitTopic
    };
  },
  template: `<slot />`
});
;// ./src/components/LifeCycleMonitor.js
const {
  onMounted: LifeCycleMonitor_onMounted,
  onUpdated,
  onUnmounted,
  onBeforeMount: LifeCycleMonitor_onBeforeMount,
  onBeforeUpdate,
  onBeforeUnmount: LifeCycleMonitor_onBeforeUnmount
} = window.Vue;
function runNow(fn) {
  fn();
}
const NAME_TO_LIFE_CYCLE = {
  created: runNow,
  beforeMount: LifeCycleMonitor_onBeforeMount,
  mounted: LifeCycleMonitor_onMounted,
  beforeUpdate: onBeforeUpdate,
  updated: onUpdated,
  beforeDestroy: LifeCycleMonitor_onBeforeUnmount,
  destroyed: onUnmounted
};
/* harmony default export */ var LifeCycleMonitor = ({
  props: {
    name: {
      type: String,
      default: 'LifeCycleMonitor'
    },
    type: {
      type: String,
      default: 'log'
    },
    value: {
      type: String,
      default: 'value'
    },
    events: {
      type: Array,
      default: () => ['created', 'beforeMount', 'mounted', 'beforeUpdate', 'updated', 'beforeDestroy', 'destroyed']
    }
  },
  emits: Object.keys(NAME_TO_LIFE_CYCLE),
  setup(props, {
    emit
  }) {
    for (let i = 0; i < props.events.length; i++) {
      const name = props.events[i];
      const fn = NAME_TO_LIFE_CYCLE[name];
      fn(() => {
        if (props.type === 'emit') {
          emit(name, {
            name: props.name,
            value: props.value
          });
        } else {
          console[props.type](props.name, name, props.value);
        }
      });
    }
  },
  template: `<slot />`
});
;// ./src/components/SizeObserver.js
const {
  inject: SizeObserver_inject,
  ref: SizeObserver_ref,
  onMounted: SizeObserver_onMounted,
  onBeforeUnmount: SizeObserver_onBeforeUnmount
} = window.Vue;
/* harmony default export */ var SizeObserver = ({
  props: {
    name: {
      type: String
    }
  },
  emits: ['change'],
  setup(props, {
    emit
  }) {
    const trame = SizeObserver_inject('trame');
    const elem = SizeObserver_ref(null);
    function resize() {
      const {
        x,
        y,
        width,
        height
      } = elem.value.getBoundingClientRect();
      const size = {
        x,
        y,
        width,
        height
      };
      const pixelRatio = window.devicePixelRatio;
      const dpi = 96 * pixelRatio;
      const event = {
        size,
        pixelRatio,
        dpi
      };
      if (props.name) {
        event.name = props.name;
      }
      if (trame) {
        trame.state.set(props.name, event);
      }
      emit('change', event);
    }
    const sizeObserver = new ResizeObserver(resize);
    SizeObserver_onMounted(() => {
      sizeObserver.observe(elem.value);
    });
    SizeObserver_onBeforeUnmount(() => {
      sizeObserver.unobserve(elem.value);
    });
    return {
      elem,
      resize
    };
  },
  template: '<div ref="elem" style="overflow: hidden; position: relative; width: 100%; height: 100%; margin: 0; padding: 0;"><slot></slot></div>'
});
;// ./src/components/index.js















/* harmony default export */ var components = ({
  TrameApp: App,
  TrameConnect: Connect,
  TrameLoading: Loading,
  TrameReconnect: Reconnect,
  TrameTemplate: ServerTemplate,
  TrameStateResolver: StateResolver,
  TrameScript: TrameScript,
  TrameStyle: Style,
  TrameDeepReactive: TrameDeepReactive,
  TrameExec: TrameExec,
  TrameGetter: Getter,
  TrameClientStateChange: ClientStateChange,
  TrameClientTriggers: ClientTriggers,
  TrameLifeCycleMonitor: LifeCycleMonitor,
  TrameSizeObserver: SizeObserver
});
;// ./src/use.js



/* harmony default export */ var use = ({
  install(Vue) {
    Object.keys(components).forEach(name => {
      Vue.component(name, components[name]);
    });
  }
});
;// ./src/main.js











const DEFAULT_CONNECTION_NAME = 'TrameConnect';
function reportWsError() {
  const status = wslink.getStatus(DEFAULT_CONNECTION_NAME);
  const elem = document.querySelector('.trame__message');
  if (elem) {
    elem.innerHTML = status.message || status.type;
  } else {
    console.error('WsError', status.message || status.type);
  }
}
async function initializeApplication(Vue) {
  // Check if we need to override websocket
  try {
    var _window;
    // Can throw exception if parent is cross-origin
    if ((_window = window) !== null && _window !== void 0 && (_window = _window.parent) !== null && _window !== void 0 && (_window = _window.trameJupyter) !== null && _window !== void 0 && _window.init) {
      window.WSLINK = window.parent.trameJupyter.init(window);
    }
  } catch (e) {
    // eslint-disable-next-line
  }

  // Add default trame components
  Vue.use(use);

  // Connect to server
  const config = wslink.configDecorator({
    application: 'trame',
    useUrl: true
  });
  const client = wslink.getClient(DEFAULT_CONNECTION_NAME);
  try {
    await client.connect(config);
  } catch (e) {
    reportWsError();
    return;
  }

  // Attach basic error feedback
  client.onConnectionError(reportWsError);
  client.onConnectionClose(reportWsError);
  setAddAttachment(client.getConnection().getSession().addAttachment);
  const {
    state
  } = await client.getRemote().Trame.getState();
  await handlePageUpdate(Object.keys(state), state);
  new Vue((0,objectSpread2/* default */.A)((0,objectSpread2/* default */.A)({}, GLOBAL_VUE_OPTIONS), {}, {
    render: h => h(App)
  })).$mount('#app');
}

// Initialize service worker to override headers for SharedArrayBuffer
// > Cross-Origin-Opener-Policy: same-origin
// > Cross-Origin-Embedder-Policy: require-corp
if (URLExtract/* default */.A.extractURLParameters().enableSharedArrayBufferServiceWorker) {
  loadScript('coi-serviceworker.js');
}
initializeApplication((external_Vue_default()));

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = __webpack_modules__;
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/chunk loaded */
/******/ 	!function() {
/******/ 		var deferred = [];
/******/ 		__webpack_require__.O = function(result, chunkIds, fn, priority) {
/******/ 			if(chunkIds) {
/******/ 				priority = priority || 0;
/******/ 				for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];
/******/ 				deferred[i] = [chunkIds, fn, priority];
/******/ 				return;
/******/ 			}
/******/ 			var notFulfilled = Infinity;
/******/ 			for (var i = 0; i < deferred.length; i++) {
/******/ 				var chunkIds = deferred[i][0];
/******/ 				var fn = deferred[i][1];
/******/ 				var priority = deferred[i][2];
/******/ 				var fulfilled = true;
/******/ 				for (var j = 0; j < chunkIds.length; j++) {
/******/ 					if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every(function(key) { return __webpack_require__.O[key](chunkIds[j]); })) {
/******/ 						chunkIds.splice(j--, 1);
/******/ 					} else {
/******/ 						fulfilled = false;
/******/ 						if(priority < notFulfilled) notFulfilled = priority;
/******/ 					}
/******/ 				}
/******/ 				if(fulfilled) {
/******/ 					deferred.splice(i--, 1)
/******/ 					var r = fn();
/******/ 					if (r !== undefined) result = r;
/******/ 				}
/******/ 			}
/******/ 			return result;
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	!function() {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = function(module) {
/******/ 			var getter = module && module.__esModule ?
/******/ 				function() { return module['default']; } :
/******/ 				function() { return module; };
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	!function() {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = function(exports, definition) {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/global */
/******/ 	!function() {
/******/ 		__webpack_require__.g = (function() {
/******/ 			if (typeof globalThis === 'object') return globalThis;
/******/ 			try {
/******/ 				return this || new Function('return this')();
/******/ 			} catch (e) {
/******/ 				if (typeof window === 'object') return window;
/******/ 			}
/******/ 		})();
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	!function() {
/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/jsonp chunk loading */
/******/ 	!function() {
/******/ 		// no baseURI
/******/ 		
/******/ 		// object to store loaded and loading chunks
/******/ 		// undefined = chunk not loaded, null = chunk preloaded/prefetched
/******/ 		// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
/******/ 		var installedChunks = {
/******/ 			524: 0
/******/ 		};
/******/ 		
/******/ 		// no chunk on demand loading
/******/ 		
/******/ 		// no prefetching
/******/ 		
/******/ 		// no preloaded
/******/ 		
/******/ 		// no HMR
/******/ 		
/******/ 		// no HMR manifest
/******/ 		
/******/ 		__webpack_require__.O.j = function(chunkId) { return installedChunks[chunkId] === 0; };
/******/ 		
/******/ 		// install a JSONP callback for chunk loading
/******/ 		var webpackJsonpCallback = function(parentChunkLoadingFunction, data) {
/******/ 			var chunkIds = data[0];
/******/ 			var moreModules = data[1];
/******/ 			var runtime = data[2];
/******/ 			// add "moreModules" to the modules object,
/******/ 			// then flag all "chunkIds" as loaded and fire callback
/******/ 			var moduleId, chunkId, i = 0;
/******/ 			if(chunkIds.some(function(id) { return installedChunks[id] !== 0; })) {
/******/ 				for(moduleId in moreModules) {
/******/ 					if(__webpack_require__.o(moreModules, moduleId)) {
/******/ 						__webpack_require__.m[moduleId] = moreModules[moduleId];
/******/ 					}
/******/ 				}
/******/ 				if(runtime) var result = runtime(__webpack_require__);
/******/ 			}
/******/ 			if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
/******/ 			for(;i < chunkIds.length; i++) {
/******/ 				chunkId = chunkIds[i];
/******/ 				if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
/******/ 					installedChunks[chunkId][0]();
/******/ 				}
/******/ 				installedChunks[chunkId] = 0;
/******/ 			}
/******/ 			return __webpack_require__.O(result);
/******/ 		}
/******/ 		
/******/ 		var chunkLoadingGlobal = self["webpackChunktrame_app_vue2"] = self["webpackChunktrame_app_vue2"] || [];
/******/ 		chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
/******/ 		chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
/******/ 	}();
/******/ 	
/************************************************************************/
/******/ 	
/******/ 	// startup
/******/ 	// Load entry module and return exports
/******/ 	// This entry module depends on other loaded chunks and execution need to be delayed
/******/ 	var __webpack_exports__ = __webpack_require__.O(undefined, [504], function() { return __webpack_require__(9219); })
/******/ 	__webpack_exports__ = __webpack_require__.O(__webpack_exports__);
/******/ 	
/******/ })()
;