@pushler/vue 1.0.0

package/dist/pushler-vue.umd.js

@@ -0,0 +1,876 @@
+/*!
+ * @pushler/vue v1.0.0
+ * (c) 2026 Pushler.ru
+ * @license MIT
+ */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'vue'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.PushlerVue = {}, global.Vue));
+})(this, (function (exports, vue) { 'use strict';
+
+  /**
+   * Состояния подключения
+   */
+  const ConnectionStates = {
+    CONNECTING: 'connecting',
+    CONNECTED: 'connected',
+    DISCONNECTED: 'disconnected',
+    RECONNECTING: 'reconnecting',
+    FAILED: 'failed'
+  };
+
+  /**
+   * Типы каналов
+   */
+  const ChannelTypes = {
+    PUBLIC: 'public',
+    PRIVATE: 'private',
+    PRESENCE: 'presence'
+  };
+
+  /**
+   * Vue composable для работы с Pushler WebSocket
+   * 
+   * @param {Object} options - Опции подключения
+   * @param {string} options.appKey - Ключ приложения
+   * @param {string} options.wsUrl - URL WebSocket сервера
+   * @param {string} options.authEndpoint - Эндпоинт авторизации для приватных каналов
+   * @param {boolean} options.autoConnect - Автоматическое подключение (по умолчанию false)
+   * @param {number} options.reconnectDelay - Задержка переподключения в мс (по умолчанию 1000)
+   * @param {number} options.maxReconnectAttempts - Максимум попыток переподключения (по умолчанию 5)
+   * @returns {Object} Реактивный объект с методами и состоянием
+   */
+  function usePushler(options = {}) {
+    // Реактивное состояние
+    const connectionState = vue.ref(ConnectionStates.DISCONNECTED);
+    const socketId = vue.ref(null);
+    const error = vue.ref(null);
+    const reconnectAttempts = vue.ref(0);
+    
+    // Каналы
+    const channels = vue.reactive(new Map());
+    const channelAliases = vue.reactive(new Map());
+    
+    // Внутренние переменные
+    let socket = null;
+    let reconnectTimer = null;
+    const eventListeners = new Map();
+    
+    // Конфигурация
+    const config = {
+      appKey: options.appKey || '',
+      wsUrl: options.wsUrl || 'ws://localhost:8081/app',
+      authEndpoint: options.authEndpoint || '/pushler/auth',
+      autoConnect: options.autoConnect || false,
+      reconnectDelay: options.reconnectDelay || 1000,
+      maxReconnectAttempts: options.maxReconnectAttempts || 5,
+    };
+    
+    // Вычисляемые свойства
+    const isConnected = vue.computed(() => connectionState.value === ConnectionStates.CONNECTED);
+    const isConnecting = vue.computed(() => connectionState.value === ConnectionStates.CONNECTING);
+    const isReconnecting = vue.computed(() => connectionState.value === ConnectionStates.RECONNECTING);
+    
+    /**
+     * Форматирование имени канала с префиксом appKey
+     */
+    function formatChannelName(channelName) {
+      if (channelName.startsWith(config.appKey + ':')) {
+        return channelName;
+      }
+      return `${config.appKey}:${channelName}`;
+    }
+    
+    /**
+     * Извлечение оригинального имени канала
+     */
+    function extractChannelName(fullChannelName) {
+      const prefix = config.appKey + ':';
+      if (fullChannelName.startsWith(prefix)) {
+        return fullChannelName.substring(prefix.length);
+      }
+      return fullChannelName;
+    }
+    
+    /**
+     * Определение типа канала
+     */
+    function getChannelType(channelName) {
+      const baseName = extractChannelName(channelName);
+      if (baseName.startsWith('private-')) return ChannelTypes.PRIVATE;
+      if (baseName.startsWith('presence-')) return ChannelTypes.PRESENCE;
+      return ChannelTypes.PUBLIC;
+    }
+    
+    /**
+     * Подключение к WebSocket серверу
+     */
+    function connect(connectOptions = {}) {
+      // Обновляем конфигурацию если переданы новые параметры
+      if (connectOptions.appKey) config.appKey = connectOptions.appKey;
+      if (connectOptions.wsUrl) config.wsUrl = connectOptions.wsUrl;
+      if (connectOptions.authEndpoint) config.authEndpoint = connectOptions.authEndpoint;
+      
+      if (connectionState.value === ConnectionStates.CONNECTED ||
+          connectionState.value === ConnectionStates.CONNECTING) {
+        return;
+      }
+      
+      connectionState.value = ConnectionStates.CONNECTING;
+      error.value = null;
+      
+      try {
+        // Формируем URL с ключом приложения
+        const wsUrl = config.wsUrl.endsWith('/') 
+          ? `${config.wsUrl}${config.appKey}`
+          : `${config.wsUrl}/${config.appKey}`;
+        
+        console.log('[Pushler Vue] Connecting to:', wsUrl);
+        socket = new WebSocket(wsUrl);
+        setupSocketHandlers();
+      } catch (err) {
+        console.error('[Pushler Vue] Connection error:', err);
+        connectionState.value = ConnectionStates.FAILED;
+        error.value = err.message;
+      }
+    }
+    
+    /**
+     * Настройка обработчиков WebSocket
+     */
+    function setupSocketHandlers() {
+      socket.onopen = () => {
+        console.log('[Pushler Vue] WebSocket opened, waiting for connection_established...');
+      };
+      
+      socket.onmessage = (event) => {
+        handleMessage(event);
+      };
+      
+      socket.onclose = (event) => {
+        console.log('[Pushler Vue] WebSocket closed:', event.code, event.reason);
+        connectionState.value = ConnectionStates.DISCONNECTED;
+        socketId.value = null;
+        
+        // Автопереподключение
+        if (event.code !== 1000 && reconnectAttempts.value < config.maxReconnectAttempts) {
+          scheduleReconnect();
+        }
+      };
+      
+      socket.onerror = (err) => {
+        console.error('[Pushler Vue] WebSocket error:', err);
+        connectionState.value = ConnectionStates.FAILED;
+        error.value = 'Connection failed';
+      };
+    }
+    
+    /**
+     * Обработка входящих сообщений
+     */
+    function handleMessage(event) {
+      try {
+        // Поддержка нескольких сообщений в одном event
+        const messages = event.data.trim().split('\n').filter(line => line.trim());
+        
+        for (const msgData of messages) {
+          processMessage(JSON.parse(msgData));
+        }
+      } catch (err) {
+        console.error('[Pushler Vue] Error parsing message:', err);
+      }
+    }
+    
+    /**
+     * Обработка отдельного сообщения
+     */
+    function processMessage(message) {
+      switch (message.event) {
+        case 'pushler:connection_established':
+          handleConnectionEstablished(message.data);
+          break;
+        case 'pushler:subscription_succeeded':
+          handleSubscriptionSucceeded(message);
+          break;
+        case 'pushler:auth_success':
+          handleAuthSuccess(message);
+          break;
+        case 'pushler:auth_error':
+          handleAuthError(message);
+          break;
+        default:
+          handleChannelMessage(message);
+      }
+    }
+    
+    /**
+     * Обработка установления соединения
+     */
+    function handleConnectionEstablished(data) {
+      socketId.value = data.socket_id;
+      connectionState.value = ConnectionStates.CONNECTED;
+      reconnectAttempts.value = 0;
+      
+      console.log('[Pushler Vue] Connected with socket ID:', socketId.value);
+      
+      // Переподписка на все каналы
+      resubscribeAllChannels();
+      
+      emit('connected', { socketId: socketId.value });
+    }
+    
+    /**
+     * Переподписка на все каналы
+     */
+    function resubscribeAllChannels() {
+      for (const [name, channel] of channels.entries()) {
+        channel.subscribed = false;
+        performChannelSubscription(channel);
+      }
+    }
+    
+    /**
+     * Обработка успешной подписки
+     */
+    function handleSubscriptionSucceeded(message) {
+      const channel = channels.get(message.channel);
+      if (channel) {
+        channel.subscribed = true;
+        channel.emit('subscribed', message.data || {});
+      }
+    }
+    
+    /**
+     * Обработка успешной авторизации
+     */
+    function handleAuthSuccess(message) {
+      const channel = channels.get(message.data.channel);
+      if (channel) {
+        channel.subscribed = true;
+        channel.emit('subscribed', message.data);
+      }
+      emit('auth_success', message.data);
+    }
+    
+    /**
+     * Обработка ошибки авторизации
+     */
+    function handleAuthError(message) {
+      error.value = message.data.error;
+      emit('auth_error', message.data);
+    }
+    
+    /**
+     * Обработка сообщения канала
+     */
+    function handleChannelMessage(message) {
+      const { channel: channelName, event, data } = message;
+      const channel = channels.get(channelName);
+      
+      if (channel) {
+        channel.emit(event, data);
+      }
+      
+      emit('message', { 
+        channel: extractChannelName(channelName), 
+        event, 
+        data 
+      });
+    }
+    
+    /**
+     * Планирование переподключения
+     */
+    function scheduleReconnect() {
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+      }
+      
+      reconnectAttempts.value++;
+      connectionState.value = ConnectionStates.RECONNECTING;
+      
+      const delay = config.reconnectDelay * reconnectAttempts.value;
+      console.log(`[Pushler Vue] Reconnecting in ${delay}ms (attempt ${reconnectAttempts.value}/${config.maxReconnectAttempts})`);
+      
+      reconnectTimer = setTimeout(() => {
+        connect();
+      }, delay);
+    }
+    
+    /**
+     * Отключение от сервера
+     */
+    function disconnect() {
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      
+      if (socket) {
+        socket.close(1000, 'User disconnect');
+        socket = null;
+      }
+      
+      connectionState.value = ConnectionStates.DISCONNECTED;
+      socketId.value = null;
+      channels.clear();
+      channelAliases.clear();
+      reconnectAttempts.value = 0;
+      
+      emit('disconnected');
+    }
+    
+    /**
+     * Отправка сообщения через WebSocket
+     */
+    function sendMessage(message) {
+      if (socket && socket.readyState === WebSocket.OPEN) {
+        socket.send(JSON.stringify(message));
+      }
+    }
+    
+    /**
+     * Подписка на канал
+     * @param {string} channelName - Имя канала
+     * @param {Object} options - Опции (signature для приватных, user для presence)
+     * @returns {Object} Реактивный объект канала
+     */
+    function subscribe(channelName, subscribeOptions = {}) {
+      const fullChannelName = formatChannelName(channelName);
+      
+      if (channels.has(fullChannelName)) {
+        return channels.get(fullChannelName);
+      }
+      
+      // Создаем реактивный канал
+      const channel = vue.reactive({
+        name: fullChannelName,
+        originalName: channelName,
+        type: getChannelType(channelName),
+        subscribed: false,
+        options: subscribeOptions,
+        listeners: new Map(),
+        
+        // Методы канала
+        on(event, callback) {
+          if (!this.listeners.has(event)) {
+            this.listeners.set(event, []);
+          }
+          this.listeners.get(event).push(callback);
+          return this;
+        },
+        
+        off(event, callback) {
+          if (this.listeners.has(event)) {
+            const list = this.listeners.get(event);
+            const idx = list.indexOf(callback);
+            if (idx > -1) list.splice(idx, 1);
+          }
+          return this;
+        },
+        
+        emit(event, data) {
+          if (this.listeners.has(event)) {
+            this.listeners.get(event).forEach(cb => {
+              try {
+                cb(data);
+              } catch (err) {
+                console.error('[Pushler Vue] Channel event error:', err);
+              }
+            });
+          }
+        },
+        
+        unsubscribe() {
+          unsubscribe(channelName);
+        }
+      });
+      
+      channels.set(fullChannelName, channel);
+      channelAliases.set(channelName, fullChannelName);
+      
+      // Подписываемся если уже подключены
+      if (connectionState.value === ConnectionStates.CONNECTED) {
+        performChannelSubscription(channel);
+      }
+      
+      return channel;
+    }
+    
+    /**
+     * Выполнение подписки на канал
+     */
+    async function performChannelSubscription(channel) {
+      if (connectionState.value !== ConnectionStates.CONNECTED) {
+        return;
+      }
+      
+      const channelType = channel.type;
+      
+      // Публичные каналы
+      if (channelType === ChannelTypes.PUBLIC) {
+        sendMessage({
+          event: 'pushler:subscribe',
+          data: {
+            channel: channel.name,
+            app_key: config.appKey
+          }
+        });
+        return;
+      }
+      
+      // Приватные и presence каналы требуют авторизации
+      try {
+        const authData = await getAuthData(channel);
+        sendMessage({
+          event: 'pushler:auth',
+          data: authData
+        });
+      } catch (err) {
+        console.error('[Pushler Vue] Auth error:', err);
+        error.value = err.message;
+      }
+    }
+    
+    /**
+     * Получение данных авторизации для приватных/presence каналов
+     * 
+     * Для приватных каналов подпись ДОЛЖНА быть получена с вашего бэкенда,
+     * либо передана в options.signature при подписке.
+     * 
+     * НИКОГДА не храните секретный ключ в клиентском коде!
+     */
+    async function getAuthData(channel) {
+      if (!socketId.value) {
+        throw new Error('Socket ID not available');
+      }
+      
+      const authData = {
+        app_key: config.appKey,
+        channel: channel.name,
+        socket_id: socketId.value
+      };
+      
+      // Если подпись уже предоставлена в options
+      if (channel.options.signature) {
+        authData.signature = channel.options.signature;
+      } else {
+        // Запрашиваем подпись с бэкенда
+        authData.signature = await fetchSignature(channel);
+      }
+      
+      // Данные пользователя для presence каналов
+      if (channel.type === ChannelTypes.PRESENCE && channel.options.user) {
+        authData.user = channel.options.user;
+      }
+      
+      return authData;
+    }
+    
+    /**
+     * Запрос подписи с бэкенда
+     * 
+     * Ваш бэкенд должен:
+     * 1. Проверить авторизацию пользователя
+     * 2. Сгенерировать HMAC-SHA256 подпись с секретным ключом
+     * 3. Вернуть подпись клиенту
+     */
+    async function fetchSignature(channel) {
+      const response = await fetch(config.authEndpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include', // Включаем куки для авторизации
+        body: JSON.stringify({
+          channel_name: channel.name,
+          socket_id: socketId.value,
+          app_key: config.appKey,
+          user_data: channel.options.user
+        })
+      });
+      
+      if (!response.ok) {
+        const err = await response.json().catch(() => ({ error: 'Auth request failed' }));
+        throw new Error(err.error || 'Failed to get signature');
+      }
+      
+      const data = await response.json();
+      return data.signature;
+    }
+    
+    /**
+     * Отписка от канала
+     */
+    function unsubscribe(channelName) {
+      const fullChannelName = channelAliases.get(channelName) || formatChannelName(channelName);
+      const channel = channels.get(fullChannelName);
+      
+      if (channel) {
+        if (channel.subscribed && connectionState.value === ConnectionStates.CONNECTED) {
+          sendMessage({
+            event: 'pushler:unsubscribe',
+            data: { channel: fullChannelName }
+          });
+        }
+        
+        channels.delete(fullChannelName);
+        channelAliases.delete(channelName);
+      }
+    }
+    
+    /**
+     * Получение канала по имени
+     */
+    function channel(channelName) {
+      const fullChannelName = channelAliases.get(channelName) || formatChannelName(channelName);
+      return channels.get(fullChannelName);
+    }
+    
+    /**
+     * Получение списка каналов
+     */
+    function getChannels() {
+      return Array.from(channels.values()).map(ch => ({
+        name: ch.originalName,
+        fullName: ch.name,
+        type: ch.type,
+        subscribed: ch.subscribed
+      }));
+    }
+    
+    /**
+     * Подписка на глобальное событие
+     */
+    function on(event, callback) {
+      if (!eventListeners.has(event)) {
+        eventListeners.set(event, []);
+      }
+      eventListeners.get(event).push(callback);
+    }
+    
+    /**
+     * Отписка от глобального события
+     */
+    function off(event, callback) {
+      if (eventListeners.has(event)) {
+        const list = eventListeners.get(event);
+        const idx = list.indexOf(callback);
+        if (idx > -1) list.splice(idx, 1);
+      }
+    }
+    
+    /**
+     * Вызов глобального события
+     */
+    function emit(event, data) {
+      if (eventListeners.has(event)) {
+        eventListeners.get(event).forEach(cb => {
+          try {
+            cb(data);
+          } catch (err) {
+            console.error('[Pushler Vue] Event error:', err);
+          }
+        });
+      }
+    }
+    
+    // Автоматическое отключение при размонтировании компонента
+    vue.onUnmounted(() => {
+      disconnect();
+    });
+    
+    // Автоподключение если указано
+    if (config.autoConnect && config.appKey) {
+      connect();
+    }
+    
+    return {
+      // Состояние (readonly для защиты от внешних изменений)
+      connectionState: vue.readonly(connectionState),
+      socketId: vue.readonly(socketId),
+      error: vue.readonly(error),
+      reconnectAttempts: vue.readonly(reconnectAttempts),
+      
+      // Вычисляемые свойства
+      isConnected,
+      isConnecting,
+      isReconnecting,
+      
+      // Методы
+      connect,
+      disconnect,
+      subscribe,
+      unsubscribe,
+      channel,
+      getChannels,
+      on,
+      off,
+      
+      // Утилиты
+      formatChannelName,
+      extractChannelName,
+      getChannelType,
+      
+      // Константы
+      ConnectionStates,
+      ChannelTypes,
+    };
+  }
+
+  /**
+   * Vue composable для работы с отдельным каналом Pushler
+   * 
+   * Можно использовать автономно или совместно с usePushler
+   * 
+   * @param {Object} pushler - Инстанс usePushler
+   * @param {string} channelName - Имя канала
+   * @param {Object} options - Опции канала
+   * @returns {Object} Реактивный объект канала с событиями
+   */
+  function usePushlerChannel(pushler, channelName, options = {}) {
+    const channel = vue.ref(null);
+    const isSubscribed = vue.ref(false);
+    const lastEvent = vue.ref(null);
+    const events = vue.reactive([]);
+    const eventHandlers = new Map();
+    
+    /**
+     * Максимальное количество событий в буфере
+     */
+    const maxEvents = options.maxEvents || 100;
+    
+    /**
+     * Подписка на канал
+     */
+    function subscribe() {
+      if (!pushler || !channelName) return;
+      
+      channel.value = pushler.subscribe(channelName, options);
+      
+      // Отслеживаем статус подписки
+      channel.value.on('subscribed', () => {
+        isSubscribed.value = true;
+      });
+      
+      return channel.value;
+    }
+    
+    /**
+     * Отписка от канала
+     */
+    function unsubscribe() {
+      if (pushler && channelName) {
+        pushler.unsubscribe(channelName);
+        channel.value = null;
+        isSubscribed.value = false;
+      }
+    }
+    
+    /**
+     * Подписка на событие канала
+     * @param {string} eventName - Имя события
+     * @param {Function} callback - Обработчик
+     */
+    function on(eventName, callback) {
+      if (!channel.value) {
+        subscribe();
+      }
+      
+      const handler = (data) => {
+        // Сохраняем последнее событие
+        lastEvent.value = {
+          event: eventName,
+          data,
+          timestamp: new Date()
+        };
+        
+        // Добавляем в буфер событий
+        events.unshift(lastEvent.value);
+        if (events.length > maxEvents) {
+          events.pop();
+        }
+        
+        // Вызываем пользовательский обработчик
+        callback(data);
+      };
+      
+      eventHandlers.set(eventName, handler);
+      channel.value.on(eventName, handler);
+      
+      return () => off(eventName);
+    }
+    
+    /**
+     * Отписка от события канала
+     */
+    function off(eventName) {
+      if (channel.value && eventHandlers.has(eventName)) {
+        channel.value.off(eventName, eventHandlers.get(eventName));
+        eventHandlers.delete(eventName);
+      }
+    }
+    
+    /**
+     * Очистка буфера событий
+     */
+    function clearEvents() {
+      events.length = 0;
+      lastEvent.value = null;
+    }
+    
+    // Автоматическая подписка если указано
+    if (options.autoSubscribe !== false && pushler?.isConnected?.value) {
+      subscribe();
+    }
+    
+    // Подписываемся при подключении
+    if (pushler) {
+      vue.watch(() => pushler.isConnected.value, (connected) => {
+        if (connected && options.autoSubscribe !== false && !channel.value) {
+          subscribe();
+        }
+      });
+    }
+    
+    // Автоматическая отписка при размонтировании
+    vue.onUnmounted(() => {
+      unsubscribe();
+    });
+    
+    return {
+      channel,
+      isSubscribed,
+      lastEvent,
+      events,
+      
+      subscribe,
+      unsubscribe,
+      on,
+      off,
+      clearEvents,
+    };
+  }
+
+  /**
+   * Символ для инъекции Pushler
+   */
+  const PushlerKey = Symbol('pushler');
+
+  /**
+   * Vue Plugin для глобальной инициализации Pushler
+   * 
+   * Использование:
+   * 
+   * ```js
+   * import { createApp } from 'vue';
+   * import { PushlerPlugin } from '@pushler/vue';
+   * 
+   * const app = createApp(App);
+   * app.use(PushlerPlugin, {
+   *   appKey: 'your-app-key',
+   *   wsUrl: 'wss://ws.pushler.ru/app',
+   *   autoConnect: true
+   * });
+   * ```
+   * 
+   * Затем в компонентах:
+   * 
+   * ```js
+   * import { inject } from 'vue';
+   * import { PushlerKey } from '@pushler/vue';
+   * 
+   * const pushler = inject(PushlerKey);
+   * ```
+   */
+  const PushlerPlugin = {
+    install(app, options = {}) {
+      // Создаем глобальный инстанс Pushler
+      const pushler = usePushler(options);
+      
+      // Предоставляем через provide/inject
+      app.provide(PushlerKey, pushler);
+      
+      // Также добавляем как глобальное свойство (для Options API)
+      app.config.globalProperties.$pushler = pushler;
+      
+      // Экспортируем константы
+      app.config.globalProperties.$PushlerConnectionStates = ConnectionStates;
+      app.config.globalProperties.$PushlerChannelTypes = ChannelTypes;
+    }
+  };
+
+  /**
+   * Хелпер для получения инстанса Pushler в setup()
+   */
+  function usePushlerInstance() {
+    const pushler = inject(PushlerKey);
+    if (!pushler) {
+      throw new Error(
+        '[Pushler Vue] No Pushler instance found. ' +
+        'Make sure to install PushlerPlugin or provide a Pushler instance.'
+      );
+    }
+    return pushler;
+  }
+
+  /**
+   * Pushler Vue SDK
+   * 
+   * Реактивный Vue.js SDK для работы с Pushler.ru WebSocket сервером
+   * 
+   * @example Базовое использование
+   * ```vue
+   * <script setup>
+   * import { usePushler } from '@pushler/vue';
+   * 
+   * const pushler = usePushler({
+   *   appKey: 'your-app-key',
+   *   wsUrl: 'wss://ws.pushler.ru/app'
+   * });
+   * 
+   * // Подключение
+   * pushler.connect();
+   * 
+   * // Подписка на канал
+   * const channel = pushler.subscribe('my-channel');
+   * channel.on('message', (data) => {
+   *   console.log('Received:', data);
+   * });
+   * </script>
+   * 
+   * <template>
+   *   <div>
+   *     <p>Status: {{ pushler.connectionState }}</p>
+   *     <p>Socket ID: {{ pushler.socketId }}</p>
+   *   </div>
+   * </template>
+   * ```
+   * 
+   * @example С Vue Plugin
+   * ```js
+   * // main.js
+   * import { createApp } from 'vue';
+   * import { PushlerPlugin } from '@pushler/vue';
+   * 
+   * const app = createApp(App);
+   * app.use(PushlerPlugin, {
+   *   appKey: 'your-app-key',
+   *   wsUrl: 'wss://ws.pushler.ru/app',
+   *   autoConnect: true
+   * });
+   * ```
+   */
+
+  exports.ChannelTypes = ChannelTypes;
+  exports.ConnectionStates = ConnectionStates;
+  exports.PushlerKey = PushlerKey;
+  exports.PushlerPlugin = PushlerPlugin;
+  exports.default = usePushler;
+  exports.usePushler = usePushler;
+  exports.usePushlerChannel = usePushlerChannel;
+  exports.usePushlerInstance = usePushlerInstance;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=pushler-vue.umd.js.map