-
Notifications
You must be signed in to change notification settings - Fork 0
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
JS #2
Comments
(function ($) {
})(jQuery); |
(function ($) {
})(jQuery); |
/** @license React v16.9.0
'use strict'; (function (global, factory) { // TODO: this is special because it gets imported during build. var ReactVersion = '16.9.0'; // The Symbol used to tag the ReactElement-like types. If there is no native Symbol var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7; var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf; var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; function getIteratorFn(maybeIterable) { /* /* eslint-disable no-unused-vars */ function toObject(val) {
} function shouldUseNative() {
} var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
}; // Do not require this module directly! Use normal // Do not require this module directly! Use normal function ReactError(error) { /**
/**
var lowPriorityWarning = function () {}; {
}; lowPriorityWarning = function (condition, format) {
}; var lowPriorityWarning$1 = lowPriorityWarning; /**
var warningWithoutStack = function () {}; {
}; var warningWithoutStack$1 = warningWithoutStack; var didWarnStateUpdateForUnmountedComponent = {}; function warnNoop(publicInstance, callerName) { /**
/**
/**
/**
var emptyObject = {}; /**
Component.prototype.isReactComponent = {}; /**
/**
/**
function ComponentDummy() {} /**
var pureComponentPrototype = PureComponent.prototype = new ComponentDummy(); // an immutable object with a single mutable value /**
/**
/**
var BEFORE_SLASH_RE = /^(.*)[\/]/; var describeComponentFrame = function (name, source, ownerName) { var Resolved = 1; function refineResolvedLazyComponent(lazyComponent) { function getWrappedName(outerType, innerType, wrapperName) { function getComponentName(type) { var ReactDebugCurrentFrame = {}; var currentlyValidatingElement = null; function setCurrentlyValidatingElement(element) { { ReactDebugCurrentFrame.getStackAddendum = function () {
}; /**
var IsSomeRendererActing = { var ReactSharedInternals = { { /**
var warning = warningWithoutStack$1; {
}; var warning$1 = warning; var hasOwnProperty$1 = Object.prototype.hasOwnProperty; var RESERVED_PROPS = { var specialPropKeyWarningShown = void 0; function hasValidRef(config) { function hasValidKey(config) { function defineKeyPropWarningGetter(props, displayName) { function defineRefPropWarningGetter(props, displayName) { /**
{
} return element; /**
/**
// Reserved names are extracted var key = null; if (hasValidRef(config)) { if (hasValidKey(config)) { // Remaining properties are added to a new props object // intentionally not checking if key was set above // Resolve default props if (key || ref) { return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props); /**
// Reserved names are extracted var key = null; if (config != null) {
} // Children can be more than one argument, and those are transferred onto // Resolve default props /**
function cloneAndReplaceKey(oldElement, newKey) { return newElement; /**
var propName = void 0; // Original props are copied // Reserved names are extracted // Owner will be preserved, unless ref is overridden if (config != null) {
} // Children can be more than one argument, and those are transferred onto return ReactElement(element.type, key, ref, self, source, owner, props); /**
var SEPARATOR = '.'; /**
return '$' + escapedString; /**
var didWarnAboutMaps = false; var userProvidedKeyEscapeRegex = //+/g; var POOL_SIZE = 10; function releaseTraverseContext(traverseContext) { /**
if (type === 'undefined' || type === 'boolean') { var invokeCallback = false; if (children === null) { if (invokeCallback) { var child = void 0; if (Array.isArray(children)) {
} return subtreeCount; /**
return traverseAllChildrenImpl(children, '', callback, traverseContext); /**
function forEachSingleChild(bookKeeping, child, name) { func.call(context, child, bookKeeping.count++); /**
function mapSingleChildIntoContext(bookKeeping, child, childKey) { var mappedChild = func.call(context, child, bookKeeping.count++); function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) { /**
/**
/**
/**
function createContext(defaultValue, calculateChangedBits) { var context = { context.Provider = { var hasWarnedAboutUsingNestedContextConsumers = false; { { return context; function lazy(ctor) { { return lazyType; function forwardRef(render) {
} return { function isValidElementType(type) { function memo(type, compare) { function resolveDispatcher() { function useContext(Context, unstable_observedBits) {
} function useState(initialState) { function useReducer(reducer, initialArg, init) { function useRef(initialValue) { function useEffect(create, inputs) { function useLayoutEffect(create, inputs) { function useCallback(callback, inputs) { function useMemo(create, inputs) { function useImperativeHandle(ref, create, inputs) { function useDebugValue(value, formatterFn) { var emptyObject$1 = {}; function useResponder(responder, listenerProps) { // Within the scope of the callback, mark all updates as being allowed to suspend. /**
var ReactPropTypesSecret$1 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; var ReactPropTypesSecret_1 = ReactPropTypesSecret$1; /**
var printWarning$1 = function() {}; { printWarning$1 = function(text) { /**
var checkPropTypes_1 = checkPropTypes; /**
var propTypesMisspellWarningShown = void 0; { function getDeclarationErrorAddendum() { function getSourceInfoErrorAddendum(source) { function getSourceInfoErrorAddendumForProps(elementProps) { /**
function getCurrentComponentErrorInfo(parentType) { if (!info) { /**
var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType); // Usually the current owner is the offender, but if it accepts children as a setCurrentlyValidatingElement(element); /**
/**
/**
var keys = Object.keys(fragment.props); if (fragment.ref !== null) { setCurrentlyValidatingElement(null); function jsxWithValidation(type, props, key, isStaticChildren, source, self) { // We warn in this case but don't throw. We expect the element creation to
} var element = jsxDEV(type, props, key, source, self); // The result can be nullish if a mock or a custom function is used. // Skip key warning if the type isn't valid since our key validation logic if (props.key !== undefined) { if (type === REACT_FRAGMENT_TYPE) { return element; // These two functions exist to still get child warnings in dev function jsxWithValidationDynamic(type, props, key) { function createElementWithValidation(type, props, children) { // We warn in this case but don't throw. We expect the element creation to
} var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used. // Skip key warning if the type isn't valid since our key validation logic if (type === REACT_FRAGMENT_TYPE) { return element; function createFactoryWithValidation(type) { return validatedFactory; function cloneElementWithValidation(element, props, children) { var enableSchedulerDebugging = false; // The DOM Scheduler implementation is similar to requestIdleCallback. It var requestHostCallback = void 0; var requestHostTimeout = void 0; if ( if (typeof console !== 'undefined') { var requestIdleCallbackBeforeFirstFrame$1 = requestIdleCallbackBeforeFirstFrame && typeof requestIdleCallback === 'function' && typeof cancelIdleCallback === 'function'; getCurrentTime = typeof performance === 'object' && typeof performance.now === 'function' ? function () { var isRAFLoopRunning = false; var frameLength = enableMessageLoopImplementation ? // We won't attempt to align with the vsync. Instead we'll yield multiple var prevRAFTime = -1; var fpsLocked = false; // TODO: Make this configurable if (enableIsInputPending && navigator !== undefined && navigator.scheduling !== undefined && navigator.scheduling.isInputPending !== undefined) {
} else {
} forceFrameRate = function (fps) { var performWorkUntilDeadline = function () { var channel = new MessageChannel(); var onAnimationFrame = function (rAFTime) {
}; requestHostCallback = function (callback) {
}; requestHostTimeout = function (callback, ms) { cancelHostTimeout = function () { /* eslint-disable no-var */ // TODO: Use symbols? // Max 31 bit integer. The max integer size in V8 for 32-bit systems. // Times out immediately // Tasks are stored as a circular, doubly linked list. // Pausing the scheduler is useful for debugging. var currentTask = null; // This is set while performing work, to prevent re-entrancy. var isHostCallbackScheduled = false; function scheduler_flushTaskAtPriority_Immediate(callback, didTimeout) { function flushTask(task, currentTime) { // Now it's safe to execute the task. // A callback may return a continuation. The continuation should be scheduled
} function advanceTimers(currentTime) { function handleTimeout(currentTime) { if (!isHostCallbackScheduled) { function flushWork(hasTimeRemaining, initialTime) { // We'll need a host callback the next time work is scheduled. var currentTime = initialTime; isPerformingWork = true; function unstable_runWithPriority(priorityLevel, eventHandler) { var previousPriorityLevel = currentPriorityLevel; try { function unstable_next(eventHandler) { var previousPriorityLevel = currentPriorityLevel; try { function unstable_wrapCallback(callback) {
}; function timeoutForPriorityLevel(priorityLevel) { function unstable_scheduleCallback(priorityLevel, callback, options) { var startTime; var expirationTime = startTime + timeout; var newTask = { if (startTime > currentTime) { return newTask; function insertScheduledTask(newTask, expirationTime) {
} function insertDelayedTask(newTask, startTime) {
} function unstable_pauseExecution() { function unstable_continueExecution() { function unstable_getFirstCallbackNode() { function unstable_cancelCallback(task) { if (task === next) { task.next = task.previous = null; function unstable_getCurrentPriorityLevel() { function unstable_shouldYield() { var unstable_requestPaint = requestPaint; var Scheduler = Object.freeze({ // Helps identify side effects in begin-phase lifecycle hooks and setState reducers: // In some cases, StrictMode should also double-render lifecycles. // To preserve the "Pause on caught exceptions" behavior of the debugger, we // Warn about deprecated, async-unsafe lifecycles; relates to RFC #6: // Gather advanced timing metrics for Profiler subtrees. // Trace which interactions trigger each commit. // Only used in www builds. // Only used in www builds. // Only used in www builds. // Disable javascript: URL strings in href for XSS protection. // React Fire: prevent the value and checked attributes from syncing // These APIs will no longer be "unstable" in the upcoming 16.7 release, // See react-native-community/discussions-and-proposals#72 for more information // Experimental React Flare event system and event components support. // Experimental Host Component support. // New API for JSX transforms to target - reactjs/rfcs#107 // We will enforce mocking scheduler with scheduler/unstable_mock at some point. (v17?) // Temporary flag to revert the fix in #15650 // For tests, we flush suspense fallbacks in an act scope; // Changes priority of some events like mousemove to user-blocking priority, // Add a callback property to suspense to notify which promises are currently // Part of the simplification of React.createElement so we can eventually move var DEFAULT_THREAD_ID = 0; // Counters used to generate unique IDs. // Set of currently traced interactions. // Listener(s) to notify when interactions begin and end. if (enableSchedulerTracing) { function unstable_clear(callback) { var prevInteractions = interactionsRef.current; try { function unstable_getCurrent() { function unstable_getThreadID() { function unstable_trace(name, timestamp, callback) { if (!enableSchedulerTracing) { var interaction = { var prevInteractions = interactionsRef.current; // Traced interactions should stack/accumulate. var subscriber = subscriberRef.current; try {
} return returnValue; function unstable_wrap(callback) { if (!enableSchedulerTracing) { var wrappedInteractions = interactionsRef.current; var subscriber = subscriberRef.current; // Update the pending async work count for the current interactions. var hasRun = false; function wrapped() {
} wrapped.cancel = function cancel() {
}; return wrapped; var subscribers = null; function unstable_subscribe(subscriber) {
} function unstable_unsubscribe(subscriber) {
} function onInteractionTraced(interaction) { subscribers.forEach(function (subscriber) { if (didCatchError) { function onInteractionScheduledWorkCompleted(interaction) { subscribers.forEach(function (subscriber) { if (didCatchError) { function onWorkScheduled(interactions, threadID) { subscribers.forEach(function (subscriber) { if (didCatchError) { function onWorkStarted(interactions, threadID) { subscribers.forEach(function (subscriber) { if (didCatchError) { function onWorkStopped(interactions, threadID) { subscribers.forEach(function (subscriber) { if (didCatchError) { function onWorkCanceled(interactions, threadID) { subscribers.forEach(function (subscriber) { if (didCatchError) { var SchedulerTracing = Object.freeze({ var ReactSharedInternals$2 = { { // Re-export the schedule API(s) for UMD bundles. var hasBadMapPolyfill = void 0; { function createFundamentalComponent(impl) { function createEventResponder(displayName, responderConfig) { var eventResponder = { var React = { createRef: createRef, createContext: createContext, useCallback: useCallback, Fragment: REACT_FRAGMENT_TYPE, createElement: createElementWithValidation, version: ReactVersion, unstable_withSuspenseConfig: withSuspenseConfig, __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals$2 if (enableFlareAPI) { if (enableFundamentalAPI) { // Note: some APIs are added with feature flags. if (enableJSXTransformAPI) { var React$2 = Object.freeze({ var React$3 = ( React$2 && React ) || React$2; // TODO: decide on the top-level export form. return react; }))); |
(function ($) {
})(jQuery); |
No description provided.
The text was updated successfully, but these errors were encountered: