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

package/dist/flicking.js

@@ -0,0 +1,1634 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory(require("react"), require("@egjs/component"), require("@egjs/flicking"), require("@egjs/list-differ")) : typeof define === "function" && define.amd ? define(["react", "@egjs/component", "@egjs/flicking", "@egjs/list-differ"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, global.ReactFlicking = factory(global.React, global.Component, global.Flicking, global.eg.ListDiffer));
+})(this, (function(React, Component, VanillaFlicking, ListDiffer) {
+  "use strict";
+  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]
+          });
+        }
+      }
+    }
+    n.default = e;
+    return Object.freeze(n);
+  }
+  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 };
+    }
+    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;
+        }
+        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 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, self2) {
+          {
+            if (typeof config.ref === "string" && ReactCurrentOwner.current && self2) ;
+          }
+        }
+        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);
+              }
+            };
+            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, self2, 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: self2
+            });
+            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, self2) {
+          {
+            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, self2);
+            }
+            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, self2, 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, self2) {
+          {
+            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, self2);
+            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;
+  }
+  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 jsxRuntime.exports;
+  }
+  var jsxRuntimeExports = requireJsxRuntime();
+  const DEFAULT_PROPS = {
+    viewportTag: "div",
+    cameraTag: "div",
+    cameraClass: "",
+    firstPanelSize: "",
+    renderOnSameKey: false,
+    plugins: [],
+    useFindDOMNode: false,
+    hideBeforeInit: false,
+    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) => {
+    }
+  };
+  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
+    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();
+      });
+    }
+    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();
+      });
+    }
+    destroy() {
+      super.destroy();
+      this._reactFlicking.renderEmitter.off("render");
+    }
+    _collectPanels() {
+      const flicking = VanillaFlicking.getFlickingAttached(this._flicking);
+      const reactFlicking = this._reactFlicking;
+      const reactPanels = reactFlicking.reactPanels;
+      this._panels = this._strategy.collectPanels(flicking, reactPanels);
+    }
+    _createPanel(externalComponent, options) {
+      return this._strategy.createPanel(externalComponent, options);
+    }
+  }
+  class StrictPanel extends React__namespace.Component {
+    constructor() {
+      super(...arguments);
+      this._hide = false;
+      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;
+    }
+    _getElement() {
+      return React__namespace.cloneElement(React__namespace.Children.only(this.props.children), {
+        ref: this._elRef
+      });
+    }
+  }
+  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
+        })
+      };
+      const flicking = new VanillaFlicking(this._viewportElement, {
+        ...props,
+        externalRenderer: new ReactRenderer(rendererOptions)
+      });
+      this._vanillaFlicking = flicking;
+      const children = this._getChildren();
+      this._jsxDiffer = new ListDiffer(children, (panel) => panel.key);
+      this._pluginsDiffer = new ListDiffer();
+      this._prevChildren = children;
+      this._bindEvents();
+      this._checkPlugins();
+      if (props.status) {
+        flicking.setStatus(props.status);
+      }
+    }
+    componentWillUnmount() {
+      this._vanillaFlicking?.destroy();
+    }
+    shouldComponentUpdate(nextProps) {
+      const vanillaFlicking = this._vanillaFlicking;
+      const prevProps = this.props;
+      if (!vanillaFlicking || !vanillaFlicking.initialized) return false;
+      const { children, ...restProps } = nextProps;
+      for (const key in restProps) {
+        if (prevProps[key] !== nextProps[key]) {
+          return true;
+        }
+      }
+      const prevChildren = this._prevChildren;
+      const nextChildren = this._getChildren(children);
+      if (nextProps.renderOnSameKey || !this._hasSameChildren(prevChildren, nextChildren)) return true;
+      return false;
+    }
+    beforeRender() {
+      const vanillaFlicking = this._vanillaFlicking;
+      const props = this.props;
+      const prevChildren = this._prevChildren;
+      if (!vanillaFlicking || !vanillaFlicking.initialized || this._diffResult) return;
+      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;
+      }
+    }
+    componentDidUpdate() {
+      const flicking = this._vanillaFlicking;
+      const renderEmitter = this._renderEmitter;
+      const diffResult = this._diffResult;
+      this._checkPlugins();
+      renderEmitter.trigger("render");
+      flicking.camera.updateOffset();
+      const { virtual, ...props } = this.props;
+      for (const key in props) {
+        if (key in flicking && flicking[key] !== props[key]) {
+          flicking[key] = props[key];
+        }
+      }
+      if (!diffResult || !flicking.initialized) return;
+      VanillaFlicking.sync(flicking, diffResult, this.reactPanels);
+      this._diffResult = null;
+    }
+    render() {
+      const props = this.props;
+      const Viewport = props.viewportTag;
+      const Camera = props.cameraTag;
+      const attributes = {};
+      this.beforeRender();
+      for (const name in props) {
+        if (!(name in DEFAULT_PROPS) && !(name in VanillaFlicking.prototype)) {
+          attributes[name] = props[name];
+        }
+      }
+      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, () => {
+        this.forceUpdate();
+      });
+    }
+    _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);
+      });
+    }
+    _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");
+      }
+      if (props.hideBeforeInit && !initialized) {
+        viewportClasses.push("flicking-hidden");
+      }
+      if (attributes.className) {
+        viewportClasses.push(attributes.className);
+      }
+      if (props.cameraClass) {
+        cameraClasses.push(props.cameraClass);
+      }
+      const cameraProps = !initialized && props.firstPanelSize ? {
+        style: {
+          transform: VanillaFlicking.getDefaultCameraTransform(this.props.align, this.props.horizontal, this.props.firstPanelSize)
+        }
+      } : {};
+      return {
+        viewportClasses,
+        cameraClasses,
+        cameraProps
+      };
+    }
+    _hasSameChildren(prevChildren, nextChildren) {
+      if (prevChildren.length !== nextChildren.length || prevChildren.length === 0) return false;
+      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);
+    };
+    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];
+      }
+      eventEmitter.trigger.apply(eventEmitter, __spreadArray([eventName], params, false));
+    };
+    var setInitialState = function(state) {
+      initialState = state;
+    };
+    var setEvents = function(events) {
+      eventNames = events;
+    };
+    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);
+      }
+    };
+  }
+  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]
+      };
+    };
+    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 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
+    }));
+  };
+  Flicking.ViewportSlot = ViewportSlot;
+  Flicking.useFlickingReactiveAPI = useFlickingReactiveAPI;
+  return Flicking;
+}));
+//# sourceMappingURL=flicking.js.map