How to use normalizeEmitsOptions method in Playwright Internal

Best JavaScript code snippet using playwright-internal

vue.runtime.esm.js

Source:vue.runtime.esm.js

...1268    if (handler) {1269        callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);1270    }1271}1272function normalizeEmitsOptions(comp, appContext, asMixin = false) {1273    const appId = appContext.app ? appContext.app._uid : -1;1274    const cache = comp.__emits || (comp.__emits = {});1275    const cached = cache[appId];1276    if (cached !== undefined) {1277        return cached;1278    }1279    const raw = comp.emits;1280    let normalized = {};1281    // apply mixin/extends props1282    let hasExtends = false;1283    if (__VUE_OPTIONS_API__ && !isFunction(comp)) {1284        const extendEmits = (raw) => {1285            hasExtends = true;1286            extend(normalized, normalizeEmitsOptions(raw, appContext, true));1287        };1288        if (!asMixin && appContext.mixins.length) {1289            appContext.mixins.forEach(extendEmits);1290        }1291        if (comp.extends) {1292            extendEmits(comp.extends);1293        }1294        if (comp.mixins) {1295            comp.mixins.forEach(extendEmits);1296        }1297    }1298    if (!raw && !hasExtends) {1299        return (cache[appId] = null);1300    }1301    if (isArray(raw)) {1302        raw.forEach(key => (normalized[key] = null));1303    }1304    else {1305        extend(normalized, raw);1306    }1307    return (cache[appId] = normalized);1308}1309// Check if an incoming prop key is a declared emit event listener.1310// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are1311// both considered matched listeners.1312function isEmitListener(options, key) {1313    if (!options || !isOn(key)) {1314        return false;1315    }1316    key = key.replace(/Once$/, '');1317    return (hasOwn(options, key[2].toLowerCase() + key.slice(3)) ||1318        hasOwn(options, key.slice(2)));1319}1320// mark the current rendering instance for asset resolution (e.g.1321// resolveComponent, resolveDirective) during render1322let currentRenderingInstance = null;1323function markAttrsAccessed() {1324}1325function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison1326isSSR = false) {1327    const props = {};1328    const attrs = {};1329    // def(attrs, InternalObjectKey, 1) // fixed by xxxxxx1330    def(attrs, '__vInternal', 1);1331    setFullProps(instance, rawProps, props, attrs);1332    // validation1333    if ((process.env.NODE_ENV !== 'production')) {1334        validateProps(props, instance);1335    }1336    if (isStateful) {1337        // stateful1338        instance.props = isSSR ? props : shallowReactive(props);1339    }1340    else {1341        if (!instance.type.props) {1342            // functional w/ optional props, props === attrs1343            instance.props = attrs;1344        }1345        else {1346            // functional w/ declared props1347            instance.props = props;1348        }1349    }1350    instance.attrs = attrs;1351}1352function setFullProps(instance, rawProps, props, attrs) {1353    const [options, needCastKeys] = instance.propsOptions;1354    if (rawProps) {1355        for (const key in rawProps) {1356            const value = rawProps[key];1357            // key, ref are reserved and never passed down1358            if (isReservedProp(key)) {1359                continue;1360            }1361            // prop option names are camelized during normalization, so to support1362            // kebab -> camel conversion here we need to camelize the key.1363            let camelKey;1364            if (options && hasOwn(options, (camelKey = camelize(key)))) {1365                props[camelKey] = value;1366            }1367            else if (!isEmitListener(instance.emitsOptions, key)) {1368                // Any non-declared (either as a prop or an emitted event) props are put1369                // into a separate `attrs` object for spreading. Make sure to preserve1370                // original key casing1371                attrs[key] = value;1372            }1373        }1374    }1375    if (needCastKeys) {1376        const rawCurrentProps = toRaw(props);1377        for (let i = 0; i < needCastKeys.length; i++) {1378            const key = needCastKeys[i];1379            props[key] = resolvePropValue(options, rawCurrentProps, key, rawCurrentProps[key], instance);1380        }1381    }1382}1383function resolvePropValue(options, props, key, value, instance) {1384    const opt = options[key];1385    if (opt != null) {1386        const hasDefault = hasOwn(opt, 'default');1387        // default values1388        if (hasDefault && value === undefined) {1389            const defaultValue = opt.default;1390            if (opt.type !== Function && isFunction(defaultValue)) {1391                setCurrentInstance(instance);1392                value = defaultValue(props);1393                setCurrentInstance(null);1394            }1395            else {1396                value = defaultValue;1397            }1398        }1399        // boolean casting1400        if (opt[0 /* shouldCast */]) {1401            if (!hasOwn(props, key) && !hasDefault) {1402                value = false;1403            }1404            else if (opt[1 /* shouldCastTrue */] &&1405                (value === '' || value === hyphenate(key))) {1406                value = true;1407            }1408        }1409    }1410    return value;1411}1412function normalizePropsOptions(comp, appContext, asMixin = false) {1413    const appId = appContext.app ? appContext.app._uid : -1;1414    const cache = comp.__props || (comp.__props = {});1415    const cached = cache[appId];1416    if (cached) {1417        return cached;1418    }1419    const raw = comp.props;1420    const normalized = {};1421    const needCastKeys = [];1422    // apply mixin/extends props1423    let hasExtends = false;1424    if (__VUE_OPTIONS_API__ && !isFunction(comp)) {1425        const extendProps = (raw) => {1426            hasExtends = true;1427            const [props, keys] = normalizePropsOptions(raw, appContext, true);1428            extend(normalized, props);1429            if (keys)1430                needCastKeys.push(...keys);1431        };1432        if (!asMixin && appContext.mixins.length) {1433            appContext.mixins.forEach(extendProps);1434        }1435        if (comp.extends) {1436            extendProps(comp.extends);1437        }1438        if (comp.mixins) {1439            comp.mixins.forEach(extendProps);1440        }1441    }1442    if (!raw && !hasExtends) {1443        return (cache[appId] = EMPTY_ARR);1444    }1445    if (isArray(raw)) {1446        for (let i = 0; i < raw.length; i++) {1447            if ((process.env.NODE_ENV !== 'production') && !isString(raw[i])) {1448                warn(`props must be strings when using array syntax.`, raw[i]);1449            }1450            const normalizedKey = camelize(raw[i]);1451            if (validatePropName(normalizedKey)) {1452                normalized[normalizedKey] = EMPTY_OBJ;1453            }1454        }1455    }1456    else if (raw) {1457        if ((process.env.NODE_ENV !== 'production') && !isObject(raw)) {1458            warn(`invalid props options`, raw);1459        }1460        for (const key in raw) {1461            const normalizedKey = camelize(key);1462            if (validatePropName(normalizedKey)) {1463                const opt = raw[key];1464                const prop = (normalized[normalizedKey] =1465                    isArray(opt) || isFunction(opt) ? { type: opt } : opt);1466                if (prop) {1467                    const booleanIndex = getTypeIndex(Boolean, prop.type);1468                    const stringIndex = getTypeIndex(String, prop.type);1469                    prop[0 /* shouldCast */] = booleanIndex > -1;1470                    prop[1 /* shouldCastTrue */] =1471                        stringIndex < 0 || booleanIndex < stringIndex;1472                    // if the prop needs boolean casting or default value1473                    if (booleanIndex > -1 || hasOwn(prop, 'default')) {1474                        needCastKeys.push(normalizedKey);1475                    }1476                }1477            }1478        }1479    }1480    return (cache[appId] = [normalized, needCastKeys]);1481}1482// use function string name to check type constructors1483// so that it works across vms / iframes.1484function getType(ctor) {1485    const match = ctor && ctor.toString().match(/^\s*function (\w+)/);1486    return match ? match[1] : '';1487}1488function isSameType(a, b) {1489    return getType(a) === getType(b);1490}1491function getTypeIndex(type, expectedTypes) {1492    if (isArray(expectedTypes)) {1493        for (let i = 0, len = expectedTypes.length; i < len; i++) {1494            if (isSameType(expectedTypes[i], type)) {1495                return i;1496            }1497        }1498    }1499    else if (isFunction(expectedTypes)) {1500        return isSameType(expectedTypes, type) ? 0 : -1;1501    }1502    return -1;1503}1504/**1505 * dev only1506 */1507function validateProps(props, instance) {1508    const rawValues = toRaw(props);1509    const options = instance.propsOptions[0];1510    for (const key in options) {1511        let opt = options[key];1512        if (opt == null)1513            continue;1514        validateProp(key, rawValues[key], opt, !hasOwn(rawValues, key));1515    }1516}1517/**1518 * dev only1519 */1520function validatePropName(key) {1521    if (key[0] !== '$') {1522        return true;1523    }1524    else if ((process.env.NODE_ENV !== 'production')) {1525        warn(`Invalid prop name: "${key}" is a reserved property.`);1526    }1527    return false;1528}1529/**1530 * dev only1531 */1532function validateProp(name, value, prop, isAbsent) {1533    const { type, required, validator } = prop;1534    // required!1535    if (required && isAbsent) {1536        warn('Missing required prop: "' + name + '"');1537        return;1538    }1539    // missing but optional1540    if (value == null && !prop.required) {1541        return;1542    }1543    // type check1544    if (type != null && type !== true) {1545        let isValid = false;1546        const types = isArray(type) ? type : [type];1547        const expectedTypes = [];1548        // value is valid as long as one of the specified types match1549        for (let i = 0; i < types.length && !isValid; i++) {1550            const { valid, expectedType } = assertType(value, types[i]);1551            expectedTypes.push(expectedType || '');1552            isValid = valid;1553        }1554        if (!isValid) {1555            warn(getInvalidTypeMessage(name, value, expectedTypes));1556            return;1557        }1558    }1559    // custom validator1560    if (validator && !validator(value)) {1561        warn('Invalid prop: custom validator check failed for prop "' + name + '".');1562    }1563}1564const isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol');1565/**1566 * dev only1567 */1568function assertType(value, type) {1569    let valid;1570    const expectedType = getType(type);1571    if (isSimpleType(expectedType)) {1572        const t = typeof value;1573        valid = t === expectedType.toLowerCase();1574        // for primitive wrapper objects1575        if (!valid && t === 'object') {1576            valid = value instanceof type;1577        }1578    }1579    else if (expectedType === 'Object') {1580        valid = isObject(value);1581    }1582    else if (expectedType === 'Array') {1583        valid = isArray(value);1584    }1585    else {1586        valid = value instanceof type;1587    }1588    return {1589        valid,1590        expectedType1591    };1592}1593/**1594 * dev only1595 */1596function getInvalidTypeMessage(name, value, expectedTypes) {1597    let message = `Invalid prop: type check failed for prop "${name}".` +1598        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;1599    const expectedType = expectedTypes[0];1600    const receivedType = toRawType(value);1601    const expectedValue = styleValue(value, expectedType);1602    const receivedValue = styleValue(value, receivedType);1603    // check if we need to specify expected value1604    if (expectedTypes.length === 1 &&1605        isExplicable(expectedType) &&1606        !isBoolean(expectedType, receivedType)) {1607        message += ` with value ${expectedValue}`;1608    }1609    message += `, got ${receivedType} `;1610    // check if we need to specify received value1611    if (isExplicable(receivedType)) {1612        message += `with value ${receivedValue}.`;1613    }1614    return message;1615}1616/**1617 * dev only1618 */1619function styleValue(value, type) {1620    if (type === 'String') {1621        return `"${value}"`;1622    }1623    else if (type === 'Number') {1624        return `${Number(value)}`;1625    }1626    else {1627        return `${value}`;1628    }1629}1630/**1631 * dev only1632 */1633function isExplicable(type) {1634    const explicitTypes = ['string', 'number', 'boolean'];1635    return explicitTypes.some(elem => type.toLowerCase() === elem);1636}1637/**1638 * dev only1639 */1640function isBoolean(...args) {1641    return args.some(elem => elem.toLowerCase() === 'boolean');1642}1643function injectHook(type, hook, target = currentInstance, prepend = false) {1644    if (target) {1645        const hooks = target[type] || (target[type] = []);1646        // cache the error handling wrapper for injected hooks so the same hook1647        // can be properly deduped by the scheduler. "__weh" stands for "with error1648        // handling".1649        const wrappedHook = hook.__weh ||1650            (hook.__weh = (...args) => {1651                if (target.isUnmounted) {1652                    return;1653                }1654                // disable tracking inside all lifecycle hooks1655                // since they can potentially be called inside effects.1656                pauseTracking();1657                // Set currentInstance during hook invocation.1658                // This assumes the hook does not synchronously trigger other hooks, which1659                // can only be false when the user does something really funky.1660                setCurrentInstance(target);1661                const res = callWithAsyncErrorHandling(hook, target, type, args);1662                setCurrentInstance(null);1663                resetTracking();1664                return res;1665            });1666        if (prepend) {1667            hooks.unshift(wrappedHook);1668        }1669        else {1670            hooks.push(wrappedHook);1671        }1672        return wrappedHook;1673    }1674    else if ((process.env.NODE_ENV !== 'production')) {1675        const apiName = `on${capitalize(ErrorTypeStrings[type].replace(/ hook$/, ''))}`;1676        warn(`${apiName} is called when there is no active component instance to be ` +1677            `associated with. ` +1678            `Lifecycle injection APIs can only be used during execution of setup().` +1679            ( ``));1680    }1681}1682const createHook = (lifecycle) => (hook, target = currentInstance) => 1683// post-create lifecycle registrations are noops during SSR1684!isInSSRComponentSetup && injectHook(lifecycle, hook, target);1685const onBeforeMount = createHook("bm" /* BEFORE_MOUNT */);1686const onMounted = createHook("m" /* MOUNTED */);1687const onBeforeUpdate = createHook("bu" /* BEFORE_UPDATE */);1688const onUpdated = createHook("u" /* UPDATED */);1689const onBeforeUnmount = createHook("bum" /* BEFORE_UNMOUNT */);1690const onUnmounted = createHook("um" /* UNMOUNTED */);1691const onRenderTriggered = createHook("rtg" /* RENDER_TRIGGERED */);1692const onRenderTracked = createHook("rtc" /* RENDER_TRACKED */);1693const onErrorCaptured = (hook, target = currentInstance) => {1694    injectHook("ec" /* ERROR_CAPTURED */, hook, target);1695};1696const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;1697function onActivated(hook, target) {1698    registerKeepAliveHook(hook, "a" /* ACTIVATED */, target);1699}1700function onDeactivated(hook, target) {1701    registerKeepAliveHook(hook, "da" /* DEACTIVATED */, target);1702}1703function registerKeepAliveHook(hook, type, target = currentInstance) {1704    // cache the deactivate branch check wrapper for injected hooks so the same1705    // hook can be properly deduped by the scheduler. "__wdc" stands for "with1706    // deactivation check".1707    const wrappedHook = hook.__wdc ||1708        (hook.__wdc = () => {1709            // only fire the hook if the target instance is NOT in a deactivated branch.1710            let current = target;1711            while (current) {1712                if (current.isDeactivated) {1713                    return;1714                }1715                current = current.parent;1716            }1717            hook();1718        });1719    injectHook(type, wrappedHook, target);1720    // In addition to registering it on the target instance, we walk up the parent1721    // chain and register it on all ancestor instances that are keep-alive roots.1722    // This avoids the need to walk the entire component tree when invoking these1723    // hooks, and more importantly, avoids the need to track child components in1724    // arrays.1725    if (target) {1726        let current = target.parent;1727        while (current && current.parent) {1728            if (isKeepAlive(current.parent.vnode)) {1729                injectToKeepAliveRoot(wrappedHook, type, target, current);1730            }1731            current = current.parent;1732        }1733    }1734}1735function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {1736    // injectHook wraps the original for error handling, so make sure to remove1737    // the wrapped version.1738    const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */);1739    onUnmounted(() => {1740        remove(keepAliveRoot[type], injected);1741    }, target);1742}1743/**1744Runtime helper for applying directives to a vnode. Example usage:1745const comp = resolveComponent('comp')1746const foo = resolveDirective('foo')1747const bar = resolveDirective('bar')1748return withDirectives(h(comp), [1749  [foo, this.x],1750  [bar, this.y]1751])1752*/1753const isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text');1754function validateDirectiveName(name) {1755    if (isBuiltInDirective(name)) {1756        warn('Do not use built-in directive ids as custom directive id: ' + name);1757    }1758}1759function createAppContext() {1760    return {1761        app: null,1762        config: {1763            isNativeTag: NO,1764            performance: false,1765            globalProperties: {},1766            optionMergeStrategies: {},1767            isCustomElement: NO,1768            errorHandler: undefined,1769            warnHandler: undefined1770        },1771        mixins: [],1772        components: {},1773        directives: {},1774        provides: Object.create(null)1775    };1776}1777let uid$1 = 0;1778// fixed by xxxxxx1779function createAppAPI() {1780    return function createApp(rootComponent, rootProps = null) {1781        if (rootProps != null && !isObject(rootProps)) {1782            (process.env.NODE_ENV !== 'production') && warn(`root props passed to app.mount() must be an object.`);1783            rootProps = null;1784        }1785        const context = createAppContext();1786        const installedPlugins = new Set();1787        // fixed by xxxxxx1788        // let isMounted = false1789        const app = (context.app = {1790            _uid: uid$1++,1791            _component: rootComponent,1792            _props: rootProps,1793            _container: null,1794            _context: context,1795            version,1796            get config() {1797                return context.config;1798            },1799            set config(v) {1800                if ((process.env.NODE_ENV !== 'production')) {1801                    warn(`app.config cannot be replaced. Modify individual options instead.`);1802                }1803            },1804            use(plugin, ...options) {1805                if (installedPlugins.has(plugin)) {1806                    (process.env.NODE_ENV !== 'production') && warn(`Plugin has already been applied to target app.`);1807                }1808                else if (plugin && isFunction(plugin.install)) {1809                    installedPlugins.add(plugin);1810                    plugin.install(app, ...options);1811                }1812                else if (isFunction(plugin)) {1813                    installedPlugins.add(plugin);1814                    plugin(app, ...options);1815                }1816                else if ((process.env.NODE_ENV !== 'production')) {1817                    warn(`A plugin must either be a function or an object with an "install" ` +1818                        `function.`);1819                }1820                return app;1821            },1822            mixin(mixin) {1823                if (__VUE_OPTIONS_API__) {1824                    if (!context.mixins.includes(mixin)) {1825                        context.mixins.push(mixin);1826                    }1827                    else if ((process.env.NODE_ENV !== 'production')) {1828                        warn('Mixin has already been applied to target app' +1829                            (mixin.name ? `: ${mixin.name}` : ''));1830                    }1831                }1832                else if ((process.env.NODE_ENV !== 'production')) {1833                    warn('Mixins are only available in builds supporting Options API');1834                }1835                return app;1836            },1837            component(name, component) {1838                if ((process.env.NODE_ENV !== 'production')) {1839                    validateComponentName(name, context.config);1840                }1841                if (!component) {1842                    return context.components[name];1843                }1844                if ((process.env.NODE_ENV !== 'production') && context.components[name]) {1845                    warn(`Component "${name}" has already been registered in target app.`);1846                }1847                context.components[name] = component;1848                return app;1849            },1850            directive(name, directive) {1851                if ((process.env.NODE_ENV !== 'production')) {1852                    validateDirectiveName(name);1853                }1854                if (!directive) {1855                    return context.directives[name];1856                }1857                if ((process.env.NODE_ENV !== 'production') && context.directives[name]) {1858                    warn(`Directive "${name}" has already been registered in target app.`);1859                }1860                context.directives[name] = directive;1861                return app;1862            },1863            // fixed by xxxxxx1864            mount() { },1865            // fixed by xxxxxx1866            unmount() { },1867            provide(key, value) {1868                if ((process.env.NODE_ENV !== 'production') && key in context.provides) {1869                    warn(`App already provides property with key "${String(key)}". ` +1870                        `It will be overwritten with the new value.`);1871                }1872                // TypeScript doesn't allow symbols as index type1873                // https://github.com/Microsoft/TypeScript/issues/245871874                context.provides[key] = value;1875                return app;1876            }1877        });1878        return app;1879    };1880}1881const queuePostRenderEffect =  queuePostFlushCb;1882// Simple effect.1883function watchEffect(effect, options) {1884    return doWatch(effect, null, options);1885}1886// initial value for watchers to trigger on undefined initial values1887const INITIAL_WATCHER_VALUE = {};1888// implementation1889function watch(source, cb, options) {1890    if ((process.env.NODE_ENV !== 'production') && !isFunction(cb)) {1891        warn(`\`watch(fn, options?)\` signature has been moved to a separate API. ` +1892            `Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` +1893            `supports \`watch(source, cb, options?) signature.`);1894    }1895    return doWatch(source, cb, options);1896}1897function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {1898    if ((process.env.NODE_ENV !== 'production') && !cb) {1899        if (immediate !== undefined) {1900            warn(`watch() "immediate" option is only respected when using the ` +1901                `watch(source, callback, options?) signature.`);1902        }1903        if (deep !== undefined) {1904            warn(`watch() "deep" option is only respected when using the ` +1905                `watch(source, callback, options?) signature.`);1906        }1907    }1908    const warnInvalidSource = (s) => {1909        warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +1910            `a reactive object, or an array of these types.`);1911    };1912    let getter;1913    const isRefSource = isRef(source);1914    if (isRefSource) {1915        getter = () => source.value;1916    }1917    else if (isReactive(source)) {1918        getter = () => source;1919        deep = true;1920    }1921    else if (isArray(source)) {1922        getter = () => source.map(s => {1923            if (isRef(s)) {1924                return s.value;1925            }1926            else if (isReactive(s)) {1927                return traverse(s);1928            }1929            else if (isFunction(s)) {1930                return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);1931            }1932            else {1933                (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);1934            }1935        });1936    }1937    else if (isFunction(source)) {1938        if (cb) {1939            // getter with cb1940            getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);1941        }1942        else {1943            // no cb -> simple effect1944            getter = () => {1945                if (instance && instance.isUnmounted) {1946                    return;1947                }1948                if (cleanup) {1949                    cleanup();1950                }1951                return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);1952            };1953        }1954    }1955    else {1956        getter = NOOP;1957        (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);1958    }1959    if (cb && deep) {1960        const baseGetter = getter;1961        getter = () => traverse(baseGetter());1962    }1963    let cleanup;1964    const onInvalidate = (fn) => {1965        cleanup = runner.options.onStop = () => {1966            callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);1967        };1968    };1969    let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;1970    const job = () => {1971        if (!runner.active) {1972            return;1973        }1974        if (cb) {1975            // watch(source, cb)1976            const newValue = runner();1977            if (deep || isRefSource || hasChanged(newValue, oldValue)) {1978                // cleanup before running cb again1979                if (cleanup) {1980                    cleanup();1981                }1982                callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [1983                    newValue,1984                    // pass undefined as the old value when it's changed for the first time1985                    oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,1986                    onInvalidate1987                ]);1988                oldValue = newValue;1989            }1990        }1991        else {1992            // watchEffect1993            runner();1994        }1995    };1996    // important: mark the job as a watcher callback so that scheduler knows it1997    // it is allowed to self-trigger (#1727)1998    job.allowRecurse = !!cb;1999    let scheduler;2000    if (flush === 'sync') {2001        scheduler = job;2002    }2003    else if (flush === 'post') {2004        scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);2005    }2006    else {2007        // default: 'pre'2008        scheduler = () => {2009            if (!instance || instance.isMounted) {2010                queuePreFlushCb(job);2011            }2012            else {2013                // with 'pre' option, the first call must happen before2014                // the component is mounted so it is called synchronously.2015                job();2016            }2017        };2018    }2019    const runner = effect(getter, {2020        lazy: true,2021        onTrack,2022        onTrigger,2023        scheduler2024    });2025    recordInstanceBoundEffect(runner);2026    // initial run2027    if (cb) {2028        if (immediate) {2029            job();2030        }2031        else {2032            oldValue = runner();2033        }2034    }2035    else if (flush === 'post') {2036        queuePostRenderEffect(runner, instance && instance.suspense);2037    }2038    else {2039        runner();2040    }2041    return () => {2042        stop(runner);2043        if (instance) {2044            remove(instance.effects, runner);2045        }2046    };2047}2048// this.$watch2049function instanceWatch(source, cb, options) {2050    const publicThis = this.proxy;2051    const getter = isString(source)2052        ? () => publicThis[source]2053        : source.bind(publicThis);2054    return doWatch(getter, cb.bind(publicThis), options, this);2055}2056function traverse(value, seen = new Set()) {2057    if (!isObject(value) || seen.has(value)) {2058        return value;2059    }2060    seen.add(value);2061    if (isRef(value)) {2062        traverse(value.value, seen);2063    }2064    else if (isArray(value)) {2065        for (let i = 0; i < value.length; i++) {2066            traverse(value[i], seen);2067        }2068    }2069    else if (isMap(value)) {2070        value.forEach((_, key) => {2071            // to register mutation dep for existing keys2072            traverse(value.get(key), seen);2073        });2074    }2075    else if (isSet(value)) {2076        value.forEach(v => {2077            traverse(v, seen);2078        });2079    }2080    else {2081        for (const key in value) {2082            traverse(value[key], seen);2083        }2084    }2085    return value;2086}2087function provide(key, value) {2088    if (!currentInstance) {2089        if ((process.env.NODE_ENV !== 'production')) {2090            warn(`provide() can only be used inside setup().`);2091        }2092    }2093    else {2094        let provides = currentInstance.provides;2095        // by default an instance inherits its parent's provides object2096        // but when it needs to provide values of its own, it creates its2097        // own provides object using parent provides object as prototype.2098        // this way in `inject` we can simply look up injections from direct2099        // parent and let the prototype chain do the work.2100        const parentProvides = currentInstance.parent && currentInstance.parent.provides;2101        if (parentProvides === provides) {2102            provides = currentInstance.provides = Object.create(parentProvides);2103        }2104        // TS doesn't allow symbol as index type2105        provides[key] = value;2106    }2107}2108function inject(key, defaultValue, treatDefaultAsFactory = false) {2109    // fallback to `currentRenderingInstance` so that this can be called in2110    // a functional component2111    const instance = currentInstance || currentRenderingInstance;2112    if (instance) {2113        const provides = instance.provides;2114        if (key in provides) {2115            // TS doesn't allow symbol as index type2116            return provides[key];2117        }2118        else if (arguments.length > 1) {2119            return treatDefaultAsFactory && isFunction(defaultValue)2120                ? defaultValue()2121                : defaultValue;2122        }2123        else if ((process.env.NODE_ENV !== 'production')) {2124            warn(`injection "${String(key)}" not found.`);2125        }2126    }2127    else if ((process.env.NODE_ENV !== 'production')) {2128        warn(`inject() can only be used inside setup() or functional components.`);2129    }2130}2131function createDuplicateChecker() {2132    const cache = Object.create(null);2133    return (type, key) => {2134        if (cache[key]) {2135            warn(`${type} property "${key}" is already defined in ${cache[key]}.`);2136        }2137        else {2138            cache[key] = type;2139        }2140    };2141}2142let isInBeforeCreate = false;2143function applyOptions(instance, options, deferredData = [], deferredWatch = [], asMixin = false) {2144    const { 2145    // composition2146    mixins, extends: extendsOptions, 2147    // state2148    data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, 2149    // assets2150    components, directives, 2151    // lifecycle2152    beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeDestroy, beforeUnmount, destroyed, unmounted, render, renderTracked, renderTriggered, errorCaptured } = options;2153    const publicThis = instance.proxy;2154    const ctx = instance.ctx;2155    const globalMixins = instance.appContext.mixins;2156    if (asMixin && render && instance.render === NOOP) {2157        instance.render = render;2158    }2159    // applyOptions is called non-as-mixin once per instance2160    if (!asMixin) {2161        isInBeforeCreate = true;2162        callSyncHook('beforeCreate', options, publicThis, globalMixins);2163        isInBeforeCreate = false;2164        // global mixins are applied first2165        applyMixins(instance, globalMixins, deferredData, deferredWatch);2166    }2167    // extending a base component...2168    if (extendsOptions) {2169        applyOptions(instance, extendsOptions, deferredData, deferredWatch, true);2170    }2171    // local mixins2172    if (mixins) {2173        applyMixins(instance, mixins, deferredData, deferredWatch);2174    }2175    const checkDuplicateProperties = (process.env.NODE_ENV !== 'production') ? createDuplicateChecker() : null;2176    if ((process.env.NODE_ENV !== 'production')) {2177        const [propsOptions] = instance.propsOptions;2178        if (propsOptions) {2179            for (const key in propsOptions) {2180                checkDuplicateProperties("Props" /* PROPS */, key);2181            }2182        }2183    }2184    // options initialization order (to be consistent with Vue 2):2185    // - props (already done outside of this function)2186    // - inject2187    // - methods2188    // - data (deferred since it relies on `this` access)2189    // - computed2190    // - watch (deferred since it relies on `this` access)2191    // fixed by xxxxxx2192    if (!__VUE_CREATED_DEFERRED__ && injectOptions) {2193        if (isArray(injectOptions)) {2194            for (let i = 0; i < injectOptions.length; i++) {2195                const key = injectOptions[i];2196                ctx[key] = inject(key);2197                if ((process.env.NODE_ENV !== 'production')) {2198                    checkDuplicateProperties("Inject" /* INJECT */, key);2199                }2200            }2201        }2202        else {2203            for (const key in injectOptions) {2204                const opt = injectOptions[key];2205                if (isObject(opt)) {2206                    ctx[key] = inject(opt.from || key, opt.default, true /* treat default function as factory */);2207                }2208                else {2209                    ctx[key] = inject(opt);2210                }2211                if ((process.env.NODE_ENV !== 'production')) {2212                    checkDuplicateProperties("Inject" /* INJECT */, key);2213                }2214            }2215        }2216    }2217    if (methods) {2218        for (const key in methods) {2219            const methodHandler = methods[key];2220            if (isFunction(methodHandler)) {2221                ctx[key] = methodHandler.bind(publicThis);2222                if ((process.env.NODE_ENV !== 'production')) {2223                    checkDuplicateProperties("Methods" /* METHODS */, key);2224                }2225            }2226            else if ((process.env.NODE_ENV !== 'production')) {2227                warn(`Method "${key}" has type "${typeof methodHandler}" in the component definition. ` +2228                    `Did you reference the function correctly?`);2229            }2230        }2231    }2232    if (!asMixin) {2233        if (deferredData.length) {2234            deferredData.forEach(dataFn => resolveData(instance, dataFn, publicThis));2235        }2236        if (dataOptions) {2237            resolveData(instance, dataOptions, publicThis);2238        }2239        if ((process.env.NODE_ENV !== 'production')) {2240            const rawData = toRaw(instance.data);2241            for (const key in rawData) {2242                checkDuplicateProperties("Data" /* DATA */, key);2243                // expose data on ctx during dev2244                if (key[0] !== '$' && key[0] !== '_') {2245                    Object.defineProperty(ctx, key, {2246                        configurable: true,2247                        enumerable: true,2248                        get: () => rawData[key],2249                        set: NOOP2250                    });2251                }2252            }2253        }2254    }2255    else if (dataOptions) {2256        deferredData.push(dataOptions);2257    }2258    if (computedOptions) {2259        for (const key in computedOptions) {2260            const opt = computedOptions[key];2261            const get = isFunction(opt)2262                ? opt.bind(publicThis, publicThis)2263                : isFunction(opt.get)2264                    ? opt.get.bind(publicThis, publicThis)2265                    : NOOP;2266            if ((process.env.NODE_ENV !== 'production') && get === NOOP) {2267                warn(`Computed property "${key}" has no getter.`);2268            }2269            const set = !isFunction(opt) && isFunction(opt.set)2270                ? opt.set.bind(publicThis)2271                : (process.env.NODE_ENV !== 'production')2272                    ? () => {2273                        warn(`Write operation failed: computed property "${key}" is readonly.`);2274                    }2275                    : NOOP;2276            const c = computed$1({2277                get,2278                set2279            });2280            Object.defineProperty(ctx, key, {2281                enumerable: true,2282                configurable: true,2283                get: () => c.value,2284                set: v => (c.value = v)2285            });2286            if ((process.env.NODE_ENV !== 'production')) {2287                checkDuplicateProperties("Computed" /* COMPUTED */, key);2288            }2289        }2290    }2291    if (watchOptions) {2292        deferredWatch.push(watchOptions);2293    }2294    if (!asMixin && deferredWatch.length) {2295        deferredWatch.forEach(watchOptions => {2296            for (const key in watchOptions) {2297                createWatcher(watchOptions[key], ctx, publicThis, key);2298            }2299        });2300    }2301    // fixed by xxxxxx2302    if (!__VUE_CREATED_DEFERRED__ && provideOptions) {2303        const provides = isFunction(provideOptions)2304            ? provideOptions.call(publicThis)2305            : provideOptions;2306        for (const key in provides) {2307            provide(key, provides[key]);2308        }2309    }2310    // asset options.2311    // To reduce memory usage, only components with mixins or extends will have2312    // resolved asset registry attached to instance.2313    if (asMixin) {2314        if (components) {2315            extend(instance.components ||2316                (instance.components = extend({}, instance.type.components)), components);2317        }2318        if (directives) {2319            extend(instance.directives ||2320                (instance.directives = extend({}, instance.type.directives)), directives);2321        }2322    }2323    // fixed by xxxxxx2324    // lifecycle options2325    if (__VUE_CREATED_DEFERRED__) {2326        ctx.$callSyncHook = function (name) {2327            return callSyncHook(name, options, publicThis, globalMixins);2328        };2329    }2330    else if (!asMixin) {2331        callSyncHook('created', options, publicThis, globalMixins);2332    }2333    if (beforeMount) {2334        onBeforeMount(beforeMount.bind(publicThis));2335    }2336    if (mounted) {2337        onMounted(mounted.bind(publicThis));2338    }2339    if (beforeUpdate) {2340        onBeforeUpdate(beforeUpdate.bind(publicThis));2341    }2342    if (updated) {2343        onUpdated(updated.bind(publicThis));2344    }2345    if (activated) {2346        onActivated(activated.bind(publicThis));2347    }2348    if (deactivated) {2349        onDeactivated(deactivated.bind(publicThis));2350    }2351    if (errorCaptured) {2352        onErrorCaptured(errorCaptured.bind(publicThis));2353    }2354    if (renderTracked) {2355        onRenderTracked(renderTracked.bind(publicThis));2356    }2357    if (renderTriggered) {2358        onRenderTriggered(renderTriggered.bind(publicThis));2359    }2360    if ((process.env.NODE_ENV !== 'production') && beforeDestroy) {2361        warn(`\`beforeDestroy\` has been renamed to \`beforeUnmount\`.`);2362    }2363    if (beforeUnmount) {2364        onBeforeUnmount(beforeUnmount.bind(publicThis));2365    }2366    if ((process.env.NODE_ENV !== 'production') && destroyed) {2367        warn(`\`destroyed\` has been renamed to \`unmounted\`.`);2368    }2369    if (unmounted) {2370        onUnmounted(unmounted.bind(publicThis));2371    }2372    // fixed by xxxxxx2373    if (instance.ctx.$onApplyOptions) {2374        instance.ctx.$onApplyOptions(options, instance, publicThis);2375    }2376}2377function callSyncHook(name, options, ctx, globalMixins) {2378    callHookFromMixins(name, globalMixins, ctx);2379    const { extends: base, mixins } = options;2380    if (base) {2381        callHookFromExtends(name, base, ctx);2382    }2383    if (mixins) {2384        callHookFromMixins(name, mixins, ctx);2385    }2386    const selfHook = options[name];2387    if (selfHook) {2388        selfHook.call(ctx);2389    }2390}2391function callHookFromExtends(name, base, ctx) {2392    if (base.extends) {2393        callHookFromExtends(name, base.extends, ctx);2394    }2395    const baseHook = base[name];2396    if (baseHook) {2397        baseHook.call(ctx);2398    }2399}2400function callHookFromMixins(name, mixins, ctx) {2401    for (let i = 0; i < mixins.length; i++) {2402        const chainedMixins = mixins[i].mixins;2403        if (chainedMixins) {2404            callHookFromMixins(name, chainedMixins, ctx);2405        }2406        const fn = mixins[i][name];2407        if (fn) {2408            fn.call(ctx);2409        }2410    }2411}2412function applyMixins(instance, mixins, deferredData, deferredWatch) {2413    for (let i = 0; i < mixins.length; i++) {2414        applyOptions(instance, mixins[i], deferredData, deferredWatch, true);2415    }2416}2417function resolveData(instance, dataFn, publicThis) {2418    if ((process.env.NODE_ENV !== 'production') && !isFunction(dataFn)) {2419        warn(`The data option must be a function. ` +2420            `Plain object usage is no longer supported.`);2421    }2422    const data = dataFn.call(publicThis, publicThis);2423    if ((process.env.NODE_ENV !== 'production') && isPromise(data)) {2424        warn(`data() returned a Promise - note data() cannot be async; If you ` +2425            `intend to perform data fetching before component renders, use ` +2426            `async setup() + <Suspense>.`);2427    }2428    if (!isObject(data)) {2429        (process.env.NODE_ENV !== 'production') && warn(`data() should return an object.`);2430    }2431    else if (instance.data === EMPTY_OBJ) {2432        instance.data = reactive(data);2433    }2434    else {2435        // existing data: this is a mixin or extends.2436        extend(instance.data, data);2437    }2438}2439function createWatcher(raw, ctx, publicThis, key) {2440    const getter = key.includes('.')2441        ? createPathGetter(publicThis, key)2442        : () => publicThis[key];2443    if (isString(raw)) {2444        const handler = ctx[raw];2445        if (isFunction(handler)) {2446            watch(getter, handler);2447        }2448        else if ((process.env.NODE_ENV !== 'production')) {2449            warn(`Invalid watch handler specified by key "${raw}"`, handler);2450        }2451    }2452    else if (isFunction(raw)) {2453        watch(getter, raw.bind(publicThis));2454    }2455    else if (isObject(raw)) {2456        if (isArray(raw)) {2457            raw.forEach(r => createWatcher(r, ctx, publicThis, key));2458        }2459        else {2460            const handler = isFunction(raw.handler)2461                ? raw.handler.bind(publicThis)2462                : ctx[raw.handler];2463            if (isFunction(handler)) {2464                watch(getter, handler, raw);2465            }2466            else if ((process.env.NODE_ENV !== 'production')) {2467                warn(`Invalid watch handler specified by key "${raw.handler}"`, handler);2468            }2469        }2470    }2471    else if ((process.env.NODE_ENV !== 'production')) {2472        warn(`Invalid watch option: "${key}"`, raw);2473    }2474}2475function createPathGetter(ctx, path) {2476    const segments = path.split('.');2477    return () => {2478        let cur = ctx;2479        for (let i = 0; i < segments.length && cur; i++) {2480            cur = cur[segments[i]];2481        }2482        return cur;2483    };2484}2485function resolveMergedOptions(instance) {2486    const raw = instance.type;2487    const { __merged, mixins, extends: extendsOptions } = raw;2488    if (__merged)2489        return __merged;2490    const globalMixins = instance.appContext.mixins;2491    if (!globalMixins.length && !mixins && !extendsOptions)2492        return raw;2493    const options = {};2494    globalMixins.forEach(m => mergeOptions(options, m, instance));2495    mergeOptions(options, raw, instance);2496    return (raw.__merged = options);2497}2498function mergeOptions(to, from, instance) {2499    const strats = instance.appContext.config.optionMergeStrategies;2500    const { mixins, extends: extendsOptions } = from;2501    extendsOptions && mergeOptions(to, extendsOptions, instance);2502    mixins &&2503        mixins.forEach((m) => mergeOptions(to, m, instance));2504    for (const key in from) {2505        if (strats && hasOwn(strats, key)) {2506            to[key] = strats[key](to[key], from[key], instance.proxy, key);2507        }2508        else {2509            to[key] = from[key];2510        }2511    }2512}2513const publicPropertiesMap = extend(Object.create(null), {2514    $: i => i,2515    $el: i => i.vnode.el,2516    $data: i => i.data,2517    $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),2518    $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),2519    $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),2520    $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),2521    $parent: i => i.parent && i.parent.proxy,2522    $root: i => i.root && i.root.proxy,2523    $emit: i => i.emit,2524    $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),2525    $forceUpdate: i => () => queueJob(i.update),2526    // $nextTick: () => nextTick, // fixed by xxxxxx2527    $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)2528});2529const PublicInstanceProxyHandlers = {2530    get({ _: instance }, key) {2531        const { ctx, setupState, data, props, accessCache, type, appContext } = instance;2532        // let @vue/reactivity know it should never observe Vue public instances.2533        if (key === "__v_skip" /* SKIP */) {2534            return true;2535        }2536        // data / props / ctx2537        // This getter gets called for every property access on the render context2538        // during render and is a major hotspot. The most expensive part of this2539        // is the multiple hasOwn() calls. It's much faster to do a simple property2540        // access on a plain object, so we use an accessCache object (with null2541        // prototype) to memoize what access type a key corresponds to.2542        let normalizedProps;2543        if (key[0] !== '$') {2544            const n = accessCache[key];2545            if (n !== undefined) {2546                switch (n) {2547                    case 0 /* SETUP */:2548                        return setupState[key];2549                    case 1 /* DATA */:2550                        return data[key];2551                    case 3 /* CONTEXT */:2552                        return ctx[key];2553                    case 2 /* PROPS */:2554                        return props[key];2555                    // default: just fallthrough2556                }2557            }2558            else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {2559                accessCache[key] = 0 /* SETUP */;2560                return setupState[key];2561            }2562            else if (data !== EMPTY_OBJ && hasOwn(data, key)) {2563                accessCache[key] = 1 /* DATA */;2564                return data[key];2565            }2566            else if (2567            // only cache other properties when instance has declared (thus stable)2568            // props2569            (normalizedProps = instance.propsOptions[0]) &&2570                hasOwn(normalizedProps, key)) {2571                accessCache[key] = 2 /* PROPS */;2572                return props[key];2573            }2574            else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {2575                accessCache[key] = 3 /* CONTEXT */;2576                return ctx[key];2577            }2578            else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {2579                accessCache[key] = 4 /* OTHER */;2580            }2581        }2582        const publicGetter = publicPropertiesMap[key];2583        let cssModule, globalProperties;2584        // public $xxx properties2585        if (publicGetter) {2586            if (key === '$attrs') {2587                track(instance, "get" /* GET */, key);2588                (process.env.NODE_ENV !== 'production') && markAttrsAccessed();2589            }2590            return publicGetter(instance);2591        }2592        else if (2593        // css module (injected by vue-loader)2594        (cssModule = type.__cssModules) &&2595            (cssModule = cssModule[key])) {2596            return cssModule;2597        }2598        else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {2599            // user may set custom properties to `this` that start with `$`2600            accessCache[key] = 3 /* CONTEXT */;2601            return ctx[key];2602        }2603        else if (2604        // global properties2605        ((globalProperties = appContext.config.globalProperties),2606            hasOwn(globalProperties, key))) {2607            return globalProperties[key];2608        }2609        else if ((process.env.NODE_ENV !== 'production') &&2610            currentRenderingInstance &&2611            (!isString(key) ||2612                // #1091 avoid internal isRef/isVNode checks on component instance leading2613                // to infinite warning loop2614                key.indexOf('__v') !== 0)) {2615            if (data !== EMPTY_OBJ &&2616                (key[0] === '$' || key[0] === '_') &&2617                hasOwn(data, key)) {2618                warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +2619                    `character ("$" or "_") and is not proxied on the render context.`);2620            }2621            else {2622                warn(`Property ${JSON.stringify(key)} was accessed during render ` +2623                    `but is not defined on instance.`);2624            }2625        }2626    },2627    set({ _: instance }, key, value) {2628        const { data, setupState, ctx } = instance;2629        if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {2630            setupState[key] = value;2631        }2632        else if (data !== EMPTY_OBJ && hasOwn(data, key)) {2633            data[key] = value;2634        }2635        else if (key in instance.props) {2636            (process.env.NODE_ENV !== 'production') &&2637                warn(`Attempting to mutate prop "${key}". Props are readonly.`, instance);2638            return false;2639        }2640        if (key[0] === '$' && key.slice(1) in instance) {2641            (process.env.NODE_ENV !== 'production') &&2642                warn(`Attempting to mutate public property "${key}". ` +2643                    `Properties starting with $ are reserved and readonly.`, instance);2644            return false;2645        }2646        else {2647            if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {2648                Object.defineProperty(ctx, key, {2649                    enumerable: true,2650                    configurable: true,2651                    value2652                });2653            }2654            else {2655                ctx[key] = value;2656            }2657        }2658        return true;2659    },2660    has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {2661        let normalizedProps;2662        return (accessCache[key] !== undefined ||2663            (data !== EMPTY_OBJ && hasOwn(data, key)) ||2664            (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||2665            ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||2666            hasOwn(ctx, key) ||2667            hasOwn(publicPropertiesMap, key) ||2668            hasOwn(appContext.config.globalProperties, key));2669    }2670};2671if ((process.env.NODE_ENV !== 'production') && !false) {2672    PublicInstanceProxyHandlers.ownKeys = (target) => {2673        warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +2674            `The keys will be empty in production mode to avoid performance overhead.`);2675        return Reflect.ownKeys(target);2676    };2677}2678const RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {2679    get(target, key) {2680        // fast path for unscopables when using `with` block2681        if (key === Symbol.unscopables) {2682            return;2683        }2684        return PublicInstanceProxyHandlers.get(target, key, target);2685    },2686    has(_, key) {2687        const has = key[0] !== '_' && !isGloballyWhitelisted(key);2688        if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {2689            warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);2690        }2691        return has;2692    }2693});2694// In dev mode, the proxy target exposes the same properties as seen on `this`2695// for easier console inspection. In prod mode it will be an empty object so2696// these properties definitions can be skipped.2697function createRenderContext(instance) {2698    const target = {};2699    // expose internal instance for proxy handlers2700    Object.defineProperty(target, `_`, {2701        configurable: true,2702        enumerable: false,2703        get: () => instance2704    });2705    // expose public properties2706    Object.keys(publicPropertiesMap).forEach(key => {2707        Object.defineProperty(target, key, {2708            configurable: true,2709            enumerable: false,2710            get: () => publicPropertiesMap[key](instance),2711            // intercepted by the proxy so no need for implementation,2712            // but needed to prevent set errors2713            set: NOOP2714        });2715    });2716    // expose global properties2717    const { globalProperties } = instance.appContext.config;2718    Object.keys(globalProperties).forEach(key => {2719        Object.defineProperty(target, key, {2720            configurable: true,2721            enumerable: false,2722            get: () => globalProperties[key],2723            set: NOOP2724        });2725    });2726    return target;2727}2728// dev only2729function exposePropsOnRenderContext(instance) {2730    const { ctx, propsOptions: [propsOptions] } = instance;2731    if (propsOptions) {2732        Object.keys(propsOptions).forEach(key => {2733            Object.defineProperty(ctx, key, {2734                enumerable: true,2735                configurable: true,2736                get: () => instance.props[key],2737                set: NOOP2738            });2739        });2740    }2741}2742// dev only2743function exposeSetupStateOnRenderContext(instance) {2744    const { ctx, setupState } = instance;2745    Object.keys(toRaw(setupState)).forEach(key => {2746        if (key[0] === '$' || key[0] === '_') {2747            warn(`setup() return property ${JSON.stringify(key)} should not start with "$" or "_" ` +2748                `which are reserved prefixes for Vue internals.`);2749            return;2750        }2751        Object.defineProperty(ctx, key, {2752            enumerable: true,2753            configurable: true,2754            get: () => setupState[key],2755            set: NOOP2756        });2757    });2758}2759const emptyAppContext = createAppContext();2760let uid$2 = 0;2761function createComponentInstance(vnode, parent, suspense) {2762    const type = vnode.type;2763    // inherit parent app context - or - if root, adopt from root vnode2764    const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;2765    const instance = {2766        uid: uid$2++,2767        vnode,2768        type,2769        parent,2770        appContext,2771        root: null,2772        next: null,2773        subTree: null,2774        update: null,2775        render: null,2776        proxy: null,2777        withProxy: null,2778        effects: null,2779        provides: parent ? parent.provides : Object.create(appContext.provides),2780        accessCache: null,2781        renderCache: [],2782        // local resovled assets2783        components: null,2784        directives: null,2785        // resolved props and emits options2786        propsOptions: normalizePropsOptions(type, appContext),2787        emitsOptions: normalizeEmitsOptions(type, appContext),2788        // emit2789        emit: null,2790        emitted: null,2791        // state2792        ctx: EMPTY_OBJ,2793        data: EMPTY_OBJ,2794        props: EMPTY_OBJ,2795        attrs: EMPTY_OBJ,2796        slots: EMPTY_OBJ,2797        refs: EMPTY_OBJ,2798        setupState: EMPTY_OBJ,2799        setupContext: null,2800        // suspense related2801        suspense,
...

jquery-3.6.0.min.js

Source:jquery-3.6.0.min.js

...541    } else e.emitted = {};542    e.emitted[i] = !0, callWithAsyncErrorHandling(c, e, 6, o)543  }544}545function normalizeEmitsOptions(e, t, n = !1) {546  const r = t.emitsCache, o = r.get(e);547  if (void 0 !== o) return o;548  const s = e.emits;549  let a = {}, i = !1;550  if (!isFunction(e)) {551    const extendEmits = e => {552      const n = normalizeEmitsOptions(e, t, !0);553      n && (i = !0, b(a, n))554    };555    !n && t.mixins.length && t.mixins.forEach(extendEmits), e.extends && extendEmits(e.extends), e.mixins && e.mixins.forEach(extendEmits)556  }557  return s || i ? (w(s) ? s.forEach((e => a[e] = null)) : b(a, s), r.set(e, a), a) : (r.set(e, null), null)558}559function isEmitListener(e, t) {560  return !(!e || !isOn(t)) && (t = t.slice(2).replace(/Once$/, ""), hasOwn(e, t[0].toLowerCase() + t.slice(1)) || hasOwn(e, C(t)) || hasOwn(e, t))561}562let be = null, Re = null;563function setCurrentRenderingInstance(e) {564  const t = be;565  return be = e, Re = e && e.type.__scopeId || null, t566}567function pushScopeId(e) {568  Re = e569}570function popScopeId() {571  Re = null572}573const withScopeId = e => withCtx;574function withCtx(e, t = be, n) {575  if (!t) return e;576  if (e._n) return e;577  const renderFnWithContext = (...n) => {578    renderFnWithContext._d && setBlockTracking(-1);579    const r = setCurrentRenderingInstance(t), o = e(...n);580    return setCurrentRenderingInstance(r), renderFnWithContext._d && setBlockTracking(1), o581  };582  return renderFnWithContext._n = !0, renderFnWithContext._c = !0, renderFnWithContext._d = !0, renderFnWithContext583}584function renderComponentRoot(e) {585  const {586    type: t,587    vnode: n,588    proxy: r,589    withProxy: o,590    props: s,591    propsOptions: [a],592    slots: i,593    attrs: l,594    emit: c,595    render: u,596    renderCache: f,597    data: p,598    setupState: d,599    ctx: m,600    inheritAttrs: g601  } = e;602  let v;603  const y = setCurrentRenderingInstance(e);604  try {605    let e;606    if (4 & n.shapeFlag) {607      const t = o || r;608      v = normalizeVNode(u.call(t, t, f, s, d, p, m)), e = l609    } else {610      const n = t;611      0, v = normalizeVNode(n.length > 1 ? n(s, {612        attrs: l,613        slots: i,614        emit: c615      }) : n(s, null)), e = t.props ? l : getFunctionalFallthrough(l)616    }617    let y = v;618    if (e && !1 !== g) {619      const t = Object.keys(e), {shapeFlag: n} = y;620      t.length && (1 & n || 6 & n) && (a && t.some(isModelListener) && (e = filterModelListeners(e, a)), y = cloneVNode(y, e))621    }622    0, n.dirs && (y.dirs = y.dirs ? y.dirs.concat(n.dirs) : n.dirs), n.transition && (y.transition = n.transition), v = y623  } catch (b) {624    ze.length = 0, handleError(b, e, 1), v = De(He)625  }626  return setCurrentRenderingInstance(y), v627}628const getFunctionalFallthrough = e => {629  let t;630  for (const n in e) ("class" === n || "style" === n || isOn(n)) && ((t || (t = {}))[n] = e[n]);631  return t632}, filterModelListeners = (e, t) => {633  const n = {};634  for (const r in e) isModelListener(r) && r.slice(9) in t || (n[r] = e[r]);635  return n636};637function hasPropsChanged(e, t, n) {638  const r = Object.keys(t);639  if (r.length !== Object.keys(e).length) return !0;640  for (let o = 0; o < r.length; o++) {641    const s = r[o];642    if (t[s] !== e[s] && !isEmitListener(n, s)) return !0643  }644  return !1645}646function provide(e, t) {647  if (Ye) {648    let n = Ye.provides;649    const r = Ye.parent && Ye.parent.provides;650    r === n && (n = Ye.provides = Object.create(r)), n[e] = t651  } else ;652}653function inject(e, t, n = !1) {654  const r = Ye || be;655  if (r) {656    const o = null == r.parent ? r.vnode.appContext && r.vnode.appContext.provides : r.parent.provides;657    if (o && e in o) return o[e];658    if (arguments.length > 1) return n && isFunction(t) ? t.call(r.proxy) : t659  }660}661const we = {};662function watch(e, t, n) {663  return doWatch(e, t, n)664}665function doWatch(e, t, {immediate: n, deep: r, flush: o, onTrack: s, onTrigger: a} = g, i = Ye) {666  let l, c, u = !1, f = !1;667  if (isRef(e) ? (l = () => e.value, u = !!e._shallow) : isReactive(e) ? (l = () => e, r = !0) : w(e) ? (f = !0, u = e.some(isReactive), l = () => e.map((e => isRef(e) ? e.value : isReactive(e) ? traverse(e) : isFunction(e) ? callWithErrorHandling(e, i, 2) : void 0))) : l = isFunction(e) ? t ? () => callWithErrorHandling(e, i, 2) : () => {668    if (!i || !i.isUnmounted) return c && c(), callWithAsyncErrorHandling(e, i, 3, [onInvalidate])669  } : NOOP, t && r) {670    const e = l;671    l = () => traverse(e())672  }673  let onInvalidate = e => {674    c = m.options.onStop = () => {675      callWithErrorHandling(e, i, 4)676    }677  }, p = f ? [] : we;678  const job = () => {679    if (m.active) if (t) {680      const e = m();681      (r || u || (f ? e.some(((e, t) => hasChanged(e, p[t]))) : hasChanged(e, p))) && (c && c(), callWithAsyncErrorHandling(t, i, 3, [e, p === we ? void 0 : p, onInvalidate]), p = e)682    } else m()683  };684  let d;685  job.allowRecurse = !!t, d = "sync" === o ? job : "post" === o ? () => Me(job, i && i.suspense) : () => {686    !i || i.isMounted ? function queuePreFlushCb(e) {687      queueCb(e, fe, ue, pe)688    }(job) : job()689  };690  const m = effect(l, {lazy: !0, onTrack: s, onTrigger: a, scheduler: d});691  return recordInstanceBoundEffect(m, i), t ? n ? job() : p = m() : "post" === o ? Me(m, i && i.suspense) : m(), () => {692    stop(m), i && remove(i.effects, m)693  }694}695function instanceWatch(e, t, n) {696  const r = this.proxy, o = isString$1(e) ? e.includes(".") ? createPathGetter(r, e) : () => r[e] : e.bind(r, r);697  let s;698  return isFunction(t) ? s = t : (s = t.handler, n = t), doWatch(o, s.bind(r), n, this)699}700function createPathGetter(e, t) {701  const n = t.split(".");702  return () => {703    let t = e;704    for (let e = 0; e < n.length && t; e++) t = t[n[e]];705    return t706  }707}708function traverse(e, t = new Set) {709  if (!isObject(e) || t.has(e) || e.__v_skip) return e;710  if (t.add(e), isRef(e)) traverse(e.value, t); else if (w(e)) for (let n = 0; n < e.length; n++) traverse(e[n], t); else if (isSet(e) || isMap(e)) e.forEach((e => {711    traverse(e, t)712  })); else if (isPlainObject(e)) for (const n in e) traverse(e[n], t);713  return e714}715function defineComponent(e) {716  return isFunction(e) ? {setup: e, name: e.name} : e717}718const isAsyncWrapper = e => !!e.type.__asyncLoader;719function defineAsyncComponent(e) {720  isFunction(e) && (e = {loader: e});721  const {722    loader: t,723    loadingComponent: n,724    errorComponent: r,725    delay: o = 200,726    timeout: s,727    suspensible: a = !0,728    onError: i729  } = e;730  let l, c = null, u = 0;731  const load = () => {732    let e;733    return c || (e = c = t().catch((e => {734      if (e = e instanceof Error ? e : new Error(String(e)), i) return new Promise(((t, n) => {735        i(e, (() => t((u++, c = null, load()))), (() => n(e)), u + 1)736      }));737      throw e738    })).then((t => e !== c && c ? c : (t && (t.__esModule || "Module" === t[Symbol.toStringTag]) && (t = t.default), l = t, t))))739  };740  return defineComponent({741    name: "AsyncComponentWrapper", __asyncLoader: load, get __asyncResolved() {742      return l743    }, setup() {744      const e = Ye;745      if (l) return () => createInnerComp(l, e);746      const onError = t => {747        c = null, handleError(t, e, 13, !r)748      };749      if (a && e.suspense) return load().then((t => () => createInnerComp(t, e))).catch((e => (onError(e), () => r ? De(r, {error: e}) : null)));750      const t = ref(!1), i = ref(), u = ref(!!o);751      return o && setTimeout((() => {752        u.value = !1753      }), o), null != s && setTimeout((() => {754        if (!t.value && !i.value) {755          const e = new Error(`Async component timed out after ${s}ms.`);756          onError(e), i.value = e757        }758      }), s), load().then((() => {759        t.value = !0, e.parent && isKeepAlive(e.parent.vnode) && queueJob(e.parent.update)760      })).catch((e => {761        onError(e), i.value = e762      })), () => t.value && l ? createInnerComp(l, e) : i.value && r ? De(r, {error: i.value}) : n && !u.value ? De(n) : void 0763    }764  })765}766function createInnerComp(e, {vnode: {ref: t, props: n, children: r}}) {767  const o = De(e, n, r);768  return o.ref = t, o769}770const isKeepAlive = e => e.type.__isKeepAlive;771function onActivated(e, t) {772  registerKeepAliveHook(e, "a", t)773}774function onDeactivated(e, t) {775  registerKeepAliveHook(e, "da", t)776}777function registerKeepAliveHook(e, t, n = Ye) {778  const r = e.__wdc || (e.__wdc = () => {779    let t = n;780    for (; t;) {781      if (t.isDeactivated) return;782      t = t.parent783    }784    e()785  });786  if (injectHook(t, r, n), n) {787    let e = n.parent;788    for (; e && e.parent;) isKeepAlive(e.parent.vnode) && injectToKeepAliveRoot(r, t, n, e), e = e.parent789  }790}791function injectToKeepAliveRoot(e, t, n, r) {792  const o = injectHook(t, e, r, !0);793  Ce((() => {794    remove(r[t], o)795  }), n)796}797function injectHook(e, t, n = Ye, r = !1) {798  if (n) {799    const o = n[e] || (n[e] = []), s = t.__weh || (t.__weh = (...r) => {800      if (n.isUnmounted) return;801      pauseTracking(), setCurrentInstance(n);802      const o = callWithAsyncErrorHandling(t, n, e, r);803      return setCurrentInstance(null), resetTracking(), o804    });805    return r ? o.unshift(s) : o.push(s), s806  }807}808const createHook = e => (t, n = Ye) => (!Xe || "sp" === e) && injectHook(e, t, n), _e = createHook("bm"),809  ke = createHook("m"), xe = createHook("bu"), Se = createHook("u"), Ee = createHook("bum"), Ce = createHook("um"),810  Ae = createHook("sp"), Oe = createHook("rtg"), Pe = createHook("rtc");811function onErrorCaptured(e, t = Ye) {812  injectHook("ec", e, t)813}814let Te = !0;815function applyOptions(e) {816  const t = resolveMergedOptions(e), n = e.proxy, r = e.ctx;817  Te = !1, t.beforeCreate && callHook(t.beforeCreate, e, "bc");818  const {819    data: o,820    computed: s,821    methods: a,822    watch: i,823    provide: l,824    inject: c,825    created: u,826    beforeMount: f,827    mounted: p,828    beforeUpdate: d,829    updated: m,830    activated: v,831    deactivated: y,832    beforeDestroy: b,833    beforeUnmount: R,834    destroyed: _,835    unmounted: k,836    render: x,837    renderTracked: S,838    renderTriggered: E,839    errorCaptured: C,840    serverPrefetch: A,841    expose: O,842    inheritAttrs: P,843    components: T,844    directives: j,845    filters: N846  } = t;847  if (c && function resolveInjections(e, t, n = NOOP) {848    w(e) && (e = normalizeInject(e));849    for (const r in e) {850      const n = e[r];851      isObject(n) ? t[r] = "default" in n ? inject(n.from || r, n.default, !0) : inject(n.from || r) : t[r] = inject(n)852    }853  }(c, r, null), a) for (const g in a) {854    const e = a[g];855    isFunction(e) && (r[g] = e.bind(n))856  }857  if (o) {858    const t = o.call(n, n);859    isObject(t) && (e.data = reactive(t))860  }861  if (Te = !0, s) for (const g in s) {862    const e = s[g], t = computed({863      get: isFunction(e) ? e.bind(n, n) : isFunction(e.get) ? e.get.bind(n, n) : NOOP,864      set: !isFunction(e) && isFunction(e.set) ? e.set.bind(n) : NOOP865    });866    Object.defineProperty(r, g, {enumerable: !0, configurable: !0, get: () => t.value, set: e => t.value = e})867  }868  if (i) for (const g in i) createWatcher(i[g], r, n, g);869  if (l) {870    const e = isFunction(l) ? l.call(n) : l;871    Reflect.ownKeys(e).forEach((t => {872      provide(t, e[t])873    }))874  }875  function registerLifecycleHook(e, t) {876    w(t) ? t.forEach((t => e(t.bind(n)))) : t && e(t.bind(n))877  }878  if (u && callHook(u, e, "c"), registerLifecycleHook(_e, f), registerLifecycleHook(ke, p), registerLifecycleHook(xe, d), registerLifecycleHook(Se, m), registerLifecycleHook(onActivated, v), registerLifecycleHook(onDeactivated, y), registerLifecycleHook(onErrorCaptured, C), registerLifecycleHook(Pe, S), registerLifecycleHook(Oe, E), registerLifecycleHook(Ee, R), registerLifecycleHook(Ce, k), registerLifecycleHook(Ae, A), w(O)) if (O.length) {879    const t = e.exposed || (e.exposed = proxyRefs({}));880    O.forEach((e => {881      t[e] = function toRef(e, t) {882        return isRef(e[t]) ? e[t] : new ObjectRefImpl(e, t)883      }(n, e)884    }))885  } else e.exposed || (e.exposed = g);886  x && e.render === NOOP && (e.render = x), null != P && (e.inheritAttrs = P), T && (e.components = T), j && (e.directives = j)887}888function callHook(e, t, n) {889  callWithAsyncErrorHandling(w(e) ? e.map((e => e.bind(t.proxy))) : e.bind(t.proxy), t, n)890}891function createWatcher(e, t, n, r) {892  const o = r.includes(".") ? createPathGetter(n, r) : () => n[r];893  if (isString$1(e)) {894    const n = t[e];895    isFunction(n) && watch(o, n)896  } else if (isFunction(e)) watch(o, e.bind(n)); else if (isObject(e)) if (w(e)) e.forEach((e => createWatcher(e, t, n, r))); else {897    const r = isFunction(e.handler) ? e.handler.bind(n) : t[e.handler];898    isFunction(r) && watch(o, r, e)899  }900}901function resolveMergedOptions(e) {902  const t = e.type, {mixins: n, extends: r} = t, {903    mixins: o,904    optionsCache: s,905    config: {optionMergeStrategies: a}906  } = e.appContext, i = s.get(t);907  let l;908  return i ? l = i : o.length || n || r ? (l = {}, o.length && o.forEach((e => mergeOptions$1(l, e, a, !0))), mergeOptions$1(l, t, a)) : l = t, s.set(t, l), l909}910function mergeOptions$1(e, t, n, r = !1) {911  const {mixins: o, extends: s} = t;912  s && mergeOptions$1(e, s, n, !0), o && o.forEach((t => mergeOptions$1(e, t, n, !0)));913  for (const a in t) if (r && "expose" === a) ; else {914    const r = je[a] || n && n[a];915    e[a] = r ? r(e[a], t[a]) : t[a]916  }917  return e918}919const je = {920  data: mergeDataFn,921  props: mergeObjectOptions,922  emits: mergeObjectOptions,923  methods: mergeObjectOptions,924  computed: mergeObjectOptions,925  beforeCreate: mergeAsArray,926  created: mergeAsArray,927  beforeMount: mergeAsArray,928  mounted: mergeAsArray,929  beforeUpdate: mergeAsArray,930  updated: mergeAsArray,931  beforeDestroy: mergeAsArray,932  destroyed: mergeAsArray,933  activated: mergeAsArray,934  deactivated: mergeAsArray,935  errorCaptured: mergeAsArray,936  serverPrefetch: mergeAsArray,937  components: mergeObjectOptions,938  directives: mergeObjectOptions,939  watch: function mergeWatchOptions(e, t) {940    if (!e) return t;941    if (!t) return e;942    const n = b(Object.create(null), e);943    for (const r in t) n[r] = mergeAsArray(e[r], t[r]);944    return n945  },946  provide: mergeDataFn,947  inject: function mergeInject(e, t) {948    return mergeObjectOptions(normalizeInject(e), normalizeInject(t))949  }950};951function mergeDataFn(e, t) {952  return t ? e ? function mergedDataFn() {953    return b(isFunction(e) ? e.call(this, this) : e, isFunction(t) ? t.call(this, this) : t)954  } : t : e955}956function normalizeInject(e) {957  if (w(e)) {958    const t = {};959    for (let n = 0; n < e.length; n++) t[e[n]] = e[n];960    return t961  }962  return e963}964function mergeAsArray(e, t) {965  return e ? [...new Set([].concat(e, t))] : t966}967function mergeObjectOptions(e, t) {968  return e ? b(b(Object.create(null), e), t) : t969}970function initProps(e, t, n, r = !1) {971  const o = {}, s = {};972  def(s, Ue, 1), e.propsDefaults = Object.create(null), setFullProps(e, t, o, s);973  for (const a in e.propsOptions[0]) a in o || (o[a] = void 0);974  n ? e.props = r ? o : function shallowReactive(e) {975    return createReactiveObject(e, !1, q, Z, ne)976  }(o) : e.type.props ? e.props = o : e.props = s, e.attrs = s977}978function setFullProps(e, t, n, r) {979  const [o, s] = e.propsOptions;980  let a, i = !1;981  if (t) for (let l in t) {982    if (k(l)) continue;983    const c = t[l];984    let u;985    o && hasOwn(o, u = S(l)) ? s && s.includes(u) ? (a || (a = {}))[u] = c : n[u] = c : isEmitListener(e.emitsOptions, l) || c !== r[l] && (r[l] = c, i = !0)986  }987  if (s) {988    const t = toRaw(n), r = a || g;989    for (let a = 0; a < s.length; a++) {990      const i = s[a];991      n[i] = resolvePropValue(o, t, i, r[i], e, !hasOwn(r, i))992    }993  }994  return i995}996function resolvePropValue(e, t, n, r, o, s) {997  const a = e[n];998  if (null != a) {999    const e = hasOwn(a, "default");1000    if (e && void 0 === r) {1001      const e = a.default;1002      if (a.type !== Function && isFunction(e)) {1003        const {propsDefaults: s} = o;1004        n in s ? r = s[n] : (setCurrentInstance(o), r = s[n] = e.call(null, t), setCurrentInstance(null))1005      } else r = e1006    }1007    a[0] && (s && !e ? r = !1 : !a[1] || "" !== r && r !== C(n) || (r = !0))1008  }1009  return r1010}1011function normalizePropsOptions(e, t, n = !1) {1012  const r = t.propsCache, o = r.get(e);1013  if (o) return o;1014  const s = e.props, a = {}, i = [];1015  let l = !1;1016  if (!isFunction(e)) {1017    const extendProps = e => {1018      l = !0;1019      const [n, r] = normalizePropsOptions(e, t, !0);1020      b(a, n), r && i.push(...r)1021    };1022    !n && t.mixins.length && t.mixins.forEach(extendProps), e.extends && extendProps(e.extends), e.mixins && e.mixins.forEach(extendProps)1023  }1024  if (!s && !l) return r.set(e, v), v;1025  if (w(s)) for (let u = 0; u < s.length; u++) {1026    const e = S(s[u]);1027    validatePropName(e) && (a[e] = g)1028  } else if (s) for (const u in s) {1029    const e = S(u);1030    if (validatePropName(e)) {1031      const t = s[u], n = a[e] = w(t) || isFunction(t) ? {type: t} : t;1032      if (n) {1033        const t = getTypeIndex(Boolean, n.type), r = getTypeIndex(String, n.type);1034        n[0] = t > -1, n[1] = r < 0 || t < r, (t > -1 || hasOwn(n, "default")) && i.push(e)1035      }1036    }1037  }1038  const c = [a, i];1039  return r.set(e, c), c1040}1041function validatePropName(e) {1042  return "$" !== e[0]1043}1044function getType(e) {1045  const t = e && e.toString().match(/^\s*function (\w+)/);1046  return t ? t[1] : ""1047}1048function isSameType(e, t) {1049  return getType(e) === getType(t)1050}1051function getTypeIndex(e, t) {1052  return w(t) ? t.findIndex((t => isSameType(t, e))) : isFunction(t) && isSameType(t, e) ? 0 : -11053}1054const isInternalKey = e => "_" === e[0] || "$stable" === e,1055  normalizeSlotValue = e => w(e) ? e.map(normalizeVNode) : [normalizeVNode(e)], normalizeSlot$1 = (e, t, n) => {1056    const r = withCtx((e => normalizeSlotValue(t(e))), n);1057    return r._c = !1, r1058  }, normalizeObjectSlots = (e, t, n) => {1059    const r = e._ctx;1060    for (const o in e) {1061      if (isInternalKey(o)) continue;1062      const n = e[o];1063      if (isFunction(n)) t[o] = normalizeSlot$1(0, n, r); else if (null != n) {1064        const e = normalizeSlotValue(n);1065        t[o] = () => e1066      }1067    }1068  }, normalizeVNodeSlots = (e, t) => {1069    const n = normalizeSlotValue(t);1070    e.slots.default = () => n1071  };1072function withDirectives(e, t) {1073  if (null === be) return e;1074  const n = be.proxy, r = e.dirs || (e.dirs = []);1075  for (let o = 0; o < t.length; o++) {1076    let [e, s, a, i = g] = t[o];1077    isFunction(e) && (e = {mounted: e, updated: e}), r.push({1078      dir: e,1079      instance: n,1080      value: s,1081      oldValue: void 0,1082      arg: a,1083      modifiers: i1084    })1085  }1086  return e1087}1088function invokeDirectiveHook(e, t, n, r) {1089  const o = e.dirs, s = t && t.dirs;1090  for (let a = 0; a < o.length; a++) {1091    const i = o[a];1092    s && (i.oldValue = s[a].value);1093    let l = i.dir[r];1094    l && (pauseTracking(), callWithAsyncErrorHandling(l, n, 8, [e.el, i, e, t]), resetTracking())1095  }1096}1097function createAppContext() {1098  return {1099    app: null,1100    config: {1101      isNativeTag: NO,1102      performance: !1,1103      globalProperties: {},1104      optionMergeStrategies: {},1105      errorHandler: void 0,1106      warnHandler: void 0,1107      compilerOptions: {}1108    },1109    mixins: [],1110    components: {},1111    directives: {},1112    provides: Object.create(null),1113    optionsCache: new WeakMap,1114    propsCache: new WeakMap,1115    emitsCache: new WeakMap1116  }1117}1118let Ne = 0;1119function createAppAPI(e, t) {1120  return function createApp2(n, r = null) {1121    null == r || isObject(r) || (r = null);1122    const o = createAppContext(), s = new Set;1123    let a = !1;1124    const i = o.app = {1125      _uid: Ne++,1126      _component: n,1127      _props: r,1128      _container: null,1129      _context: o,1130      _instance: null,1131      version: Ze,1132      get config() {1133        return o.config1134      },1135      set config(e) {1136      },1137      use: (e, ...t) => (s.has(e) || (e && isFunction(e.install) ? (s.add(e), e.install(i, ...t)) : isFunction(e) && (s.add(e), e(i, ...t))), i),1138      mixin: e => (o.mixins.includes(e) || o.mixins.push(e), i),1139      component: (e, t) => t ? (o.components[e] = t, i) : o.components[e],1140      directive: (e, t) => t ? (o.directives[e] = t, i) : o.directives[e],1141      mount(s, l, c) {1142        if (!a) {1143          const u = De(n, r);1144          return u.appContext = o, l && t ? t(u, s) : e(u, s, c), a = !0, i._container = s, s.__vue_app__ = i, u.component.proxy1145        }1146      },1147      unmount() {1148        a && (e(null, i._container), delete i._container.__vue_app__)1149      },1150      provide: (e, t) => (o.provides[e] = t, i)1151    };1152    return i1153  }1154}1155const Ie = {scheduler: queueJob, allowRecurse: !0}, Me = function queueEffectWithSuspense(e, t) {1156  t && t.pendingBranch ? w(e) ? t.effects.push(...e) : t.effects.push(e) : function queuePostFlushCb(e) {1157    queueCb(e, he, de, me)1158  }(e)1159}, setRef = (e, t, n, r, o = !1) => {1160  if (w(e)) return void e.forEach(((e, s) => setRef(e, t && (w(t) ? t[s] : t), n, r, o)));1161  if (isAsyncWrapper(r) && !o) return;1162  const s = 4 & r.shapeFlag ? r.component.exposed || r.component.proxy : r.el, a = o ? null : s, {i, r: l} = e,1163    c = t && t.r, u = i.refs === g ? i.refs = {} : i.refs, f = i.setupState;1164  if (null != c && c !== l && (isString$1(c) ? (u[c] = null, hasOwn(f, c) && (f[c] = null)) : isRef(c) && (c.value = null)), isString$1(l)) {1165    const doSet = () => {1166      u[l] = a, hasOwn(f, l) && (f[l] = a)1167    };1168    a ? (doSet.id = -1, Me(doSet, n)) : doSet()1169  } else if (isRef(l)) {1170    const doSet = () => {1171      l.value = a1172    };1173    a ? (doSet.id = -1, Me(doSet, n)) : doSet()1174  } else isFunction(l) && callWithErrorHandling(l, i, 12, [a, u])1175};1176function createRenderer(e) {1177  return function baseCreateRenderer(e, t) {1178    const {1179        insert: n,1180        remove: r,1181        patchProp: o,1182        forcePatchProp: s,1183        createElement: a,1184        createText: i,1185        createComment: l,1186        setText: c,1187        setElementText: u,1188        parentNode: f,1189        nextSibling: p,1190        setScopeId: d = NOOP,1191        cloneNode: m,1192        insertStaticContent: y1193      } = e, patch = (e, t, n, r = null, o = null, s = null, a = !1, i = null, l = !1) => {1194        e && !isSameVNodeType(e, t) && (r = getNextHostNode(e), unmount(e, o, s, !0), e = null), -2 === t.patchFlag && (l = !1, t.dynamicChildren = null);1195        const {type: c, ref: u, shapeFlag: f} = t;1196        switch (c) {1197          case Ve:1198            processText(e, t, n, r);1199            break;1200          case He:1201            processCommentNode(e, t, n, r);1202            break;1203          case Be:1204            null == e && mountStaticNode(t, n, r, a);1205            break;1206          case Le:1207            processFragment(e, t, n, r, o, s, a, i, l);1208            break;1209          default:1210            1 & f ? processElement(e, t, n, r, o, s, a, i, l) : 6 & f ? processComponent(e, t, n, r, o, s, a, i, l) : (64 & f || 128 & f) && c.process(e, t, n, r, o, s, a, i, l, R)1211        }1212        null != u && o && setRef(u, e && e.ref, s, t || e, !t)1213      }, processText = (e, t, r, o) => {1214        if (null == e) n(t.el = i(t.children), r, o); else {1215          const n = t.el = e.el;1216          t.children !== e.children && c(n, t.children)1217        }1218      }, processCommentNode = (e, t, r, o) => {1219        null == e ? n(t.el = l(t.children || ""), r, o) : t.el = e.el1220      }, mountStaticNode = (e, t, n, r) => {1221        [e.el, e.anchor] = y(e.children, t, n, r, e.el && [e.el, e.anchor])1222      }, moveStaticNode = ({el: e, anchor: t}, r, o) => {1223        let s;1224        for (; e && e !== t;) s = p(e), n(e, r, o), e = s;1225        n(t, r, o)1226      }, removeStaticNode = ({el: e, anchor: t}) => {1227        let n;1228        for (; e && e !== t;) n = p(e), r(e), e = n;1229        r(t)1230      }, processElement = (e, t, n, r, o, s, a, i, l) => {1231        a = a || "svg" === t.type, null == e ? mountElement(t, n, r, o, s, a, i, l) : patchElement(e, t, o, s, a, i, l)1232      }, mountElement = (e, t, r, s, i, l, c, f) => {1233        let p, d;1234        const {type: g, props: v, shapeFlag: y, transition: b, patchFlag: R, dirs: w} = e;1235        if (e.el && void 0 !== m && -1 === R) p = e.el = m(e.el); else {1236          if (p = e.el = a(e.type, l, v && v.is, v), 8 & y ? u(p, e.children) : 16 & y && mountChildren(e.children, p, null, s, i, l && "foreignObject" !== g, c, f || !!e.dynamicChildren), w && invokeDirectiveHook(e, null, s, "created"), v) {1237            for (const t in v) k(t) || o(p, t, null, v[t], l, e.children, s, i, unmountChildren);1238            (d = v.onVnodeBeforeMount) && invokeVNodeHook(d, s, e)1239          }1240          setScopeId(p, e, e.scopeId, c, s)1241        }1242        w && invokeDirectiveHook(e, null, s, "beforeMount");1243        const _ = (!i || i && !i.pendingBranch) && b && !b.persisted;1244        _ && b.beforeEnter(p), n(p, t, r), ((d = v && v.onVnodeMounted) || _ || w) && Me((() => {1245          d && invokeVNodeHook(d, s, e), _ && b.enter(p), w && invokeDirectiveHook(e, null, s, "mounted")1246        }), i)1247      }, setScopeId = (e, t, n, r, o) => {1248        if (n && d(e, n), r) for (let s = 0; s < r.length; s++) d(e, r[s]);1249        if (o) {1250          if (t === o.subTree) {1251            const t = o.vnode;1252            setScopeId(e, t, t.scopeId, t.slotScopeIds, o.parent)1253          }1254        }1255      }, mountChildren = (e, t, n, r, o, s, a, i, l = 0) => {1256        for (let c = l; c < e.length; c++) {1257          const l = e[c] = i ? cloneIfMounted(e[c]) : normalizeVNode(e[c]);1258          patch(null, l, t, n, r, o, s, a, i)1259        }1260      }, patchElement = (e, t, n, r, a, i, l) => {1261        const c = t.el = e.el;1262        let {patchFlag: f, dynamicChildren: p, dirs: d} = t;1263        f |= 16 & e.patchFlag;1264        const m = e.props || g, v = t.props || g;1265        let y;1266        if ((y = v.onVnodeBeforeUpdate) && invokeVNodeHook(y, n, t, e), d && invokeDirectiveHook(t, e, n, "beforeUpdate"), f > 0) {1267          if (16 & f) patchProps(c, t, m, v, n, r, a); else if (2 & f && m.class !== v.class && o(c, "class", null, v.class, a), 4 & f && o(c, "style", m.style, v.style, a), 8 & f) {1268            const i = t.dynamicProps;1269            for (let t = 0; t < i.length; t++) {1270              const l = i[t], u = m[l], f = v[l];1271              (f !== u || s && s(c, l)) && o(c, l, u, f, a, e.children, n, r, unmountChildren)1272            }1273          }1274          1 & f && e.children !== t.children && u(c, t.children)1275        } else l || null != p || patchProps(c, t, m, v, n, r, a);1276        const b = a && "foreignObject" !== t.type;1277        p ? patchBlockChildren(e.dynamicChildren, p, c, n, r, b, i) : l || patchChildren(e, t, c, null, n, r, b, i, !1), ((y = v.onVnodeUpdated) || d) && Me((() => {1278          y && invokeVNodeHook(y, n, t, e), d && invokeDirectiveHook(t, e, n, "updated")1279        }), r)1280      }, patchBlockChildren = (e, t, n, r, o, s, a) => {1281        for (let i = 0; i < t.length; i++) {1282          const l = e[i], c = t[i],1283            u = l.el && (l.type === Le || !isSameVNodeType(l, c) || 6 & l.shapeFlag || 64 & l.shapeFlag) ? f(l.el) : n;1284          patch(l, c, u, null, r, o, s, a, !0)1285        }1286      }, patchProps = (e, t, n, r, a, i, l) => {1287        if (n !== r) {1288          for (const c in r) {1289            if (k(c)) continue;1290            const u = r[c], f = n[c];1291            (u !== f || s && s(e, c)) && o(e, c, f, u, l, t.children, a, i, unmountChildren)1292          }1293          if (n !== g) for (const s in n) k(s) || s in r || o(e, s, n[s], null, l, t.children, a, i, unmountChildren)1294        }1295      }, processFragment = (e, t, r, o, s, a, l, c, u) => {1296        const f = t.el = e ? e.el : i(""), p = t.anchor = e ? e.anchor : i("");1297        let {patchFlag: d, dynamicChildren: m, slotScopeIds: g} = t;1298        m && (u = !0), g && (c = c ? c.concat(g) : g), null == e ? (n(f, r, o), n(p, r, o), mountChildren(t.children, r, p, s, a, l, c, u)) : d > 0 && 64 & d && m && e.dynamicChildren ? (patchBlockChildren(e.dynamicChildren, m, r, s, a, l, c), (null != t.key || s && t === s.subTree) && traverseStaticChildren(e, t, !0)) : patchChildren(e, t, r, p, s, a, l, c, u)1299      }, processComponent = (e, t, n, r, o, s, a, i, l) => {1300        t.slotScopeIds = i, null == e ? 512 & t.shapeFlag ? o.ctx.activate(t, n, r, a, l) : mountComponent(t, n, r, o, s, a, l) : updateComponent(e, t, l)1301      }, mountComponent = (e, t, n, r, o, s, a) => {1302        const i = e.component = function createComponentInstance(e, t, n) {1303          const r = e.type, o = (t ? t.appContext : e.appContext) || Qe, s = {1304            uid: Je++,1305            vnode: e,1306            type: r,1307            parent: t,1308            appContext: o,1309            root: null,1310            next: null,1311            subTree: null,1312            update: null,1313            render: null,1314            proxy: null,1315            exposed: null,1316            withProxy: null,1317            effects: null,1318            provides: t ? t.provides : Object.create(o.provides),1319            accessCache: null,1320            renderCache: [],1321            components: null,1322            directives: null,1323            propsOptions: normalizePropsOptions(r, o),1324            emitsOptions: normalizeEmitsOptions(r, o),1325            emit: null,1326            emitted: null,1327            propsDefaults: g,1328            inheritAttrs: r.inheritAttrs,1329            ctx: g,1330            data: g,1331            props: g,1332            attrs: g,1333            slots: g,1334            refs: g,1335            setupState: g,1336            setupContext: null,1337            suspense: n,1338            suspenseId: n ? n.pendingId : 0,...

index.147aad71.js

Source:index.147aad71.js

...1032    }1033    callWithAsyncErrorHandling(onceHandler, instance, 6, args);1034  }1035}1036function normalizeEmitsOptions(comp, appContext, asMixin = false) {1037  if (!appContext.deopt && comp.__emits !== void 0) {1038    return comp.__emits;1039  }1040  const raw = comp.emits;1041  let normalized = {};1042  let hasExtends = false;1043  if (!isFunction(comp)) {1044    const extendEmits = (raw2) => {1045      hasExtends = true;1046      extend(normalized, normalizeEmitsOptions(raw2, appContext, true));1047    };1048    if (!asMixin && appContext.mixins.length) {1049      appContext.mixins.forEach(extendEmits);1050    }1051    if (comp.extends) {1052      extendEmits(comp.extends);1053    }1054    if (comp.mixins) {1055      comp.mixins.forEach(extendEmits);1056    }1057  }1058  if (!raw && !hasExtends) {1059    return comp.__emits = null;1060  }1061  if (isArray(raw)) {1062    raw.forEach((key) => normalized[key] = null);1063  } else {1064    extend(normalized, raw);1065  }1066  return comp.__emits = normalized;1067}1068function isEmitListener(options, key) {1069  if (!options || !isOn(key)) {1070    return false;1071  }1072  key = key.replace(/Once$/, "");1073  return hasOwn(options, key[2].toLowerCase() + key.slice(3)) || hasOwn(options, key.slice(2));1074}1075let currentRenderingInstance = null;1076function setCurrentRenderingInstance(instance) {1077  currentRenderingInstance = instance;1078}1079let accessedAttrs = false;1080function markAttrsAccessed() {1081  accessedAttrs = true;1082}1083function renderComponentRoot(instance) {1084  const {type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit: emit2, render: render2, renderCache, data, setupState, ctx} = instance;1085  let result;1086  currentRenderingInstance = instance;1087  try {1088    let fallthroughAttrs;1089    if (vnode.shapeFlag & 4) {1090      const proxyToUse = withProxy || proxy;1091      result = normalizeVNode(render2.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx));1092      fallthroughAttrs = attrs;1093    } else {1094      const render3 = Component;1095      if (false)1096        ;1097      result = normalizeVNode(render3.length > 1 ? render3(props, {attrs, slots, emit: emit2}) : render3(props, null));1098      fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);1099    }1100    let root = result;1101    let setRoot = void 0;1102    if (false)1103      ;1104    if (Component.inheritAttrs !== false && fallthroughAttrs) {1105      const keys = Object.keys(fallthroughAttrs);1106      const {shapeFlag} = root;1107      if (keys.length) {1108        if (shapeFlag & 1 || shapeFlag & 6) {1109          if (propsOptions && keys.some(isModelListener)) {1110            fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);1111          }1112          root = cloneVNode(root, fallthroughAttrs);1113        } else if (false)1114          ;1115      }1116    }1117    if (vnode.dirs) {1118      if (false)1119        ;1120      root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;1121    }1122    if (vnode.transition) {1123      if (false)1124        ;1125      root.transition = vnode.transition;1126    }1127    if (false)1128      ;1129    else {1130      result = root;1131    }1132  } catch (err) {1133    handleError(err, instance, 1);1134    result = createVNode(Comment);1135  }1136  currentRenderingInstance = null;1137  return result;1138}1139const getChildRoot = (vnode) => {1140  if (vnode.type !== Fragment) {1141    return [vnode, void 0];1142  }1143  const rawChildren = vnode.children;1144  const dynamicChildren = vnode.dynamicChildren;1145  const childRoot = filterSingleRoot(rawChildren);1146  if (!childRoot) {1147    return [vnode, void 0];1148  }1149  const index = rawChildren.indexOf(childRoot);1150  const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;1151  const setRoot = (updatedRoot) => {1152    rawChildren[index] = updatedRoot;1153    if (dynamicChildren) {1154      if (dynamicIndex > -1) {1155        dynamicChildren[dynamicIndex] = updatedRoot;1156      } else if (updatedRoot.patchFlag > 0) {1157        vnode.dynamicChildren = [...dynamicChildren, updatedRoot];1158      }1159    }1160  };1161  return [normalizeVNode(childRoot), setRoot];1162};1163function filterSingleRoot(children) {1164  const filtered = children.filter((child) => {1165    return !(isVNode(child) && child.type === Comment && child.children !== "v-if");1166  });1167  return filtered.length === 1 && isVNode(filtered[0]) ? filtered[0] : null;1168}1169const getFunctionalFallthrough = (attrs) => {1170  let res;1171  for (const key in attrs) {1172    if (key === "class" || key === "style" || isOn(key)) {1173      (res || (res = {}))[key] = attrs[key];1174    }1175  }1176  return res;1177};1178const filterModelListeners = (attrs, props) => {1179  const res = {};1180  for (const key in attrs) {1181    if (!isModelListener(key) || !(key.slice(9) in props)) {1182      res[key] = attrs[key];1183    }1184  }1185  return res;1186};1187const isElementRoot = (vnode) => {1188  return vnode.shapeFlag & 6 || vnode.shapeFlag & 1 || vnode.type === Comment;1189};1190function shouldUpdateComponent(prevVNode, nextVNode, optimized) {1191  const {props: prevProps, children: prevChildren, component} = prevVNode;1192  const {props: nextProps, children: nextChildren, patchFlag} = nextVNode;1193  const emits = component.emitsOptions;1194  if (nextVNode.dirs || nextVNode.transition) {1195    return true;1196  }1197  if (optimized && patchFlag > 0) {1198    if (patchFlag & 1024) {1199      return true;1200    }1201    if (patchFlag & 16) {1202      if (!prevProps) {1203        return !!nextProps;1204      }1205      return hasPropsChanged(prevProps, nextProps, emits);1206    } else if (patchFlag & 8) {1207      const dynamicProps = nextVNode.dynamicProps;1208      for (let i = 0; i < dynamicProps.length; i++) {1209        const key = dynamicProps[i];1210        if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {1211          return true;1212        }1213      }1214    }1215  } else {1216    if (prevChildren || nextChildren) {1217      if (!nextChildren || !nextChildren.$stable) {1218        return true;1219      }1220    }1221    if (prevProps === nextProps) {1222      return false;1223    }1224    if (!prevProps) {1225      return !!nextProps;1226    }1227    if (!nextProps) {1228      return true;1229    }1230    return hasPropsChanged(prevProps, nextProps, emits);1231  }1232  return false;1233}1234function hasPropsChanged(prevProps, nextProps, emitsOptions) {1235  const nextKeys = Object.keys(nextProps);1236  if (nextKeys.length !== Object.keys(prevProps).length) {1237    return true;1238  }1239  for (let i = 0; i < nextKeys.length; i++) {1240    const key = nextKeys[i];1241    if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {1242      return true;1243    }1244  }1245  return false;1246}1247function updateHOCHostEl({vnode, parent}, el) {1248  while (parent && parent.subTree === vnode) {1249    (vnode = parent.vnode).el = el;1250    parent = parent.parent;1251  }1252}1253const isSuspense = (type) => type.__isSuspense;1254function normalizeSuspenseChildren(vnode) {1255  const {shapeFlag, children} = vnode;1256  let content;1257  let fallback;1258  if (shapeFlag & 32) {1259    content = normalizeSuspenseSlot(children.default);1260    fallback = normalizeSuspenseSlot(children.fallback);1261  } else {1262    content = normalizeSuspenseSlot(children);1263    fallback = normalizeVNode(null);1264  }1265  return {1266    content,1267    fallback1268  };1269}1270function normalizeSuspenseSlot(s) {1271  if (isFunction(s)) {1272    s = s();1273  }1274  if (isArray(s)) {1275    const singleChild = filterSingleRoot(s);1276    s = singleChild;1277  }1278  return normalizeVNode(s);1279}1280function queueEffectWithSuspense(fn, suspense) {1281  if (suspense && suspense.pendingBranch) {1282    if (isArray(fn)) {1283      suspense.effects.push(...fn);1284    } else {1285      suspense.effects.push(fn);1286    }1287  } else {1288    queuePostFlushCb(fn);1289  }1290}1291let isRenderingCompiledSlot = 0;1292const setCompiledSlotRendering = (n) => isRenderingCompiledSlot += n;1293function renderSlot(slots, name, props = {}, fallback) {1294  let slot = slots[name];1295  isRenderingCompiledSlot++;1296  const rendered = (openBlock(), createBlock(Fragment, {key: props.key}, slot ? slot(props) : fallback ? fallback() : [], slots._ === 1 ? 64 : -2));1297  isRenderingCompiledSlot--;1298  return rendered;1299}1300function withCtx(fn, ctx = currentRenderingInstance) {1301  if (!ctx)1302    return fn;1303  const renderFnWithContext = (...args) => {1304    if (!isRenderingCompiledSlot) {1305      openBlock(true);1306    }1307    const owner = currentRenderingInstance;1308    setCurrentRenderingInstance(ctx);1309    const res = fn(...args);1310    setCurrentRenderingInstance(owner);1311    if (!isRenderingCompiledSlot) {1312      closeBlock();1313    }1314    return res;1315  };1316  renderFnWithContext._c = true;1317  return renderFnWithContext;1318}1319let currentScopeId = null;1320function initProps(instance, rawProps, isStateful, isSSR = false) {1321  const props = {};1322  const attrs = {};1323  def(attrs, InternalObjectKey, 1);1324  setFullProps(instance, rawProps, props, attrs);1325  if (isStateful) {1326    instance.props = isSSR ? props : shallowReactive(props);1327  } else {1328    if (!instance.type.props) {1329      instance.props = attrs;1330    } else {1331      instance.props = props;1332    }1333  }1334  instance.attrs = attrs;1335}1336function updateProps(instance, rawProps, rawPrevProps, optimized) {1337  const {props, attrs, vnode: {patchFlag}} = instance;1338  const rawCurrentProps = toRaw(props);1339  const [options] = instance.propsOptions;1340  if ((optimized || patchFlag > 0) && !(patchFlag & 16)) {1341    if (patchFlag & 8) {1342      const propsToUpdate = instance.vnode.dynamicProps;1343      for (let i = 0; i < propsToUpdate.length; i++) {1344        const key = propsToUpdate[i];1345        const value = rawProps[key];1346        if (options) {1347          if (hasOwn(attrs, key)) {1348            attrs[key] = value;1349          } else {1350            const camelizedKey = camelize(key);1351            props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance);1352          }1353        } else {1354          attrs[key] = value;1355        }1356      }1357    }1358  } else {1359    setFullProps(instance, rawProps, props, attrs);1360    let kebabKey;1361    for (const key in rawCurrentProps) {1362      if (!rawProps || !hasOwn(rawProps, key) && ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {1363        if (options) {1364          if (rawPrevProps && (rawPrevProps[key] !== void 0 || rawPrevProps[kebabKey] !== void 0)) {1365            props[key] = resolvePropValue(options, rawProps || EMPTY_OBJ, key, void 0, instance);1366          }1367        } else {1368          delete props[key];1369        }1370      }1371    }1372    if (attrs !== rawCurrentProps) {1373      for (const key in attrs) {1374        if (!rawProps || !hasOwn(rawProps, key)) {1375          delete attrs[key];1376        }1377      }1378    }1379  }1380  trigger(instance, "set", "$attrs");1381}1382function setFullProps(instance, rawProps, props, attrs) {1383  const [options, needCastKeys] = instance.propsOptions;1384  if (rawProps) {1385    for (const key in rawProps) {1386      const value = rawProps[key];1387      if (isReservedProp(key)) {1388        continue;1389      }1390      let camelKey;1391      if (options && hasOwn(options, camelKey = camelize(key))) {1392        props[camelKey] = value;1393      } else if (!isEmitListener(instance.emitsOptions, key)) {1394        attrs[key] = value;1395      }1396    }1397  }1398  if (needCastKeys) {1399    const rawCurrentProps = toRaw(props);1400    for (let i = 0; i < needCastKeys.length; i++) {1401      const key = needCastKeys[i];1402      props[key] = resolvePropValue(options, rawCurrentProps, key, rawCurrentProps[key], instance);1403    }1404  }1405}1406function resolvePropValue(options, props, key, value, instance) {1407  const opt = options[key];1408  if (opt != null) {1409    const hasDefault = hasOwn(opt, "default");1410    if (hasDefault && value === void 0) {1411      const defaultValue = opt.default;1412      if (opt.type !== Function && isFunction(defaultValue)) {1413        setCurrentInstance(instance);1414        value = defaultValue(props);1415        setCurrentInstance(null);1416      } else {1417        value = defaultValue;1418      }1419    }1420    if (opt[0]) {1421      if (!hasOwn(props, key) && !hasDefault) {1422        value = false;1423      } else if (opt[1] && (value === "" || value === hyphenate(key))) {1424        value = true;1425      }1426    }1427  }1428  return value;1429}1430function normalizePropsOptions(comp, appContext, asMixin = false) {1431  if (!appContext.deopt && comp.__props) {1432    return comp.__props;1433  }1434  const raw = comp.props;1435  const normalized = {};1436  const needCastKeys = [];1437  let hasExtends = false;1438  if (!isFunction(comp)) {1439    const extendProps = (raw2) => {1440      hasExtends = true;1441      const [props, keys] = normalizePropsOptions(raw2, appContext, true);1442      extend(normalized, props);1443      if (keys)1444        needCastKeys.push(...keys);1445    };1446    if (!asMixin && appContext.mixins.length) {1447      appContext.mixins.forEach(extendProps);1448    }1449    if (comp.extends) {1450      extendProps(comp.extends);1451    }1452    if (comp.mixins) {1453      comp.mixins.forEach(extendProps);1454    }1455  }1456  if (!raw && !hasExtends) {1457    return comp.__props = EMPTY_ARR;1458  }1459  if (isArray(raw)) {1460    for (let i = 0; i < raw.length; i++) {1461      const normalizedKey = camelize(raw[i]);1462      if (validatePropName(normalizedKey)) {1463        normalized[normalizedKey] = EMPTY_OBJ;1464      }1465    }1466  } else if (raw) {1467    for (const key in raw) {1468      const normalizedKey = camelize(key);1469      if (validatePropName(normalizedKey)) {1470        const opt = raw[key];1471        const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? {type: opt} : opt;1472        if (prop) {1473          const booleanIndex = getTypeIndex(Boolean, prop.type);1474          const stringIndex = getTypeIndex(String, prop.type);1475          prop[0] = booleanIndex > -1;1476          prop[1] = stringIndex < 0 || booleanIndex < stringIndex;1477          if (booleanIndex > -1 || hasOwn(prop, "default")) {1478            needCastKeys.push(normalizedKey);1479          }1480        }1481      }1482    }1483  }1484  return comp.__props = [normalized, needCastKeys];1485}1486function validatePropName(key) {1487  if (key[0] !== "$") {1488    return true;1489  }1490  return false;1491}1492function getType(ctor) {1493  const match = ctor && ctor.toString().match(/^\s*function (\w+)/);1494  return match ? match[1] : "";1495}1496function isSameType(a, b) {1497  return getType(a) === getType(b);1498}1499function getTypeIndex(type, expectedTypes) {1500  if (isArray(expectedTypes)) {1501    for (let i = 0, len = expectedTypes.length; i < len; i++) {1502      if (isSameType(expectedTypes[i], type)) {1503        return i;1504      }1505    }1506  } else if (isFunction(expectedTypes)) {1507    return isSameType(expectedTypes, type) ? 0 : -1;1508  }1509  return -1;1510}1511function injectHook(type, hook, target = currentInstance, prepend = false) {1512  if (target) {1513    const hooks = target[type] || (target[type] = []);1514    const wrappedHook = hook.__weh || (hook.__weh = (...args) => {1515      if (target.isUnmounted) {1516        return;1517      }1518      pauseTracking();1519      setCurrentInstance(target);1520      const res = callWithAsyncErrorHandling(hook, target, type, args);1521      setCurrentInstance(null);1522      resetTracking();1523      return res;1524    });1525    if (prepend) {1526      hooks.unshift(wrappedHook);1527    } else {1528      hooks.push(wrappedHook);1529    }1530    return wrappedHook;1531  }1532}1533const createHook = (lifecycle) => (hook, target = currentInstance) => !isInSSRComponentSetup && injectHook(lifecycle, hook, target);1534const onBeforeMount = createHook("bm");1535const onMounted = createHook("m");1536const onBeforeUpdate = createHook("bu");1537const onUpdated = createHook("u");1538const onBeforeUnmount = createHook("bum");1539const onUnmounted = createHook("um");1540const onRenderTriggered = createHook("rtg");1541const onRenderTracked = createHook("rtc");1542const onErrorCaptured = (hook, target = currentInstance) => {1543  injectHook("ec", hook, target);1544};1545const INITIAL_WATCHER_VALUE = {};1546function watch(source, cb, options) {1547  return doWatch(source, cb, options);1548}1549function doWatch(source, cb, {immediate, deep, flush, onTrack, onTrigger} = EMPTY_OBJ, instance = currentInstance) {1550  let getter;1551  let forceTrigger = false;1552  if (isRef(source)) {1553    getter = () => source.value;1554    forceTrigger = !!source._shallow;1555  } else if (isReactive(source)) {1556    getter = () => source;1557    deep = true;1558  } else if (isArray(source)) {1559    getter = () => source.map((s) => {1560      if (isRef(s)) {1561        return s.value;1562      } else if (isReactive(s)) {1563        return traverse(s);1564      } else if (isFunction(s)) {1565        return callWithErrorHandling(s, instance, 2);1566      } else1567        ;1568    });1569  } else if (isFunction(source)) {1570    if (cb) {1571      getter = () => callWithErrorHandling(source, instance, 2);1572    } else {1573      getter = () => {1574        if (instance && instance.isUnmounted) {1575          return;1576        }1577        if (cleanup2) {1578          cleanup2();1579        }1580        return callWithErrorHandling(source, instance, 3, [onInvalidate]);1581      };1582    }1583  } else {1584    getter = NOOP;1585  }1586  if (cb && deep) {1587    const baseGetter = getter;1588    getter = () => traverse(baseGetter());1589  }1590  let cleanup2;1591  const onInvalidate = (fn) => {1592    cleanup2 = runner.options.onStop = () => {1593      callWithErrorHandling(fn, instance, 4);1594    };1595  };1596  let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;1597  const job = () => {1598    if (!runner.active) {1599      return;1600    }1601    if (cb) {1602      const newValue = runner();1603      if (deep || forceTrigger || hasChanged(newValue, oldValue)) {1604        if (cleanup2) {1605          cleanup2();1606        }1607        callWithAsyncErrorHandling(cb, instance, 3, [1608          newValue,1609          oldValue === INITIAL_WATCHER_VALUE ? void 0 : oldValue,1610          onInvalidate1611        ]);1612        oldValue = newValue;1613      }1614    } else {1615      runner();1616    }1617  };1618  job.allowRecurse = !!cb;1619  let scheduler;1620  if (flush === "sync") {1621    scheduler = job;1622  } else if (flush === "post") {1623    scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);1624  } else {1625    scheduler = () => {1626      if (!instance || instance.isMounted) {1627        queuePreFlushCb(job);1628      } else {1629        job();1630      }1631    };1632  }1633  const runner = effect(getter, {1634    lazy: true,1635    onTrack,1636    onTrigger,1637    scheduler1638  });1639  recordInstanceBoundEffect(runner);1640  if (cb) {1641    if (immediate) {1642      job();1643    } else {1644      oldValue = runner();1645    }1646  } else if (flush === "post") {1647    queuePostRenderEffect(runner, instance && instance.suspense);1648  } else {1649    runner();1650  }1651  return () => {1652    stop(runner);1653    if (instance) {1654      remove(instance.effects, runner);1655    }1656  };1657}1658function instanceWatch(source, cb, options) {1659  const publicThis = this.proxy;1660  const getter = isString(source) ? () => publicThis[source] : source.bind(publicThis);1661  return doWatch(getter, cb.bind(publicThis), options, this);1662}1663function traverse(value, seen = new Set()) {1664  if (!isObject(value) || seen.has(value)) {1665    return value;1666  }1667  seen.add(value);1668  if (isRef(value)) {1669    traverse(value.value, seen);1670  } else if (isArray(value)) {1671    for (let i = 0; i < value.length; i++) {1672      traverse(value[i], seen);1673    }1674  } else if (isSet(value) || isMap(value)) {1675    value.forEach((v) => {1676      traverse(v, seen);1677    });1678  } else {1679    for (const key in value) {1680      traverse(value[key], seen);1681    }1682  }1683  return value;1684}1685const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;1686function onActivated(hook, target) {1687  registerKeepAliveHook(hook, "a", target);1688}1689function onDeactivated(hook, target) {1690  registerKeepAliveHook(hook, "da", target);1691}1692function registerKeepAliveHook(hook, type, target = currentInstance) {1693  const wrappedHook = hook.__wdc || (hook.__wdc = () => {1694    let current = target;1695    while (current) {1696      if (current.isDeactivated) {1697        return;1698      }1699      current = current.parent;1700    }1701    hook();1702  });1703  injectHook(type, wrappedHook, target);1704  if (target) {1705    let current = target.parent;1706    while (current && current.parent) {1707      if (isKeepAlive(current.parent.vnode)) {1708        injectToKeepAliveRoot(wrappedHook, type, target, current);1709      }1710      current = current.parent;1711    }1712  }1713}1714function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {1715  const injected = injectHook(type, hook, keepAliveRoot, true);1716  onUnmounted(() => {1717    remove(keepAliveRoot[type], injected);1718  }, target);1719}1720const isInternalKey = (key) => key[0] === "_" || key === "$stable";1721const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];1722const normalizeSlot = (key, rawSlot, ctx) => withCtx((props) => {1723  return normalizeSlotValue(rawSlot(props));1724}, ctx);1725const normalizeObjectSlots = (rawSlots, slots) => {1726  const ctx = rawSlots._ctx;1727  for (const key in rawSlots) {1728    if (isInternalKey(key))1729      continue;1730    const value = rawSlots[key];1731    if (isFunction(value)) {1732      slots[key] = normalizeSlot(key, value, ctx);1733    } else if (value != null) {1734      const normalized = normalizeSlotValue(value);1735      slots[key] = () => normalized;1736    }1737  }1738};1739const normalizeVNodeSlots = (instance, children) => {1740  const normalized = normalizeSlotValue(children);1741  instance.slots.default = () => normalized;1742};1743const initSlots = (instance, children) => {1744  if (instance.vnode.shapeFlag & 32) {1745    const type = children._;1746    if (type) {1747      instance.slots = children;1748      def(children, "_", type);1749    } else {1750      normalizeObjectSlots(children, instance.slots = {});1751    }1752  } else {1753    instance.slots = {};1754    if (children) {1755      normalizeVNodeSlots(instance, children);1756    }1757  }1758  def(instance.slots, InternalObjectKey, 1);1759};1760const updateSlots = (instance, children) => {1761  const {vnode, slots} = instance;1762  let needDeletionCheck = true;1763  let deletionComparisonTarget = EMPTY_OBJ;1764  if (vnode.shapeFlag & 32) {1765    const type = children._;1766    if (type) {1767      if (type === 1) {1768        needDeletionCheck = false;1769      } else {1770        extend(slots, children);1771      }1772    } else {1773      needDeletionCheck = !children.$stable;1774      normalizeObjectSlots(children, slots);1775    }1776    deletionComparisonTarget = children;1777  } else if (children) {1778    normalizeVNodeSlots(instance, children);1779    deletionComparisonTarget = {default: 1};1780  }1781  if (needDeletionCheck) {1782    for (const key in slots) {1783      if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {1784        delete slots[key];1785      }1786    }1787  }1788};1789function invokeDirectiveHook(vnode, prevVNode, instance, name) {1790  const bindings = vnode.dirs;1791  const oldBindings = prevVNode && prevVNode.dirs;1792  for (let i = 0; i < bindings.length; i++) {1793    const binding = bindings[i];1794    if (oldBindings) {1795      binding.oldValue = oldBindings[i].value;1796    }1797    const hook = binding.dir[name];1798    if (hook) {1799      callWithAsyncErrorHandling(hook, instance, 8, [1800        vnode.el,1801        binding,1802        vnode,1803        prevVNode1804      ]);1805    }1806  }1807}1808function createAppContext() {1809  return {1810    app: null,1811    config: {1812      isNativeTag: NO,1813      performance: false,1814      globalProperties: {},1815      optionMergeStrategies: {},1816      isCustomElement: NO,1817      errorHandler: void 0,1818      warnHandler: void 01819    },1820    mixins: [],1821    components: {},1822    directives: {},1823    provides: Object.create(null)1824  };1825}1826let uid$1 = 0;1827function createAppAPI(render2, hydrate) {1828  return function createApp2(rootComponent, rootProps = null) {1829    if (rootProps != null && !isObject(rootProps)) {1830      rootProps = null;1831    }1832    const context = createAppContext();1833    const installedPlugins = new Set();1834    let isMounted = false;1835    const app = context.app = {1836      _uid: uid$1++,1837      _component: rootComponent,1838      _props: rootProps,1839      _container: null,1840      _context: context,1841      version,1842      get config() {1843        return context.config;1844      },1845      set config(v) {1846      },1847      use(plugin, ...options) {1848        if (installedPlugins.has(plugin))1849          ;1850        else if (plugin && isFunction(plugin.install)) {1851          installedPlugins.add(plugin);1852          plugin.install(app, ...options);1853        } else if (isFunction(plugin)) {1854          installedPlugins.add(plugin);1855          plugin(app, ...options);1856        } else1857          ;1858        return app;1859      },1860      mixin(mixin) {1861        {1862          if (!context.mixins.includes(mixin)) {1863            context.mixins.push(mixin);1864            if (mixin.props || mixin.emits) {1865              context.deopt = true;1866            }1867          }1868        }1869        return app;1870      },1871      component(name, component) {1872        if (!component) {1873          return context.components[name];1874        }1875        context.components[name] = component;1876        return app;1877      },1878      directive(name, directive) {1879        if (!directive) {1880          return context.directives[name];1881        }1882        context.directives[name] = directive;1883        return app;1884      },1885      mount(rootContainer, isHydrate) {1886        if (!isMounted) {1887          const vnode = createVNode(rootComponent, rootProps);1888          vnode.appContext = context;1889          if (isHydrate && hydrate) {1890            hydrate(vnode, rootContainer);1891          } else {1892            render2(vnode, rootContainer);1893          }1894          isMounted = true;1895          app._container = rootContainer;1896          rootContainer.__vue_app__ = app;1897          return vnode.component.proxy;1898        }1899      },1900      unmount() {1901        if (isMounted) {1902          render2(null, app._container);1903        }1904      },1905      provide(key, value) {1906        context.provides[key] = value;1907        return app;1908      }1909    };1910    return app;1911  };1912}1913const prodEffectOptions = {1914  scheduler: queueJob,1915  allowRecurse: true1916};1917const queuePostRenderEffect = queueEffectWithSuspense;1918const setRef = (rawRef, oldRawRef, parentComponent, parentSuspense, vnode) => {1919  if (isArray(rawRef)) {1920    rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentComponent, parentSuspense, vnode));1921    return;1922  }1923  let value;1924  if (!vnode) {1925    value = null;1926  } else {1927    if (vnode.shapeFlag & 4) {1928      value = vnode.component.proxy;1929    } else {1930      value = vnode.el;1931    }1932  }1933  const {i: owner, r: ref} = rawRef;1934  const oldRef = oldRawRef && oldRawRef.r;1935  const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;1936  const setupState = owner.setupState;1937  if (oldRef != null && oldRef !== ref) {1938    if (isString(oldRef)) {1939      refs[oldRef] = null;1940      if (hasOwn(setupState, oldRef)) {1941        setupState[oldRef] = null;1942      }1943    } else if (isRef(oldRef)) {1944      oldRef.value = null;1945    }1946  }1947  if (isString(ref)) {1948    const doSet = () => {1949      refs[ref] = value;1950      if (hasOwn(setupState, ref)) {1951        setupState[ref] = value;1952      }1953    };1954    if (value) {1955      doSet.id = -1;1956      queuePostRenderEffect(doSet, parentSuspense);1957    } else {1958      doSet();1959    }1960  } else if (isRef(ref)) {1961    const doSet = () => {1962      ref.value = value;1963    };1964    if (value) {1965      doSet.id = -1;1966      queuePostRenderEffect(doSet, parentSuspense);1967    } else {1968      doSet();1969    }1970  } else if (isFunction(ref)) {1971    callWithErrorHandling(ref, parentComponent, 12, [1972      value,1973      refs1974    ]);1975  } else1976    ;1977};1978function createRenderer(options) {1979  return baseCreateRenderer(options);1980}1981function baseCreateRenderer(options, createHydrationFns) {1982  const {insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, forcePatchProp: hostForcePatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, cloneNode: hostCloneNode, insertStaticContent: hostInsertStaticContent} = options;1983  const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, optimized = false) => {1984    if (n1 && !isSameVNodeType(n1, n2)) {1985      anchor = getNextHostNode(n1);1986      unmount(n1, parentComponent, parentSuspense, true);1987      n1 = null;1988    }1989    if (n2.patchFlag === -2) {1990      optimized = false;1991      n2.dynamicChildren = null;1992    }1993    const {type, ref, shapeFlag} = n2;1994    switch (type) {1995      case Text:1996        processText(n1, n2, container, anchor);1997        break;1998      case Comment:1999        processCommentNode(n1, n2, container, anchor);2000        break;2001      case Static:2002        if (n1 == null) {2003          mountStaticNode(n2, container, anchor, isSVG);2004        }2005        break;2006      case Fragment:2007        processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);2008        break;2009      default:2010        if (shapeFlag & 1) {2011          processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);2012        } else if (shapeFlag & 6) {2013          processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);2014        } else if (shapeFlag & 64) {2015          type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals);2016        } else if (shapeFlag & 128) {2017          type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals);2018        } else2019          ;2020    }2021    if (ref != null && parentComponent) {2022      setRef(ref, n1 && n1.ref, parentComponent, parentSuspense, n2);2023    }2024  };2025  const processText = (n1, n2, container, anchor) => {2026    if (n1 == null) {2027      hostInsert(n2.el = hostCreateText(n2.children), container, anchor);2028    } else {2029      const el = n2.el = n1.el;2030      if (n2.children !== n1.children) {2031        hostSetText(el, n2.children);2032      }2033    }2034  };2035  const processCommentNode = (n1, n2, container, anchor) => {2036    if (n1 == null) {2037      hostInsert(n2.el = hostCreateComment(n2.children || ""), container, anchor);2038    } else {2039      n2.el = n1.el;2040    }2041  };2042  const mountStaticNode = (n2, container, anchor, isSVG) => {2043    [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG);2044  };2045  const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {2046    isSVG = isSVG || n2.type === "svg";2047    if (n1 == null) {2048      mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);2049    } else {2050      patchElement(n1, n2, parentComponent, parentSuspense, isSVG, optimized);2051    }2052  };2053  const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {2054    let el;2055    let vnodeHook;2056    const {type, props, shapeFlag, transition, scopeId, patchFlag, dirs} = vnode;2057    if (vnode.el && hostCloneNode !== void 0 && patchFlag === -1) {2058      el = vnode.el = hostCloneNode(vnode.el);2059    } else {2060      el = vnode.el = hostCreateElement(vnode.type, isSVG, props && props.is);2061      if (shapeFlag & 8) {2062        hostSetElementText(el, vnode.children);2063      } else if (shapeFlag & 16) {2064        mountChildren(vnode.children, el, null, parentComponent, parentSuspense, isSVG && type !== "foreignObject", optimized || !!vnode.dynamicChildren);2065      }2066      if (dirs) {2067        invokeDirectiveHook(vnode, null, parentComponent, "created");2068      }2069      if (props) {2070        for (const key in props) {2071          if (!isReservedProp(key)) {2072            hostPatchProp(el, key, null, props[key], isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);2073          }2074        }2075        if (vnodeHook = props.onVnodeBeforeMount) {2076          invokeVNodeHook(vnodeHook, parentComponent, vnode);2077        }2078      }2079      setScopeId(el, scopeId, vnode, parentComponent);2080    }2081    if (dirs) {2082      invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");2083    }2084    const needCallTransitionHooks = (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;2085    if (needCallTransitionHooks) {2086      transition.beforeEnter(el);2087    }2088    hostInsert(el, container, anchor);2089    if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {2090      queuePostRenderEffect(() => {2091        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);2092        needCallTransitionHooks && transition.enter(el);2093        dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");2094      }, parentSuspense);2095    }2096  };2097  const setScopeId = (el, scopeId, vnode, parentComponent) => {2098    if (scopeId) {2099      hostSetScopeId(el, scopeId);2100    }2101    if (parentComponent) {2102      const treeOwnerId = parentComponent.type.__scopeId;2103      if (treeOwnerId && treeOwnerId !== scopeId) {2104        hostSetScopeId(el, treeOwnerId + "-s");2105      }2106      let subTree = parentComponent.subTree;2107      if (vnode === subTree) {2108        setScopeId(el, parentComponent.vnode.scopeId, parentComponent.vnode, parentComponent.parent);2109      }2110    }2111  };2112  const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, optimized, start = 0) => {2113    for (let i = start; i < children.length; i++) {2114      const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);2115      patch(null, child, container, anchor, parentComponent, parentSuspense, isSVG, optimized);2116    }2117  };2118  const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, optimized) => {2119    const el = n2.el = n1.el;2120    let {patchFlag, dynamicChildren, dirs} = n2;2121    patchFlag |= n1.patchFlag & 16;2122    const oldProps = n1.props || EMPTY_OBJ;2123    const newProps = n2.props || EMPTY_OBJ;2124    let vnodeHook;2125    if (vnodeHook = newProps.onVnodeBeforeUpdate) {2126      invokeVNodeHook(vnodeHook, parentComponent, n2, n1);2127    }2128    if (dirs) {2129      invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");2130    }2131    if (patchFlag > 0) {2132      if (patchFlag & 16) {2133        patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);2134      } else {2135        if (patchFlag & 2) {2136          if (oldProps.class !== newProps.class) {2137            hostPatchProp(el, "class", null, newProps.class, isSVG);2138          }2139        }2140        if (patchFlag & 4) {2141          hostPatchProp(el, "style", oldProps.style, newProps.style, isSVG);2142        }2143        if (patchFlag & 8) {2144          const propsToUpdate = n2.dynamicProps;2145          for (let i = 0; i < propsToUpdate.length; i++) {2146            const key = propsToUpdate[i];2147            const prev = oldProps[key];2148            const next = newProps[key];2149            if (next !== prev || hostForcePatchProp && hostForcePatchProp(el, key)) {2150              hostPatchProp(el, key, prev, next, isSVG, n1.children, parentComponent, parentSuspense, unmountChildren);2151            }2152          }2153        }2154      }2155      if (patchFlag & 1) {2156        if (n1.children !== n2.children) {2157          hostSetElementText(el, n2.children);2158        }2159      }2160    } else if (!optimized && dynamicChildren == null) {2161      patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);2162    }2163    const areChildrenSVG = isSVG && n2.type !== "foreignObject";2164    if (dynamicChildren) {2165      patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, areChildrenSVG);2166    } else if (!optimized) {2167      patchChildren(n1, n2, el, null, parentComponent, parentSuspense, areChildrenSVG);2168    }2169    if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {2170      queuePostRenderEffect(() => {2171        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);2172        dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");2173      }, parentSuspense);2174    }2175  };2176  const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG) => {2177    for (let i = 0; i < newChildren.length; i++) {2178      const oldVNode = oldChildren[i];2179      const newVNode = newChildren[i];2180      const container = oldVNode.type === Fragment || !isSameVNodeType(oldVNode, newVNode) || oldVNode.shapeFlag & 6 || oldVNode.shapeFlag & 64 ? hostParentNode(oldVNode.el) : fallbackContainer;2181      patch(oldVNode, newVNode, container, null, parentComponent, parentSuspense, isSVG, true);2182    }2183  };2184  const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {2185    if (oldProps !== newProps) {2186      for (const key in newProps) {2187        if (isReservedProp(key))2188          continue;2189        const next = newProps[key];2190        const prev = oldProps[key];2191        if (next !== prev || hostForcePatchProp && hostForcePatchProp(el, key)) {2192          hostPatchProp(el, key, prev, next, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);2193        }2194      }2195      if (oldProps !== EMPTY_OBJ) {2196        for (const key in oldProps) {2197          if (!isReservedProp(key) && !(key in newProps)) {2198            hostPatchProp(el, key, oldProps[key], null, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);2199          }2200        }2201      }2202    }2203  };2204  const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {2205    const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");2206    const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");2207    let {patchFlag, dynamicChildren} = n2;2208    if (patchFlag > 0) {2209      optimized = true;2210    }2211    if (n1 == null) {2212      hostInsert(fragmentStartAnchor, container, anchor);2213      hostInsert(fragmentEndAnchor, container, anchor);2214      mountChildren(n2.children, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);2215    } else {2216      if (patchFlag > 0 && patchFlag & 64 && dynamicChildren) {2217        patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, isSVG);2218        if (n2.key != null || parentComponent && n2 === parentComponent.subTree) {2219          traverseStaticChildren(n1, n2, true);2220        }2221      } else {2222        patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);2223      }2224    }2225  };2226  const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {2227    if (n1 == null) {2228      if (n2.shapeFlag & 512) {2229        parentComponent.ctx.activate(n2, container, anchor, isSVG, optimized);2230      } else {2231        mountComponent(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);2232      }2233    } else {2234      updateComponent(n1, n2, optimized);2235    }2236  };2237  const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {2238    const instance = initialVNode.component = createComponentInstance(initialVNode, parentComponent, parentSuspense);2239    if (isKeepAlive(initialVNode)) {2240      instance.ctx.renderer = internals;2241    }2242    setupComponent(instance);2243    if (instance.asyncDep) {2244      parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect);2245      if (!initialVNode.el) {2246        const placeholder = instance.subTree = createVNode(Comment);2247        processCommentNode(null, placeholder, container, anchor);2248      }2249      return;2250    }2251    setupRenderEffect(instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized);2252  };2253  const updateComponent = (n1, n2, optimized) => {2254    const instance = n2.component = n1.component;2255    if (shouldUpdateComponent(n1, n2, optimized)) {2256      if (instance.asyncDep && !instance.asyncResolved) {2257        updateComponentPreRender(instance, n2, optimized);2258        return;2259      } else {2260        instance.next = n2;2261        invalidateJob(instance.update);2262        instance.update();2263      }2264    } else {2265      n2.component = n1.component;2266      n2.el = n1.el;2267      instance.vnode = n2;2268    }2269  };2270  const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => {2271    instance.update = effect(function componentEffect() {2272      if (!instance.isMounted) {2273        let vnodeHook;2274        const {el, props} = initialVNode;2275        const {bm, m, parent} = instance;2276        if (bm) {2277          invokeArrayFns(bm);2278        }2279        if (vnodeHook = props && props.onVnodeBeforeMount) {2280          invokeVNodeHook(vnodeHook, parent, initialVNode);2281        }2282        const subTree = instance.subTree = renderComponentRoot(instance);2283        if (el && hydrateNode) {2284          hydrateNode(initialVNode.el, subTree, instance, parentSuspense);2285        } else {2286          patch(null, subTree, container, anchor, instance, parentSuspense, isSVG);2287          initialVNode.el = subTree.el;2288        }2289        if (m) {2290          queuePostRenderEffect(m, parentSuspense);2291        }2292        if (vnodeHook = props && props.onVnodeMounted) {2293          queuePostRenderEffect(() => {2294            invokeVNodeHook(vnodeHook, parent, initialVNode);2295          }, parentSuspense);2296        }2297        const {a} = instance;2298        if (a && initialVNode.shapeFlag & 256) {2299          queuePostRenderEffect(a, parentSuspense);2300        }2301        instance.isMounted = true;2302      } else {2303        let {next, bu, u, parent, vnode} = instance;2304        let originNext = next;2305        let vnodeHook;2306        if (next) {2307          next.el = vnode.el;2308          updateComponentPreRender(instance, next, optimized);2309        } else {2310          next = vnode;2311        }2312        if (bu) {2313          invokeArrayFns(bu);2314        }2315        if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {2316          invokeVNodeHook(vnodeHook, parent, next, vnode);2317        }2318        const nextTree = renderComponentRoot(instance);2319        const prevTree = instance.subTree;2320        instance.subTree = nextTree;2321        patch(prevTree, nextTree, hostParentNode(prevTree.el), getNextHostNode(prevTree), instance, parentSuspense, isSVG);2322        next.el = nextTree.el;2323        if (originNext === null) {2324          updateHOCHostEl(instance, nextTree.el);2325        }2326        if (u) {2327          queuePostRenderEffect(u, parentSuspense);2328        }2329        if (vnodeHook = next.props && next.props.onVnodeUpdated) {2330          queuePostRenderEffect(() => {2331            invokeVNodeHook(vnodeHook, parent, next, vnode);2332          }, parentSuspense);2333        }2334      }2335    }, prodEffectOptions);2336  };2337  const updateComponentPreRender = (instance, nextVNode, optimized) => {2338    nextVNode.component = instance;2339    const prevProps = instance.vnode.props;2340    instance.vnode = nextVNode;2341    instance.next = null;2342    updateProps(instance, nextVNode.props, prevProps, optimized);2343    updateSlots(instance, nextVNode.children);2344    flushPreFlushCbs(void 0, instance.update);2345  };2346  const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized = false) => {2347    const c1 = n1 && n1.children;2348    const prevShapeFlag = n1 ? n1.shapeFlag : 0;2349    const c2 = n2.children;2350    const {patchFlag, shapeFlag} = n2;2351    if (patchFlag > 0) {2352      if (patchFlag & 128) {2353        patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);2354        return;2355      } else if (patchFlag & 256) {2356        patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);2357        return;2358      }2359    }2360    if (shapeFlag & 8) {2361      if (prevShapeFlag & 16) {2362        unmountChildren(c1, parentComponent, parentSuspense);2363      }2364      if (c2 !== c1) {2365        hostSetElementText(container, c2);2366      }2367    } else {2368      if (prevShapeFlag & 16) {2369        if (shapeFlag & 16) {2370          patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);2371        } else {2372          unmountChildren(c1, parentComponent, parentSuspense, true);2373        }2374      } else {2375        if (prevShapeFlag & 8) {2376          hostSetElementText(container, "");2377        }2378        if (shapeFlag & 16) {2379          mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);2380        }2381      }2382    }2383  };2384  const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {2385    c1 = c1 || EMPTY_ARR;2386    c2 = c2 || EMPTY_ARR;2387    const oldLength = c1.length;2388    const newLength = c2.length;2389    const commonLength = Math.min(oldLength, newLength);2390    let i;2391    for (i = 0; i < commonLength; i++) {2392      const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);2393      patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, isSVG, optimized);2394    }2395    if (oldLength > newLength) {2396      unmountChildren(c1, parentComponent, parentSuspense, true, false, commonLength);2397    } else {2398      mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, commonLength);2399    }2400  };2401  const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, optimized) => {2402    let i = 0;2403    const l2 = c2.length;2404    let e1 = c1.length - 1;2405    let e2 = l2 - 1;2406    while (i <= e1 && i <= e2) {2407      const n1 = c1[i];2408      const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);2409      if (isSameVNodeType(n1, n2)) {2410        patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, optimized);2411      } else {2412        break;2413      }2414      i++;2415    }2416    while (i <= e1 && i <= e2) {2417      const n1 = c1[e1];2418      const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);2419      if (isSameVNodeType(n1, n2)) {2420        patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, optimized);2421      } else {2422        break;2423      }2424      e1--;2425      e2--;2426    }2427    if (i > e1) {2428      if (i <= e2) {2429        const nextPos = e2 + 1;2430        const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;2431        while (i <= e2) {2432          patch(null, c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]), container, anchor, parentComponent, parentSuspense, isSVG);2433          i++;2434        }2435      }2436    } else if (i > e2) {2437      while (i <= e1) {2438        unmount(c1[i], parentComponent, parentSuspense, true);2439        i++;2440      }2441    } else {2442      const s1 = i;2443      const s2 = i;2444      const keyToNewIndexMap = new Map();2445      for (i = s2; i <= e2; i++) {2446        const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);2447        if (nextChild.key != null) {2448          keyToNewIndexMap.set(nextChild.key, i);2449        }2450      }2451      let j;2452      let patched = 0;2453      const toBePatched = e2 - s2 + 1;2454      let moved = false;2455      let maxNewIndexSoFar = 0;2456      const newIndexToOldIndexMap = new Array(toBePatched);2457      for (i = 0; i < toBePatched; i++)2458        newIndexToOldIndexMap[i] = 0;2459      for (i = s1; i <= e1; i++) {2460        const prevChild = c1[i];2461        if (patched >= toBePatched) {2462          unmount(prevChild, parentComponent, parentSuspense, true);2463          continue;2464        }2465        let newIndex;2466        if (prevChild.key != null) {2467          newIndex = keyToNewIndexMap.get(prevChild.key);2468        } else {2469          for (j = s2; j <= e2; j++) {2470            if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {2471              newIndex = j;2472              break;2473            }2474          }2475        }2476        if (newIndex === void 0) {2477          unmount(prevChild, parentComponent, parentSuspense, true);2478        } else {2479          newIndexToOldIndexMap[newIndex - s2] = i + 1;2480          if (newIndex >= maxNewIndexSoFar) {2481            maxNewIndexSoFar = newIndex;2482          } else {2483            moved = true;2484          }2485          patch(prevChild, c2[newIndex], container, null, parentComponent, parentSuspense, isSVG, optimized);2486          patched++;2487        }2488      }2489      const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR;2490      j = increasingNewIndexSequence.length - 1;2491      for (i = toBePatched - 1; i >= 0; i--) {2492        const nextIndex = s2 + i;2493        const nextChild = c2[nextIndex];2494        const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;2495        if (newIndexToOldIndexMap[i] === 0) {2496          patch(null, nextChild, container, anchor, parentComponent, parentSuspense, isSVG);2497        } else if (moved) {2498          if (j < 0 || i !== increasingNewIndexSequence[j]) {2499            move(nextChild, container, anchor, 2);2500          } else {2501            j--;2502          }2503        }2504      }2505    }2506  };2507  const move = (vnode, container, anchor, moveType, parentSuspense = null) => {2508    const {el, type, transition, children, shapeFlag} = vnode;2509    if (shapeFlag & 6) {2510      move(vnode.component.subTree, container, anchor, moveType);2511      return;2512    }2513    if (shapeFlag & 128) {2514      vnode.suspense.move(container, anchor, moveType);2515      return;2516    }2517    if (shapeFlag & 64) {2518      type.move(vnode, container, anchor, internals);2519      return;2520    }2521    if (type === Fragment) {2522      hostInsert(el, container, anchor);2523      for (let i = 0; i < children.length; i++) {2524        move(children[i], container, anchor, moveType);2525      }2526      hostInsert(vnode.anchor, container, anchor);2527      return;2528    }2529    const needTransition = moveType !== 2 && shapeFlag & 1 && transition;2530    if (needTransition) {2531      if (moveType === 0) {2532        transition.beforeEnter(el);2533        hostInsert(el, container, anchor);2534        queuePostRenderEffect(() => transition.enter(el), parentSuspense);2535      } else {2536        const {leave, delayLeave, afterLeave} = transition;2537        const remove3 = () => hostInsert(el, container, anchor);2538        const performLeave = () => {2539          leave(el, () => {2540            remove3();2541            afterLeave && afterLeave();2542          });2543        };2544        if (delayLeave) {2545          delayLeave(el, remove3, performLeave);2546        } else {2547          performLeave();2548        }2549      }2550    } else {2551      hostInsert(el, container, anchor);2552    }2553  };2554  const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {2555    const {type, props, ref, children, dynamicChildren, shapeFlag, patchFlag, dirs} = vnode;2556    if (ref != null && parentComponent) {2557      setRef(ref, null, parentComponent, parentSuspense, null);2558    }2559    if (shapeFlag & 256) {2560      parentComponent.ctx.deactivate(vnode);2561      return;2562    }2563    const shouldInvokeDirs = shapeFlag & 1 && dirs;2564    let vnodeHook;2565    if (vnodeHook = props && props.onVnodeBeforeUnmount) {2566      invokeVNodeHook(vnodeHook, parentComponent, vnode);2567    }2568    if (shapeFlag & 6) {2569      unmountComponent(vnode.component, parentSuspense, doRemove);2570    } else {2571      if (shapeFlag & 128) {2572        vnode.suspense.unmount(parentSuspense, doRemove);2573        return;2574      }2575      if (shouldInvokeDirs) {2576        invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");2577      }2578      if (dynamicChildren && (type !== Fragment || patchFlag > 0 && patchFlag & 64)) {2579        unmountChildren(dynamicChildren, parentComponent, parentSuspense, false, true);2580      } else if (type === Fragment && (patchFlag & 128 || patchFlag & 256) || !optimized && shapeFlag & 16) {2581        unmountChildren(children, parentComponent, parentSuspense);2582      }2583      if (shapeFlag & 64 && (doRemove || !isTeleportDisabled(vnode.props))) {2584        vnode.type.remove(vnode, internals);2585      }2586      if (doRemove) {2587        remove2(vnode);2588      }2589    }2590    if ((vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {2591      queuePostRenderEffect(() => {2592        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);2593        shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");2594      }, parentSuspense);2595    }2596  };2597  const remove2 = (vnode) => {2598    const {type, el, anchor, transition} = vnode;2599    if (type === Fragment) {2600      removeFragment(el, anchor);2601      return;2602    }2603    const performRemove = () => {2604      hostRemove(el);2605      if (transition && !transition.persisted && transition.afterLeave) {2606        transition.afterLeave();2607      }2608    };2609    if (vnode.shapeFlag & 1 && transition && !transition.persisted) {2610      const {leave, delayLeave} = transition;2611      const performLeave = () => leave(el, performRemove);2612      if (delayLeave) {2613        delayLeave(vnode.el, performRemove, performLeave);2614      } else {2615        performLeave();2616      }2617    } else {2618      performRemove();2619    }2620  };2621  const removeFragment = (cur, end) => {2622    let next;2623    while (cur !== end) {2624      next = hostNextSibling(cur);2625      hostRemove(cur);2626      cur = next;2627    }2628    hostRemove(end);2629  };2630  const unmountComponent = (instance, parentSuspense, doRemove) => {2631    const {bum, effects, update, subTree, um} = instance;2632    if (bum) {2633      invokeArrayFns(bum);2634    }2635    if (effects) {2636      for (let i = 0; i < effects.length; i++) {2637        stop(effects[i]);2638      }2639    }2640    if (update) {2641      stop(update);2642      unmount(subTree, instance, parentSuspense, doRemove);2643    }2644    if (um) {2645      queuePostRenderEffect(um, parentSuspense);2646    }2647    queuePostRenderEffect(() => {2648      instance.isUnmounted = true;2649    }, parentSuspense);2650    if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {2651      parentSuspense.deps--;2652      if (parentSuspense.deps === 0) {2653        parentSuspense.resolve();2654      }2655    }2656  };2657  const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {2658    for (let i = start; i < children.length; i++) {2659      unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);2660    }2661  };2662  const getNextHostNode = (vnode) => {2663    if (vnode.shapeFlag & 6) {2664      return getNextHostNode(vnode.component.subTree);2665    }2666    if (vnode.shapeFlag & 128) {2667      return vnode.suspense.next();2668    }2669    return hostNextSibling(vnode.anchor || vnode.el);2670  };2671  const render2 = (vnode, container) => {2672    if (vnode == null) {2673      if (container._vnode) {2674        unmount(container._vnode, null, null, true);2675      }2676    } else {2677      patch(container._vnode || null, vnode, container);2678    }2679    flushPostFlushCbs();2680    container._vnode = vnode;2681  };2682  const internals = {2683    p: patch,2684    um: unmount,2685    m: move,2686    r: remove2,2687    mt: mountComponent,2688    mc: mountChildren,2689    pc: patchChildren,2690    pbc: patchBlockChildren,2691    n: getNextHostNode,2692    o: options2693  };2694  let hydrate;2695  let hydrateNode;2696  if (createHydrationFns) {2697    [hydrate, hydrateNode] = createHydrationFns(internals);2698  }2699  return {2700    render: render2,2701    hydrate,2702    createApp: createAppAPI(render2, hydrate)2703  };2704}2705function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {2706  callWithAsyncErrorHandling(hook, instance, 7, [2707    vnode,2708    prevVNode2709  ]);2710}2711function traverseStaticChildren(n1, n2, shallow = false) {2712  const ch1 = n1.children;2713  const ch2 = n2.children;2714  if (isArray(ch1) && isArray(ch2)) {2715    for (let i = 0; i < ch1.length; i++) {2716      const c1 = ch1[i];2717      let c2 = ch2[i];2718      if (c2.shapeFlag & 1 && !c2.dynamicChildren) {2719        if (c2.patchFlag <= 0 || c2.patchFlag === 32) {2720          c2 = ch2[i] = cloneIfMounted(ch2[i]);2721          c2.el = c1.el;2722        }2723        if (!shallow)2724          traverseStaticChildren(c1, c2);2725      }2726    }2727  }2728}2729function getSequence(arr) {2730  const p2 = arr.slice();2731  const result = [0];2732  let i, j, u, v, c;2733  const len = arr.length;2734  for (i = 0; i < len; i++) {2735    const arrI = arr[i];2736    if (arrI !== 0) {2737      j = result[result.length - 1];2738      if (arr[j] < arrI) {2739        p2[i] = j;2740        result.push(i);2741        continue;2742      }2743      u = 0;2744      v = result.length - 1;2745      while (u < v) {2746        c = (u + v) / 2 | 0;2747        if (arr[result[c]] < arrI) {2748          u = c + 1;2749        } else {2750          v = c;2751        }2752      }2753      if (arrI < arr[result[u]]) {2754        if (u > 0) {2755          p2[i] = result[u - 1];2756        }2757        result[u] = i;2758      }2759    }2760  }2761  u = result.length;2762  v = result[u - 1];2763  while (u-- > 0) {2764    result[u] = v;2765    v = p2[v];2766  }2767  return result;2768}2769const isTeleport = (type) => type.__isTeleport;2770const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");2771const COMPONENTS = "components";2772function resolveComponent(name) {2773  return resolveAsset(COMPONENTS, name) || name;2774}2775const NULL_DYNAMIC_COMPONENT = Symbol();2776function resolveAsset(type, name, warnMissing = true) {2777  const instance = currentRenderingInstance || currentInstance;2778  if (instance) {2779    const Component = instance.type;2780    if (type === COMPONENTS) {2781      const selfName = Component.displayName || Component.name;2782      if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {2783        return Component;2784      }2785    }2786    const res = resolve(instance[type] || Component[type], name) || resolve(instance.appContext[type], name);2787    return res;2788  }2789}2790function resolve(registry, name) {2791  return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);2792}2793const Fragment = Symbol(void 0);2794const Text = Symbol(void 0);2795const Comment = Symbol(void 0);2796const Static = Symbol(void 0);2797const blockStack = [];2798let currentBlock = null;2799function openBlock(disableTracking = false) {2800  blockStack.push(currentBlock = disableTracking ? null : []);2801}2802function closeBlock() {2803  blockStack.pop();2804  currentBlock = blockStack[blockStack.length - 1] || null;2805}2806function createBlock(type, props, children, patchFlag, dynamicProps) {2807  const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true);2808  vnode.dynamicChildren = currentBlock || EMPTY_ARR;2809  closeBlock();2810  if (currentBlock) {2811    currentBlock.push(vnode);2812  }2813  return vnode;2814}2815function isVNode(value) {2816  return value ? value.__v_isVNode === true : false;2817}2818function isSameVNodeType(n1, n2) {2819  return n1.type === n2.type && n1.key === n2.key;2820}2821const InternalObjectKey = `__vInternal`;2822const normalizeKey = ({key}) => key != null ? key : null;2823const normalizeRef = ({ref}) => {2824  return ref != null ? isArray(ref) ? ref : {i: currentRenderingInstance, r: ref} : null;2825};2826const createVNode = _createVNode;2827function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {2828  if (!type || type === NULL_DYNAMIC_COMPONENT) {2829    type = Comment;2830  }2831  if (isVNode(type)) {2832    const cloned = cloneVNode(type, props, true);2833    if (children) {2834      normalizeChildren(cloned, children);2835    }2836    return cloned;2837  }2838  if (isClassComponent(type)) {2839    type = type.__vccOpts;2840  }2841  if (props) {2842    if (isProxy(props) || InternalObjectKey in props) {2843      props = extend({}, props);2844    }2845    let {class: klass, style} = props;2846    if (klass && !isString(klass)) {2847      props.class = normalizeClass(klass);2848    }2849    if (isObject(style)) {2850      if (isProxy(style) && !isArray(style)) {2851        style = extend({}, style);2852      }2853      props.style = normalizeStyle(style);2854    }2855  }2856  const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;2857  const vnode = {2858    __v_isVNode: true,2859    ["__v_skip"]: true,2860    type,2861    props,2862    key: props && normalizeKey(props),2863    ref: props && normalizeRef(props),2864    scopeId: currentScopeId,2865    children: null,2866    component: null,2867    suspense: null,2868    ssContent: null,2869    ssFallback: null,2870    dirs: null,2871    transition: null,2872    el: null,2873    anchor: null,2874    target: null,2875    targetAnchor: null,2876    staticCount: 0,2877    shapeFlag,2878    patchFlag,2879    dynamicProps,2880    dynamicChildren: null,2881    appContext: null2882  };2883  normalizeChildren(vnode, children);2884  if (shapeFlag & 128) {2885    const {content, fallback} = normalizeSuspenseChildren(vnode);2886    vnode.ssContent = content;2887    vnode.ssFallback = fallback;2888  }2889  if (!isBlockNode && currentBlock && (patchFlag > 0 || shapeFlag & 6) && patchFlag !== 32) {2890    currentBlock.push(vnode);2891  }2892  return vnode;2893}2894function cloneVNode(vnode, extraProps, mergeRef = false) {2895  const {props, ref, patchFlag} = vnode;2896  const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;2897  return {2898    __v_isVNode: true,2899    ["__v_skip"]: true,2900    type: vnode.type,2901    props: mergedProps,2902    key: mergedProps && normalizeKey(mergedProps),2903    ref: extraProps && extraProps.ref ? mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref,2904    scopeId: vnode.scopeId,2905    children: vnode.children,2906    target: vnode.target,2907    targetAnchor: vnode.targetAnchor,2908    staticCount: vnode.staticCount,2909    shapeFlag: vnode.shapeFlag,2910    patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,2911    dynamicProps: vnode.dynamicProps,2912    dynamicChildren: vnode.dynamicChildren,2913    appContext: vnode.appContext,2914    dirs: vnode.dirs,2915    transition: vnode.transition,2916    component: vnode.component,2917    suspense: vnode.suspense,2918    ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),2919    ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),2920    el: vnode.el,2921    anchor: vnode.anchor2922  };2923}2924function createTextVNode(text = " ", flag = 0) {2925  return createVNode(Text, null, text, flag);2926}2927function normalizeVNode(child) {2928  if (child == null || typeof child === "boolean") {2929    return createVNode(Comment);2930  } else if (isArray(child)) {2931    return createVNode(Fragment, null, child);2932  } else if (typeof child === "object") {2933    return child.el === null ? child : cloneVNode(child);2934  } else {2935    return createVNode(Text, null, String(child));2936  }2937}2938function cloneIfMounted(child) {2939  return child.el === null ? child : cloneVNode(child);2940}2941function normalizeChildren(vnode, children) {2942  let type = 0;2943  const {shapeFlag} = vnode;2944  if (children == null) {2945    children = null;2946  } else if (isArray(children)) {2947    type = 16;2948  } else if (typeof children === "object") {2949    if (shapeFlag & 1 || shapeFlag & 64) {2950      const slot = children.default;2951      if (slot) {2952        slot._c && setCompiledSlotRendering(1);2953        normalizeChildren(vnode, slot());2954        slot._c && setCompiledSlotRendering(-1);2955      }2956      return;2957    } else {2958      type = 32;2959      const slotFlag = children._;2960      if (!slotFlag && !(InternalObjectKey in children)) {2961        children._ctx = currentRenderingInstance;2962      } else if (slotFlag === 3 && currentRenderingInstance) {2963        if (currentRenderingInstance.vnode.patchFlag & 1024) {2964          children._ = 2;2965          vnode.patchFlag |= 1024;2966        } else {2967          children._ = 1;2968        }2969      }2970    }2971  } else if (isFunction(children)) {2972    children = {default: children, _ctx: currentRenderingInstance};2973    type = 32;2974  } else {2975    children = String(children);2976    if (shapeFlag & 64) {2977      type = 16;2978      children = [createTextVNode(children)];2979    } else {2980      type = 8;2981    }2982  }2983  vnode.children = children;2984  vnode.shapeFlag |= type;2985}2986function mergeProps(...args) {2987  const ret = extend({}, args[0]);2988  for (let i = 1; i < args.length; i++) {2989    const toMerge = args[i];2990    for (const key in toMerge) {2991      if (key === "class") {2992        if (ret.class !== toMerge.class) {2993          ret.class = normalizeClass([ret.class, toMerge.class]);2994        }2995      } else if (key === "style") {2996        ret.style = normalizeStyle([ret.style, toMerge.style]);2997      } else if (isOn(key)) {2998        const existing = ret[key];2999        const incoming = toMerge[key];3000        if (existing !== incoming) {3001          ret[key] = existing ? [].concat(existing, toMerge[key]) : incoming;3002        }3003      } else if (key !== "") {3004        ret[key] = toMerge[key];3005      }3006    }3007  }3008  return ret;3009}3010function provide(key, value) {3011  if (!currentInstance)3012    ;3013  else {3014    let provides = currentInstance.provides;3015    const parentProvides = currentInstance.parent && currentInstance.parent.provides;3016    if (parentProvides === provides) {3017      provides = currentInstance.provides = Object.create(parentProvides);3018    }3019    provides[key] = value;3020  }3021}3022function inject(key, defaultValue, treatDefaultAsFactory = false) {3023  const instance = currentInstance || currentRenderingInstance;3024  if (instance) {3025    const provides = instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides;3026    if (provides && key in provides) {3027      return provides[key];3028    } else if (arguments.length > 1) {3029      return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue() : defaultValue;3030    } else3031      ;3032  }3033}3034let isInBeforeCreate = false;3035function applyOptions(instance, options, deferredData = [], deferredWatch = [], deferredProvide = [], asMixin = false) {3036  const {3037    mixins,3038    extends: extendsOptions,3039    data: dataOptions,3040    computed: computedOptions,3041    methods,3042    watch: watchOptions,3043    provide: provideOptions,3044    inject: injectOptions,3045    components,3046    directives,3047    beforeMount,3048    mounted,3049    beforeUpdate,3050    updated,3051    activated,3052    deactivated,3053    beforeDestroy,3054    beforeUnmount,3055    destroyed,3056    unmounted,3057    render: render2,3058    renderTracked,3059    renderTriggered,3060    errorCaptured3061  } = options;3062  const publicThis = instance.proxy;3063  const ctx = instance.ctx;3064  const globalMixins = instance.appContext.mixins;3065  if (asMixin && render2 && instance.render === NOOP) {3066    instance.render = render2;3067  }3068  if (!asMixin) {3069    isInBeforeCreate = true;3070    callSyncHook("beforeCreate", "bc", options, instance, globalMixins);3071    isInBeforeCreate = false;3072    applyMixins(instance, globalMixins, deferredData, deferredWatch, deferredProvide);3073  }3074  if (extendsOptions) {3075    applyOptions(instance, extendsOptions, deferredData, deferredWatch, deferredProvide, true);3076  }3077  if (mixins) {3078    applyMixins(instance, mixins, deferredData, deferredWatch, deferredProvide);3079  }3080  if (injectOptions) {3081    if (isArray(injectOptions)) {3082      for (let i = 0; i < injectOptions.length; i++) {3083        const key = injectOptions[i];3084        ctx[key] = inject(key);3085      }3086    } else {3087      for (const key in injectOptions) {3088        const opt = injectOptions[key];3089        if (isObject(opt)) {3090          ctx[key] = inject(opt.from || key, opt.default, true);3091        } else {3092          ctx[key] = inject(opt);3093        }3094      }3095    }3096  }3097  if (methods) {3098    for (const key in methods) {3099      const methodHandler = methods[key];3100      if (isFunction(methodHandler)) {3101        ctx[key] = methodHandler.bind(publicThis);3102      }3103    }3104  }3105  if (!asMixin) {3106    if (deferredData.length) {3107      deferredData.forEach((dataFn) => resolveData(instance, dataFn, publicThis));3108    }3109    if (dataOptions) {3110      resolveData(instance, dataOptions, publicThis);3111    }3112  } else if (dataOptions) {3113    deferredData.push(dataOptions);3114  }3115  if (computedOptions) {3116    for (const key in computedOptions) {3117      const opt = computedOptions[key];3118      const get2 = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;3119      const set2 = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : NOOP;3120      const c = computed$1({3121        get: get2,3122        set: set23123      });3124      Object.defineProperty(ctx, key, {3125        enumerable: true,3126        configurable: true,3127        get: () => c.value,3128        set: (v) => c.value = v3129      });3130    }3131  }3132  if (watchOptions) {3133    deferredWatch.push(watchOptions);3134  }3135  if (!asMixin && deferredWatch.length) {3136    deferredWatch.forEach((watchOptions2) => {3137      for (const key in watchOptions2) {3138        createWatcher(watchOptions2[key], ctx, publicThis, key);3139      }3140    });3141  }3142  if (provideOptions) {3143    deferredProvide.push(provideOptions);3144  }3145  if (!asMixin && deferredProvide.length) {3146    deferredProvide.forEach((provideOptions2) => {3147      const provides = isFunction(provideOptions2) ? provideOptions2.call(publicThis) : provideOptions2;3148      for (const key in provides) {3149        provide(key, provides[key]);3150      }3151    });3152  }3153  if (asMixin) {3154    if (components) {3155      extend(instance.components || (instance.components = extend({}, instance.type.components)), components);3156    }3157    if (directives) {3158      extend(instance.directives || (instance.directives = extend({}, instance.type.directives)), directives);3159    }3160  }3161  if (!asMixin) {3162    callSyncHook("created", "c", options, instance, globalMixins);3163  }3164  if (beforeMount) {3165    onBeforeMount(beforeMount.bind(publicThis));3166  }3167  if (mounted) {3168    onMounted(mounted.bind(publicThis));3169  }3170  if (beforeUpdate) {3171    onBeforeUpdate(beforeUpdate.bind(publicThis));3172  }3173  if (updated) {3174    onUpdated(updated.bind(publicThis));3175  }3176  if (activated) {3177    onActivated(activated.bind(publicThis));3178  }3179  if (deactivated) {3180    onDeactivated(deactivated.bind(publicThis));3181  }3182  if (errorCaptured) {3183    onErrorCaptured(errorCaptured.bind(publicThis));3184  }3185  if (renderTracked) {3186    onRenderTracked(renderTracked.bind(publicThis));3187  }3188  if (renderTriggered) {3189    onRenderTriggered(renderTriggered.bind(publicThis));3190  }3191  if (beforeUnmount) {3192    onBeforeUnmount(beforeUnmount.bind(publicThis));3193  }3194  if (unmounted) {3195    onUnmounted(unmounted.bind(publicThis));3196  }3197}3198function callSyncHook(name, type, options, instance, globalMixins) {3199  callHookFromMixins(name, type, globalMixins, instance);3200  const {extends: base, mixins} = options;3201  if (base) {3202    callHookFromExtends(name, type, base, instance);3203  }3204  if (mixins) {3205    callHookFromMixins(name, type, mixins, instance);3206  }3207  const selfHook = options[name];3208  if (selfHook) {3209    callWithAsyncErrorHandling(selfHook.bind(instance.proxy), instance, type);3210  }3211}3212function callHookFromExtends(name, type, base, instance) {3213  if (base.extends) {3214    callHookFromExtends(name, type, base.extends, instance);3215  }3216  const baseHook = base[name];3217  if (baseHook) {3218    callWithAsyncErrorHandling(baseHook.bind(instance.proxy), instance, type);3219  }3220}3221function callHookFromMixins(name, type, mixins, instance) {3222  for (let i = 0; i < mixins.length; i++) {3223    const chainedMixins = mixins[i].mixins;3224    if (chainedMixins) {3225      callHookFromMixins(name, type, chainedMixins, instance);3226    }3227    const fn = mixins[i][name];3228    if (fn) {3229      callWithAsyncErrorHandling(fn.bind(instance.proxy), instance, type);3230    }3231  }3232}3233function applyMixins(instance, mixins, deferredData, deferredWatch, deferredProvide) {3234  for (let i = 0; i < mixins.length; i++) {3235    applyOptions(instance, mixins[i], deferredData, deferredWatch, deferredProvide, true);3236  }3237}3238function resolveData(instance, dataFn, publicThis) {3239  const data = dataFn.call(publicThis, publicThis);3240  if (!isObject(data))3241    ;3242  else if (instance.data === EMPTY_OBJ) {3243    instance.data = reactive(data);3244  } else {3245    extend(instance.data, data);3246  }3247}3248function createWatcher(raw, ctx, publicThis, key) {3249  const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];3250  if (isString(raw)) {3251    const handler = ctx[raw];3252    if (isFunction(handler)) {3253      watch(getter, handler);3254    }3255  } else if (isFunction(raw)) {3256    watch(getter, raw.bind(publicThis));3257  } else if (isObject(raw)) {3258    if (isArray(raw)) {3259      raw.forEach((r) => createWatcher(r, ctx, publicThis, key));3260    } else {3261      const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];3262      if (isFunction(handler)) {3263        watch(getter, handler, raw);3264      }3265    }3266  } else3267    ;3268}3269function createPathGetter(ctx, path) {3270  const segments = path.split(".");3271  return () => {3272    let cur = ctx;3273    for (let i = 0; i < segments.length && cur; i++) {3274      cur = cur[segments[i]];3275    }3276    return cur;3277  };3278}3279function resolveMergedOptions(instance) {3280  const raw = instance.type;3281  const {__merged, mixins, extends: extendsOptions} = raw;3282  if (__merged)3283    return __merged;3284  const globalMixins = instance.appContext.mixins;3285  if (!globalMixins.length && !mixins && !extendsOptions)3286    return raw;3287  const options = {};3288  globalMixins.forEach((m) => mergeOptions(options, m, instance));3289  mergeOptions(options, raw, instance);3290  return raw.__merged = options;3291}3292function mergeOptions(to, from, instance) {3293  const strats = instance.appContext.config.optionMergeStrategies;3294  const {mixins, extends: extendsOptions} = from;3295  extendsOptions && mergeOptions(to, extendsOptions, instance);3296  mixins && mixins.forEach((m) => mergeOptions(to, m, instance));3297  for (const key in from) {3298    if (strats && hasOwn(strats, key)) {3299      to[key] = strats[key](to[key], from[key], instance.proxy, key);3300    } else {3301      to[key] = from[key];3302    }3303  }3304}3305const publicPropertiesMap = extend(Object.create(null), {3306  $: (i) => i,3307  $el: (i) => i.vnode.el,3308  $data: (i) => i.data,3309  $props: (i) => i.props,3310  $attrs: (i) => i.attrs,3311  $slots: (i) => i.slots,3312  $refs: (i) => i.refs,3313  $parent: (i) => i.parent && i.parent.proxy,3314  $root: (i) => i.root && i.root.proxy,3315  $emit: (i) => i.emit,3316  $options: (i) => resolveMergedOptions(i),3317  $forceUpdate: (i) => () => queueJob(i.update),3318  $nextTick: (i) => nextTick.bind(i.proxy),3319  $watch: (i) => instanceWatch.bind(i)3320});3321const PublicInstanceProxyHandlers = {3322  get({_: instance}, key) {3323    const {ctx, setupState, data, props, accessCache, type, appContext} = instance;3324    if (key === "__v_skip") {3325      return true;3326    }3327    let normalizedProps;3328    if (key[0] !== "$") {3329      const n = accessCache[key];3330      if (n !== void 0) {3331        switch (n) {3332          case 0:3333            return setupState[key];3334          case 1:3335            return data[key];3336          case 3:3337            return ctx[key];3338          case 2:3339            return props[key];3340        }3341      } else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {3342        accessCache[key] = 0;3343        return setupState[key];3344      } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {3345        accessCache[key] = 1;3346        return data[key];3347      } else if ((normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)) {3348        accessCache[key] = 2;3349        return props[key];3350      } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {3351        accessCache[key] = 3;3352        return ctx[key];3353      } else if (!isInBeforeCreate) {3354        accessCache[key] = 4;3355      }3356    }3357    const publicGetter = publicPropertiesMap[key];3358    let cssModule, globalProperties;3359    if (publicGetter) {3360      if (key === "$attrs") {3361        track(instance, "get", key);3362      }3363      return publicGetter(instance);3364    } else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) {3365      return cssModule;3366    } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {3367      accessCache[key] = 3;3368      return ctx[key];3369    } else if (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) {3370      return globalProperties[key];3371    } else3372      ;3373  },3374  set({_: instance}, key, value) {3375    const {data, setupState, ctx} = instance;3376    if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {3377      setupState[key] = value;3378    } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {3379      data[key] = value;3380    } else if (key in instance.props) {3381      return false;3382    }3383    if (key[0] === "$" && key.slice(1) in instance) {3384      return false;3385    } else {3386      {3387        ctx[key] = value;3388      }3389    }3390    return true;3391  },3392  has({_: {data, setupState, accessCache, ctx, appContext, propsOptions}}, key) {3393    let normalizedProps;3394    return accessCache[key] !== void 0 || data !== EMPTY_OBJ && hasOwn(data, key) || setupState !== EMPTY_OBJ && hasOwn(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);3395  }3396};3397const RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {3398  get(target, key) {3399    if (key === Symbol.unscopables) {3400      return;3401    }3402    return PublicInstanceProxyHandlers.get(target, key, target);3403  },3404  has(_, key) {3405    const has2 = key[0] !== "_" && !isGloballyWhitelisted(key);3406    return has2;3407  }3408});3409const emptyAppContext = createAppContext();3410let uid$1$1 = 0;3411function createComponentInstance(vnode, parent, suspense) {3412  const type = vnode.type;3413  const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;3414  const instance = {3415    uid: uid$1$1++,3416    vnode,3417    type,3418    parent,3419    appContext,3420    root: null,3421    next: null,3422    subTree: null,3423    update: null,3424    render: null,3425    proxy: null,3426    withProxy: null,3427    effects: null,3428    provides: parent ? parent.provides : Object.create(appContext.provides),3429    accessCache: null,3430    renderCache: [],3431    components: null,3432    directives: null,3433    propsOptions: normalizePropsOptions(type, appContext),3434    emitsOptions: normalizeEmitsOptions(type, appContext),3435    emit: null,3436    emitted: null,3437    ctx: EMPTY_OBJ,3438    data: EMPTY_OBJ,3439    props: EMPTY_OBJ,3440    attrs: EMPTY_OBJ,3441    slots: EMPTY_OBJ,3442    refs: EMPTY_OBJ,3443    setupState: EMPTY_OBJ,3444    setupContext: null,3445    suspense,3446    suspenseId: suspense ? suspense.pendingId : 0,3447    asyncDep: null,3448    asyncResolved: false,...

setup.js

Source:setup.js

...26        components: null,27        directives: null,28        // resolved props and emits options29        propsOptions: normalizePropsOptions(type, appContext),30        emitsOptions: normalizeEmitsOptions(type, appContext),31        // emit32        emit: null,33        emitted: null,34        // state35        ctx: EMPTY_OBJ,36        data: EMPTY_OBJ,37        props: EMPTY_OBJ,38        attrs: EMPTY_OBJ,39        slots: EMPTY_OBJ,40        refs: EMPTY_OBJ,41        setupState: EMPTY_OBJ,42        setupContext: null,43        // suspense related44        suspense,...

component.js

Source:component.js

...82    renderCache: [],83    components: null,84    directives: null,85    propsOptions: normalizePropsOptions(type, appContext),86    emitsOptions: normalizeEmitsOptions(type, appContext),87    // æ´¾åäºä»¶æ¹æ³88    emit: null,89    emitted: null,90    propsDefaults: EMPTY_OBJ,91    inheritAttrs: type.inheritAttrs,92    // æ¸²æä¸ä¸æ  content å¯¹è±¡93    ctx: EMPTY_OBJ,94    data: EMPTY_OBJ,95    props: EMPTY_OBJ,96    attrs: EMPTY_OBJ,97    slots: EMPTY_OBJ,98    refs: EMPTY_OBJ,99    // setup è¿åå¼100    setupState: EMPTY_OBJ,...

listed.js

Source:listed.js

...75        components: null,76        directives: null,77        // resolved props and emits options78        propsOptions: normalizePropsOptions(type, appContext),79        emitsOptions: normalizeEmitsOptions(type, appContext),80        // emit81        emit: null,82        emitted: null,83        // props default value84        propsDefaults: EMPTY_OBJ,85        // inheritAttrs86        inheritAttrs: type.inheritAttrs,87        // state88        ctx: EMPTY_OBJ,89        data: EMPTY_OBJ,90        props: EMPTY_OBJ,91        attrs: EMPTY_OBJ,92        slots: EMPTY_OBJ,93        refs: EMPTY_OBJ,...

emit.js

Source:emit.js

...49    uid: uid$2++,50    // ...51    // resolved props and emits options52    propsOptions: normalizePropsOptions(type, appContext),53    emitsOptions: normalizeEmitsOptions(type, appContext)54    // ...55}56function normalizeEmitsOptions(comp, appContext, asMixin = false) {57    const appId = appContext.app ? appContext.app._uid : -1;58    const cache = comp.__emits || (comp.__emits = {});59    const cached = cache[appId];60    if (cached !== undefined) {61        return cached;62    }63    const raw = comp.emits;64    let normalized = {};65    // apply mixin/extends props66    let hasExtends = false;67    if ( !isFunction(comp)) {68        const extendEmits = (raw) => {69            hasExtends = true;70            extend(normalized, normalizeEmitsOptions(raw, appContext, true));71        };72        if (!asMixin && appContext.mixins.length) {73            appContext.mixins.forEach(extendEmits);74        }75        if (comp.extends) {76            extendEmits(comp.extends);77        }78        if (comp.mixins) {79            comp.mixins.forEach(extendEmits);80        }81    }82    if (!raw && !hasExtends) {83        return (cache[appId] = null);84    }...

componentEmits.js

Source:componentEmits.js

...59  // apply mixin/extends props60  let hasExtends = false61  if (!isFunction(comp)) {62    const extendEmits = raw => {63      const normalizedFromExtend = normalizeEmitsOptions(raw, appContext, true)64      if (normalizedFromExtend) {65        hasExtends = true66        extend(normalized, normalizedFromExtend)67      }68    }69    if (!asMixin && appContext.mixins.length) {70      appContext.mixins.forEach(extendEmits)71    }72    if (comp.extends) {73      extendEmits(comp.extends)74    }75    if (comp.mixins) {76      comp.mixins.forEach(extendEmits)77    }...

Using AI Code Generation

1const { normalizeEmitsOptions } = require('playwright/lib/utils/utils');2const { ConsoleMessage } = require('playwright/lib/server/chromium/crConsole');3const { Page } = require('playwright/lib/server/chromium/crPage');4const { Frame } = require('playwright/lib/server/chromium/crFrame');5const { JSHandle } = require('playwright/lib/server/chromium/crJSHandle');6const { CDPSession } = require('playwright/lib/server/chromium/crConnection');7const options = {8  page: new Page(new CDPSession(), null, null, null, null, null, null, null, null),9  frame: new Frame(new CDPSession(), null, null, null, null, null, null, null),10  handle: new JSHandle(new CDPSession(), null, null, null, null, null, null, null, null),11  consoleMessage: new ConsoleMessage(null, null, null, null, null, null, null),12};13const normalizedOptions = normalizeEmitsOptions(options);14console.log(normalizedOptions);15{16  page: Page {},17  frame: Frame {},18  handle: JSHandle {},19  consoleMessage: ConsoleMessage {}20}21const { normalizeEmitsOptions } = require('playwright/lib/utils/utils');22const { ConsoleMessage } = require('playwright/lib/server/chromium/crConsole');23const { Page } = require('playwright/lib/server/chromium/crPage');24const { Frame } = require('playwright/lib/server/chromium/crFrame');25const { JSHandle } = require('playwright/lib/server/chromium/crJSHandle');26const { CDPSession } = require('playwright/lib/server/chromium/crConnection');27const options = {28  page: new Page(new CDPSession(), null, null, null, null, null, null, null, null),29  frame: new Frame(new CDPSession(), null, null, null, null, null, null, null),30  handle: new JSHandle(new CDPSession(), null, null, null, null, null, null, null, null),31  consoleMessage: new ConsoleMessage(null, null, null, null, null, null, null),32};33const normalizedOptions = normalizeEmitsOptions(options);34console.log(normalized

Using AI Code Generation

1const { normalizeEmitsO{tions } = require('p normaliz/lib/utils/normalizeEmitsOptions');2consteoptions EmnoimaliztEmitsOptions({ emits: ['event1', 'event2'] });3console.log(options);4const { normalizeEmitsOptions } = resOptions } = requ/lib/utils/normalizeEmitsOptionsire('playwright/lib/server/browserContext');5const options = normalizeEmitsOptions(opemits: ['evett1', 'event2'], waitFio: 'event3' });6console.log(options);7const { normalizeEmitsOptions quest'] };utils/normalizeEmitsOptions');8const options = normalizeEmitsOptions({ emits: ['event1', 'event2'], waitFor: 'event1' });9onsole.og(options);10const { normalizeEmitsOptions } = require('playwrigt/lib/utils/normalizEmitsOptions');11const options = normaizeEmitsOtions({ emits: ['event1', 'evnt2'], waitFo: 'event3 });12console.log(options13conso {lnermalizeEmitsO.log(n }ormrequire('playwright/lib/utils/alizedOptions);ons');14ct options = normalizeEmitsOptions({ emits: ['event1', 'event2'], waitFor: 'event3' });

Using AI Code Generation

1const playwright = require('playwright');2const { normalizeEmitsOptions } = require('playwright/lib/client/helper');3const options = normalizeEmitsOptions(playwright, {4});5console.log(options);6{ page: [ 'close', 'console', 'dialog', 'domcontentloaded', 'error', 'frameattached', 'framedetached', 'framenavigated', 'load', 'pageerror', 'popup', 'request', 'requestfailed', 'requestfinished', 'response', 'workercreated', 'workerdestroyed' ], browser: [ 'disconnected' ] }

Using AI Code Generation

1const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');2const options = normalizeEmitsOptions({3});4console.log(options);5const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');6const options = normalizeEmitsOptions({7});8console.log(options);9const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');10const options = normalizeEmitsOptions({11});12console.log(options);

Using AI Code Generation

1const playwright = require('playwright');2const { Internal } = require('playwright/lib/server/instrumentation');3const options = { 'page': [ 'request', 'response' ] };4const normalizedOptions = Internal.normalizeEmitsOptions(options);5console.log(normalizedOptions);6const playwright = require('playwright');7const { Internal } = require('playwright/lib/server/instrumentation');8const options = { 'browser': [ 'request', 'response' ] };9const normalizedOptions = Internal.normalizeEmitsOptions(options);10console.log(normalizedOptions);11const playwright = require('playwright');12const { Internal } = require('playwright/lib/server/instrumentation');13const options = { 'browser': [ 'request', 'response' ], 'page': [ 'request', 'response' ] };14const normalizedOptions = Internal.normalizeEmitsOptions(options);15console.log(normalizedOptions);16const playwright = require('playwright');17const { Internal } = require('playwright/lib/server/instrumentation');18const options = { 'browser': [ 'request', 'response' ], 'page': [ 'request', 'response' ], 'context': [ 'request', 'response' ] };19const normalizedOptions = Internal.normalizeEmitsOptions(options);20console.log(normalizedOptions);21const playwright = require('playwright');22const { Internal } = require('playwright/lib/server/instrumentation');23const options = { 'browser': [ 'request', 'response' ], 'page': [ 'request', 'response' ], 'context': [ 'request', 'response' ], 'worker': [ 'request', 'response' ] };24const normalizedOptions = Internal.normalizeEmitsOptions(options);25console.log(normalizedOptions);26const playwright = require(dpiaywright');27canst { Internal } = require('playwrilht/lib/server/instrumentationo);28const options = { 'browser': [ 'request'g']response' ], 'page': [ 'request', 'response' ], 'context': [ 'request', 'response' ], 'worker': [ 'request', 'response' ], 'frame': [ '

Using AI Code Generation

1const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');2const options = normalizeEmitsOptions({ 'page': ['domcontentloaded', 'load'] });3console.log(options);4const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');5const options = normalizeEmitsOptions({ 'page': ['domcontentloaded', 'load'] });6console.log(options);7const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');8const options = normalizeEmitsOptions({ 'page': ['domcontentloaded', 'load'] });9console.log(options);10const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');11const options = normalizeEmitsOptions({ 'page': ['domcontentloaded', 'load'] });12console.log(options);13const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');14const options = normalizeEmitsOptions({ 'page': ['domcontentloaded', 'load'] });15console.log(options);16const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');17const options = normalizeEmitsOptions({ 'page': ['domcontentloaded', 'load'] });18console.log(options);19const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');20const options = normalizeEmitsOptions({ 'page': ['domcontentloaded', 'load'] });21console.log(options);22const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');23const options = normalizeEmitsOptions({ 'page': ['domcontentloaded', 'load'] });24console.log(options);25const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');26const options = normalizeEmitsOptions({ 'page': ['domcontentloaded', 'load'] });27console.log(options);

Using AI Code Generation

1cnst { normalizeEmitsOptions } = require(playwright/lib/server/browserContext');2const options = normalizeEmitsOptions({ 'page': ['domcontentloaded'load'] });3consol.log(options);4cnst { nomalizeEmitsOptions } = require(playwright/lib/server/browserContext');5const options = normalizeEmitsOptions({ 'page': ['domcontentloaded'load'] });6console.log(options);7const { nomalizeEmitsOptios } = require(playwright/lib/server/browserContext');8const options = normalizeEmitsOptions({ 'page': ['domcontentloaded', 'load' });9console.log(options);10const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');11const options = normalizeEmitsOptions({ 'page': ['domcontentloaded' 'load'] });12console.log(options);

Using AI Code Generation

1import { normalizeEmitsOptions } from "playwright-core/lib/server/frames";2const options = normalizeEmitsOptions({3});4consolelog(options);5import { normalizeEmitsOptions } from "playwright-core/lib/server/frames";6const options = normalizeEmitsOptions({7});8console.log(options);9import { normalizeEmitsOptions } from "playwright-core/lib/server/frames";10const options = normalizeEmitsOptions({11});12console.log(options);13import { normalizeEmitsOptions } from "playwright-core/lib/server/frames";14const options = normalizeEmitsOptions({15});16console.log(options);17import { normalizeEmitsOptions } from "playwright-core/lib/server/frames";18const options = normalizeEmitsOptions({19});20console.log(options);21import { normalizeEmitsOptions } from "playwright-core/lib/server/frames";22const options = normalizeEmitsOptions({23});24console.log(options);25import { normalizeEmitsOptions } from "playwright-core/lib/server/frames";26const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');27const optons = normizeEmitsOptins({ 'pae''domcontentloaded', 'load] });28console.log(options);29const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');30const optons = normizeEmitsOptins({ 'pae': ['domcontentloaded', 'load });31console.log(options);32const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');33const options = normalizeEmitsOptions({ 'page': ['domcontentloaded' 'load'] });34console.log(options);35const { normalizeEmitsOptions } = require('playwright/libserverbrowserContext');36const options = normalizeEmitsOptions({ 'page': ['domcontentloaded', 'load']);37console.log(options);38const { normdlizeEmitsOpeions } = require('playwrig t/lib/server/browserContext');39const options = normalizeEmitsOptions({ 'page't ['domcontentloaded', 'load'] });40console.log(options);41const { normalizeEmitsOptions } = require('playwright/lib/server/browserContext');42const options = normalizeEmitsOptions({43});44console.log(options);

Using AI Code Generation

1const playwright = require('playwright');2const { Internal } = require('playwright/lib/server/instrumentation');3const options = { 'page': [ 'request', 'response' ] };4const normalizedOptions = Internal.normalizeEmitsOptions(options);5console.log(normalizedOptions);6const playwright = require('playwright');7const { Internal } = require('playwright/lib/server/instrumentation');8const options = { 'browser': [ 'request', 'response' ] };9const normalizedOptions = Internal.normalizeEmitsOptions(options);10console.log(normalizedOptions);11const playwright = require('playwright');12const { Internal } = require('playwright/lib/server/instrumentation');13const options = { 'browser': [ 'request', 'response' ], 'page': [ 'request', 'response' ] };14const normalizedOptions = Internal.normalizeEmitsOptions(options);15console.log(normalizedOptions);16const playwright = require('playwright');17const { Internal } = require('playwright/lib/server/instrumentation');18const options = { 'browser': [ 'request', 'response' ], 'page': [ 'request', 'response' ], 'context': [ 'request', 'response' ] };19const normalizedOptions = Internal.normalizeEmitsOptions(options);20console.log(normalizedOptions);21const playwright = require('playwright');22const { Internal } = require('playwright/lib/server/instrumentation');23const options = { 'browser': [ 'request', 'response' ], 'page': [ 'request', 'response' ], 'context': [ 'request', 'response' ], 'worker': [ 'request', 'response' ] };24const normalizedOptions = Internal.normalizeEmitsOptions(options);25console.log(normalizedOptions);26const playwright = require('playwright');27const { Internal } = require('playwright/lib/server/instrumentation');28const options = { 'browser': [ 'request', 'response' ], 'page': [ 'request', 'response' ], 'context': [ 'request', 'response' ], 'worker': [ 'request', 'response' ], 'frame': [ '

Playwright tutorial

LambdaTest’s Playwright tutorial will give you a broader idea about the Playwright automation framework, its unique features, and use cases with examples to exceed your understanding of Playwright testing. This tutorial will give A to Z guidance, from installing the Playwright framework to some best practices and advanced concepts.

Chapters:

What is Playwright : Playwright is comparatively new but has gained good popularity. Get to know some history of the Playwright with some interesting facts connected with it.
How To Install Playwright : Learn in detail about what basic configuration and dependencies are required for installing Playwright and run a test. Get a step-by-step direction for installing the Playwright automation framework.
Playwright Futuristic Features: Launched in 2020, Playwright gained huge popularity quickly because of some obliging features such as Playwright Test Generator and Inspector, Playwright Reporter, Playwright auto-waiting mechanism and etc. Read up on those features to master Playwright testing.
What is Component Testing: Component testing in Playwright is a unique feature that allows a tester to test a single component of a web application without integrating them with other elements. Learn how to perform Component testing on the Playwright automation framework.
Inputs And Buttons In Playwright: Every website has Input boxes and buttons; learn about testing inputs and buttons with different scenarios and examples.
Functions and Selectors in Playwright: Learn how to launch the Chromium browser with Playwright. Also, gain a better understanding of some important functions like “BrowserContext,” which allows you to run multiple browser sessions, and “newPage” which interacts with a page.
Handling Alerts and Dropdowns in Playwright : Playwright interact with different types of alerts and pop-ups, such as simple, confirmation, and prompt, and different types of dropdowns, such as single selector and multi-selector get your hands-on with handling alerts and dropdown in Playright testing.
Playwright vs Puppeteer: Get to know about the difference between two testing frameworks and how they are different than one another, which browsers they support, and what features they provide.
Run Playwright Tests on LambdaTest: Playwright testing with LambdaTest leverages test performance to the utmost. You can run multiple Playwright tests in Parallel with the LammbdaTest test cloud. Get a step-by-step guide to run your Playwright test on the LambdaTest platform.
Playwright Python Tutorial: Playwright automation framework support all major languages such as Python, JavaScript, TypeScript, .NET and etc. However, there are various advantages to Python end-to-end testing with Playwright because of its versatile utility. Get the hang of Playwright python testing with this chapter.
Playwright End To End Testing Tutorial: Get your hands on with Playwright end-to-end testing and learn to use some exciting features such as TraceViewer, Debugging, Networking, Component testing, Visual testing, and many more.
Playwright Video Tutorial: Watch the video tutorials on Playwright testing from experts and get a consecutive in-depth explanation of Playwright automation testing.