https://ngoaingutomato.edu.vn/assets/data/pnotify/js/PNotifyFontAwesome5.js

1(function (global, factory) {
2  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
3  typeof define === 'function' && define.amd ? define(['exports'], factory) :
4  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.PNotifyFontAwesome5 = {}));
5}(this, (function (exports) { 'use strict';
6
7  function _typeof(obj) {
8    "@babel/helpers - typeof";
9
10    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
11      _typeof = function (obj) {
12        return typeof obj;
13      };
14    } else {
15      _typeof = function (obj) {
16        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
17      };
18    }
19
20    return _typeof(obj);
21  }
22
23  function _classCallCheck(instance, Constructor) {
24    if (!(instance instanceof Constructor)) {
25      throw new TypeError("Cannot call a class as a function");
26    }
27  }
28
29  function _defineProperties(target, props) {
30    for (var i = 0; i < props.length; i++) {
31      var descriptor = props[i];
32      descriptor.enumerable = descriptor.enumerable || false;
33      descriptor.configurable = true;
34      if ("value" in descriptor) descriptor.writable = true;
35      Object.defineProperty(target, descriptor.key, descriptor);
36    }
37  }
38
39  function _createClass(Constructor, protoProps, staticProps) {
40    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
41    if (staticProps) _defineProperties(Constructor, staticProps);
42    return Constructor;
43  }
44
45  function _inherits(subClass, superClass) {
46    if (typeof superClass !== "function" && superClass !== null) {
47      throw new TypeError("Super expression must either be null or a function");
48    }
49
50    subClass.prototype = Object.create(superClass && superClass.prototype, {
51      constructor: {
52        value: subClass,
53        writable: true,
54        configurable: true
55      }
56    });
57    if (superClass) _setPrototypeOf(subClass, superClass);
58  }
59
60  function _getPrototypeOf(o) {
61    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
62      return o.__proto__ || Object.getPrototypeOf(o);
63    };
64    return _getPrototypeOf(o);
65  }
66
67  function _setPrototypeOf(o, p) {
68    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
69      o.__proto__ = p;
70      return o;
71    };
72
73    return _setPrototypeOf(o, p);
74  }
75
76  function _isNativeReflectConstruct() {
77    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
78    if (Reflect.construct.sham) return false;
79    if (typeof Proxy === "function") return true;
80
81    try {
82      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
83      return true;
84    } catch (e) {
85      return false;
86    }
87  }
88
89  function _assertThisInitialized(self) {
90    if (self === void 0) {
91      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
92    }
93
94    return self;
95  }
96
97  function _possibleConstructorReturn(self, call) {
98    if (call && (typeof call === "object" || typeof call === "function")) {
99      return call;
100    }
101
102    return _assertThisInitialized(self);
103  }
104
105  function _createSuper(Derived) {
106    var hasNativeReflectConstruct = _isNativeReflectConstruct();
107
108    return function _createSuperInternal() {
109      var Super = _getPrototypeOf(Derived),
110          result;
111
112      if (hasNativeReflectConstruct) {
113        var NewTarget = _getPrototypeOf(this).constructor;
114
115        result = Reflect.construct(Super, arguments, NewTarget);
116      } else {
117        result = Super.apply(this, arguments);
118      }
119
120      return _possibleConstructorReturn(this, result);
121    };
122  }
123
124  function _toConsumableArray(arr) {
125    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
126  }
127
128  function _arrayWithoutHoles(arr) {
129    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
130  }
131
132  function _iterableToArray(iter) {
133    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
134  }
135
136  function _unsupportedIterableToArray(o, minLen) {
137    if (!o) return;
138    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
139    var n = Object.prototype.toString.call(o).slice(8, -1);
140    if (n === "Object" && o.constructor) n = o.constructor.name;
141    if (n === "Map" || n === "Set") return Array.from(o);
142    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
143  }
144
145  function _arrayLikeToArray(arr, len) {
146    if (len == null || len > arr.length) len = arr.length;
147
148    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
149
150    return arr2;
151  }
152
153  function _nonIterableSpread() {
154    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
155  }
156
157  function noop() {}
158
159  function run(fn) {
160    return fn();
161  }
162
163  function blank_object() {
164    return Object.create(null);
165  }
166
167  function run_all(fns) {
168    fns.forEach(run);
169  }
170
171  function is_function(thing) {
172    return typeof thing === 'function';
173  }
174
175  function safe_not_equal(a, b) {
176    return a != a ? b == b : a !== b || a && _typeof(a) === 'object' || typeof a === 'function';
177  }
178
179  function is_empty(obj) {
180    return Object.keys(obj).length === 0;
181  }
182
183  function detach(node) {
184    node.parentNode.removeChild(node);
185  }
186
187  function children(element) {
188    return Array.from(element.childNodes);
189  }
190
191  var current_component;
192
193  function set_current_component(component) {
194    current_component = component;
195  }
196
197  var dirty_components = [];
198  var binding_callbacks = [];
199  var render_callbacks = [];
200  var flush_callbacks = [];
201  var resolved_promise = Promise.resolve();
202  var update_scheduled = false;

203
204  function schedule_update() {
205    if (!update_scheduled) {
206      update_scheduled = true;
207      resolved_promise.then(flush);
208    }
209  }
210
211  function add_render_callback(fn) {
212    render_callbacks.push(fn);
213  }
214
215  var flushing = false;
216  var seen_callbacks = new Set();
217
218  function flush() {
219    if (flushing) return;
220    flushing = true;
221
222    do {
223      // first, call beforeUpdate functions
224      // and update components
225      for (var i = 0; i < dirty_components.length; i += 1) {
226        var component = dirty_components[i];
227        set_current_component(component);
228        update(component.$$);
229      }
230
231      set_current_component(null);
232      dirty_components.length = 0;
233
234      while (binding_callbacks.length) {
235        binding_callbacks.pop()();
236      } // then, once components are updated, call
237      // afterUpdate functions. This may cause
238      // subsequent updates...
239
240
241      for (var _i = 0; _i < render_callbacks.length; _i += 1) {
242        var callback = render_callbacks[_i];
243
244        if (!seen_callbacks.has(callback)) {
245          // ...so guard against infinite loops
246          seen_callbacks.add(callback);
247          callback();
248        }
249      }
250
251      render_callbacks.length = 0;
252    } while (dirty_components.length);
253
254    while (flush_callbacks.length) {
255      flush_callbacks.pop()();
256    }
257
258    update_scheduled = false;
259    flushing = false;
260    seen_callbacks.clear();
261  }
262
263  function update($$) {
264    if ($$.fragment !== null) {
265      $$.update();
266      run_all($$.before_update);
267      var dirty = $$.dirty;
268      $$.dirty = [-1];
269      $$.fragment && $$.fragment.p($$.ctx, dirty);
270      $$.after_update.forEach(add_render_callback);
271    }
272  }
273
274  var outroing = new Set();
275
276  function transition_in(block, local) {
277    if (block && block.i) {
278      outroing["delete"](block);
279      block.i(local);
280    }
281  }
282
283  function mount_component(component, target, anchor) {
284    var _component$$$ = component.$$,
285        fragment = _component$$$.fragment,
286        on_mount = _component$$$.on_mount,
287        on_destroy = _component$$$.on_destroy,
288        after_update = _component$$$.after_update;
289    fragment && fragment.m(target, anchor); // onMount happens before the initial afterUpdate
290
291    add_render_callback(function () {
292      var new_on_destroy = on_mount.map(run).filter(is_function);
293
294      if (on_destroy) {
295        on_destroy.push.apply(on_destroy, _toConsumableArray(new_on_destroy));
296      } else {
297        // Edge case - component was destroyed immediately,
298        // most likely as a result of a binding initialising
299        run_all(new_on_destroy);
300      }
301
302      component.$$.on_mount = [];
303    });
304    after_update.forEach(add_render_callback);
305  }
306
307  function destroy_component(component, detaching) {
308    var $$ = component.$$;
309
310    if ($$.fragment !== null) {
311      run_all($$.on_destroy);
312      $$.fragment && $$.fragment.d(detaching); // TODO null out other refs, including component.$$ (but need to
313      // preserve final state?)
314
315      $$.on_destroy = $$.fragment = null;
316      $$.ctx = [];
317    }
318  }
319
320  function make_dirty(component, i) {
321    if (component.$$.dirty[0] === -1) {
322      dirty_components.push(component);
323      schedule_update();
324      component.$$.dirty.fill(0);
325    }
326
327    component.$$.dirty[i / 31 | 0] |= 1 << i % 31;
328  }
329
330  function init(component, options, instance, create_fragment, not_equal, props) {
331    var dirty = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : [-1];
332    var parent_component = current_component;
333    set_current_component(component);
334    var prop_values = options.props || {};
335    var $$ = component.$$ = {
336      fragment: null,
337      ctx: null,
338      // state
339      props: props,
340      update: noop,
341      not_equal: not_equal,
342      bound: blank_object(),
343      // lifecycle
344      on_mount: [],
345      on_destroy: [],
346      before_update: [],
347      after_update: [],
348      context: new Map(parent_component ? parent_component.$$.context : []),
349      // everything else
350      callbacks: blank_object(),
351      dirty: dirty,
352      skip_bound: false
353    };
354    var ready = false;

355    $$.ctx = instance ? instance(component, prop_values, function (i, ret) {
356      var value = (arguments.length <= 2 ? 0 : arguments.length - 2) ? arguments.length <= 2 ? undefined : arguments[2] : ret;
357
358      if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
359        if (!$$.skip_bound && $$.bound[i]) $$.bound[i](value);
360        if (ready) make_dirty(component, i);
361      }
362
363      return ret;
364    }) : [];
365    $$.update();
366    ready = true;
367    run_all($$.before_update); // `false` as a special case of no DOM component
368
369    $$.fragment = create_fragment ? create_fragment($$.ctx) : false;
370
371    if (options.target) {
372      if (options.hydrate) {
373        var nodes = children(options.target); // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
374
375        $$.fragment && $$.fragment.l(nodes);
376        nodes.forEach(detach);
377      } else {
378        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
379        $$.fragment && $$.fragment.c();
380      }
381
382      if (options.intro) transition_in(component.$$.fragment);
383      mount_component(component, options.target, options.anchor);
384      flush();
385    }
386
387    set_current_component(parent_component);
388  }
389
390  var SvelteComponent = /*#__PURE__*/function () {
391    function SvelteComponent() {
392      _classCallCheck(this, SvelteComponent);
393    }
394
395    _createClass(SvelteComponent, [{
396      key: "$destroy",
397      value: function $destroy() {
398        destroy_component(this, 1);
399        this.$destroy = noop;
400      }
401    }, {
402      key: "$on",
403      value: function $on(type, callback) {
404        var callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
405        callbacks.push(callback);
406        return function () {
407          var index = callbacks.indexOf(callback);
408          if (index !== -1) callbacks.splice(index, 1);
409        };
410      }
411    }, {
412      key: "$set",
413      value: function $set($$props) {
414        if (this.$$set && !is_empty($$props)) {
415          this.$$.skip_bound = true;
416          this.$$set($$props);
417          this.$$.skip_bound = false;
418        }
419      }
420    }]);
421
422    return SvelteComponent;
423  }();
424
425  var position = "PrependContainer";
426  var defaults = {};
427
428  function init$1(eventDetail) {
429    // You must have Font Awesome v5.0+
430    eventDetail.defaults.icons = {
431      prefix: "fontawesome5",
432      notice: "fas fa-exclamation-circle",
433      info: "fas fa-info-circle",
434      success: "fas fa-check-circle",
435      error: "fas fa-exclamation-triangle",
436      // Buttons Module
437      closer: "fas fa-times",
438      sticker: "fas",
439      stuck: "fa-play",
440      unstuck: "fa-pause",
441      // Reference Module (Useful for other modules.)
442      refresh: "fas fa-sync"
443    };
444  }
445
446  var Font_awesome5 = /*#__PURE__*/function (_SvelteComponent) {
447    _inherits(Font_awesome5, _SvelteComponent);
448
449    var _super = _createSuper(Font_awesome5);
450
451    function Font_awesome5(options) {
452      var _this;
453
454      _classCallCheck(this, Font_awesome5);
455
456      _this = _super.call(this);
457      init(_assertThisInitialized(_this), options, null, null, safe_not_equal, {});
458      return _this;
459    }
460
461    return Font_awesome5;
462  }(SvelteComponent);
463
464  exports.default = Font_awesome5;
465  exports.defaults = defaults;
466  exports.init = init$1;
467  exports.position = position;
468
469  Object.defineProperty(exports, '__esModule', { value: true });
470
471})));