update
This commit is contained in:
@@ -0,0 +1 @@
|
||||
module.exports={C:{"52":0.00164,"115":0.01973,"122":0.00164,"123":0.00164,"127":0.00164,"128":0.00493,"131":0.00164,"133":0.00329,"134":0.00329,"135":0.09042,"136":0.23674,"137":0.00164,_:"2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 116 117 118 119 120 121 124 125 126 129 130 132 138 139 140 3.5 3.6"},D:{"11":0.00164,"38":0.00329,"39":0.00164,"40":0.00164,"41":0.00164,"42":0.00164,"43":0.00164,"44":0.00164,"45":0.00164,"46":0.00164,"47":0.00329,"48":0.00164,"49":0.00164,"50":0.00164,"51":0.00164,"52":0.00164,"53":0.00164,"54":0.00164,"55":0.00164,"56":0.00329,"57":0.00164,"58":0.01644,"59":0.00164,"60":0.00164,"63":0.00164,"64":0.00164,"68":0.00164,"69":0.00164,"70":0.00164,"72":0.00658,"73":0.00329,"75":0.00164,"76":0.00164,"78":0.00164,"79":0.01644,"80":0.00164,"81":0.00164,"83":0.00822,"85":0.00164,"86":0.00164,"87":0.0263,"88":0.00329,"89":0.00164,"90":0.00329,"91":0.00329,"92":0.00164,"93":0.00822,"94":0.00658,"95":0.00164,"97":0.00164,"98":0.00822,"99":0.00164,"101":0.00329,"102":0.00164,"103":0.01644,"104":0.02137,"106":0.01315,"107":0.00658,"108":0.0148,"109":0.26797,"110":0.01808,"111":0.00493,"112":0.00658,"113":0.00164,"114":0.01973,"115":0.00329,"116":0.02302,"117":0.00493,"118":0.00493,"119":0.01315,"120":0.02795,"121":0.01151,"122":0.03617,"123":0.01315,"124":0.0263,"125":0.0559,"126":0.02137,"127":0.0148,"128":0.03946,"129":0.01973,"130":0.0263,"131":0.12823,"132":0.27784,"133":3.37349,"134":5.85593,"135":0.00658,"136":0.00329,_:"4 5 6 7 8 9 10 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 61 62 65 66 67 71 74 77 84 96 100 105 137 138"},F:{"46":0.00164,"87":0.01644,"88":0.00658,"95":0.00164,"113":0.00164,"116":0.08056,"117":0.21043,_:"9 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 47 48 49 50 51 52 53 54 55 56 57 58 60 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 89 90 91 92 93 94 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 114 115 9.5-9.6 10.0-10.1 10.5 10.6 11.1 11.5 11.6 12.1"},B:{"18":0.00658,"92":0.00658,"107":0.00164,"108":0.00164,"109":0.00822,"111":0.00164,"114":0.00493,"117":0.00164,"119":0.00164,"120":0.00329,"121":0.00493,"122":0.00164,"124":0.00164,"125":0.00164,"126":0.00822,"127":0.00986,"128":0.00658,"129":0.00493,"130":0.00493,"131":0.02302,"132":0.04768,"133":0.63623,"134":1.00613,_:"12 13 14 15 16 17 79 80 81 83 84 85 86 87 88 89 90 91 93 94 95 96 97 98 99 100 101 102 103 104 105 106 110 112 113 115 116 118 123"},E:{"13":0.00164,"14":0.00493,"15":0.00164,_:"0 4 5 6 7 8 9 10 11 12 3.1 3.2 6.1 7.1 9.1 10.1 11.1","5.1":0.00493,"12.1":0.00164,"13.1":0.00493,"14.1":0.00986,"15.1":0.00164,"15.2-15.3":0.00164,"15.4":0.00329,"15.5":0.00493,"15.6":0.03288,"16.0":0.00658,"16.1":0.01808,"16.2":0.00658,"16.3":0.01644,"16.4":0.01151,"16.5":0.00658,"16.6":0.07069,"17.0":0.00329,"17.1":0.0148,"17.2":0.01644,"17.3":0.01151,"17.4":0.02137,"17.5":0.05918,"17.6":0.15618,"18.0":0.03452,"18.1":0.10357,"18.2":0.04439,"18.3":0.62801,"18.4":0.00658},G:{"8":0,"3.2":0,"4.0-4.1":0,"4.2-4.3":0.00413,"5.0-5.1":0,"6.0-6.1":0.0124,"7.0-7.1":0.00827,"8.1-8.4":0,"9.0-9.2":0.0062,"9.3":0.02894,"10.0-10.2":0.00207,"10.3":0.04755,"11.0-11.2":0.21913,"11.3-11.4":0.01447,"12.0-12.1":0.00827,"12.2-12.5":0.20466,"13.0-13.1":0.00413,"13.2":0.0062,"13.3":0.00827,"13.4-13.7":0.02894,"14.0-14.4":0.07235,"14.5-14.8":0.08683,"15.0-15.1":0.04755,"15.2-15.3":0.04755,"15.4":0.05788,"15.5":0.06615,"15.6-15.8":0.81451,"16.0":0.11577,"16.1":0.23774,"16.2":0.12404,"16.3":0.215,"16.4":0.04755,"16.5":0.08889,"16.6-16.7":0.96542,"17.0":0.05788,"17.1":0.10336,"17.2":0.07856,"17.3":0.10957,"17.4":0.21913,"17.5":0.48788,"17.6-17.7":1.41608,"18.0":0.39692,"18.1":1.29825,"18.2":0.5809,"18.3":12.1411,"18.4":0.17985},P:{"20":0.01036,"21":0.01036,"22":0.04143,"23":0.04143,"24":0.04143,"25":0.06214,"26":0.06214,"27":1.90564,_:"4 5.0-5.4 6.2-6.4 8.2 9.2 10.1 11.1-11.2 12.0 13.0 15.0 16.0 17.0 18.0","7.2-7.4":0.01036,"14.0":0.01036,"19.0":0.01036},I:{"0":0.04169,"3":0,"4":0,"2.1":0,"2.2":0,"2.3":0,"4.1":0,"4.2-4.3":0.00001,"4.4":0,"4.4.3-4.4.4":0.00005},K:{"0":0.45958,_:"10 11 12 11.1 11.5 12.1"},A:{"11":0.01315,_:"6 7 8 9 10 5.5"},S:{_:"2.5 3.0-3.1"},J:{_:"7 10"},N:{_:"10 11"},R:{_:"0"},M:{"0":0.0752},Q:{_:"14.9"},O:{"0":1.36203},H:{"0":0},L:{"0":60.38355}};
|
||||
Binary file not shown.
@@ -0,0 +1,440 @@
|
||||
'use strict';
|
||||
|
||||
const reduxImpl = (reducer, initial) => (set, _get, api) => {
|
||||
api.dispatch = (action) => {
|
||||
set((state) => reducer(state, action), false, action);
|
||||
return action;
|
||||
};
|
||||
api.dispatchFromDevtools = true;
|
||||
return { dispatch: (...a) => api.dispatch(...a), ...initial };
|
||||
};
|
||||
const redux = reduxImpl;
|
||||
|
||||
const trackedConnections = /* @__PURE__ */ new Map();
|
||||
const getTrackedConnectionState = (name) => {
|
||||
const api = trackedConnections.get(name);
|
||||
if (!api) return {};
|
||||
return Object.fromEntries(
|
||||
Object.entries(api.stores).map(([key, api2]) => [key, api2.getState()])
|
||||
);
|
||||
};
|
||||
const extractConnectionInformation = (store, extensionConnector, options) => {
|
||||
if (store === undefined) {
|
||||
return {
|
||||
type: "untracked",
|
||||
connection: extensionConnector.connect(options)
|
||||
};
|
||||
}
|
||||
const existingConnection = trackedConnections.get(options.name);
|
||||
if (existingConnection) {
|
||||
return { type: "tracked", store, ...existingConnection };
|
||||
}
|
||||
const newConnection = {
|
||||
connection: extensionConnector.connect(options),
|
||||
stores: {}
|
||||
};
|
||||
trackedConnections.set(options.name, newConnection);
|
||||
return { type: "tracked", store, ...newConnection };
|
||||
};
|
||||
const devtoolsImpl = (fn, devtoolsOptions = {}) => (set, get, api) => {
|
||||
const { enabled, anonymousActionType, store, ...options } = devtoolsOptions;
|
||||
let extensionConnector;
|
||||
try {
|
||||
extensionConnector = (enabled != null ? enabled : process.env.NODE_ENV !== "production") && window.__REDUX_DEVTOOLS_EXTENSION__;
|
||||
} catch (e) {
|
||||
}
|
||||
if (!extensionConnector) {
|
||||
return fn(set, get, api);
|
||||
}
|
||||
const { connection, ...connectionInformation } = extractConnectionInformation(store, extensionConnector, options);
|
||||
let isRecording = true;
|
||||
api.setState = (state, replace, nameOrAction) => {
|
||||
const r = set(state, replace);
|
||||
if (!isRecording) return r;
|
||||
const action = nameOrAction === undefined ? { type: anonymousActionType || "anonymous" } : typeof nameOrAction === "string" ? { type: nameOrAction } : nameOrAction;
|
||||
if (store === undefined) {
|
||||
connection == null ? undefined : connection.send(action, get());
|
||||
return r;
|
||||
}
|
||||
connection == null ? undefined : connection.send(
|
||||
{
|
||||
...action,
|
||||
type: `${store}/${action.type}`
|
||||
},
|
||||
{
|
||||
...getTrackedConnectionState(options.name),
|
||||
[store]: api.getState()
|
||||
}
|
||||
);
|
||||
return r;
|
||||
};
|
||||
const setStateFromDevtools = (...a) => {
|
||||
const originalIsRecording = isRecording;
|
||||
isRecording = false;
|
||||
set(...a);
|
||||
isRecording = originalIsRecording;
|
||||
};
|
||||
const initialState = fn(api.setState, get, api);
|
||||
if (connectionInformation.type === "untracked") {
|
||||
connection == null ? undefined : connection.init(initialState);
|
||||
} else {
|
||||
connectionInformation.stores[connectionInformation.store] = api;
|
||||
connection == null ? undefined : connection.init(
|
||||
Object.fromEntries(
|
||||
Object.entries(connectionInformation.stores).map(([key, store2]) => [
|
||||
key,
|
||||
key === connectionInformation.store ? initialState : store2.getState()
|
||||
])
|
||||
)
|
||||
);
|
||||
}
|
||||
if (api.dispatchFromDevtools && typeof api.dispatch === "function") {
|
||||
let didWarnAboutReservedActionType = false;
|
||||
const originalDispatch = api.dispatch;
|
||||
api.dispatch = (...a) => {
|
||||
if (process.env.NODE_ENV !== "production" && a[0].type === "__setState" && !didWarnAboutReservedActionType) {
|
||||
console.warn(
|
||||
'[zustand devtools middleware] "__setState" action type is reserved to set state from the devtools. Avoid using it.'
|
||||
);
|
||||
didWarnAboutReservedActionType = true;
|
||||
}
|
||||
originalDispatch(...a);
|
||||
};
|
||||
}
|
||||
connection.subscribe((message) => {
|
||||
var _a;
|
||||
switch (message.type) {
|
||||
case "ACTION":
|
||||
if (typeof message.payload !== "string") {
|
||||
console.error(
|
||||
"[zustand devtools middleware] Unsupported action format"
|
||||
);
|
||||
return;
|
||||
}
|
||||
return parseJsonThen(
|
||||
message.payload,
|
||||
(action) => {
|
||||
if (action.type === "__setState") {
|
||||
if (store === undefined) {
|
||||
setStateFromDevtools(action.state);
|
||||
return;
|
||||
}
|
||||
if (Object.keys(action.state).length !== 1) {
|
||||
console.error(
|
||||
`
|
||||
[zustand devtools middleware] Unsupported __setState action format.
|
||||
When using 'store' option in devtools(), the 'state' should have only one key, which is a value of 'store' that was passed in devtools(),
|
||||
and value of this only key should be a state object. Example: { "type": "__setState", "state": { "abc123Store": { "foo": "bar" } } }
|
||||
`
|
||||
);
|
||||
}
|
||||
const stateFromDevtools = action.state[store];
|
||||
if (stateFromDevtools === undefined || stateFromDevtools === null) {
|
||||
return;
|
||||
}
|
||||
if (JSON.stringify(api.getState()) !== JSON.stringify(stateFromDevtools)) {
|
||||
setStateFromDevtools(stateFromDevtools);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (!api.dispatchFromDevtools) return;
|
||||
if (typeof api.dispatch !== "function") return;
|
||||
api.dispatch(action);
|
||||
}
|
||||
);
|
||||
case "DISPATCH":
|
||||
switch (message.payload.type) {
|
||||
case "RESET":
|
||||
setStateFromDevtools(initialState);
|
||||
if (store === undefined) {
|
||||
return connection == null ? undefined : connection.init(api.getState());
|
||||
}
|
||||
return connection == null ? undefined : connection.init(getTrackedConnectionState(options.name));
|
||||
case "COMMIT":
|
||||
if (store === undefined) {
|
||||
connection == null ? undefined : connection.init(api.getState());
|
||||
return;
|
||||
}
|
||||
return connection == null ? undefined : connection.init(getTrackedConnectionState(options.name));
|
||||
case "ROLLBACK":
|
||||
return parseJsonThen(message.state, (state) => {
|
||||
if (store === undefined) {
|
||||
setStateFromDevtools(state);
|
||||
connection == null ? undefined : connection.init(api.getState());
|
||||
return;
|
||||
}
|
||||
setStateFromDevtools(state[store]);
|
||||
connection == null ? undefined : connection.init(getTrackedConnectionState(options.name));
|
||||
});
|
||||
case "JUMP_TO_STATE":
|
||||
case "JUMP_TO_ACTION":
|
||||
return parseJsonThen(message.state, (state) => {
|
||||
if (store === undefined) {
|
||||
setStateFromDevtools(state);
|
||||
return;
|
||||
}
|
||||
if (JSON.stringify(api.getState()) !== JSON.stringify(state[store])) {
|
||||
setStateFromDevtools(state[store]);
|
||||
}
|
||||
});
|
||||
case "IMPORT_STATE": {
|
||||
const { nextLiftedState } = message.payload;
|
||||
const lastComputedState = (_a = nextLiftedState.computedStates.slice(-1)[0]) == null ? undefined : _a.state;
|
||||
if (!lastComputedState) return;
|
||||
if (store === undefined) {
|
||||
setStateFromDevtools(lastComputedState);
|
||||
} else {
|
||||
setStateFromDevtools(lastComputedState[store]);
|
||||
}
|
||||
connection == null ? undefined : connection.send(
|
||||
null,
|
||||
// FIXME no-any
|
||||
nextLiftedState
|
||||
);
|
||||
return;
|
||||
}
|
||||
case "PAUSE_RECORDING":
|
||||
return isRecording = !isRecording;
|
||||
}
|
||||
return;
|
||||
}
|
||||
});
|
||||
return initialState;
|
||||
};
|
||||
const devtools = devtoolsImpl;
|
||||
const parseJsonThen = (stringified, f) => {
|
||||
let parsed;
|
||||
try {
|
||||
parsed = JSON.parse(stringified);
|
||||
} catch (e) {
|
||||
console.error(
|
||||
"[zustand devtools middleware] Could not parse the received json",
|
||||
e
|
||||
);
|
||||
}
|
||||
if (parsed !== undefined) f(parsed);
|
||||
};
|
||||
|
||||
const subscribeWithSelectorImpl = (fn) => (set, get, api) => {
|
||||
const origSubscribe = api.subscribe;
|
||||
api.subscribe = (selector, optListener, options) => {
|
||||
let listener = selector;
|
||||
if (optListener) {
|
||||
const equalityFn = (options == null ? undefined : options.equalityFn) || Object.is;
|
||||
let currentSlice = selector(api.getState());
|
||||
listener = (state) => {
|
||||
const nextSlice = selector(state);
|
||||
if (!equalityFn(currentSlice, nextSlice)) {
|
||||
const previousSlice = currentSlice;
|
||||
optListener(currentSlice = nextSlice, previousSlice);
|
||||
}
|
||||
};
|
||||
if (options == null ? undefined : options.fireImmediately) {
|
||||
optListener(currentSlice, currentSlice);
|
||||
}
|
||||
}
|
||||
return origSubscribe(listener);
|
||||
};
|
||||
const initialState = fn(set, get, api);
|
||||
return initialState;
|
||||
};
|
||||
const subscribeWithSelector = subscribeWithSelectorImpl;
|
||||
|
||||
const combine = (initialState, create) => (...a) => Object.assign({}, initialState, create(...a));
|
||||
|
||||
function createJSONStorage(getStorage, options) {
|
||||
let storage;
|
||||
try {
|
||||
storage = getStorage();
|
||||
} catch (e) {
|
||||
return;
|
||||
}
|
||||
const persistStorage = {
|
||||
getItem: (name) => {
|
||||
var _a;
|
||||
const parse = (str2) => {
|
||||
if (str2 === null) {
|
||||
return null;
|
||||
}
|
||||
return JSON.parse(str2, options == null ? undefined : options.reviver);
|
||||
};
|
||||
const str = (_a = storage.getItem(name)) != null ? _a : null;
|
||||
if (str instanceof Promise) {
|
||||
return str.then(parse);
|
||||
}
|
||||
return parse(str);
|
||||
},
|
||||
setItem: (name, newValue) => storage.setItem(
|
||||
name,
|
||||
JSON.stringify(newValue, options == null ? undefined : options.replacer)
|
||||
),
|
||||
removeItem: (name) => storage.removeItem(name)
|
||||
};
|
||||
return persistStorage;
|
||||
}
|
||||
const toThenable = (fn) => (input) => {
|
||||
try {
|
||||
const result = fn(input);
|
||||
if (result instanceof Promise) {
|
||||
return result;
|
||||
}
|
||||
return {
|
||||
then(onFulfilled) {
|
||||
return toThenable(onFulfilled)(result);
|
||||
},
|
||||
catch(_onRejected) {
|
||||
return this;
|
||||
}
|
||||
};
|
||||
} catch (e) {
|
||||
return {
|
||||
then(_onFulfilled) {
|
||||
return this;
|
||||
},
|
||||
catch(onRejected) {
|
||||
return toThenable(onRejected)(e);
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
const persistImpl = (config, baseOptions) => (set, get, api) => {
|
||||
let options = {
|
||||
storage: createJSONStorage(() => localStorage),
|
||||
partialize: (state) => state,
|
||||
version: 0,
|
||||
merge: (persistedState, currentState) => ({
|
||||
...currentState,
|
||||
...persistedState
|
||||
}),
|
||||
...baseOptions
|
||||
};
|
||||
let hasHydrated = false;
|
||||
const hydrationListeners = /* @__PURE__ */ new Set();
|
||||
const finishHydrationListeners = /* @__PURE__ */ new Set();
|
||||
let storage = options.storage;
|
||||
if (!storage) {
|
||||
return config(
|
||||
(...args) => {
|
||||
console.warn(
|
||||
`[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
|
||||
);
|
||||
set(...args);
|
||||
},
|
||||
get,
|
||||
api
|
||||
);
|
||||
}
|
||||
const setItem = () => {
|
||||
const state = options.partialize({ ...get() });
|
||||
return storage.setItem(options.name, {
|
||||
state,
|
||||
version: options.version
|
||||
});
|
||||
};
|
||||
const savedSetState = api.setState;
|
||||
api.setState = (state, replace) => {
|
||||
savedSetState(state, replace);
|
||||
void setItem();
|
||||
};
|
||||
const configResult = config(
|
||||
(...args) => {
|
||||
set(...args);
|
||||
void setItem();
|
||||
},
|
||||
get,
|
||||
api
|
||||
);
|
||||
api.getInitialState = () => configResult;
|
||||
let stateFromStorage;
|
||||
const hydrate = () => {
|
||||
var _a, _b;
|
||||
if (!storage) return;
|
||||
hasHydrated = false;
|
||||
hydrationListeners.forEach((cb) => {
|
||||
var _a2;
|
||||
return cb((_a2 = get()) != null ? _a2 : configResult);
|
||||
});
|
||||
const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? undefined : _b.call(options, (_a = get()) != null ? _a : configResult)) || undefined;
|
||||
return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
|
||||
if (deserializedStorageValue) {
|
||||
if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
|
||||
if (options.migrate) {
|
||||
const migration = options.migrate(
|
||||
deserializedStorageValue.state,
|
||||
deserializedStorageValue.version
|
||||
);
|
||||
if (migration instanceof Promise) {
|
||||
return migration.then((result) => [true, result]);
|
||||
}
|
||||
return [true, migration];
|
||||
}
|
||||
console.error(
|
||||
`State loaded from storage couldn't be migrated since no migrate function was provided`
|
||||
);
|
||||
} else {
|
||||
return [false, deserializedStorageValue.state];
|
||||
}
|
||||
}
|
||||
return [false, undefined];
|
||||
}).then((migrationResult) => {
|
||||
var _a2;
|
||||
const [migrated, migratedState] = migrationResult;
|
||||
stateFromStorage = options.merge(
|
||||
migratedState,
|
||||
(_a2 = get()) != null ? _a2 : configResult
|
||||
);
|
||||
set(stateFromStorage, true);
|
||||
if (migrated) {
|
||||
return setItem();
|
||||
}
|
||||
}).then(() => {
|
||||
postRehydrationCallback == null ? undefined : postRehydrationCallback(stateFromStorage, undefined);
|
||||
stateFromStorage = get();
|
||||
hasHydrated = true;
|
||||
finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
|
||||
}).catch((e) => {
|
||||
postRehydrationCallback == null ? undefined : postRehydrationCallback(undefined, e);
|
||||
});
|
||||
};
|
||||
api.persist = {
|
||||
setOptions: (newOptions) => {
|
||||
options = {
|
||||
...options,
|
||||
...newOptions
|
||||
};
|
||||
if (newOptions.storage) {
|
||||
storage = newOptions.storage;
|
||||
}
|
||||
},
|
||||
clearStorage: () => {
|
||||
storage == null ? undefined : storage.removeItem(options.name);
|
||||
},
|
||||
getOptions: () => options,
|
||||
rehydrate: () => hydrate(),
|
||||
hasHydrated: () => hasHydrated,
|
||||
onHydrate: (cb) => {
|
||||
hydrationListeners.add(cb);
|
||||
return () => {
|
||||
hydrationListeners.delete(cb);
|
||||
};
|
||||
},
|
||||
onFinishHydration: (cb) => {
|
||||
finishHydrationListeners.add(cb);
|
||||
return () => {
|
||||
finishHydrationListeners.delete(cb);
|
||||
};
|
||||
}
|
||||
};
|
||||
if (!options.skipHydration) {
|
||||
hydrate();
|
||||
}
|
||||
return stateFromStorage || configResult;
|
||||
};
|
||||
const persist = persistImpl;
|
||||
|
||||
exports.combine = combine;
|
||||
exports.createJSONStorage = createJSONStorage;
|
||||
exports.devtools = devtools;
|
||||
exports.persist = persist;
|
||||
exports.redux = redux;
|
||||
exports.subscribeWithSelector = subscribeWithSelector;
|
||||
@@ -0,0 +1,658 @@
|
||||
/**
|
||||
* @license React
|
||||
* react-refresh-runtime.development.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
if (process.env.NODE_ENV !== "production") {
|
||||
(function() {
|
||||
'use strict';
|
||||
|
||||
// ATTENTION
|
||||
var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
|
||||
var REACT_MEMO_TYPE = Symbol.for('react.memo');
|
||||
|
||||
var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; // We never remove these associations.
|
||||
// It's OK to reference families, but use WeakMap/Set for types.
|
||||
|
||||
var allFamiliesByID = new Map();
|
||||
var allFamiliesByType = new PossiblyWeakMap();
|
||||
var allSignaturesByType = new PossiblyWeakMap(); // This WeakMap is read by React, so we only put families
|
||||
// that have actually been edited here. This keeps checks fast.
|
||||
// $FlowIssue
|
||||
|
||||
var updatedFamiliesByType = new PossiblyWeakMap(); // This is cleared on every performReactRefresh() call.
|
||||
// It is an array of [Family, NextType] tuples.
|
||||
|
||||
var pendingUpdates = []; // This is injected by the renderer via DevTools global hook.
|
||||
|
||||
var helpersByRendererID = new Map();
|
||||
var helpersByRoot = new Map(); // We keep track of mounted roots so we can schedule updates.
|
||||
|
||||
var mountedRoots = new Set(); // If a root captures an error, we remember it so we can retry on edit.
|
||||
|
||||
var failedRoots = new Set(); // In environments that support WeakMap, we also remember the last element for every root.
|
||||
// It needs to be weak because we do this even for roots that failed to mount.
|
||||
// If there is no WeakMap, we won't attempt to do retrying.
|
||||
// $FlowIssue
|
||||
|
||||
var rootElements = // $FlowIssue
|
||||
typeof WeakMap === 'function' ? new WeakMap() : null;
|
||||
var isPerformingRefresh = false;
|
||||
|
||||
function computeFullKey(signature) {
|
||||
if (signature.fullKey !== null) {
|
||||
return signature.fullKey;
|
||||
}
|
||||
|
||||
var fullKey = signature.ownKey;
|
||||
var hooks;
|
||||
|
||||
try {
|
||||
hooks = signature.getCustomHooks();
|
||||
} catch (err) {
|
||||
// This can happen in an edge case, e.g. if expression like Foo.useSomething
|
||||
// depends on Foo which is lazily initialized during rendering.
|
||||
// In that case just assume we'll have to remount.
|
||||
signature.forceReset = true;
|
||||
signature.fullKey = fullKey;
|
||||
return fullKey;
|
||||
}
|
||||
|
||||
for (var i = 0; i < hooks.length; i++) {
|
||||
var hook = hooks[i];
|
||||
|
||||
if (typeof hook !== 'function') {
|
||||
// Something's wrong. Assume we need to remount.
|
||||
signature.forceReset = true;
|
||||
signature.fullKey = fullKey;
|
||||
return fullKey;
|
||||
}
|
||||
|
||||
var nestedHookSignature = allSignaturesByType.get(hook);
|
||||
|
||||
if (nestedHookSignature === undefined) {
|
||||
// No signature means Hook wasn't in the source code, e.g. in a library.
|
||||
// We'll skip it because we can assume it won't change during this session.
|
||||
continue;
|
||||
}
|
||||
|
||||
var nestedHookKey = computeFullKey(nestedHookSignature);
|
||||
|
||||
if (nestedHookSignature.forceReset) {
|
||||
signature.forceReset = true;
|
||||
}
|
||||
|
||||
fullKey += '\n---\n' + nestedHookKey;
|
||||
}
|
||||
|
||||
signature.fullKey = fullKey;
|
||||
return fullKey;
|
||||
}
|
||||
|
||||
function haveEqualSignatures(prevType, nextType) {
|
||||
var prevSignature = allSignaturesByType.get(prevType);
|
||||
var nextSignature = allSignaturesByType.get(nextType);
|
||||
|
||||
if (prevSignature === undefined && nextSignature === undefined) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (prevSignature === undefined || nextSignature === undefined) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (computeFullKey(prevSignature) !== computeFullKey(nextSignature)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (nextSignature.forceReset) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
function isReactClass(type) {
|
||||
return type.prototype && type.prototype.isReactComponent;
|
||||
}
|
||||
|
||||
function canPreserveStateBetween(prevType, nextType) {
|
||||
if (isReactClass(prevType) || isReactClass(nextType)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (haveEqualSignatures(prevType, nextType)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function resolveFamily(type) {
|
||||
// Only check updated types to keep lookups fast.
|
||||
return updatedFamiliesByType.get(type);
|
||||
} // If we didn't care about IE11, we could use new Map/Set(iterable).
|
||||
|
||||
|
||||
function cloneMap(map) {
|
||||
var clone = new Map();
|
||||
map.forEach(function (value, key) {
|
||||
clone.set(key, value);
|
||||
});
|
||||
return clone;
|
||||
}
|
||||
|
||||
function cloneSet(set) {
|
||||
var clone = new Set();
|
||||
set.forEach(function (value) {
|
||||
clone.add(value);
|
||||
});
|
||||
return clone;
|
||||
} // This is a safety mechanism to protect against rogue getters and Proxies.
|
||||
|
||||
|
||||
function getProperty(object, property) {
|
||||
try {
|
||||
return object[property];
|
||||
} catch (err) {
|
||||
// Intentionally ignore.
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
function performReactRefresh() {
|
||||
|
||||
if (pendingUpdates.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (isPerformingRefresh) {
|
||||
return null;
|
||||
}
|
||||
|
||||
isPerformingRefresh = true;
|
||||
|
||||
try {
|
||||
var staleFamilies = new Set();
|
||||
var updatedFamilies = new Set();
|
||||
var updates = pendingUpdates;
|
||||
pendingUpdates = [];
|
||||
updates.forEach(function (_ref) {
|
||||
var family = _ref[0],
|
||||
nextType = _ref[1];
|
||||
// Now that we got a real edit, we can create associations
|
||||
// that will be read by the React reconciler.
|
||||
var prevType = family.current;
|
||||
updatedFamiliesByType.set(prevType, family);
|
||||
updatedFamiliesByType.set(nextType, family);
|
||||
family.current = nextType; // Determine whether this should be a re-render or a re-mount.
|
||||
|
||||
if (canPreserveStateBetween(prevType, nextType)) {
|
||||
updatedFamilies.add(family);
|
||||
} else {
|
||||
staleFamilies.add(family);
|
||||
}
|
||||
}); // TODO: rename these fields to something more meaningful.
|
||||
|
||||
var update = {
|
||||
updatedFamilies: updatedFamilies,
|
||||
// Families that will re-render preserving state
|
||||
staleFamilies: staleFamilies // Families that will be remounted
|
||||
|
||||
};
|
||||
helpersByRendererID.forEach(function (helpers) {
|
||||
// Even if there are no roots, set the handler on first update.
|
||||
// This ensures that if *new* roots are mounted, they'll use the resolve handler.
|
||||
helpers.setRefreshHandler(resolveFamily);
|
||||
});
|
||||
var didError = false;
|
||||
var firstError = null; // We snapshot maps and sets that are mutated during commits.
|
||||
// If we don't do this, there is a risk they will be mutated while
|
||||
// we iterate over them. For example, trying to recover a failed root
|
||||
// may cause another root to be added to the failed list -- an infinite loop.
|
||||
|
||||
var failedRootsSnapshot = cloneSet(failedRoots);
|
||||
var mountedRootsSnapshot = cloneSet(mountedRoots);
|
||||
var helpersByRootSnapshot = cloneMap(helpersByRoot);
|
||||
failedRootsSnapshot.forEach(function (root) {
|
||||
var helpers = helpersByRootSnapshot.get(root);
|
||||
|
||||
if (helpers === undefined) {
|
||||
throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
|
||||
}
|
||||
|
||||
if (!failedRoots.has(root)) {// No longer failed.
|
||||
}
|
||||
|
||||
if (rootElements === null) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!rootElements.has(root)) {
|
||||
return;
|
||||
}
|
||||
|
||||
var element = rootElements.get(root);
|
||||
|
||||
try {
|
||||
helpers.scheduleRoot(root, element);
|
||||
} catch (err) {
|
||||
if (!didError) {
|
||||
didError = true;
|
||||
firstError = err;
|
||||
} // Keep trying other roots.
|
||||
|
||||
}
|
||||
});
|
||||
mountedRootsSnapshot.forEach(function (root) {
|
||||
var helpers = helpersByRootSnapshot.get(root);
|
||||
|
||||
if (helpers === undefined) {
|
||||
throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
|
||||
}
|
||||
|
||||
if (!mountedRoots.has(root)) {// No longer mounted.
|
||||
}
|
||||
|
||||
try {
|
||||
helpers.scheduleRefresh(root, update);
|
||||
} catch (err) {
|
||||
if (!didError) {
|
||||
didError = true;
|
||||
firstError = err;
|
||||
} // Keep trying other roots.
|
||||
|
||||
}
|
||||
});
|
||||
|
||||
if (didError) {
|
||||
throw firstError;
|
||||
}
|
||||
|
||||
return update;
|
||||
} finally {
|
||||
isPerformingRefresh = false;
|
||||
}
|
||||
}
|
||||
function register(type, id) {
|
||||
{
|
||||
if (type === null) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (typeof type !== 'function' && typeof type !== 'object') {
|
||||
return;
|
||||
} // This can happen in an edge case, e.g. if we register
|
||||
// return value of a HOC but it returns a cached component.
|
||||
// Ignore anything but the first registration for each type.
|
||||
|
||||
|
||||
if (allFamiliesByType.has(type)) {
|
||||
return;
|
||||
} // Create family or remember to update it.
|
||||
// None of this bookkeeping affects reconciliation
|
||||
// until the first performReactRefresh() call above.
|
||||
|
||||
|
||||
var family = allFamiliesByID.get(id);
|
||||
|
||||
if (family === undefined) {
|
||||
family = {
|
||||
current: type
|
||||
};
|
||||
allFamiliesByID.set(id, family);
|
||||
} else {
|
||||
pendingUpdates.push([family, type]);
|
||||
}
|
||||
|
||||
allFamiliesByType.set(type, family); // Visit inner types because we might not have registered them.
|
||||
|
||||
if (typeof type === 'object' && type !== null) {
|
||||
switch (getProperty(type, '$$typeof')) {
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
register(type.render, id + '$render');
|
||||
break;
|
||||
|
||||
case REACT_MEMO_TYPE:
|
||||
register(type.type, id + '$type');
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function setSignature(type, key) {
|
||||
var forceReset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
||||
var getCustomHooks = arguments.length > 3 ? arguments[3] : undefined;
|
||||
|
||||
{
|
||||
if (!allSignaturesByType.has(type)) {
|
||||
allSignaturesByType.set(type, {
|
||||
forceReset: forceReset,
|
||||
ownKey: key,
|
||||
fullKey: null,
|
||||
getCustomHooks: getCustomHooks || function () {
|
||||
return [];
|
||||
}
|
||||
});
|
||||
} // Visit inner types because we might not have signed them.
|
||||
|
||||
|
||||
if (typeof type === 'object' && type !== null) {
|
||||
switch (getProperty(type, '$$typeof')) {
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
setSignature(type.render, key, forceReset, getCustomHooks);
|
||||
break;
|
||||
|
||||
case REACT_MEMO_TYPE:
|
||||
setSignature(type.type, key, forceReset, getCustomHooks);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} // This is lazily called during first render for a type.
|
||||
// It captures Hook list at that time so inline requires don't break comparisons.
|
||||
|
||||
function collectCustomHooksForSignature(type) {
|
||||
{
|
||||
var signature = allSignaturesByType.get(type);
|
||||
|
||||
if (signature !== undefined) {
|
||||
computeFullKey(signature);
|
||||
}
|
||||
}
|
||||
}
|
||||
function getFamilyByID(id) {
|
||||
{
|
||||
return allFamiliesByID.get(id);
|
||||
}
|
||||
}
|
||||
function getFamilyByType(type) {
|
||||
{
|
||||
return allFamiliesByType.get(type);
|
||||
}
|
||||
}
|
||||
function findAffectedHostInstances(families) {
|
||||
{
|
||||
var affectedInstances = new Set();
|
||||
mountedRoots.forEach(function (root) {
|
||||
var helpers = helpersByRoot.get(root);
|
||||
|
||||
if (helpers === undefined) {
|
||||
throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
|
||||
}
|
||||
|
||||
var instancesForRoot = helpers.findHostInstancesForRefresh(root, families);
|
||||
instancesForRoot.forEach(function (inst) {
|
||||
affectedInstances.add(inst);
|
||||
});
|
||||
});
|
||||
return affectedInstances;
|
||||
}
|
||||
}
|
||||
function injectIntoGlobalHook(globalObject) {
|
||||
{
|
||||
// For React Native, the global hook will be set up by require('react-devtools-core').
|
||||
// That code will run before us. So we need to monkeypatch functions on existing hook.
|
||||
// For React Web, the global hook will be set up by the extension.
|
||||
// This will also run before us.
|
||||
var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
|
||||
|
||||
if (hook === undefined) {
|
||||
// However, if there is no DevTools extension, we'll need to set up the global hook ourselves.
|
||||
// Note that in this case it's important that renderer code runs *after* this method call.
|
||||
// Otherwise, the renderer will think that there is no global hook, and won't do the injection.
|
||||
var nextID = 0;
|
||||
globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
|
||||
renderers: new Map(),
|
||||
supportsFiber: true,
|
||||
inject: function (injected) {
|
||||
return nextID++;
|
||||
},
|
||||
onScheduleFiberRoot: function (id, root, children) {},
|
||||
onCommitFiberRoot: function (id, root, maybePriorityLevel, didError) {},
|
||||
onCommitFiberUnmount: function () {}
|
||||
};
|
||||
}
|
||||
|
||||
if (hook.isDisabled) {
|
||||
// This isn't a real property on the hook, but it can be set to opt out
|
||||
// of DevTools integration and associated warnings and logs.
|
||||
// Using console['warn'] to evade Babel and ESLint
|
||||
console['warn']('Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). ' + 'Fast Refresh is not compatible with this shim and will be disabled.');
|
||||
return;
|
||||
} // Here, we just want to get a reference to scheduleRefresh.
|
||||
|
||||
|
||||
var oldInject = hook.inject;
|
||||
|
||||
hook.inject = function (injected) {
|
||||
var id = oldInject.apply(this, arguments);
|
||||
|
||||
if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') {
|
||||
// This version supports React Refresh.
|
||||
helpersByRendererID.set(id, injected);
|
||||
}
|
||||
|
||||
return id;
|
||||
}; // Do the same for any already injected roots.
|
||||
// This is useful if ReactDOM has already been initialized.
|
||||
// https://github.com/facebook/react/issues/17626
|
||||
|
||||
|
||||
hook.renderers.forEach(function (injected, id) {
|
||||
if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') {
|
||||
// This version supports React Refresh.
|
||||
helpersByRendererID.set(id, injected);
|
||||
}
|
||||
}); // We also want to track currently mounted roots.
|
||||
|
||||
var oldOnCommitFiberRoot = hook.onCommitFiberRoot;
|
||||
|
||||
var oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function () {};
|
||||
|
||||
hook.onScheduleFiberRoot = function (id, root, children) {
|
||||
if (!isPerformingRefresh) {
|
||||
// If it was intentionally scheduled, don't attempt to restore.
|
||||
// This includes intentionally scheduled unmounts.
|
||||
failedRoots.delete(root);
|
||||
|
||||
if (rootElements !== null) {
|
||||
rootElements.set(root, children);
|
||||
}
|
||||
}
|
||||
|
||||
return oldOnScheduleFiberRoot.apply(this, arguments);
|
||||
};
|
||||
|
||||
hook.onCommitFiberRoot = function (id, root, maybePriorityLevel, didError) {
|
||||
var helpers = helpersByRendererID.get(id);
|
||||
|
||||
if (helpers !== undefined) {
|
||||
helpersByRoot.set(root, helpers);
|
||||
var current = root.current;
|
||||
var alternate = current.alternate; // We need to determine whether this root has just (un)mounted.
|
||||
// This logic is copy-pasted from similar logic in the DevTools backend.
|
||||
// If this breaks with some refactoring, you'll want to update DevTools too.
|
||||
|
||||
if (alternate !== null) {
|
||||
var wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null && mountedRoots.has(root);
|
||||
var isMounted = current.memoizedState != null && current.memoizedState.element != null;
|
||||
|
||||
if (!wasMounted && isMounted) {
|
||||
// Mount a new root.
|
||||
mountedRoots.add(root);
|
||||
failedRoots.delete(root);
|
||||
} else if (wasMounted && isMounted) ; else if (wasMounted && !isMounted) {
|
||||
// Unmount an existing root.
|
||||
mountedRoots.delete(root);
|
||||
|
||||
if (didError) {
|
||||
// We'll remount it on future edits.
|
||||
failedRoots.add(root);
|
||||
} else {
|
||||
helpersByRoot.delete(root);
|
||||
}
|
||||
} else if (!wasMounted && !isMounted) {
|
||||
if (didError) {
|
||||
// We'll remount it on future edits.
|
||||
failedRoots.add(root);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Mount a new root.
|
||||
mountedRoots.add(root);
|
||||
}
|
||||
} // Always call the decorated DevTools hook.
|
||||
|
||||
|
||||
return oldOnCommitFiberRoot.apply(this, arguments);
|
||||
};
|
||||
}
|
||||
}
|
||||
function hasUnrecoverableErrors() {
|
||||
// TODO: delete this after removing dependency in RN.
|
||||
return false;
|
||||
} // Exposed for testing.
|
||||
|
||||
function _getMountedRootCount() {
|
||||
{
|
||||
return mountedRoots.size;
|
||||
}
|
||||
} // This is a wrapper over more primitive functions for setting signature.
|
||||
// Signatures let us decide whether the Hook order has changed on refresh.
|
||||
//
|
||||
// This function is intended to be used as a transform target, e.g.:
|
||||
// var _s = createSignatureFunctionForTransform()
|
||||
//
|
||||
// function Hello() {
|
||||
// const [foo, setFoo] = useState(0);
|
||||
// const value = useCustomHook();
|
||||
// _s(); /* Call without arguments triggers collecting the custom Hook list.
|
||||
// * This doesn't happen during the module evaluation because we
|
||||
// * don't want to change the module order with inline requires.
|
||||
// * Next calls are noops. */
|
||||
// return <h1>Hi</h1>;
|
||||
// }
|
||||
//
|
||||
// /* Call with arguments attaches the signature to the type: */
|
||||
// _s(
|
||||
// Hello,
|
||||
// 'useState{[foo, setFoo]}(0)',
|
||||
// () => [useCustomHook], /* Lazy to avoid triggering inline requires */
|
||||
// );
|
||||
|
||||
function createSignatureFunctionForTransform() {
|
||||
{
|
||||
var savedType;
|
||||
var hasCustomHooks;
|
||||
var didCollectHooks = false;
|
||||
return function (type, key, forceReset, getCustomHooks) {
|
||||
if (typeof key === 'string') {
|
||||
// We're in the initial phase that associates signatures
|
||||
// with the functions. Note this may be called multiple times
|
||||
// in HOC chains like _s(hoc1(_s(hoc2(_s(actualFunction))))).
|
||||
if (!savedType) {
|
||||
// We're in the innermost call, so this is the actual type.
|
||||
savedType = type;
|
||||
hasCustomHooks = typeof getCustomHooks === 'function';
|
||||
} // Set the signature for all types (even wrappers!) in case
|
||||
// they have no signatures of their own. This is to prevent
|
||||
// problems like https://github.com/facebook/react/issues/20417.
|
||||
|
||||
|
||||
if (type != null && (typeof type === 'function' || typeof type === 'object')) {
|
||||
setSignature(type, key, forceReset, getCustomHooks);
|
||||
}
|
||||
|
||||
return type;
|
||||
} else {
|
||||
// We're in the _s() call without arguments, which means
|
||||
// this is the time to collect custom Hook signatures.
|
||||
// Only do this once. This path is hot and runs *inside* every render!
|
||||
if (!didCollectHooks && hasCustomHooks) {
|
||||
didCollectHooks = true;
|
||||
collectCustomHooksForSignature(savedType);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
function isLikelyComponentType(type) {
|
||||
{
|
||||
switch (typeof type) {
|
||||
case 'function':
|
||||
{
|
||||
// First, deal with classes.
|
||||
if (type.prototype != null) {
|
||||
if (type.prototype.isReactComponent) {
|
||||
// React class.
|
||||
return true;
|
||||
}
|
||||
|
||||
var ownNames = Object.getOwnPropertyNames(type.prototype);
|
||||
|
||||
if (ownNames.length > 1 || ownNames[0] !== 'constructor') {
|
||||
// This looks like a class.
|
||||
return false;
|
||||
} // eslint-disable-next-line no-proto
|
||||
|
||||
|
||||
if (type.prototype.__proto__ !== Object.prototype) {
|
||||
// It has a superclass.
|
||||
return false;
|
||||
} // Pass through.
|
||||
// This looks like a regular function with empty prototype.
|
||||
|
||||
} // For plain functions and arrows, use name as a heuristic.
|
||||
|
||||
|
||||
var name = type.name || type.displayName;
|
||||
return typeof name === 'string' && /^[A-Z]/.test(name);
|
||||
}
|
||||
|
||||
case 'object':
|
||||
{
|
||||
if (type != null) {
|
||||
switch (getProperty(type, '$$typeof')) {
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
case REACT_MEMO_TYPE:
|
||||
// Definitely React components.
|
||||
return true;
|
||||
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
default:
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
exports._getMountedRootCount = _getMountedRootCount;
|
||||
exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
|
||||
exports.createSignatureFunctionForTransform = createSignatureFunctionForTransform;
|
||||
exports.findAffectedHostInstances = findAffectedHostInstances;
|
||||
exports.getFamilyByID = getFamilyByID;
|
||||
exports.getFamilyByType = getFamilyByType;
|
||||
exports.hasUnrecoverableErrors = hasUnrecoverableErrors;
|
||||
exports.injectIntoGlobalHook = injectIntoGlobalHook;
|
||||
exports.isLikelyComponentType = isLikelyComponentType;
|
||||
exports.performReactRefresh = performReactRefresh;
|
||||
exports.register = register;
|
||||
exports.setSignature = setSignature;
|
||||
})();
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={C:{"135":44.0004,"136":0.666,_:"2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 137 138 139 140 3.5 3.6"},D:{"109":8.6654,"124":0.666,"133":4.0034,"134":4.0034,_:"4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 110 111 112 113 114 115 116 117 118 119 120 121 122 123 125 126 127 128 129 130 131 132 135 136 137 138"},F:{_:"9 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 60 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 9.5-9.6 10.0-10.1 10.5 10.6 11.1 11.5 11.6 12.1"},B:{"131":9.3314,"134":2.664,_:"12 13 14 15 16 17 18 79 80 81 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 132 133"},E:{_:"0 4 5 6 7 8 9 10 11 12 13 14 15 3.1 3.2 5.1 6.1 7.1 9.1 10.1 11.1 12.1 13.1 14.1 15.1 15.2-15.3 15.4 15.5 15.6 16.0 16.1 16.2 16.3 16.4 16.5 16.6 17.0 17.1 17.2 17.3 17.4 17.5 17.6 18.0 18.1 18.2 18.3 18.4"},G:{"8":0,"3.2":0,"4.0-4.1":0,"4.2-4.3":0.00151,"5.0-5.1":0,"6.0-6.1":0.00452,"7.0-7.1":0.00301,"8.1-8.4":0,"9.0-9.2":0.00226,"9.3":0.01054,"10.0-10.2":0.00075,"10.3":0.01731,"11.0-11.2":0.07979,"11.3-11.4":0.00527,"12.0-12.1":0.00301,"12.2-12.5":0.07452,"13.0-13.1":0.00151,"13.2":0.00226,"13.3":0.00301,"13.4-13.7":0.01054,"14.0-14.4":0.02634,"14.5-14.8":0.03161,"15.0-15.1":0.01731,"15.2-15.3":0.01731,"15.4":0.02108,"15.5":0.02409,"15.6-15.8":0.29656,"16.0":0.04215,"16.1":0.08656,"16.2":0.04516,"16.3":0.07828,"16.4":0.01731,"16.5":0.03237,"16.6-16.7":0.35151,"17.0":0.02108,"17.1":0.03764,"17.2":0.0286,"17.3":0.03989,"17.4":0.07979,"17.5":0.17764,"17.6-17.7":0.5156,"18.0":0.14452,"18.1":0.4727,"18.2":0.21151,"18.3":4.42061,"18.4":0.06548},P:{_:"4 20 21 22 23 24 25 26 27 5.0-5.4 6.2-6.4 7.2-7.4 8.2 9.2 10.1 11.1-11.2 12.0 13.0 14.0 15.0 16.0 17.0 18.0 19.0"},I:{"0":0,"3":0,"4":0,"2.1":0,"2.2":0,"2.3":0,"4.1":0,"4.2-4.3":0,"4.4":0,"4.4.3-4.4.4":0},K:{"0":0,_:"10 11 12 11.1 11.5 12.1"},A:{_:"6 7 8 9 10 11 5.5"},S:{_:"2.5 3.0-3.1"},J:{_:"7 10"},N:{_:"10 11"},R:{_:"0"},M:{_:"0"},Q:{_:"14.9"},O:{_:"0"},H:{"0":0},L:{"0":18.473}};
|
||||
@@ -0,0 +1,7 @@
|
||||
import { URISchemeHandler, URIOptions } from "../uri";
|
||||
import { URNComponents } from "./urn";
|
||||
export interface UUIDComponents extends URNComponents {
|
||||
uuid?: string;
|
||||
}
|
||||
declare const handler: URISchemeHandler<UUIDComponents, URIOptions, URNComponents>;
|
||||
export default handler;
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"utils.js","sources":["../../src/utils.ts"],"sourcesContent":["import * as React from 'react'\n\nexport function useStableCallback<T extends (...args: Array<any>) => any>(\n fn: T,\n): T {\n const fnRef = React.useRef(fn)\n fnRef.current = fn\n\n const ref = React.useRef((...args: Array<any>) => fnRef.current(...args))\n return ref.current as T\n}\n\nexport const useLayoutEffect =\n typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\n/**\n * Taken from https://www.developerway.com/posts/implementing-advanced-use-previous-hook#part3\n */\nexport function usePrevious<T>(value: T): T | null {\n // initialise the ref with previous and current values\n const ref = React.useRef<{ value: T; prev: T | null }>({\n value: value,\n prev: null,\n })\n\n const current = ref.current.value\n\n // if the value passed into hook doesn't match what we store as \"current\"\n // move the \"current\" to the \"previous\"\n // and store the passed value as \"current\"\n if (value !== current) {\n ref.current = {\n value: value,\n prev: current,\n }\n }\n\n // return the previous value only\n return ref.current.prev\n}\n\n/**\n * React hook to wrap `IntersectionObserver`.\n *\n * This hook will create an `IntersectionObserver` and observe the ref passed to it.\n *\n * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.\n *\n * @param ref - The ref to observe\n * @param intersectionObserverOptions - The options to pass to the IntersectionObserver\n * @param options - The options to pass to the hook\n * @param callback - The callback to call when the intersection changes\n * @returns The IntersectionObserver instance\n * @example\n * ```tsx\n * const MyComponent = () => {\n * const ref = React.useRef<HTMLDivElement>(null)\n * useIntersectionObserver(\n * ref,\n * (entry) => { doSomething(entry) },\n * { rootMargin: '10px' },\n * { disabled: false }\n * )\n * return <div ref={ref} />\n * ```\n */\nexport function useIntersectionObserver<T extends Element>(\n ref: React.RefObject<T | null>,\n callback: (entry: IntersectionObserverEntry | undefined) => void,\n intersectionObserverOptions: IntersectionObserverInit = {},\n options: { disabled?: boolean } = {},\n): IntersectionObserver | null {\n const isIntersectionObserverAvailable = React.useRef(\n typeof IntersectionObserver === 'function',\n )\n\n const observerRef = React.useRef<IntersectionObserver | null>(null)\n\n React.useEffect(() => {\n if (\n !ref.current ||\n !isIntersectionObserverAvailable.current ||\n options.disabled\n ) {\n return\n }\n\n observerRef.current = new IntersectionObserver(([entry]) => {\n callback(entry)\n }, intersectionObserverOptions)\n\n observerRef.current.observe(ref.current)\n\n return () => {\n observerRef.current?.disconnect()\n }\n }, [callback, intersectionObserverOptions, options.disabled, ref])\n\n return observerRef.current\n}\n\n/**\n * React hook to take a `React.ForwardedRef` and returns a `ref` that can be used on a DOM element.\n *\n * @param ref - The forwarded ref\n * @returns The inner ref returned by `useRef`\n * @example\n * ```tsx\n * const MyComponent = React.forwardRef((props, ref) => {\n * const innerRef = useForwardedRef(ref)\n * return <div ref={innerRef} />\n * })\n * ```\n */\nexport function useForwardedRef<T>(ref?: React.ForwardedRef<T>) {\n const innerRef = React.useRef<T>(null)\n React.useImperativeHandle(ref, () => innerRef.current!, [])\n return innerRef\n}\n"],"names":[],"mappings":";AAEO,SAAS,kBACd,IACG;AACG,QAAA,QAAQ,MAAM,OAAO,EAAE;AAC7B,QAAM,UAAU;AAEV,QAAA,MAAM,MAAM,OAAO,IAAI,SAAqB,MAAM,QAAQ,GAAG,IAAI,CAAC;AACxE,SAAO,IAAI;AACb;AAEO,MAAM,kBACX,OAAO,WAAW,cAAc,MAAM,kBAAkB,MAAM;AAKzD,SAAS,YAAe,OAAoB;AAE3C,QAAA,MAAM,MAAM,OAAqC;AAAA,IACrD;AAAA,IACA,MAAM;AAAA,EAAA,CACP;AAEK,QAAA,UAAU,IAAI,QAAQ;AAK5B,MAAI,UAAU,SAAS;AACrB,QAAI,UAAU;AAAA,MACZ;AAAA,MACA,MAAM;AAAA,IACR;AAAA,EAAA;AAIF,SAAO,IAAI,QAAQ;AACrB;AA2BgB,SAAA,wBACd,KACA,UACA,8BAAwD,CACxD,GAAA,UAAkC,IACL;AAC7B,QAAM,kCAAkC,MAAM;AAAA,IAC5C,OAAO,yBAAyB;AAAA,EAClC;AAEM,QAAA,cAAc,MAAM,OAAoC,IAAI;AAElE,QAAM,UAAU,MAAM;AACpB,QACE,CAAC,IAAI,WACL,CAAC,gCAAgC,WACjC,QAAQ,UACR;AACA;AAAA,IAAA;AAGF,gBAAY,UAAU,IAAI,qBAAqB,CAAC,CAAC,KAAK,MAAM;AAC1D,eAAS,KAAK;AAAA,OACb,2BAA2B;AAElB,gBAAA,QAAQ,QAAQ,IAAI,OAAO;AAEvC,WAAO,MAAM;;AACX,wBAAY,YAAZ,mBAAqB;AAAA,IACvB;AAAA,EAAA,GACC,CAAC,UAAU,6BAA6B,QAAQ,UAAU,GAAG,CAAC;AAEjE,SAAO,YAAY;AACrB;AAeO,SAAS,gBAAmB,KAA6B;AACxD,QAAA,WAAW,MAAM,OAAU,IAAI;AACrC,QAAM,oBAAoB,KAAK,MAAM,SAAS,SAAU,CAAA,CAAE;AACnD,SAAA;AACT;"}
|
||||
@@ -0,0 +1,384 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
/**
|
||||
* @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
|
||||
*/
|
||||
|
||||
/**
|
||||
* @type {VisitorKeys}
|
||||
*/
|
||||
const KEYS = {
|
||||
ArrayExpression: [
|
||||
"elements"
|
||||
],
|
||||
ArrayPattern: [
|
||||
"elements"
|
||||
],
|
||||
ArrowFunctionExpression: [
|
||||
"params",
|
||||
"body"
|
||||
],
|
||||
AssignmentExpression: [
|
||||
"left",
|
||||
"right"
|
||||
],
|
||||
AssignmentPattern: [
|
||||
"left",
|
||||
"right"
|
||||
],
|
||||
AwaitExpression: [
|
||||
"argument"
|
||||
],
|
||||
BinaryExpression: [
|
||||
"left",
|
||||
"right"
|
||||
],
|
||||
BlockStatement: [
|
||||
"body"
|
||||
],
|
||||
BreakStatement: [
|
||||
"label"
|
||||
],
|
||||
CallExpression: [
|
||||
"callee",
|
||||
"arguments"
|
||||
],
|
||||
CatchClause: [
|
||||
"param",
|
||||
"body"
|
||||
],
|
||||
ChainExpression: [
|
||||
"expression"
|
||||
],
|
||||
ClassBody: [
|
||||
"body"
|
||||
],
|
||||
ClassDeclaration: [
|
||||
"id",
|
||||
"superClass",
|
||||
"body"
|
||||
],
|
||||
ClassExpression: [
|
||||
"id",
|
||||
"superClass",
|
||||
"body"
|
||||
],
|
||||
ConditionalExpression: [
|
||||
"test",
|
||||
"consequent",
|
||||
"alternate"
|
||||
],
|
||||
ContinueStatement: [
|
||||
"label"
|
||||
],
|
||||
DebuggerStatement: [],
|
||||
DoWhileStatement: [
|
||||
"body",
|
||||
"test"
|
||||
],
|
||||
EmptyStatement: [],
|
||||
ExperimentalRestProperty: [
|
||||
"argument"
|
||||
],
|
||||
ExperimentalSpreadProperty: [
|
||||
"argument"
|
||||
],
|
||||
ExportAllDeclaration: [
|
||||
"exported",
|
||||
"source"
|
||||
],
|
||||
ExportDefaultDeclaration: [
|
||||
"declaration"
|
||||
],
|
||||
ExportNamedDeclaration: [
|
||||
"declaration",
|
||||
"specifiers",
|
||||
"source"
|
||||
],
|
||||
ExportSpecifier: [
|
||||
"exported",
|
||||
"local"
|
||||
],
|
||||
ExpressionStatement: [
|
||||
"expression"
|
||||
],
|
||||
ForInStatement: [
|
||||
"left",
|
||||
"right",
|
||||
"body"
|
||||
],
|
||||
ForOfStatement: [
|
||||
"left",
|
||||
"right",
|
||||
"body"
|
||||
],
|
||||
ForStatement: [
|
||||
"init",
|
||||
"test",
|
||||
"update",
|
||||
"body"
|
||||
],
|
||||
FunctionDeclaration: [
|
||||
"id",
|
||||
"params",
|
||||
"body"
|
||||
],
|
||||
FunctionExpression: [
|
||||
"id",
|
||||
"params",
|
||||
"body"
|
||||
],
|
||||
Identifier: [],
|
||||
IfStatement: [
|
||||
"test",
|
||||
"consequent",
|
||||
"alternate"
|
||||
],
|
||||
ImportDeclaration: [
|
||||
"specifiers",
|
||||
"source"
|
||||
],
|
||||
ImportDefaultSpecifier: [
|
||||
"local"
|
||||
],
|
||||
ImportExpression: [
|
||||
"source"
|
||||
],
|
||||
ImportNamespaceSpecifier: [
|
||||
"local"
|
||||
],
|
||||
ImportSpecifier: [
|
||||
"imported",
|
||||
"local"
|
||||
],
|
||||
JSXAttribute: [
|
||||
"name",
|
||||
"value"
|
||||
],
|
||||
JSXClosingElement: [
|
||||
"name"
|
||||
],
|
||||
JSXClosingFragment: [],
|
||||
JSXElement: [
|
||||
"openingElement",
|
||||
"children",
|
||||
"closingElement"
|
||||
],
|
||||
JSXEmptyExpression: [],
|
||||
JSXExpressionContainer: [
|
||||
"expression"
|
||||
],
|
||||
JSXFragment: [
|
||||
"openingFragment",
|
||||
"children",
|
||||
"closingFragment"
|
||||
],
|
||||
JSXIdentifier: [],
|
||||
JSXMemberExpression: [
|
||||
"object",
|
||||
"property"
|
||||
],
|
||||
JSXNamespacedName: [
|
||||
"namespace",
|
||||
"name"
|
||||
],
|
||||
JSXOpeningElement: [
|
||||
"name",
|
||||
"attributes"
|
||||
],
|
||||
JSXOpeningFragment: [],
|
||||
JSXSpreadAttribute: [
|
||||
"argument"
|
||||
],
|
||||
JSXSpreadChild: [
|
||||
"expression"
|
||||
],
|
||||
JSXText: [],
|
||||
LabeledStatement: [
|
||||
"label",
|
||||
"body"
|
||||
],
|
||||
Literal: [],
|
||||
LogicalExpression: [
|
||||
"left",
|
||||
"right"
|
||||
],
|
||||
MemberExpression: [
|
||||
"object",
|
||||
"property"
|
||||
],
|
||||
MetaProperty: [
|
||||
"meta",
|
||||
"property"
|
||||
],
|
||||
MethodDefinition: [
|
||||
"key",
|
||||
"value"
|
||||
],
|
||||
NewExpression: [
|
||||
"callee",
|
||||
"arguments"
|
||||
],
|
||||
ObjectExpression: [
|
||||
"properties"
|
||||
],
|
||||
ObjectPattern: [
|
||||
"properties"
|
||||
],
|
||||
PrivateIdentifier: [],
|
||||
Program: [
|
||||
"body"
|
||||
],
|
||||
Property: [
|
||||
"key",
|
||||
"value"
|
||||
],
|
||||
PropertyDefinition: [
|
||||
"key",
|
||||
"value"
|
||||
],
|
||||
RestElement: [
|
||||
"argument"
|
||||
],
|
||||
ReturnStatement: [
|
||||
"argument"
|
||||
],
|
||||
SequenceExpression: [
|
||||
"expressions"
|
||||
],
|
||||
SpreadElement: [
|
||||
"argument"
|
||||
],
|
||||
StaticBlock: [
|
||||
"body"
|
||||
],
|
||||
Super: [],
|
||||
SwitchCase: [
|
||||
"test",
|
||||
"consequent"
|
||||
],
|
||||
SwitchStatement: [
|
||||
"discriminant",
|
||||
"cases"
|
||||
],
|
||||
TaggedTemplateExpression: [
|
||||
"tag",
|
||||
"quasi"
|
||||
],
|
||||
TemplateElement: [],
|
||||
TemplateLiteral: [
|
||||
"quasis",
|
||||
"expressions"
|
||||
],
|
||||
ThisExpression: [],
|
||||
ThrowStatement: [
|
||||
"argument"
|
||||
],
|
||||
TryStatement: [
|
||||
"block",
|
||||
"handler",
|
||||
"finalizer"
|
||||
],
|
||||
UnaryExpression: [
|
||||
"argument"
|
||||
],
|
||||
UpdateExpression: [
|
||||
"argument"
|
||||
],
|
||||
VariableDeclaration: [
|
||||
"declarations"
|
||||
],
|
||||
VariableDeclarator: [
|
||||
"id",
|
||||
"init"
|
||||
],
|
||||
WhileStatement: [
|
||||
"test",
|
||||
"body"
|
||||
],
|
||||
WithStatement: [
|
||||
"object",
|
||||
"body"
|
||||
],
|
||||
YieldExpression: [
|
||||
"argument"
|
||||
]
|
||||
};
|
||||
|
||||
// Types.
|
||||
const NODE_TYPES = Object.keys(KEYS);
|
||||
|
||||
// Freeze the keys.
|
||||
for (const type of NODE_TYPES) {
|
||||
Object.freeze(KEYS[type]);
|
||||
}
|
||||
Object.freeze(KEYS);
|
||||
|
||||
/**
|
||||
* @author Toru Nagashima <https://github.com/mysticatea>
|
||||
* See LICENSE file in root directory for full license.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @typedef {import('./visitor-keys.js').VisitorKeys} VisitorKeys
|
||||
*/
|
||||
|
||||
// List to ignore keys.
|
||||
const KEY_BLACKLIST = new Set([
|
||||
"parent",
|
||||
"leadingComments",
|
||||
"trailingComments"
|
||||
]);
|
||||
|
||||
/**
|
||||
* Check whether a given key should be used or not.
|
||||
* @param {string} key The key to check.
|
||||
* @returns {boolean} `true` if the key should be used.
|
||||
*/
|
||||
function filterKey(key) {
|
||||
return !KEY_BLACKLIST.has(key) && key[0] !== "_";
|
||||
}
|
||||
|
||||
/**
|
||||
* Get visitor keys of a given node.
|
||||
* @param {object} node The AST node to get keys.
|
||||
* @returns {readonly string[]} Visitor keys of the node.
|
||||
*/
|
||||
function getKeys(node) {
|
||||
return Object.keys(node).filter(filterKey);
|
||||
}
|
||||
|
||||
// Disable valid-jsdoc rule because it reports syntax error on the type of @returns.
|
||||
// eslint-disable-next-line valid-jsdoc
|
||||
/**
|
||||
* Make the union set with `KEYS` and given keys.
|
||||
* @param {VisitorKeys} additionalKeys The additional keys.
|
||||
* @returns {VisitorKeys} The union set.
|
||||
*/
|
||||
function unionWith(additionalKeys) {
|
||||
const retv = /** @type {{
|
||||
[type: string]: ReadonlyArray<string>
|
||||
}} */ (Object.assign({}, KEYS));
|
||||
|
||||
for (const type of Object.keys(additionalKeys)) {
|
||||
if (Object.prototype.hasOwnProperty.call(retv, type)) {
|
||||
const keys = new Set(additionalKeys[type]);
|
||||
|
||||
for (const key of retv[type]) {
|
||||
keys.add(key);
|
||||
}
|
||||
|
||||
retv[type] = Object.freeze(Array.from(keys));
|
||||
} else {
|
||||
retv[type] = Object.freeze(Array.from(additionalKeys[type]));
|
||||
}
|
||||
}
|
||||
|
||||
return Object.freeze(retv);
|
||||
}
|
||||
|
||||
exports.KEYS = KEYS;
|
||||
exports.getKeys = getKeys;
|
||||
exports.unionWith = unionWith;
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E F mC","132":"A B"},B:{"1":"0 9 C L M G N O P Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I"},C:{"1":"0 1 2 3 4 5 6 7 8 9 N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC oC pC","2":"nC LC J PB K D E F qC rC","33":"A B C L M G"},D:{"1":"0 9 ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC","2":"J PB K D E F A B","33":"1 2 3 4 5 6 7 8 C L M G N O P QB RB SB TB UB VB WB XB YB"},E:{"1":"VC HC 0C IC WC XC YC ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC 3C","2":"sC SC","33":"J PB K D E tC uC vC","257":"F A B C L M G wC TC FC GC xC yC zC UC"},F:{"1":"0 4 5 6 7 8 RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z","2":"F B C 4C 5C 6C 7C FC kC 8C GC","33":"1 2 3 G N O P QB"},G:{"1":"VC HC TD IC WC XC YC ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC","33":"E SC 9C lC AD BD CD DD","257":"ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD UC"},H:{"2":"WD"},I:{"1":"I","2":"XD YD ZD","33":"LC J aD lC bD cD"},J:{"33":"D A"},K:{"1":"H","2":"A B C FC kC GC"},L:{"1":"I"},M:{"1":"EC"},N:{"132":"A B"},O:{"1":"HC"},P:{"1":"1 2 3 4 5 6 7 8 J dD eD fD gD hD TC iD jD kD lD mD IC JC KC nD"},Q:{"1":"oD"},R:{"1":"pD"},S:{"1":"qD rD"}},B:5,C:"CSS3 3D Transforms",D:true};
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_classPrivateMethodSet","TypeError"],"sources":["../../src/helpers/classPrivateMethodSet.js"],"sourcesContent":["/* @minVersion 7.1.6 */\n/* @onlyBabel7 */\n\n// use readOnlyError instead of attemptSet\n\nexport default function _classPrivateMethodSet() {\n throw new TypeError(\"attempted to reassign private method\");\n}\n"],"mappings":";;;;;;AAKe,SAASA,sBAAsBA,CAAA,EAAG;EAC/C,MAAM,IAAIC,SAAS,CAAC,sCAAsC,CAAC;AAC7D","ignoreList":[]}
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E F A B mC"},B:{"1":"0 9 C L M G N O P Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I"},C:{"1":"0 1 2 3 4 5 6 7 8 9 QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC oC pC","33":"J PB K D E F A B C L M G N O P qC rC","164":"nC LC"},D:{"1":"0 1 2 3 4 5 6 7 8 9 J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC"},E:{"1":"J PB K D E F A B C L M G SC tC uC vC wC TC FC GC xC yC zC UC VC HC 0C IC WC XC YC ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC 3C","16":"sC"},F:{"1":"0 1 2 3 4 5 6 7 8 G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z","2":"F B C 4C 5C 6C 7C FC kC 8C GC"},G:{"1":"E 9C lC AD BD CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD UC VC HC TD IC WC XC YC ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC","16":"SC"},H:{"2":"WD"},I:{"1":"LC J I ZD aD lC bD cD","16":"XD YD"},J:{"1":"D A"},K:{"1":"H","2":"A B C FC kC GC"},L:{"1":"I"},M:{"1":"EC"},N:{"2":"A B"},O:{"1":"HC"},P:{"1":"1 2 3 4 5 6 7 8 J dD eD fD gD hD TC iD jD kD lD mD IC JC KC nD"},Q:{"1":"oD"},R:{"1":"pD"},S:{"1":"qD rD"}},B:4,C:"CSS initial value",D:true};
|
||||
@@ -0,0 +1,85 @@
|
||||
'use strict';
|
||||
module.exports = function generate__limitLength(it, $keyword, $ruleType) {
|
||||
var out = ' ';
|
||||
var $lvl = it.level;
|
||||
var $dataLvl = it.dataLevel;
|
||||
var $schema = it.schema[$keyword];
|
||||
var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
|
||||
var $errSchemaPath = it.errSchemaPath + '/' + $keyword;
|
||||
var $breakOnError = !it.opts.allErrors;
|
||||
var $errorKeyword;
|
||||
var $data = 'data' + ($dataLvl || '');
|
||||
var $isData = it.opts.$data && $schema && $schema.$data,
|
||||
$schemaValue;
|
||||
if ($isData) {
|
||||
out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';
|
||||
$schemaValue = 'schema' + $lvl;
|
||||
} else {
|
||||
$schemaValue = $schema;
|
||||
}
|
||||
if (!($isData || typeof $schema == 'number')) {
|
||||
throw new Error($keyword + ' must be number');
|
||||
}
|
||||
var $op = $keyword == 'maxLength' ? '>' : '<';
|
||||
out += 'if ( ';
|
||||
if ($isData) {
|
||||
out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || ';
|
||||
}
|
||||
if (it.opts.unicode === false) {
|
||||
out += ' ' + ($data) + '.length ';
|
||||
} else {
|
||||
out += ' ucs2length(' + ($data) + ') ';
|
||||
}
|
||||
out += ' ' + ($op) + ' ' + ($schemaValue) + ') { ';
|
||||
var $errorKeyword = $keyword;
|
||||
var $$outStack = $$outStack || [];
|
||||
$$outStack.push(out);
|
||||
out = ''; /* istanbul ignore else */
|
||||
if (it.createErrors !== false) {
|
||||
out += ' { keyword: \'' + ($errorKeyword || '_limitLength') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } ';
|
||||
if (it.opts.messages !== false) {
|
||||
out += ' , message: \'should NOT be ';
|
||||
if ($keyword == 'maxLength') {
|
||||
out += 'longer';
|
||||
} else {
|
||||
out += 'shorter';
|
||||
}
|
||||
out += ' than ';
|
||||
if ($isData) {
|
||||
out += '\' + ' + ($schemaValue) + ' + \'';
|
||||
} else {
|
||||
out += '' + ($schema);
|
||||
}
|
||||
out += ' characters\' ';
|
||||
}
|
||||
if (it.opts.verbose) {
|
||||
out += ' , schema: ';
|
||||
if ($isData) {
|
||||
out += 'validate.schema' + ($schemaPath);
|
||||
} else {
|
||||
out += '' + ($schema);
|
||||
}
|
||||
out += ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';
|
||||
}
|
||||
out += ' } ';
|
||||
} else {
|
||||
out += ' {} ';
|
||||
}
|
||||
var __err = out;
|
||||
out = $$outStack.pop();
|
||||
if (!it.compositeRule && $breakOnError) {
|
||||
/* istanbul ignore if */
|
||||
if (it.async) {
|
||||
out += ' throw new ValidationError([' + (__err) + ']); ';
|
||||
} else {
|
||||
out += ' validate.errors = [' + (__err) + ']; return false; ';
|
||||
}
|
||||
} else {
|
||||
out += ' var err = ' + (__err) + '; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';
|
||||
}
|
||||
out += '} ';
|
||||
if ($breakOnError) {
|
||||
out += ' else { ';
|
||||
}
|
||||
return out;
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
/**
|
||||
* @fileoverview Defining the hashing function in one place.
|
||||
* @author Michael Ficarra
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const murmur = require("imurmurhash");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Private
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* hash the given string
|
||||
* @param {string} str the string to hash
|
||||
* @returns {string} the hash
|
||||
*/
|
||||
function hash(str) {
|
||||
return murmur(str).result().toString(36);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Public Interface
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
module.exports = hash;
|
||||
@@ -0,0 +1,52 @@
|
||||
{
|
||||
"name": "@tanstack/router-core",
|
||||
"version": "1.114.33",
|
||||
"description": "Modern and scalable routing for React applications",
|
||||
"author": "Tanner Linsley",
|
||||
"license": "MIT",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/TanStack/router.git",
|
||||
"directory": "packages/router-core"
|
||||
},
|
||||
"homepage": "https://tanstack.com/router",
|
||||
"funding": {
|
||||
"type": "github",
|
||||
"url": "https://github.com/sponsors/tannerlinsley"
|
||||
},
|
||||
"keywords": [
|
||||
"history",
|
||||
"typescript"
|
||||
],
|
||||
"type": "module",
|
||||
"types": "dist/esm/index.d.ts",
|
||||
"main": "dist/cjs/index.cjs",
|
||||
"module": "dist/esm/index.js",
|
||||
"exports": {
|
||||
".": {
|
||||
"import": {
|
||||
"types": "./dist/esm/index.d.ts",
|
||||
"default": "./dist/esm/index.js"
|
||||
},
|
||||
"require": {
|
||||
"types": "./dist/cjs/index.d.cts",
|
||||
"default": "./dist/cjs/index.cjs"
|
||||
}
|
||||
},
|
||||
"./package.json": "./package.json"
|
||||
},
|
||||
"sideEffects": false,
|
||||
"files": [
|
||||
"dist",
|
||||
"src"
|
||||
],
|
||||
"engines": {
|
||||
"node": ">=12"
|
||||
},
|
||||
"dependencies": {
|
||||
"@tanstack/store": "^0.7.0",
|
||||
"tiny-invariant": "^1.3.3",
|
||||
"@tanstack/history": "1.114.29"
|
||||
},
|
||||
"scripts": {}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2018 Mathias Buus
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
@@ -0,0 +1,120 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag when using constructor without parentheses
|
||||
* @author Ilya Volodin
|
||||
* @deprecated in ESLint v8.53.0
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
deprecated: {
|
||||
message: "Formatting rules are being moved out of ESLint core.",
|
||||
url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
|
||||
deprecatedSince: "8.53.0",
|
||||
availableUntil: "10.0.0",
|
||||
replacedBy: [
|
||||
{
|
||||
message:
|
||||
"ESLint Stylistic now maintains deprecated stylistic core rules.",
|
||||
url: "https://eslint.style/guide/migration",
|
||||
plugin: {
|
||||
name: "@stylistic/eslint-plugin-js",
|
||||
url: "https://eslint.style/packages/js",
|
||||
},
|
||||
rule: {
|
||||
name: "new-parens",
|
||||
url: "https://eslint.style/rules/js/new-parens",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
type: "layout",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Enforce or disallow parentheses when invoking a constructor with no arguments",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/new-parens",
|
||||
},
|
||||
|
||||
fixable: "code",
|
||||
schema: [
|
||||
{
|
||||
enum: ["always", "never"],
|
||||
},
|
||||
],
|
||||
messages: {
|
||||
missing: "Missing '()' invoking a constructor.",
|
||||
unnecessary:
|
||||
"Unnecessary '()' invoking a constructor with no arguments.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const options = context.options;
|
||||
const always = options[0] !== "never"; // Default is always
|
||||
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
return {
|
||||
NewExpression(node) {
|
||||
if (node.arguments.length !== 0) {
|
||||
return; // if there are arguments, there have to be parens
|
||||
}
|
||||
|
||||
const lastToken = sourceCode.getLastToken(node);
|
||||
const hasLastParen =
|
||||
lastToken && astUtils.isClosingParenToken(lastToken);
|
||||
|
||||
// `hasParens` is true only if the new expression ends with its own parens, e.g., new new foo() does not end with its own parens
|
||||
const hasParens =
|
||||
hasLastParen &&
|
||||
astUtils.isOpeningParenToken(
|
||||
sourceCode.getTokenBefore(lastToken),
|
||||
) &&
|
||||
node.callee.range[1] < node.range[1];
|
||||
|
||||
if (always) {
|
||||
if (!hasParens) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "missing",
|
||||
fix: fixer => fixer.insertTextAfter(node, "()"),
|
||||
});
|
||||
}
|
||||
} else {
|
||||
if (hasParens) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unnecessary",
|
||||
fix: fixer => [
|
||||
fixer.remove(
|
||||
sourceCode.getTokenBefore(lastToken),
|
||||
),
|
||||
fixer.remove(lastToken),
|
||||
fixer.insertTextBefore(node, "("),
|
||||
fixer.insertTextAfter(node, ")"),
|
||||
],
|
||||
});
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,232 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "TargetNames", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _options.TargetNames;
|
||||
}
|
||||
});
|
||||
exports.default = getTargets;
|
||||
Object.defineProperty(exports, "filterItems", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _filterItems.default;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "getInclusionReasons", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _debug.getInclusionReasons;
|
||||
}
|
||||
});
|
||||
exports.isBrowsersQueryValid = isBrowsersQueryValid;
|
||||
Object.defineProperty(exports, "isRequired", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _filterItems.isRequired;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "prettifyTargets", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _pretty.prettifyTargets;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "unreleasedLabels", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _targets.unreleasedLabels;
|
||||
}
|
||||
});
|
||||
var _browserslist = require("browserslist");
|
||||
var _helperValidatorOption = require("@babel/helper-validator-option");
|
||||
var _nativeModules = require("@babel/compat-data/native-modules");
|
||||
var _lruCache = require("lru-cache");
|
||||
var _utils = require("./utils.js");
|
||||
var _targets = require("./targets.js");
|
||||
var _options = require("./options.js");
|
||||
var _pretty = require("./pretty.js");
|
||||
var _debug = require("./debug.js");
|
||||
var _filterItems = require("./filter-items.js");
|
||||
const ESM_SUPPORT = _nativeModules["es6.module"];
|
||||
const v = new _helperValidatorOption.OptionValidator("@babel/helper-compilation-targets");
|
||||
function validateTargetNames(targets) {
|
||||
const validTargets = Object.keys(_options.TargetNames);
|
||||
for (const target of Object.keys(targets)) {
|
||||
if (!(target in _options.TargetNames)) {
|
||||
throw new Error(v.formatMessage(`'${target}' is not a valid target
|
||||
- Did you mean '${(0, _helperValidatorOption.findSuggestion)(target, validTargets)}'?`));
|
||||
}
|
||||
}
|
||||
return targets;
|
||||
}
|
||||
function isBrowsersQueryValid(browsers) {
|
||||
return typeof browsers === "string" || Array.isArray(browsers) && browsers.every(b => typeof b === "string");
|
||||
}
|
||||
function validateBrowsers(browsers) {
|
||||
v.invariant(browsers === undefined || isBrowsersQueryValid(browsers), `'${String(browsers)}' is not a valid browserslist query`);
|
||||
return browsers;
|
||||
}
|
||||
function getLowestVersions(browsers) {
|
||||
return browsers.reduce((all, browser) => {
|
||||
const [browserName, browserVersion] = browser.split(" ");
|
||||
const target = _targets.browserNameMap[browserName];
|
||||
if (!target) {
|
||||
return all;
|
||||
}
|
||||
try {
|
||||
const splitVersion = browserVersion.split("-")[0].toLowerCase();
|
||||
const isSplitUnreleased = (0, _utils.isUnreleasedVersion)(splitVersion, target);
|
||||
if (!all[target]) {
|
||||
all[target] = isSplitUnreleased ? splitVersion : (0, _utils.semverify)(splitVersion);
|
||||
return all;
|
||||
}
|
||||
const version = all[target];
|
||||
const isUnreleased = (0, _utils.isUnreleasedVersion)(version, target);
|
||||
if (isUnreleased && isSplitUnreleased) {
|
||||
all[target] = (0, _utils.getLowestUnreleased)(version, splitVersion, target);
|
||||
} else if (isUnreleased) {
|
||||
all[target] = (0, _utils.semverify)(splitVersion);
|
||||
} else if (!isUnreleased && !isSplitUnreleased) {
|
||||
const parsedBrowserVersion = (0, _utils.semverify)(splitVersion);
|
||||
all[target] = (0, _utils.semverMin)(version, parsedBrowserVersion);
|
||||
}
|
||||
} catch (_) {}
|
||||
return all;
|
||||
}, {});
|
||||
}
|
||||
function outputDecimalWarning(decimalTargets) {
|
||||
if (!decimalTargets.length) {
|
||||
return;
|
||||
}
|
||||
console.warn("Warning, the following targets are using a decimal version:\n");
|
||||
decimalTargets.forEach(({
|
||||
target,
|
||||
value
|
||||
}) => console.warn(` ${target}: ${value}`));
|
||||
console.warn(`
|
||||
We recommend using a string for minor/patch versions to avoid numbers like 6.10
|
||||
getting parsed as 6.1, which can lead to unexpected behavior.
|
||||
`);
|
||||
}
|
||||
function semverifyTarget(target, value) {
|
||||
try {
|
||||
return (0, _utils.semverify)(value);
|
||||
} catch (_) {
|
||||
throw new Error(v.formatMessage(`'${value}' is not a valid value for 'targets.${target}'.`));
|
||||
}
|
||||
}
|
||||
function nodeTargetParser(value) {
|
||||
const parsed = value === true || value === "current" ? process.versions.node.split("-")[0] : semverifyTarget("node", value);
|
||||
return ["node", parsed];
|
||||
}
|
||||
function defaultTargetParser(target, value) {
|
||||
const version = (0, _utils.isUnreleasedVersion)(value, target) ? value.toLowerCase() : semverifyTarget(target, value);
|
||||
return [target, version];
|
||||
}
|
||||
function generateTargets(inputTargets) {
|
||||
const input = Object.assign({}, inputTargets);
|
||||
delete input.esmodules;
|
||||
delete input.browsers;
|
||||
return input;
|
||||
}
|
||||
function resolveTargets(queries, env) {
|
||||
const resolved = _browserslist(queries, {
|
||||
mobileToDesktop: true,
|
||||
env
|
||||
});
|
||||
return getLowestVersions(resolved);
|
||||
}
|
||||
const targetsCache = new _lruCache({
|
||||
max: 64
|
||||
});
|
||||
function resolveTargetsCached(queries, env) {
|
||||
const cacheKey = typeof queries === "string" ? queries : queries.join() + env;
|
||||
let cached = targetsCache.get(cacheKey);
|
||||
if (!cached) {
|
||||
cached = resolveTargets(queries, env);
|
||||
targetsCache.set(cacheKey, cached);
|
||||
}
|
||||
return Object.assign({}, cached);
|
||||
}
|
||||
function getTargets(inputTargets = {}, options = {}) {
|
||||
var _browsers, _browsers2;
|
||||
let {
|
||||
browsers,
|
||||
esmodules
|
||||
} = inputTargets;
|
||||
const {
|
||||
configPath = ".",
|
||||
onBrowserslistConfigFound
|
||||
} = options;
|
||||
validateBrowsers(browsers);
|
||||
const input = generateTargets(inputTargets);
|
||||
let targets = validateTargetNames(input);
|
||||
const shouldParseBrowsers = !!browsers;
|
||||
const hasTargets = shouldParseBrowsers || Object.keys(targets).length > 0;
|
||||
const shouldSearchForConfig = !options.ignoreBrowserslistConfig && !hasTargets;
|
||||
if (!browsers && shouldSearchForConfig) {
|
||||
browsers = process.env.BROWSERSLIST;
|
||||
if (!browsers) {
|
||||
const configFile = options.configFile || process.env.BROWSERSLIST_CONFIG || _browserslist.findConfigFile(configPath);
|
||||
if (configFile != null) {
|
||||
onBrowserslistConfigFound == null || onBrowserslistConfigFound(configFile);
|
||||
browsers = _browserslist.loadConfig({
|
||||
config: configFile,
|
||||
env: options.browserslistEnv
|
||||
});
|
||||
}
|
||||
}
|
||||
if (browsers == null) {
|
||||
{
|
||||
browsers = [];
|
||||
}
|
||||
}
|
||||
}
|
||||
;
|
||||
if (esmodules && (esmodules !== "intersect" || !((_browsers = browsers) != null && _browsers.length))) {
|
||||
browsers = Object.keys(ESM_SUPPORT).map(browser => `${browser} >= ${ESM_SUPPORT[browser]}`).join(", ");
|
||||
esmodules = false;
|
||||
}
|
||||
if ((_browsers2 = browsers) != null && _browsers2.length) {
|
||||
const queryBrowsers = resolveTargetsCached(browsers, options.browserslistEnv);
|
||||
if (esmodules === "intersect") {
|
||||
for (const browser of Object.keys(queryBrowsers)) {
|
||||
if (browser !== "deno" && browser !== "ie") {
|
||||
const esmSupportVersion = ESM_SUPPORT[browser === "opera_mobile" ? "op_mob" : browser];
|
||||
if (esmSupportVersion) {
|
||||
const version = queryBrowsers[browser];
|
||||
queryBrowsers[browser] = (0, _utils.getHighestUnreleased)(version, (0, _utils.semverify)(esmSupportVersion), browser);
|
||||
} else {
|
||||
delete queryBrowsers[browser];
|
||||
}
|
||||
} else {
|
||||
delete queryBrowsers[browser];
|
||||
}
|
||||
}
|
||||
}
|
||||
targets = Object.assign(queryBrowsers, targets);
|
||||
}
|
||||
const result = {};
|
||||
const decimalWarnings = [];
|
||||
for (const target of Object.keys(targets).sort()) {
|
||||
const value = targets[target];
|
||||
if (typeof value === "number" && value % 1 !== 0) {
|
||||
decimalWarnings.push({
|
||||
target,
|
||||
value
|
||||
});
|
||||
}
|
||||
const [parsedTarget, parsedValue] = target === "node" ? nodeTargetParser(value) : defaultTargetParser(target, value);
|
||||
if (parsedValue) {
|
||||
result[parsedTarget] = parsedValue;
|
||||
}
|
||||
}
|
||||
outputDecimalWarning(decimalWarnings);
|
||||
return result;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=index.js.map
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,36 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = matchesPattern;
|
||||
var _index = require("./generated/index.js");
|
||||
function matchesPattern(member, match, allowPartial) {
|
||||
if (!(0, _index.isMemberExpression)(member)) return false;
|
||||
const parts = Array.isArray(match) ? match : match.split(".");
|
||||
const nodes = [];
|
||||
let node;
|
||||
for (node = member; (0, _index.isMemberExpression)(node); node = node.object) {
|
||||
nodes.push(node.property);
|
||||
}
|
||||
nodes.push(node);
|
||||
if (nodes.length < parts.length) return false;
|
||||
if (!allowPartial && nodes.length > parts.length) return false;
|
||||
for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {
|
||||
const node = nodes[j];
|
||||
let value;
|
||||
if ((0, _index.isIdentifier)(node)) {
|
||||
value = node.name;
|
||||
} else if ((0, _index.isStringLiteral)(node)) {
|
||||
value = node.value;
|
||||
} else if ((0, _index.isThisExpression)(node)) {
|
||||
value = "this";
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
if (parts[i] !== value) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=matchesPattern.js.map
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_setPrototypeOf","o","p","exports","default","Object","setPrototypeOf","bind","__proto__"],"sources":["../../src/helpers/setPrototypeOf.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _setPrototypeOf(o: object, p: object) {\n // @ts-expect-error - assigning to function\n _setPrototypeOf = Object.setPrototypeOf\n ? // @ts-expect-error - intentionally omitted argument\n Object.setPrototypeOf.bind(/* undefined */)\n : function _setPrototypeOf(o: object, p: object) {\n (o as any).__proto__ = p;\n return o;\n };\n return _setPrototypeOf(o, p);\n}\n"],"mappings":";;;;;;AAEe,SAASA,eAAeA,CAACC,CAAS,EAAEC,CAAS,EAAE;EAE5DC,OAAA,CAAAC,OAAA,GAAAJ,eAAe,GAAGK,MAAM,CAACC,cAAc,GAEnCD,MAAM,CAACC,cAAc,CAACC,IAAI,CAAgB,CAAC,GAC3C,SAASP,eAAeA,CAACC,CAAS,EAAEC,CAAS,EAAE;IAC5CD,CAAC,CAASO,SAAS,GAAGN,CAAC;IACxB,OAAOD,CAAC;EACV,CAAC;EACL,OAAOD,eAAe,CAACC,CAAC,EAAEC,CAAC,CAAC;AAC9B","ignoreList":[]}
|
||||
@@ -0,0 +1,147 @@
|
||||
/**
|
||||
* @fileoverview Disallow mixed spaces and tabs for indentation
|
||||
* @author Jary Niebur
|
||||
* @deprecated in ESLint v8.53.0
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
deprecated: {
|
||||
message: "Formatting rules are being moved out of ESLint core.",
|
||||
url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
|
||||
deprecatedSince: "8.53.0",
|
||||
availableUntil: "10.0.0",
|
||||
replacedBy: [
|
||||
{
|
||||
message:
|
||||
"ESLint Stylistic now maintains deprecated stylistic core rules.",
|
||||
url: "https://eslint.style/guide/migration",
|
||||
plugin: {
|
||||
name: "@stylistic/eslint-plugin-js",
|
||||
url: "https://eslint.style/packages/js",
|
||||
},
|
||||
rule: {
|
||||
name: "no-mixed-spaces-and-tabs",
|
||||
url: "https://eslint.style/rules/js/no-mixed-spaces-and-tabs",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
type: "layout",
|
||||
|
||||
docs: {
|
||||
description: "Disallow mixed spaces and tabs for indentation",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs",
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
enum: ["smart-tabs", true, false],
|
||||
},
|
||||
],
|
||||
|
||||
messages: {
|
||||
mixedSpacesAndTabs: "Mixed spaces and tabs.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
let smartTabs;
|
||||
|
||||
switch (context.options[0]) {
|
||||
case true: // Support old syntax, maybe add deprecation warning here
|
||||
case "smart-tabs":
|
||||
smartTabs = true;
|
||||
break;
|
||||
default:
|
||||
smartTabs = false;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Public
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
return {
|
||||
"Program:exit"(node) {
|
||||
const lines = sourceCode.lines,
|
||||
comments = sourceCode.getAllComments(),
|
||||
ignoredCommentLines = new Set();
|
||||
|
||||
// Add all lines except the first ones.
|
||||
comments.forEach(comment => {
|
||||
for (
|
||||
let i = comment.loc.start.line + 1;
|
||||
i <= comment.loc.end.line;
|
||||
i++
|
||||
) {
|
||||
ignoredCommentLines.add(i);
|
||||
}
|
||||
});
|
||||
|
||||
/*
|
||||
* At least one space followed by a tab
|
||||
* or the reverse before non-tab/-space
|
||||
* characters begin.
|
||||
*/
|
||||
let regex = /^(?=( +|\t+))\1(?:\t| )/u;
|
||||
|
||||
if (smartTabs) {
|
||||
/*
|
||||
* At least one space followed by a tab
|
||||
* before non-tab/-space characters begin.
|
||||
*/
|
||||
regex = /^(?=(\t*))\1(?=( +))\2\t/u;
|
||||
}
|
||||
|
||||
lines.forEach((line, i) => {
|
||||
const match = regex.exec(line);
|
||||
|
||||
if (match) {
|
||||
const lineNumber = i + 1;
|
||||
const loc = {
|
||||
start: {
|
||||
line: lineNumber,
|
||||
column: match[0].length - 2,
|
||||
},
|
||||
end: {
|
||||
line: lineNumber,
|
||||
column: match[0].length,
|
||||
},
|
||||
};
|
||||
|
||||
if (!ignoredCommentLines.has(lineNumber)) {
|
||||
const containingNode =
|
||||
sourceCode.getNodeByRangeIndex(
|
||||
sourceCode.getIndexFromLoc(loc.start),
|
||||
);
|
||||
|
||||
if (
|
||||
!(
|
||||
containingNode &&
|
||||
["Literal", "TemplateElement"].includes(
|
||||
containingNode.type,
|
||||
)
|
||||
)
|
||||
) {
|
||||
context.report({
|
||||
node,
|
||||
loc,
|
||||
messageId: "mixedSpacesAndTabs",
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
Binary file not shown.
Reference in New Issue
Block a user