@egjs/react-flicking 4.15.0 → 4.16.0-beta.1

package/dist/flicking.cjs.js

@@ -1,204 +1,936 @@
-/*
-Copyright (c) 2015-present NAVER Corp.
-name: @egjs/react-flicking
-license: MIT
-author: NAVER Corp.
-repository: https://github.com/naver/egjs-flicking/tree/master/packages/react-flicking
-version: 4.15.0
-*/
-'use strict';
-
-var React = require('react');
-var Component = require('@egjs/component');
-var ListDiffer = require('@egjs/list-differ');
-var VanillaFlicking = require('@egjs/flicking');
-var react = require('@cfcs/react');
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function (d, b) {
-  extendStatics = Object.setPrototypeOf || {
-    __proto__: []
-  } instanceof Array && function (d, b) {
-    d.__proto__ = b;
-  } || function (d, b) {
-    for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
-  };
-  return extendStatics(d, b);
-};
-function __extends(d, b) {
-  if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-  extendStatics(d, b);
-  function __() {
-    this.constructor = d;
-  }
-  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-var __assign = function () {
-  __assign = Object.assign || function __assign(t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-      s = arguments[i];
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+"use strict";
+const React = require("react");
+const Component = require("@egjs/component");
+const VanillaFlicking = require("@egjs/flicking");
+const ListDiffer = require("@egjs/list-differ");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
     }
-    return t;
-  };
-  return __assign.apply(this, arguments);
-};
-function __rest(s, e) {
-  var t = {};
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
   }
-  return t;
-}
-function __decorate(decorators, target, key, desc) {
-  var c = arguments.length,
-    r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
-    d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+  n.default = e;
+  return Object.freeze(n);
 }
-function __awaiter(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
-      resolve(value);
-    });
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+var jsxRuntime = { exports: {} };
+var reactJsxRuntime_production_min = {};
+var hasRequiredReactJsxRuntime_production_min;
+function requireReactJsxRuntime_production_min() {
+  if (hasRequiredReactJsxRuntime_production_min) return reactJsxRuntime_production_min;
+  hasRequiredReactJsxRuntime_production_min = 1;
+  var f = React, k = Symbol.for("react.element"), l = Symbol.for("react.fragment"), m = Object.prototype.hasOwnProperty, n = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, p = { key: true, ref: true, __self: true, __source: true };
+  function q(c, a, g) {
+    var b, d = {}, e = null, h = null;
+    void 0 !== g && (e = "" + g);
+    void 0 !== a.key && (e = "" + a.key);
+    void 0 !== a.ref && (h = a.ref);
+    for (b in a) m.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]);
+    if (c && c.defaultProps) for (b in a = c.defaultProps, a) void 0 === d[b] && (d[b] = a[b]);
+    return { $$typeof: k, type: c, key: e, ref: h, props: d, _owner: n.current };
   }
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
+  reactJsxRuntime_production_min.Fragment = l;
+  reactJsxRuntime_production_min.jsx = q;
+  reactJsxRuntime_production_min.jsxs = q;
+  return reactJsxRuntime_production_min;
+}
+var reactJsxRuntime_development = {};
+var hasRequiredReactJsxRuntime_development;
+function requireReactJsxRuntime_development() {
+  if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
+  hasRequiredReactJsxRuntime_development = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      var React$1 = React;
+      var REACT_ELEMENT_TYPE = Symbol.for("react.element");
+      var REACT_PORTAL_TYPE = Symbol.for("react.portal");
+      var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+      var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
+      var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+      var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
+      var REACT_CONTEXT_TYPE = Symbol.for("react.context");
+      var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
+      var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
+      var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
+      var REACT_MEMO_TYPE = Symbol.for("react.memo");
+      var REACT_LAZY_TYPE = Symbol.for("react.lazy");
+      var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
+      var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+      var FAUX_ITERATOR_SYMBOL = "@@iterator";
+      function getIteratorFn(maybeIterable) {
+        if (maybeIterable === null || typeof maybeIterable !== "object") {
+          return null;
+        }
+        var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+        if (typeof maybeIterator === "function") {
+          return maybeIterator;
+        }
+        return null;
       }
-    }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
+      var ReactSharedInternals = React$1.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+      function error(format) {
+        {
+          {
+            for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+              args[_key2 - 1] = arguments[_key2];
+            }
+            printWarning("error", format, args);
+          }
+        }
       }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-}
-function __generator(thisArg, body) {
-  var _ = {
-      label: 0,
-      sent: function () {
-        if (t[0] & 1) throw t[1];
-        return t[1];
-      },
-      trys: [],
-      ops: []
-    },
-    f,
-    y,
-    t,
-    g;
-  return g = {
-    next: verb(0),
-    "throw": verb(1),
-    "return": verb(2)
-  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
-    return this;
-  }), g;
-  function verb(n) {
-    return function (v) {
-      return step([n, v]);
-    };
-  }
-  function step(op) {
-    if (f) throw new TypeError("Generator is already executing.");
-    while (g && (g = 0, op[0] && (_ = 0)), _) try {
-      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-      if (y = 0, t) op = [op[0] & 2, t.value];
-      switch (op[0]) {
-        case 0:
-        case 1:
-          t = op;
-          break;
-        case 4:
-          _.label++;
-          return {
-            value: op[1],
-            done: false
+      function printWarning(level, format, args) {
+        {
+          var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
+          var stack = ReactDebugCurrentFrame2.getStackAddendum();
+          if (stack !== "") {
+            format += "%s";
+            args = args.concat([stack]);
+          }
+          var argsWithFormat = args.map(function(item) {
+            return String(item);
+          });
+          argsWithFormat.unshift("Warning: " + format);
+          Function.prototype.apply.call(console[level], console, argsWithFormat);
+        }
+      }
+      var enableScopeAPI = false;
+      var enableCacheElement = false;
+      var enableTransitionTracing = false;
+      var enableLegacyHidden = false;
+      var enableDebugTracing = false;
+      var REACT_MODULE_REFERENCE;
+      {
+        REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
+      }
+      function isValidElementType(type) {
+        if (typeof type === "string" || typeof type === "function") {
+          return true;
+        }
+        if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) {
+          return true;
+        }
+        if (typeof type === "object" && type !== null) {
+          if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
+          // types supported by any Flight configuration anywhere since
+          // we don't know which Flight build this will end up being used
+          // with.
+          type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function getWrappedName(outerType, innerType, wrapperName) {
+        var displayName = outerType.displayName;
+        if (displayName) {
+          return displayName;
+        }
+        var functionName = innerType.displayName || innerType.name || "";
+        return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName;
+      }
+      function getContextName(type) {
+        return type.displayName || "Context";
+      }
+      function getComponentNameFromType(type) {
+        if (type == null) {
+          return null;
+        }
+        {
+          if (typeof type.tag === "number") {
+            error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue.");
+          }
+        }
+        if (typeof type === "function") {
+          return type.displayName || type.name || null;
+        }
+        if (typeof type === "string") {
+          return type;
+        }
+        switch (type) {
+          case REACT_FRAGMENT_TYPE:
+            return "Fragment";
+          case REACT_PORTAL_TYPE:
+            return "Portal";
+          case REACT_PROFILER_TYPE:
+            return "Profiler";
+          case REACT_STRICT_MODE_TYPE:
+            return "StrictMode";
+          case REACT_SUSPENSE_TYPE:
+            return "Suspense";
+          case REACT_SUSPENSE_LIST_TYPE:
+            return "SuspenseList";
+        }
+        if (typeof type === "object") {
+          switch (type.$$typeof) {
+            case REACT_CONTEXT_TYPE:
+              var context = type;
+              return getContextName(context) + ".Consumer";
+            case REACT_PROVIDER_TYPE:
+              var provider = type;
+              return getContextName(provider._context) + ".Provider";
+            case REACT_FORWARD_REF_TYPE:
+              return getWrappedName(type, type.render, "ForwardRef");
+            case REACT_MEMO_TYPE:
+              var outerName = type.displayName || null;
+              if (outerName !== null) {
+                return outerName;
+              }
+              return getComponentNameFromType(type.type) || "Memo";
+            case REACT_LAZY_TYPE: {
+              var lazyComponent = type;
+              var payload = lazyComponent._payload;
+              var init = lazyComponent._init;
+              try {
+                return getComponentNameFromType(init(payload));
+              } catch (x) {
+                return null;
+              }
+            }
+          }
+        }
+        return null;
+      }
+      var assign = Object.assign;
+      var disabledDepth = 0;
+      var prevLog;
+      var prevInfo;
+      var prevWarn;
+      var prevError;
+      var prevGroup;
+      var prevGroupCollapsed;
+      var prevGroupEnd;
+      function disabledLog() {
+      }
+      disabledLog.__reactDisabledLog = true;
+      function disableLogs() {
+        {
+          if (disabledDepth === 0) {
+            prevLog = console.log;
+            prevInfo = console.info;
+            prevWarn = console.warn;
+            prevError = console.error;
+            prevGroup = console.group;
+            prevGroupCollapsed = console.groupCollapsed;
+            prevGroupEnd = console.groupEnd;
+            var props = {
+              configurable: true,
+              enumerable: true,
+              value: disabledLog,
+              writable: true
+            };
+            Object.defineProperties(console, {
+              info: props,
+              log: props,
+              warn: props,
+              error: props,
+              group: props,
+              groupCollapsed: props,
+              groupEnd: props
+            });
+          }
+          disabledDepth++;
+        }
+      }
+      function reenableLogs() {
+        {
+          disabledDepth--;
+          if (disabledDepth === 0) {
+            var props = {
+              configurable: true,
+              enumerable: true,
+              writable: true
+            };
+            Object.defineProperties(console, {
+              log: assign({}, props, {
+                value: prevLog
+              }),
+              info: assign({}, props, {
+                value: prevInfo
+              }),
+              warn: assign({}, props, {
+                value: prevWarn
+              }),
+              error: assign({}, props, {
+                value: prevError
+              }),
+              group: assign({}, props, {
+                value: prevGroup
+              }),
+              groupCollapsed: assign({}, props, {
+                value: prevGroupCollapsed
+              }),
+              groupEnd: assign({}, props, {
+                value: prevGroupEnd
+              })
+            });
+          }
+          if (disabledDepth < 0) {
+            error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+          }
+        }
+      }
+      var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+      var prefix;
+      function describeBuiltInComponentFrame(name, source, ownerFn) {
+        {
+          if (prefix === void 0) {
+            try {
+              throw Error();
+            } catch (x) {
+              var match = x.stack.trim().match(/\n( *(at )?)/);
+              prefix = match && match[1] || "";
+            }
+          }
+          return "\n" + prefix + name;
+        }
+      }
+      var reentry = false;
+      var componentFrameCache;
+      {
+        var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+        componentFrameCache = new PossiblyWeakMap();
+      }
+      function describeNativeComponentFrame(fn, construct) {
+        if (!fn || reentry) {
+          return "";
+        }
+        {
+          var frame = componentFrameCache.get(fn);
+          if (frame !== void 0) {
+            return frame;
+          }
+        }
+        var control;
+        reentry = true;
+        var previousPrepareStackTrace = Error.prepareStackTrace;
+        Error.prepareStackTrace = void 0;
+        var previousDispatcher;
+        {
+          previousDispatcher = ReactCurrentDispatcher.current;
+          ReactCurrentDispatcher.current = null;
+          disableLogs();
+        }
+        try {
+          if (construct) {
+            var Fake = function() {
+              throw Error();
+            };
+            Object.defineProperty(Fake.prototype, "props", {
+              set: function() {
+                throw Error();
+              }
+            });
+            if (typeof Reflect === "object" && Reflect.construct) {
+              try {
+                Reflect.construct(Fake, []);
+              } catch (x) {
+                control = x;
+              }
+              Reflect.construct(fn, [], Fake);
+            } else {
+              try {
+                Fake.call();
+              } catch (x) {
+                control = x;
+              }
+              fn.call(Fake.prototype);
+            }
+          } else {
+            try {
+              throw Error();
+            } catch (x) {
+              control = x;
+            }
+            fn();
+          }
+        } catch (sample) {
+          if (sample && control && typeof sample.stack === "string") {
+            var sampleLines = sample.stack.split("\n");
+            var controlLines = control.stack.split("\n");
+            var s = sampleLines.length - 1;
+            var c = controlLines.length - 1;
+            while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+              c--;
+            }
+            for (; s >= 1 && c >= 0; s--, c--) {
+              if (sampleLines[s] !== controlLines[c]) {
+                if (s !== 1 || c !== 1) {
+                  do {
+                    s--;
+                    c--;
+                    if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                      var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
+                      if (fn.displayName && _frame.includes("<anonymous>")) {
+                        _frame = _frame.replace("<anonymous>", fn.displayName);
+                      }
+                      {
+                        if (typeof fn === "function") {
+                          componentFrameCache.set(fn, _frame);
+                        }
+                      }
+                      return _frame;
+                    }
+                  } while (s >= 1 && c >= 0);
+                }
+                break;
+              }
+            }
+          }
+        } finally {
+          reentry = false;
+          {
+            ReactCurrentDispatcher.current = previousDispatcher;
+            reenableLogs();
+          }
+          Error.prepareStackTrace = previousPrepareStackTrace;
+        }
+        var name = fn ? fn.displayName || fn.name : "";
+        var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
+        {
+          if (typeof fn === "function") {
+            componentFrameCache.set(fn, syntheticFrame);
+          }
+        }
+        return syntheticFrame;
+      }
+      function describeFunctionComponentFrame(fn, source, ownerFn) {
+        {
+          return describeNativeComponentFrame(fn, false);
+        }
+      }
+      function shouldConstruct(Component2) {
+        var prototype = Component2.prototype;
+        return !!(prototype && prototype.isReactComponent);
+      }
+      function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
+        if (type == null) {
+          return "";
+        }
+        if (typeof type === "function") {
+          {
+            return describeNativeComponentFrame(type, shouldConstruct(type));
+          }
+        }
+        if (typeof type === "string") {
+          return describeBuiltInComponentFrame(type);
+        }
+        switch (type) {
+          case REACT_SUSPENSE_TYPE:
+            return describeBuiltInComponentFrame("Suspense");
+          case REACT_SUSPENSE_LIST_TYPE:
+            return describeBuiltInComponentFrame("SuspenseList");
+        }
+        if (typeof type === "object") {
+          switch (type.$$typeof) {
+            case REACT_FORWARD_REF_TYPE:
+              return describeFunctionComponentFrame(type.render);
+            case REACT_MEMO_TYPE:
+              return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
+            case REACT_LAZY_TYPE: {
+              var lazyComponent = type;
+              var payload = lazyComponent._payload;
+              var init = lazyComponent._init;
+              try {
+                return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
+              } catch (x) {
+              }
+            }
+          }
+        }
+        return "";
+      }
+      var hasOwnProperty = Object.prototype.hasOwnProperty;
+      var loggedTypeFailures = {};
+      var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+      function setCurrentlyValidatingElement(element) {
+        {
+          if (element) {
+            var owner = element._owner;
+            var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+            ReactDebugCurrentFrame.setExtraStackFrame(stack);
+          } else {
+            ReactDebugCurrentFrame.setExtraStackFrame(null);
+          }
+        }
+      }
+      function checkPropTypes(typeSpecs, values, location, componentName, element) {
+        {
+          var has = Function.call.bind(hasOwnProperty);
+          for (var typeSpecName in typeSpecs) {
+            if (has(typeSpecs, typeSpecName)) {
+              var error$1 = void 0;
+              try {
+                if (typeof typeSpecs[typeSpecName] !== "function") {
+                  var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                  err.name = "Invariant Violation";
+                  throw err;
+                }
+                error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+              } catch (ex) {
+                error$1 = ex;
+              }
+              if (error$1 && !(error$1 instanceof Error)) {
+                setCurrentlyValidatingElement(element);
+                error("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1);
+                setCurrentlyValidatingElement(null);
+              }
+              if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
+                loggedTypeFailures[error$1.message] = true;
+                setCurrentlyValidatingElement(element);
+                error("Failed %s type: %s", location, error$1.message);
+                setCurrentlyValidatingElement(null);
+              }
+            }
+          }
+        }
+      }
+      var isArrayImpl = Array.isArray;
+      function isArray(a) {
+        return isArrayImpl(a);
+      }
+      function typeName(value) {
+        {
+          var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag;
+          var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+          return type;
+        }
+      }
+      function willCoercionThrow(value) {
+        {
+          try {
+            testStringCoercion(value);
+            return false;
+          } catch (e) {
+            return true;
+          }
+        }
+      }
+      function testStringCoercion(value) {
+        return "" + value;
+      }
+      function checkKeyStringCoercion(value) {
+        {
+          if (willCoercionThrow(value)) {
+            error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
+            return testStringCoercion(value);
+          }
+        }
+      }
+      var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+      var RESERVED_PROPS = {
+        key: true,
+        ref: true,
+        __self: true,
+        __source: true
+      };
+      var specialPropKeyWarningShown;
+      var specialPropRefWarningShown;
+      function hasValidRef(config) {
+        {
+          if (hasOwnProperty.call(config, "ref")) {
+            var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
+            if (getter && getter.isReactWarning) {
+              return false;
+            }
+          }
+        }
+        return config.ref !== void 0;
+      }
+      function hasValidKey(config) {
+        {
+          if (hasOwnProperty.call(config, "key")) {
+            var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+            if (getter && getter.isReactWarning) {
+              return false;
+            }
+          }
+        }
+        return config.key !== void 0;
+      }
+      function warnIfStringRefCannotBeAutoConverted(config, self) {
+        {
+          if (typeof config.ref === "string" && ReactCurrentOwner.current && self) ;
+        }
+      }
+      function defineKeyPropWarningGetter(props, displayName) {
+        {
+          var warnAboutAccessingKey = function() {
+            if (!specialPropKeyWarningShown) {
+              specialPropKeyWarningShown = true;
+              error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
+            }
           };
-        case 5:
-          _.label++;
-          y = op[1];
-          op = [0];
-          continue;
-        case 7:
-          op = _.ops.pop();
-          _.trys.pop();
-          continue;
-        default:
-          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-            _ = 0;
-            continue;
-          }
-          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-            _.label = op[1];
-            break;
-          }
-          if (op[0] === 6 && _.label < t[1]) {
-            _.label = t[1];
-            t = op;
-            break;
-          }
-          if (t && _.label < t[2]) {
-            _.label = t[2];
-            _.ops.push(op);
-            break;
-          }
-          if (t[2]) _.ops.pop();
-          _.trys.pop();
-          continue;
-      }
-      op = body.call(thisArg, _);
-    } catch (e) {
-      op = [6, e];
-      y = 0;
-    } finally {
-      f = t = 0;
-    }
-    if (op[0] & 5) throw op[1];
-    return {
-      value: op[0] ? op[1] : void 0,
-      done: true
-    };
+          warnAboutAccessingKey.isReactWarning = true;
+          Object.defineProperty(props, "key", {
+            get: warnAboutAccessingKey,
+            configurable: true
+          });
+        }
+      }
+      function defineRefPropWarningGetter(props, displayName) {
+        {
+          var warnAboutAccessingRef = function() {
+            if (!specialPropRefWarningShown) {
+              specialPropRefWarningShown = true;
+              error("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
+            }
+          };
+          warnAboutAccessingRef.isReactWarning = true;
+          Object.defineProperty(props, "ref", {
+            get: warnAboutAccessingRef,
+            configurable: true
+          });
+        }
+      }
+      var ReactElement = function(type, key, ref, self, source, owner, props) {
+        var element = {
+          // This tag allows us to uniquely identify this as a React Element
+          $$typeof: REACT_ELEMENT_TYPE,
+          // Built-in properties that belong on the element
+          type,
+          key,
+          ref,
+          props,
+          // Record the component responsible for creating this element.
+          _owner: owner
+        };
+        {
+          element._store = {};
+          Object.defineProperty(element._store, "validated", {
+            configurable: false,
+            enumerable: false,
+            writable: true,
+            value: false
+          });
+          Object.defineProperty(element, "_self", {
+            configurable: false,
+            enumerable: false,
+            writable: false,
+            value: self
+          });
+          Object.defineProperty(element, "_source", {
+            configurable: false,
+            enumerable: false,
+            writable: false,
+            value: source
+          });
+          if (Object.freeze) {
+            Object.freeze(element.props);
+            Object.freeze(element);
+          }
+        }
+        return element;
+      };
+      function jsxDEV(type, config, maybeKey, source, self) {
+        {
+          var propName;
+          var props = {};
+          var key = null;
+          var ref = null;
+          if (maybeKey !== void 0) {
+            {
+              checkKeyStringCoercion(maybeKey);
+            }
+            key = "" + maybeKey;
+          }
+          if (hasValidKey(config)) {
+            {
+              checkKeyStringCoercion(config.key);
+            }
+            key = "" + config.key;
+          }
+          if (hasValidRef(config)) {
+            ref = config.ref;
+            warnIfStringRefCannotBeAutoConverted(config, self);
+          }
+          for (propName in config) {
+            if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+              props[propName] = config[propName];
+            }
+          }
+          if (type && type.defaultProps) {
+            var defaultProps = type.defaultProps;
+            for (propName in defaultProps) {
+              if (props[propName] === void 0) {
+                props[propName] = defaultProps[propName];
+              }
+            }
+          }
+          if (key || ref) {
+            var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
+            if (key) {
+              defineKeyPropWarningGetter(props, displayName);
+            }
+            if (ref) {
+              defineRefPropWarningGetter(props, displayName);
+            }
+          }
+          return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+        }
+      }
+      var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
+      var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
+      function setCurrentlyValidatingElement$1(element) {
+        {
+          if (element) {
+            var owner = element._owner;
+            var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+            ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
+          } else {
+            ReactDebugCurrentFrame$1.setExtraStackFrame(null);
+          }
+        }
+      }
+      var propTypesMisspellWarningShown;
+      {
+        propTypesMisspellWarningShown = false;
+      }
+      function isValidElement(object) {
+        {
+          return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+        }
+      }
+      function getDeclarationErrorAddendum() {
+        {
+          if (ReactCurrentOwner$1.current) {
+            var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);
+            if (name) {
+              return "\n\nCheck the render method of `" + name + "`.";
+            }
+          }
+          return "";
+        }
+      }
+      function getSourceInfoErrorAddendum(source) {
+        {
+          return "";
+        }
+      }
+      var ownerHasKeyUseWarning = {};
+      function getCurrentComponentErrorInfo(parentType) {
+        {
+          var info = getDeclarationErrorAddendum();
+          if (!info) {
+            var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
+            if (parentName) {
+              info = "\n\nCheck the top-level render call using <" + parentName + ">.";
+            }
+          }
+          return info;
+        }
+      }
+      function validateExplicitKey(element, parentType) {
+        {
+          if (!element._store || element._store.validated || element.key != null) {
+            return;
+          }
+          element._store.validated = true;
+          var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
+          if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+            return;
+          }
+          ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
+          var childOwner = "";
+          if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
+            childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
+          }
+          setCurrentlyValidatingElement$1(element);
+          error('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
+          setCurrentlyValidatingElement$1(null);
+        }
+      }
+      function validateChildKeys(node, parentType) {
+        {
+          if (typeof node !== "object") {
+            return;
+          }
+          if (isArray(node)) {
+            for (var i = 0; i < node.length; i++) {
+              var child = node[i];
+              if (isValidElement(child)) {
+                validateExplicitKey(child, parentType);
+              }
+            }
+          } else if (isValidElement(node)) {
+            if (node._store) {
+              node._store.validated = true;
+            }
+          } else if (node) {
+            var iteratorFn = getIteratorFn(node);
+            if (typeof iteratorFn === "function") {
+              if (iteratorFn !== node.entries) {
+                var iterator = iteratorFn.call(node);
+                var step;
+                while (!(step = iterator.next()).done) {
+                  if (isValidElement(step.value)) {
+                    validateExplicitKey(step.value, parentType);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      function validatePropTypes(element) {
+        {
+          var type = element.type;
+          if (type === null || type === void 0 || typeof type === "string") {
+            return;
+          }
+          var propTypes;
+          if (typeof type === "function") {
+            propTypes = type.propTypes;
+          } else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
+          // Inner props are checked in the reconciler.
+          type.$$typeof === REACT_MEMO_TYPE)) {
+            propTypes = type.propTypes;
+          } else {
+            return;
+          }
+          if (propTypes) {
+            var name = getComponentNameFromType(type);
+            checkPropTypes(propTypes, element.props, "prop", name, element);
+          } else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
+            propTypesMisspellWarningShown = true;
+            var _name = getComponentNameFromType(type);
+            error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", _name || "Unknown");
+          }
+          if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) {
+            error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+          }
+        }
+      }
+      function validateFragmentProps(fragment) {
+        {
+          var keys2 = Object.keys(fragment.props);
+          for (var i = 0; i < keys2.length; i++) {
+            var key = keys2[i];
+            if (key !== "children" && key !== "key") {
+              setCurrentlyValidatingElement$1(fragment);
+              error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key);
+              setCurrentlyValidatingElement$1(null);
+              break;
+            }
+          }
+          if (fragment.ref !== null) {
+            setCurrentlyValidatingElement$1(fragment);
+            error("Invalid attribute `ref` supplied to `React.Fragment`.");
+            setCurrentlyValidatingElement$1(null);
+          }
+        }
+      }
+      var didWarnAboutKeySpread = {};
+      function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
+        {
+          var validType = isValidElementType(type);
+          if (!validType) {
+            var info = "";
+            if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
+              info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
+            }
+            var sourceInfo = getSourceInfoErrorAddendum();
+            if (sourceInfo) {
+              info += sourceInfo;
+            } else {
+              info += getDeclarationErrorAddendum();
+            }
+            var typeString;
+            if (type === null) {
+              typeString = "null";
+            } else if (isArray(type)) {
+              typeString = "array";
+            } else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
+              typeString = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />";
+              info = " Did you accidentally export a JSX literal instead of a component?";
+            } else {
+              typeString = typeof type;
+            }
+            error("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", typeString, info);
+          }
+          var element = jsxDEV(type, props, key, source, self);
+          if (element == null) {
+            return element;
+          }
+          if (validType) {
+            var children = props.children;
+            if (children !== void 0) {
+              if (isStaticChildren) {
+                if (isArray(children)) {
+                  for (var i = 0; i < children.length; i++) {
+                    validateChildKeys(children[i], type);
+                  }
+                  if (Object.freeze) {
+                    Object.freeze(children);
+                  }
+                } else {
+                  error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+                }
+              } else {
+                validateChildKeys(children, type);
+              }
+            }
+          }
+          {
+            if (hasOwnProperty.call(props, "key")) {
+              var componentName = getComponentNameFromType(type);
+              var keys2 = Object.keys(props).filter(function(k) {
+                return k !== "key";
+              });
+              var beforeExample = keys2.length > 0 ? "{key: someKey, " + keys2.join(": ..., ") + ": ...}" : "{key: someKey}";
+              if (!didWarnAboutKeySpread[componentName + beforeExample]) {
+                var afterExample = keys2.length > 0 ? "{" + keys2.join(": ..., ") + ": ...}" : "{}";
+                error('A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />', beforeExample, componentName, afterExample, componentName);
+                didWarnAboutKeySpread[componentName + beforeExample] = true;
+              }
+            }
+          }
+          if (type === REACT_FRAGMENT_TYPE) {
+            validateFragmentProps(element);
+          } else {
+            validatePropTypes(element);
+          }
+          return element;
+        }
+      }
+      function jsxWithValidationStatic(type, props, key) {
+        {
+          return jsxWithValidation(type, props, key, true);
+        }
+      }
+      function jsxWithValidationDynamic(type, props, key) {
+        {
+          return jsxWithValidation(type, props, key, false);
+        }
+      }
+      var jsx = jsxWithValidationDynamic;
+      var jsxs = jsxWithValidationStatic;
+      reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
+      reactJsxRuntime_development.jsx = jsx;
+      reactJsxRuntime_development.jsxs = jsxs;
+    })();
   }
+  return reactJsxRuntime_development;
 }
-function __spreadArray(to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
+var hasRequiredJsxRuntime;
+function requireJsxRuntime() {
+  if (hasRequiredJsxRuntime) return jsxRuntime.exports;
+  hasRequiredJsxRuntime = 1;
+  if (process.env.NODE_ENV === "production") {
+    jsxRuntime.exports = requireReactJsxRuntime_production_min();
+  } else {
+    jsxRuntime.exports = requireReactJsxRuntime_development();
   }
-  return to.concat(ar || Array.prototype.slice.call(from));
+  return jsxRuntime.exports;
 }
-
-var DEFAULT_PROPS = {
+var jsxRuntimeExports = requireJsxRuntime();
+const DEFAULT_PROPS = {
   viewportTag: "div",
   cameraTag: "div",
   cameraClass: "",
@@ -207,235 +939,182 @@ var DEFAULT_PROPS = {
   plugins: [],
   useFindDOMNode: false,
   hideBeforeInit: false,
-  onReady: function (e) {},
-  onBeforeResize: function (e) {},
-  onAfterResize: function (e) {},
-  onHoldStart: function (e) {},
-  onHoldEnd: function (e) {},
-  onMoveStart: function (e) {},
-  onMove: function (e) {},
-  onMoveEnd: function (e) {},
-  onWillChange: function (e) {},
-  onChanged: function (e) {},
-  onWillRestore: function (e) {},
-  onRestored: function (e) {},
-  onSelect: function (e) {},
-  onNeedPanel: function (e) {},
-  onVisibleChange: function (e) {},
-  onReachEdge: function (e) {},
-  onPanelChange: function (e) {}
+  onReady: (e) => {
+  },
+  onBeforeResize: (e) => {
+  },
+  onAfterResize: (e) => {
+  },
+  onHoldStart: (e) => {
+  },
+  onHoldEnd: (e) => {
+  },
+  onMoveStart: (e) => {
+  },
+  onMove: (e) => {
+  },
+  onMoveEnd: (e) => {
+  },
+  onWillChange: (e) => {
+  },
+  onChanged: (e) => {
+  },
+  onWillRestore: (e) => {
+  },
+  onRestored: (e) => {
+  },
+  onSelect: (e) => {
+  },
+  onNeedPanel: (e) => {
+  },
+  onVisibleChange: (e) => {
+  },
+  onReachEdge: (e) => {
+  },
+  onPanelChange: (e) => {
+  }
 };
-
-var ReactRenderer = /*#__PURE__*/function (_super) {
-  __extends(ReactRenderer, _super);
-  function ReactRenderer(options) {
-    var _this = _super.call(this, options) || this;
-    _this._reactFlicking = options.reactFlicking;
-    return _this;
+class ReactElementProvider {
+  get element() {
+    return this._el?.nativeElement;
+  }
+  get rendered() {
+    return this._el?.rendered;
+  }
+  constructor(el) {
+    this._el = el;
+  }
+  show() {
+    this._el?.show();
+  }
+  hide() {
+    this._el?.hide();
+  }
+}
+class ReactRenderer extends VanillaFlicking.ExternalRenderer {
+  constructor(options) {
+    super(options);
+    this._reactFlicking = options.reactFlicking;
   }
   // eslint-disable-next-line @typescript-eslint/require-await
-  var __proto = ReactRenderer.prototype;
-  __proto.render = function () {
-    return __awaiter(this, void 0, void 0, function () {
-      var flicking, reactFlicking, strategy;
-      var _this = this;
-      return __generator(this, function (_a) {
-        flicking = VanillaFlicking.getFlickingAttached(this._flicking);
-        reactFlicking = this._reactFlicking;
-        strategy = this._strategy;
-        if (flicking.virtualEnabled) {
-          // virtual 값은 VirtualManager Object 이므로 virtualEnabled 로 검사하는 것이 맞습니다.
-          // applyTransform does not work when renderer.rendering is true. #916
-          // updateRenderingPanels should be called before rendering becomes true, or transform will be applied later.
-          strategy.updateRenderingPanels(flicking);
-          this._rendering = true;
-        } else {
-          this._rendering = true;
-          strategy.updateRenderingPanels(flicking);
-        }
-        strategy.renderPanels(flicking);
-        return [2 /*return*/, new Promise(function (resolve) {
-          reactFlicking.renderEmitter.once("render", function () {
-            _this._rendering = false;
-            _this._afterRender();
-            resolve();
-          });
-          reactFlicking.forceUpdate();
-        })];
+  async render() {
+    const flicking = VanillaFlicking.getFlickingAttached(this._flicking);
+    const reactFlicking = this._reactFlicking;
+    const strategy = this._strategy;
+    if (flicking.virtualEnabled) {
+      strategy.updateRenderingPanels(flicking);
+      this._rendering = true;
+    } else {
+      this._rendering = true;
+      strategy.updateRenderingPanels(flicking);
+    }
+    strategy.renderPanels(flicking);
+    return new Promise((resolve) => {
+      reactFlicking.renderEmitter.once("render", () => {
+        this._rendering = false;
+        this._afterRender();
+        resolve();
       });
+      reactFlicking.forceUpdate();
     });
-  };
-  __proto.forceRenderAllPanels = function () {
-    return __awaiter(this, void 0, void 0, function () {
-      var reactFlicking;
-      var _this = this;
-      return __generator(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            reactFlicking = this._reactFlicking;
-            this._rendering = true;
-            return [4 /*yield*/, _super.prototype.forceRenderAllPanels.call(this)];
-          case 1:
-            _a.sent();
-            return [2 /*return*/, new Promise(function (resolve) {
-              reactFlicking.renderEmitter.once("render", function () {
-                _this._rendering = false;
-                resolve();
-              });
-              reactFlicking.forceUpdate();
-            })];
-        }
+  }
+  async forceRenderAllPanels() {
+    const reactFlicking = this._reactFlicking;
+    this._rendering = true;
+    await super.forceRenderAllPanels();
+    return new Promise((resolve) => {
+      reactFlicking.renderEmitter.once("render", () => {
+        this._rendering = false;
+        resolve();
       });
+      reactFlicking.forceUpdate();
     });
-  };
-  __proto.destroy = function () {
-    _super.prototype.destroy.call(this);
+  }
+  destroy() {
+    super.destroy();
     this._reactFlicking.renderEmitter.off("render");
-  };
-  __proto._collectPanels = function () {
-    var flicking = VanillaFlicking.getFlickingAttached(this._flicking);
-    var reactFlicking = this._reactFlicking;
-    var reactPanels = reactFlicking.reactPanels;
+  }
+  _collectPanels() {
+    const flicking = VanillaFlicking.getFlickingAttached(this._flicking);
+    const reactFlicking = this._reactFlicking;
+    const reactPanels = reactFlicking.reactPanels;
     this._panels = this._strategy.collectPanels(flicking, reactPanels);
-  };
-  __proto._createPanel = function (externalComponent, options) {
+  }
+  _createPanel(externalComponent, options) {
     return this._strategy.createPanel(externalComponent, options);
-  };
-  return ReactRenderer;
-}(VanillaFlicking.ExternalRenderer);
-
-var StrictPanel = /*#__PURE__*/function (_super) {
-  __extends(StrictPanel, _super);
-  function StrictPanel() {
-    var _this = _super !== null && _super.apply(this, arguments) || this;
-    _this._hide = false;
-    _this._elRef = React.createRef();
-    return _this;
-  }
-  var __proto = StrictPanel.prototype;
-  Object.defineProperty(__proto, "nativeElement", {
-    get: function () {
-      return this._elRef.current;
-    },
-    enumerable: false,
-    configurable: true
-  });
-  Object.defineProperty(__proto, "rendered", {
-    get: function () {
-      return !this._hide;
-    },
-    enumerable: false,
-    configurable: true
-  });
-  Object.defineProperty(__proto, "elRef", {
-    get: function () {
-      return this._elRef;
-    },
-    enumerable: false,
-    configurable: true
-  });
-  __proto.render = function () {
-    return this._hide ? React.createElement(React.Fragment, null) : this._getElement();
-  };
-  __proto.show = function () {
+  }
+}
+class StrictPanel extends React__namespace.Component {
+  constructor() {
+    super(...arguments);
     this._hide = false;
-  };
-  __proto.hide = function () {
+    this._elRef = React__namespace.createRef();
+  }
+  get nativeElement() {
+    return this._elRef.current;
+  }
+  get rendered() {
+    return !this._hide;
+  }
+  get elRef() {
+    return this._elRef;
+  }
+  render() {
+    return this._hide ? /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, {}) : this._getElement();
+  }
+  show() {
+    this._hide = false;
+  }
+  hide() {
     this._hide = true;
-  };
-  __proto._getElement = function () {
-    return React.cloneElement(React.Children.only(this.props.children), {
+  }
+  _getElement() {
+    return React__namespace.cloneElement(React__namespace.Children.only(this.props.children), {
       ref: this._elRef
     });
-  };
-  return StrictPanel;
-}(React.Component);
-
-/*
- * Copyright (c) 2015 NAVER Corp.
- * egjs projects are licensed under the MIT license
- */
-var ViewportSlot = React.memo(function (props) {
-  return React.createElement(React.Fragment, null, props.children);
-});
-
-var ReactElementProvider = /*#__PURE__*/function () {
-  function ReactElementProvider(el) {
-    this._el = el;
   }
-  var __proto = ReactElementProvider.prototype;
-  Object.defineProperty(__proto, "element", {
-    get: function () {
-      var _a;
-      return (_a = this._el) === null || _a === void 0 ? void 0 : _a.nativeElement;
-    },
-    enumerable: false,
-    configurable: true
-  });
-  Object.defineProperty(__proto, "rendered", {
-    get: function () {
-      var _a;
-      return (_a = this._el) === null || _a === void 0 ? void 0 : _a.rendered;
-    },
-    enumerable: false,
-    configurable: true
-  });
-  __proto.show = function () {
-    var _a;
-    (_a = this._el) === null || _a === void 0 ? void 0 : _a.show();
-  };
-  __proto.hide = function () {
-    var _a;
-    (_a = this._el) === null || _a === void 0 ? void 0 : _a.hide();
-  };
-  return ReactElementProvider;
-}();
-
-var Flicking = /*#__PURE__*/function (_super) {
-  __extends(Flicking, _super);
-  function Flicking(props) {
-    var _this = _super.call(this, props) || this;
-    _this._panels = [];
-    _this._renderEmitter = new Component();
-    var children = _this._getChildren();
-    _this._panels = _this._createPanelRefs(props, children);
-    _this._prevChildren = children;
-    return _this;
-  }
-  var __proto = Flicking.prototype;
-  Object.defineProperty(__proto, "reactPanels", {
-    get: function () {
-      return this._panels.map(function (panel) {
-        return panel.current;
-      });
-    },
-    enumerable: false,
-    configurable: true
-  });
-  Object.defineProperty(__proto, "renderEmitter", {
-    get: function () {
-      return this._renderEmitter;
-    },
-    enumerable: false,
-    configurable: true
-  });
-  __proto.componentDidMount = function () {
-    var props = this.props;
-    var rendererOptions = {
+}
+const ViewportSlot = React.memo((props) => /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: props.children }));
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(target, key, result) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+const _Flicking = class _Flicking extends React__namespace.Component {
+  constructor(props) {
+    super(props);
+    this._panels = [];
+    this._renderEmitter = new Component();
+    const children = this._getChildren();
+    this._panels = this._createPanelRefs(props, children);
+    this._prevChildren = children;
+  }
+  get reactPanels() {
+    return this._panels.map((panel) => panel.current);
+  }
+  get renderEmitter() {
+    return this._renderEmitter;
+  }
+  componentDidMount() {
+    const props = this.props;
+    const rendererOptions = {
       reactFlicking: this,
       align: props.align,
       strategy: props.virtual && props.panelsPerView > 0 ? new VanillaFlicking.VirtualRenderingStrategy() : new VanillaFlicking.NormalRenderingStrategy({
         providerCtor: ReactElementProvider
       })
     };
-    var flicking = new VanillaFlicking(this._viewportElement, __assign(__assign({}, props), {
+    const flicking = new VanillaFlicking(this._viewportElement, {
+      ...props,
       externalRenderer: new ReactRenderer(rendererOptions)
-    }));
-    this._vanillaFlicking = flicking;
-    var children = this._getChildren();
-    this._jsxDiffer = new ListDiffer(children, function (panel) {
-      return panel.key;
     });
+    this._vanillaFlicking = flicking;
+    const children = this._getChildren();
+    this._jsxDiffer = new ListDiffer(children, (panel) => panel.key);
     this._pluginsDiffer = new ListDiffer();
     this._prevChildren = children;
     this._bindEvents();
@@ -443,54 +1122,46 @@ var Flicking = /*#__PURE__*/function (_super) {
     if (props.status) {
       flicking.setStatus(props.status);
     }
-  };
-  __proto.componentWillUnmount = function () {
-    var _a;
-    (_a = this._vanillaFlicking) === null || _a === void 0 ? void 0 : _a.destroy();
-  };
-  __proto.shouldComponentUpdate = function (nextProps) {
-    var vanillaFlicking = this._vanillaFlicking;
-    var prevProps = this.props;
+  }
+  componentWillUnmount() {
+    this._vanillaFlicking?.destroy();
+  }
+  shouldComponentUpdate(nextProps) {
+    const vanillaFlicking = this._vanillaFlicking;
+    const prevProps = this.props;
     if (!vanillaFlicking || !vanillaFlicking.initialized) return false;
-    var children = nextProps.children,
-      restProps = __rest(nextProps, ["children"]);
-    for (var key in restProps) {
+    const { children, ...restProps } = nextProps;
+    for (const key in restProps) {
       if (prevProps[key] !== nextProps[key]) {
         return true;
       }
     }
-    var prevChildren = this._prevChildren;
-    var nextChildren = this._getChildren(children);
+    const prevChildren = this._prevChildren;
+    const nextChildren = this._getChildren(children);
     if (nextProps.renderOnSameKey || !this._hasSameChildren(prevChildren, nextChildren)) return true;
     return false;
-  };
-  __proto.beforeRender = function () {
-    var vanillaFlicking = this._vanillaFlicking;
-    var props = this.props;
-    var prevChildren = this._prevChildren;
-    // Ignore updates before init, they will be updated after "ready" event's force update
-    // Also, prevent updates when another update is already queued.
-    // This usually happens when render() called twice without calling componentDidMount, like in the case of React.StrictMode.
+  }
+  beforeRender() {
+    const vanillaFlicking = this._vanillaFlicking;
+    const props = this.props;
+    const prevChildren = this._prevChildren;
     if (!vanillaFlicking || !vanillaFlicking.initialized || this._diffResult) return;
-    var nextChildren = this._getChildren(props.children);
+    const nextChildren = this._getChildren(props.children);
     if (props.renderOnSameKey || !this._hasSameChildren(prevChildren, nextChildren)) {
       this._panels = this._createPanelRefs(props, nextChildren);
       this._diffResult = this._jsxDiffer.update(nextChildren);
       this._prevChildren = nextChildren;
     }
-  };
-  __proto.componentDidUpdate = function () {
-    var flicking = this._vanillaFlicking;
-    var renderEmitter = this._renderEmitter;
-    var diffResult = this._diffResult;
+  }
+  componentDidUpdate() {
+    const flicking = this._vanillaFlicking;
+    const renderEmitter = this._renderEmitter;
+    const diffResult = this._diffResult;
     this._checkPlugins();
     renderEmitter.trigger("render");
     flicking.camera.updateOffset();
-    // Omit 'virtual', as it can't have any setter
-    var _a = this.props;
-      _a.virtual;
-      var props = __rest(_a, ["virtual"]);
-    for (var key in props) {
+    const { virtual, ...props } = this.props;
+    for (const key in props) {
       if (key in flicking && flicking[key] !== props[key]) {
         flicking[key] = props[key];
       }
@@ -498,84 +1169,69 @@ var Flicking = /*#__PURE__*/function (_super) {
     if (!diffResult || !flicking.initialized) return;
     VanillaFlicking.sync(flicking, diffResult, this.reactPanels);
     this._diffResult = null;
-  };
-  __proto.render = function () {
-    var _this = this;
-    var _a;
-    var props = this.props;
-    var Viewport = props.viewportTag;
-    var Camera = props.cameraTag;
-    var attributes = {};
+  }
+  render() {
+    const props = this.props;
+    const Viewport = props.viewportTag;
+    const Camera = props.cameraTag;
+    const attributes = {};
     this.beforeRender();
-    for (var name in props) {
+    for (const name in props) {
       if (!(name in DEFAULT_PROPS) && !(name in VanillaFlicking.prototype)) {
         attributes[name] = props[name];
       }
     }
-    var _b = this._getClasses(attributes, props),
-      viewportClasses = _b.viewportClasses,
-      cameraClasses = _b.cameraClasses,
-      cameraProps = _b.cameraProps;
-    var panels = !!props.virtual && ((_a = props.panelsPerView) !== null && _a !== void 0 ? _a : -1) > 0 ? this._getVirtualPanels() : this._getPanels();
-    return React.createElement(Viewport, __assign({}, attributes, {
-      className: viewportClasses.join(" "),
-      ref: function (e) {
-        e && (_this._viewportElement = e);
-      }
-    }), React.createElement(Camera, __assign({
-      className: cameraClasses.join(" ")
-    }, cameraProps), panels), this._getViewportSlot());
-  };
-  __proto._createPanelRefs = function (props, children) {
-    var _a;
-    var panelsPerView = (_a = props.panelsPerView) !== null && _a !== void 0 ? _a : -1;
-    return panelsPerView > 0 && !!props.virtual ? VanillaFlicking.range(panelsPerView + 1).map(function () {
-      return React.createRef();
-    }) : children.map(function () {
-      return React.createRef();
-    });
-  };
-  __proto._bindEvents = function () {
-    var _this = this;
-    var flicking = this._vanillaFlicking;
-    Object.keys(VanillaFlicking.EVENTS).forEach(function (eventKey) {
-      var eventName = VanillaFlicking.EVENTS[eventKey];
-      _this._bindEvent(eventName);
+    const { viewportClasses, cameraClasses, cameraProps } = this._getClasses(attributes, props);
+    const panels = !!props.virtual && (props.panelsPerView ?? -1) > 0 ? this._getVirtualPanels() : this._getPanels();
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      Viewport,
+      {
+        ...attributes,
+        className: viewportClasses.join(" "),
+        ref: (e) => {
+          e && (this._viewportElement = e);
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx(Camera, { className: cameraClasses.join(" "), ...cameraProps, children: panels }),
+          this._getViewportSlot()
+        ]
+      }
+    );
+  }
+  _createPanelRefs(props, children) {
+    const panelsPerView = props.panelsPerView ?? -1;
+    return panelsPerView > 0 && !!props.virtual ? VanillaFlicking.range(panelsPerView + 1).map(() => React__namespace.createRef()) : children.map(() => React__namespace.createRef());
+  }
+  _bindEvents() {
+    const flicking = this._vanillaFlicking;
+    Object.keys(VanillaFlicking.EVENTS).forEach((eventKey) => {
+      const eventName = VanillaFlicking.EVENTS[eventKey];
+      this._bindEvent(eventName);
     });
-    flicking.once(VanillaFlicking.EVENTS.READY, function () {
-      _this.forceUpdate();
+    flicking.once(VanillaFlicking.EVENTS.READY, () => {
+      this.forceUpdate();
     });
-  };
-  __proto._bindEvent = function (eventName) {
-    var _this = this;
-    var propName = "on".concat(eventName.charAt(0).toUpperCase() + eventName.slice(1));
-    this._vanillaFlicking.on(eventName, function (e) {
-      e.currentTarget = _this;
-      var evtHandler = _this.props[propName];
+  }
+  _bindEvent(eventName) {
+    const propName = `on${eventName.charAt(0).toUpperCase() + eventName.slice(1)}`;
+    this._vanillaFlicking.on(eventName, (e) => {
+      e.currentTarget = this;
+      const evtHandler = this.props[propName];
       evtHandler(e);
     });
-  };
-  __proto._checkPlugins = function () {
-    var flicking = this._vanillaFlicking;
-    var _a = this._pluginsDiffer.update(this.props.plugins),
-      list = _a.list,
-      added = _a.added,
-      removed = _a.removed,
-      prevList = _a.prevList;
-    flicking.addPlugins.apply(flicking, added.map(function (index) {
-      return list[index];
-    }));
-    flicking.removePlugins.apply(flicking, removed.map(function (index) {
-      return prevList[index];
-    }));
-  };
-  __proto._getClasses = function (attributes, props) {
-    var _a;
-    var flicking = this._vanillaFlicking;
-    var initialized = flicking && flicking.initialized;
-    var viewportClasses = ["flicking-viewport"];
-    var cameraClasses = ["flicking-camera"];
-    var isHorizontal = flicking ? flicking.horizontal : (_a = props.horizontal) !== null && _a !== void 0 ? _a : true;
+  }
+  _checkPlugins() {
+    const flicking = this._vanillaFlicking;
+    const { list, added, removed, prevList } = this._pluginsDiffer.update(this.props.plugins);
+    flicking.addPlugins(...added.map((index) => list[index]));
+    flicking.removePlugins(...removed.map((index) => prevList[index]));
+  }
+  _getClasses(attributes, props) {
+    const flicking = this._vanillaFlicking;
+    const initialized = flicking?.initialized;
+    const viewportClasses = ["flicking-viewport"];
+    const cameraClasses = ["flicking-camera"];
+    const isHorizontal = flicking ? flicking.horizontal : props.horizontal ?? true;
     if (!isHorizontal) {
       viewportClasses.push("vertical");
     }
@@ -588,112 +1244,391 @@ var Flicking = /*#__PURE__*/function (_super) {
     if (props.cameraClass) {
       cameraClasses.push(props.cameraClass);
     }
-    var cameraProps = !initialized && props.firstPanelSize ? {
+    const cameraProps = !initialized && props.firstPanelSize ? {
       style: {
         transform: VanillaFlicking.getDefaultCameraTransform(this.props.align, this.props.horizontal, this.props.firstPanelSize)
       }
     } : {};
     return {
-      viewportClasses: viewportClasses,
-      cameraClasses: cameraClasses,
-      cameraProps: cameraProps
+      viewportClasses,
+      cameraClasses,
+      cameraProps
     };
-  };
-  __proto._hasSameChildren = function (prevChildren, nextChildren) {
+  }
+  _hasSameChildren(prevChildren, nextChildren) {
     if (prevChildren.length !== nextChildren.length || prevChildren.length === 0) return false;
-    var same = prevChildren.every(function (child, idx) {
-      var nextChild = nextChildren[idx];
+    const same = prevChildren.every((child, idx) => {
+      const nextChild = nextChildren[idx];
       return child === nextChild;
     });
     return same;
+  }
+  _getChildren(children = this.props.children) {
+    return React__namespace.Children.toArray(children).filter((child) => child.type !== ViewportSlot).reduce((all, child) => {
+      return [...all, ...this._unpackFragment(child)];
+    }, []);
+  }
+  _getViewportSlot() {
+    return React__namespace.Children.toArray(this.props.children).filter(
+      (child) => child.type === ViewportSlot
+    );
+  }
+  _unpackFragment(child) {
+    return this._isFragment(child) ? React__namespace.Children.toArray(child.props.children).reduce(
+      (allChilds, fragChild) => [
+        ...allChilds,
+        ...this._unpackFragment(fragChild)
+      ],
+      []
+    ) : [child];
+  }
+  _getVirtualPanels() {
+    const { panelClass = "flicking-panel" } = this.props.virtual;
+    const panelsPerView = this.props.panelsPerView;
+    const flicking = this._vanillaFlicking;
+    const initialized = flicking?.initialized;
+    const renderingIndexes = initialized ? flicking.renderer.strategy.getRenderingIndexesByOrder(flicking) : VanillaFlicking.range(panelsPerView + 1);
+    const firstPanel = flicking?.panels[0];
+    const size = firstPanel ? flicking.horizontal ? { width: firstPanel.size } : { height: firstPanel.size } : {};
+    return renderingIndexes.map((idx) => {
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(StrictPanel, { ref: this._panels[idx], children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { "data-element-index": idx, className: panelClass, style: size }) }, idx);
+    });
+  }
+  _getPanels() {
+    const origChildren = this._getChildren();
+    const vanillaFlicking = this._vanillaFlicking;
+    const diffResult = this._diffResult;
+    const children = vanillaFlicking?.initialized ? diffResult ? VanillaFlicking.getRenderingPanels(vanillaFlicking, diffResult) : VanillaFlicking.getRenderingPanels(vanillaFlicking, ListDiffer.diff(origChildren, origChildren)) : origChildren;
+    return children.map((child, idx) => /* @__PURE__ */ jsxRuntimeExports.jsx(StrictPanel, { ref: this._panels[idx], children: child }, child.key));
+  }
+  _isFragment(child) {
+    if (child.type) {
+      return child.type === React__namespace.Fragment;
+    }
+    return child === React__namespace.Fragment;
+  }
+};
+_Flicking.defaultProps = DEFAULT_PROPS;
+let Flicking = _Flicking;
+__decorateClass([
+  VanillaFlicking.withFlickingMethods
+], Flicking.prototype, "_vanillaFlicking");
+function keys(obj) {
+  return Object.keys(obj);
+}
+function camelize(str) {
+  return str.replace(/[\s-_]([a-z])/g, function(all, letter) {
+    return letter.toUpperCase();
+  });
+}
+function isFunction(val) {
+  return typeof val === "function";
+}
+var OBSERVERS_PATH = "__observers__";
+var COMPUTED_PATH = "__computed__";
+function __spreadArray(to, from, pack) {
+  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+function withReactiveMethods(ref, methods) {
+  var obj = {};
+  if (!methods) {
+    return obj;
+  }
+  methods.forEach(function(name) {
+    obj[name] = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      var current = ref.current || ref.value;
+      return current[name].apply(current, args);
+    };
+  });
+  return obj;
+}
+function defineObservers(instance) {
+  var observers = {};
+  Object.defineProperty(instance, OBSERVERS_PATH, {
+    get: function() {
+      return observers;
+    }
+  });
+  return observers;
+}
+function getObservers(instance, isComputed) {
+  var _a, _b;
+  if (!instance[OBSERVERS_PATH]) {
+    defineObservers(instance);
+  }
+  var observers = instance[OBSERVERS_PATH];
+  {
+    var computedList = (_b = (_a = instance === null || instance === void 0 ? void 0 : instance.constructor) === null || _a === void 0 ? void 0 : _a.prototype) === null || _b === void 0 ? void 0 : _b[COMPUTED_PATH];
+    if (computedList) {
+      computedList.forEach(function(name) {
+        if (!(name in observers) && name in instance) {
+          instance[name];
+        }
+      });
+    }
+  }
+  return observers;
+}
+function adaptReactive(adapter, props) {
+  var objectAdapter = isFunction(adapter) ? {
+    setup: adapter
+  } : adapter;
+  function getProps() {
+    var _a, _b, _c, _d, _e;
+    return (_e = (_c = (_a = props === null || props === void 0 ? void 0 : props()) !== null && _a !== void 0 ? _a : (_b = objectAdapter.props) === null || _b === void 0 ? void 0 : _b.call(objectAdapter)) !== null && _c !== void 0 ? _c : (_d = objectAdapter.data) === null || _d === void 0 ? void 0 : _d.call(objectAdapter)) !== null && _e !== void 0 ? _e : {};
+  }
+  var eventEmitter = new Component();
+  var mountedHooks = [];
+  var initHooks = [];
+  var destroyHooks = [];
+  var onHooks = [];
+  var instanceRef = {
+    current: null
+  };
+  var offHooksList = [];
+  var initialState = null;
+  var eventNames = [];
+  var methodNames = [];
+  var onMounted = function(callback) {
+    mountedHooks.push(callback);
+  };
+  var onInit = function(callback) {
+    initHooks.push(callback);
   };
-  __proto._getChildren = function (children) {
-    var _this = this;
-    if (children === void 0) {
-      children = this.props.children;
+  var onDestroy = function(callback) {
+    destroyHooks.push(callback);
+  };
+  var on = function(callback) {
+    onHooks.push(callback);
+  };
+  var emit = function(eventName) {
+    var params = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+      params[_i - 1] = arguments[_i];
     }
-    return React.Children.toArray(children).filter(function (child) {
-      return child.type !== ViewportSlot;
-    }).reduce(function (all, child) {
-      return __spreadArray(__spreadArray([], all, true), _this._unpackFragment(child), true);
-    }, []);
+    eventEmitter.trigger.apply(eventEmitter, __spreadArray([eventName], params, false));
   };
-  __proto._getViewportSlot = function () {
-    return React.Children.toArray(this.props.children).filter(function (child) {
-      return child.type === ViewportSlot;
-    });
+  var setInitialState = function(state) {
+    initialState = state;
   };
-  __proto._unpackFragment = function (child) {
-    var _this = this;
-    return this._isFragment(child) ? React.Children.toArray(child.props.children).reduce(function (allChilds, fragChild) {
-      return __spreadArray(__spreadArray([], allChilds, true), _this._unpackFragment(fragChild), true);
-    }, []) : [child];
+  var setEvents = function(events) {
+    eventNames = events;
   };
-  __proto._getVirtualPanels = function () {
-    var _this = this;
-    var _a = this.props.virtual.panelClass,
-      panelClass = _a === void 0 ? "flicking-panel" : _a;
-    var panelsPerView = this.props.panelsPerView;
-    var flicking = this._vanillaFlicking;
-    var initialized = flicking && flicking.initialized;
-    var renderingIndexes = initialized ? flicking.renderer.strategy.getRenderingIndexesByOrder(flicking) : VanillaFlicking.range(panelsPerView + 1);
-    var firstPanel = flicking && flicking.panels[0];
-    var size = firstPanel ? flicking.horizontal ? {
-      width: firstPanel.size
-    } : {
-      height: firstPanel.size
-    } : {};
-    return renderingIndexes.map(function (idx) {
-      return React.createElement(StrictPanel, {
-        key: idx,
-        ref: _this._panels[idx]
-      }, React.createElement("div", {
-        "data-element-index": idx,
-        className: panelClass,
-        style: size
-      }));
+  var setMethods = function(methods) {
+    methodNames = methods;
+  };
+  if (objectAdapter.setup) {
+    instanceRef.current = objectAdapter.setup({
+      getProps,
+      setInitialState,
+      setEvents,
+      setMethods,
+      onMounted,
+      onDestroy,
+      onInit,
+      emit,
+      on
+    }) || null;
+  }
+  if (objectAdapter.created) {
+    instanceRef.current = objectAdapter.created(getProps()) || null;
+  }
+  if (objectAdapter.events) {
+    setEvents(objectAdapter.events);
+  }
+  if (objectAdapter.state) {
+    setInitialState(objectAdapter.state);
+  }
+  if (objectAdapter.methods) {
+    setMethods(objectAdapter.methods);
+  }
+  if (objectAdapter.mounted) {
+    onMounted(objectAdapter.mounted);
+  }
+  if (objectAdapter.destroy) {
+    destroyHooks.push(objectAdapter.destroy);
+  }
+  if (objectAdapter.init) {
+    initHooks.push(objectAdapter.init);
+  }
+  if (objectAdapter.on) {
+    onHooks.push(function(instance, eventName, listener) {
+      var off = objectAdapter.on(instance, eventName, listener);
+      return function() {
+        var _a;
+        off && off();
+        (_a = objectAdapter.off) === null || _a === void 0 ? void 0 : _a.call(objectAdapter, instance, eventName, listener);
+      };
     });
+  }
+  return {
+    events: function() {
+      return eventNames;
+    },
+    state: function() {
+      var inst = instanceRef.current;
+      if (initialState) {
+        return initialState;
+      }
+      if (inst) {
+        var observers_1 = getObservers(inst);
+        setInitialState(keys(observers_1).reduce(function(prev, cur) {
+          prev[cur] = observers_1[cur].current;
+          return prev;
+        }, {}));
+      }
+      return initialState || {};
+    },
+    instance: function() {
+      return instanceRef.current;
+    },
+    mounted: function() {
+      var props2 = getProps();
+      mountedHooks.forEach(function(hook) {
+        instanceRef.current = hook(props2, instanceRef.current) || instanceRef.current;
+      });
+    },
+    init: function() {
+      var instance = instanceRef.current;
+      var props2 = getProps();
+      offHooksList = eventNames.map(function(eventName) {
+        var listener = function() {
+          var _a;
+          var params = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+          }
+          (_a = eventEmitter).trigger.apply(_a, __spreadArray([eventName], params, false));
+        };
+        var instance2 = instanceRef.current;
+        return onHooks.map(function(hook) {
+          return hook(instance2, eventName, listener);
+        }).filter(Boolean);
+      });
+      initHooks.forEach(function(hook) {
+        hook(instance, props2);
+      });
+    },
+    destroy: function() {
+      offHooksList.forEach(function(offHooks) {
+        offHooks.forEach(function(hook) {
+          hook();
+        });
+      });
+      eventEmitter.off();
+      var instance = instanceRef.current;
+      var props2 = getProps();
+      destroyHooks.forEach(function(hook) {
+        hook(instance, props2);
+      });
+    },
+    methods: function() {
+      return withReactiveMethods(instanceRef, methodNames);
+    },
+    on: function(eventName, listener) {
+      eventEmitter.on(eventName, listener);
+    },
+    off: function(eventName, listener) {
+      eventEmitter.off(eventName, listener);
+    }
   };
-  __proto._getPanels = function () {
-    var _this = this;
-    var origChildren = this._getChildren();
-    var vanillaFlicking = this._vanillaFlicking;
-    var diffResult = this._diffResult;
-    var children = vanillaFlicking && vanillaFlicking.initialized ? diffResult ? VanillaFlicking.getRenderingPanels(vanillaFlicking, diffResult) : VanillaFlicking.getRenderingPanels(vanillaFlicking, ListDiffer.diff(origChildren, origChildren)) : origChildren;
-    return children.map(function (child, idx) {
-      return React.createElement(StrictPanel, {
-        key: child.key,
-        ref: _this._panels[idx]
-      }, child);
+}
+function useReactive(reactiveAdapter, props) {
+  var readRef = React.useRef(true);
+  var adaptResult = React.useMemo(function() {
+    return adaptReactive(reactiveAdapter, props);
+  }, []);
+  var reactiveState = adaptResult.state();
+  var names = keys(reactiveState);
+  var states = React.useState({})[0];
+  var _loop_1 = function(name2) {
+    var state = React.useState(function() {
+      return reactiveState[name2];
     });
+    states[name2] = {
+      getter: false,
+      set: state[1],
+      value: state[0]
+    };
   };
-  __proto._isFragment = function (child) {
-    if (child.type) {
-      return child.type === React.Fragment;
+  for (var name in reactiveState) {
+    _loop_1(name);
+  }
+  readRef.current = true;
+  var methods = React.useMemo(function() {
+    return adaptResult.methods();
+  }, []);
+  React.useEffect(function() {
+    readRef.current = false;
+  });
+  React.useEffect(function() {
+    adaptResult.mounted();
+    var inst = adaptResult.instance();
+    names.forEach(function(name2) {
+      inst.subscribe(name2, function(value) {
+        states[name2].value = value;
+        if (states[name2].getter) {
+          states[name2].set(value);
+        }
+      });
+    });
+    adaptResult.init();
+    return function() {
+      adaptResult.destroy();
+    };
+  }, []);
+  var result = names.reduce(function(result2, name2) {
+    if (!methods[name2]) {
+      Object.defineProperty(result2, name2, {
+        enumerable: true,
+        get: function() {
+          if (readRef.current) {
+            states[name2].getter = true;
+          }
+          return states[name2].value;
+        }
+      });
     }
-    return child === React.Fragment;
-  };
-  Flicking.defaultProps = DEFAULT_PROPS;
-  __decorate([VanillaFlicking.withFlickingMethods], Flicking.prototype, "_vanillaFlicking", void 0);
-  return Flicking;
-}(React.Component);
-
-var useFlickingReactiveAPI = function (flickingRef, options) {
-  return react.useReactive(VanillaFlicking.flickingReactiveAPIAdapter, function () {
-    var _a;
-    return {
-      flicking: (_a = flickingRef.current) !== null && _a !== void 0 ? _a : undefined,
-      options: options
+    return result2;
+  }, {});
+  var reactiveEvents = adaptResult.events();
+  reactiveEvents.forEach(function(name2) {
+    result[camelize("on ".concat(name2))] = function(callback, dependencies) {
+      var listener = React.useMemo(function() {
+        adaptResult.on(name2, callback);
+        return callback;
+      }, dependencies);
+      React.useEffect(function() {
+        adaptResult.off(name2, listener);
+        adaptResult.on(name2, listener);
+        return function() {
+          adaptResult.off(name2, listener);
+        };
+      }, [listener]);
     };
   });
+  keys(methods).forEach(function(name2) {
+    result[name2] = methods[name2];
+  });
+  return result;
+}
+const useFlickingReactiveAPI = (flickingRef, options) => {
+  return useReactive(VanillaFlicking.flickingReactiveAPIAdapter, () => ({
+    flicking: flickingRef.current ?? void 0,
+    options
+  }));
 };
-
-/*
- * Copyright (c) 2015 NAVER Corp.
- * egjs projects are licensed under the MIT license
- */
 Flicking.ViewportSlot = ViewportSlot;
 Flicking.useFlickingReactiveAPI = useFlickingReactiveAPI;
-
 module.exports = Flicking;
 //# sourceMappingURL=flicking.cjs.js.map