Last active
September 19, 2023 19:24
-
-
Save mimalef70/6ff3a49e86596f158c1cf2d4b80644a7 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import { | |
j as g, | |
r as N, | |
R as _, | |
a as ws, | |
b as Ss, | |
g as Cs, | |
c as Ds, | |
} from '../../../assets/tailwind-c7e7a826.js'; | |
function Is({ onClick: e, selectedTab: t }) { | |
return g.jsxs('div', { | |
className: 'pt-5 px-10 flex justify-center items-center gap-5 text-base h-[15h] mx-auto z-10', | |
children: [ | |
g.jsx('div', { | |
children: g.jsxs('a', { | |
href: 'https://quickyai.com', | |
target: '_blank', | |
className: 'flex flex-col justify-center items-center', | |
rel: 'noreferrer', | |
children: [ | |
g.jsx('img', { src: '/icon-32.png', alt: 'QuickyAI', className: 'w-10 h-10 ' }), | |
g.jsx('span', { children: 'QuickyAI' }), | |
], | |
}), | |
}), | |
g.jsxs('div', { | |
className: 'inline-flex rounded-md shadow-sm self-center shrink-0', | |
children: [ | |
g.jsx('a', { | |
className: | |
'px-4 py-2 text-sm font-medium bg-white border border-gray-200 rounded-l-lg hover:bg-gray-100 focus:z-10 focus:ring-2 focus:ring-gray-400 cursor-pointer', | |
style: t === 'prompts' ? { backgroundColor: '#3b82f6', color: '#f9fafb' } : {}, | |
onClick: () => e('prompts'), | |
children: 'Prompts', | |
}), | |
g.jsx('a', { | |
className: | |
'px-4 py-2 text-sm font-medium bg-white border-y border-r border-gray-200 hover:bg-gray-100 focus:z-10 focus:ring-2 focus:ring-gray-400 cursor-pointer', | |
style: t === 'shortcuts' ? { backgroundColor: '#3b82f6', color: '#f9fafb' } : {}, | |
onClick: () => e('shortcuts'), | |
children: 'Shortcuts', | |
}), | |
g.jsx('a', { | |
className: | |
'px-4 py-2 text-sm font-medium bg-white border-y border-r border-gray-200 hover:bg-gray-100 focus:z-10 focus:ring-2 focus:ring-gray-400 cursor-pointer', | |
style: t === 'history' ? { backgroundColor: '#3b82f6', color: '#f9fafb' } : {}, | |
onClick: () => e('history'), | |
children: 'History', | |
}), | |
g.jsx('a', { | |
className: | |
'px-4 py-2 text-sm font-medium bg-white border-y border-r border-gray-200 hover:bg-gray-100 focus:z-10 focus:ring-2 focus:ring-gray-400 cursor-pointer', | |
style: t === 'guide' ? { backgroundColor: '#3b82f6', color: '#f9fafb' } : {}, | |
onClick: () => e('guide'), | |
children: 'How to use', | |
}), | |
g.jsx('a', { | |
className: | |
'px-4 py-2 text-sm font-medium bg-white border-y border-gray-200 hover:bg-gray-100 focus:z-10 focus:ring-2 focus:ring-gray-400 cursor-pointer', | |
style: t === 'settings' ? { backgroundColor: '#3b82f6', color: '#f9fafb' } : {}, | |
onClick: () => e('settings'), | |
children: 'Settings', | |
}), | |
g.jsx('a', { | |
className: | |
'px-4 py-2 text-sm font-medium bg-white border border-gray-200 rounded-r-md hover:bg-gray-100 focus:z-10 focus:ring-2 focus:ring-gray-400 cursor-pointer', | |
style: t === 'keys' ? { backgroundColor: '#3b82f6', color: '#f9fafb' } : {}, | |
onClick: () => e('keys'), | |
children: 'Keys', | |
}), | |
], | |
}), | |
], | |
}); | |
} | |
const $i = (e) => e.slice(0, 4) + '...' + e.slice(-4), | |
ks = 'https://api.openai.com/v1/chat/completions', | |
Es = 'https://api.quickyai.com/activate'; | |
function Ps() { | |
const [e, t] = N.useState({ license: '', openAIkey: '' }), | |
[n, r] = N.useState({ liStatus: !1, keyStatus: !1 }), | |
[i, a] = N.useState(!1), | |
[o, l] = N.useState({ liError: '', keyError: '' }), | |
[s, c] = N.useState(!1), | |
[d, u] = N.useState({ liLoading: 'no', keyLoading: 'no' }), | |
f = () => { | |
a(() => !0); | |
}, | |
p = async (x) => { | |
x.preventDefault(); | |
const { license: b } = e; | |
if (b) { | |
l((C) => ({ ...C, liError: '' })); | |
try { | |
u((D) => ({ ...D, liLoading: 'yes' })); | |
const S = await ( | |
await fetch(`${Es}/${b}`, { | |
method: 'POST', | |
headers: { 'Content-Type': 'application/json' }, | |
body: JSON.stringify({}), | |
}) | |
).json(); | |
if (!S.error && S.message === 'OK') { | |
const D = S.isSubscription || !1, | |
E = { liStatus: !0, license: b, isSubscription: D }; | |
chrome.storage.sync.set(E), | |
r((w) => ({ ...w, liStatus: !0 })), | |
u((w) => ({ ...w, liLoading: 'success' })), | |
c(D); | |
} else u((D) => ({ ...D, liLoading: 'no' })), l((D) => ({ ...D, liError: S.error })); | |
} catch { | |
u((S) => ({ ...S, liLoading: 'no' })), | |
l((S) => ({ ...S, liError: 'Something went wrong' })); | |
} | |
} | |
}, | |
m = async (x) => { | |
if ((x.preventDefault(), n.keyStatus && !i)) return; | |
const { openAIkey: b } = e; | |
if (!b) return; | |
const C = { model: 'gpt-3.5-turbo', messages: [{ role: 'user', content: 'hello world' }] }; | |
l((S) => ({ ...S, keyError: '' })); | |
try { | |
if ( | |
(u((E) => ({ ...E, keyLoading: 'yes' })), | |
( | |
await ( | |
await fetch(ks, { | |
method: 'POST', | |
headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${b}` }, | |
body: JSON.stringify(C), | |
}) | |
).json() | |
).error) | |
) | |
u((E) => ({ ...E, keyLoading: 'no' })), l((E) => ({ ...E, keyError: 'Invalid API key' })); | |
else { | |
const E = { keyStatus: !0, openAIkey: b }; | |
chrome.storage.sync.set(E), | |
u((w) => ({ ...w, keyLoading: 'success' })), | |
r((w) => ({ ...w, keyStatus: !0 })); | |
} | |
} catch { | |
u((D) => ({ ...D, keyLoading: 'no' })), l((D) => ({ ...D, keyError: 'Invalid API key' })); | |
} | |
}, | |
h = () => { | |
chrome.storage.sync.get(['license', 'liStatus'], (x) => { | |
const b = x == null ? void 0 : x.license; | |
t((C) => ({ ...C, license: b })), r((C) => ({ ...C, liStatus: !1 })); | |
}); | |
}; | |
return ( | |
N.useEffect(() => { | |
chrome.storage.sync.get( | |
['openAIkey', 'license', 'keyStatus', 'liStatus', 'isSubscription'], | |
(x) => { | |
const b = x == null ? void 0 : x.openAIkey, | |
C = x == null ? void 0 : x.license, | |
S = x == null ? void 0 : x.liStatus, | |
D = x == null ? void 0 : x.keyStatus, | |
E = (x == null ? void 0 : x.isSubscription) || !1; | |
if (C) { | |
const w = S ? $i(C) : C; | |
t((O) => ({ ...O, license: w })); | |
} | |
if (b) { | |
const w = D ? $i(b) : b; | |
t((O) => ({ ...O, openAIkey: w })), D && a(!1); | |
} | |
r(() => ({ liStatus: S, keyStatus: D })), c(E); | |
} | |
); | |
}, []), | |
g.jsxs('div', { | |
className: 'px-10 relative text-base h-full mx-auto', | |
children: [ | |
g.jsx('h1', { | |
className: 'text-3xl font-semibold text-center font-sans mt-6', | |
children: 'Keys', | |
}), | |
g.jsx('div', { | |
className: 'mt-6 flex flex-col', | |
children: g.jsxs('div', { | |
className: 'flex flex-col gap-10 w-full items-center mx-auto', | |
children: [ | |
g.jsxs('form', { | |
className: 'w-[450px]', | |
children: [ | |
g.jsxs('div', { | |
className: 'mb-2 text-left', | |
children: [ | |
g.jsx('span', { className: 'font-medium text-md', children: 'License key' }), | |
' (', | |
g.jsx('a', { | |
href: 'https://app.lemonsqueezy.com/my-orders/', | |
target: '_blank', | |
className: 'text-blue-500 hover:text-blue-600 text-sm', | |
rel: 'noreferrer', | |
children: n.liStatus ? 'Manage license here' : 'Get license here', | |
}), | |
')', | |
], | |
}), | |
g.jsxs('div', { | |
className: 'flex justify-between gap-4', | |
children: [ | |
g.jsx('input', { | |
type: 'text', | |
id: 'text', | |
className: | |
' bg-gray-50 border border-gray-300 text-gray-800 rounded-lg focus:ring-blue-400 focus:ring-2 block w-full p-2.5 py-2 focus:outline-none disabled:bg-gray-200', | |
placeholder: 'Your license key', | |
value: e.license, | |
onChange: (x) => t((b) => ({ ...b, license: x.target.value })), | |
disabled: n.liStatus, | |
spellCheck: !1, | |
autoComplete: 'off', | |
autoCorrect: 'off', | |
autoCapitalize: 'off', | |
}), | |
g.jsxs('button', { | |
type: 'submit', | |
className: `transform rounded-lg ${ | |
d.liLoading === 'success' || n.liStatus | |
? 'bg-green-500' | |
: 'bg-blue-600/95 hover:bg-blue-700' | |
} px-10 py-2 font-medium text-white transition-colors duration-200 w-28 flex justify-center items-center whitespace-nowrap gap-2 disabled:bg-gray-400`, | |
onClick: p, | |
disabled: n.liStatus, | |
children: [ | |
d.liLoading === 'yes' && | |
g.jsx('span', { | |
className: 'flex items-center', | |
children: g.jsxs('svg', { | |
'aria-hidden': 'true', | |
role: 'status', | |
className: 'inline w-4 h-4 text-white animate-spin', | |
viewBox: '0 0 100 101', | |
fill: 'none', | |
xmlns: 'http://www.w3.org/2000/svg', | |
children: [ | |
g.jsx('path', { | |
d: 'M100 50.5908C100 78.2051 77.6142 100.591 50 100.591C22.3858 100.591 0 78.2051 0 50.5908C0 22.9766 22.3858 0.59082 50 0.59082C77.6142 0.59082 100 22.9766 100 50.5908ZM9.08144 50.5908C9.08144 73.1895 27.4013 91.5094 50 91.5094C72.5987 91.5094 90.9186 73.1895 90.9186 50.5908C90.9186 27.9921 72.5987 9.67226 50 9.67226C27.4013 9.67226 9.08144 27.9921 9.08144 50.5908Z', | |
fill: '#E5E7EB', | |
}), | |
g.jsx('path', { | |
d: 'M93.9676 39.0409C96.393 38.4038 97.8624 35.9116 97.0079 33.5539C95.2932 28.8227 92.871 24.3692 89.8167 20.348C85.8452 15.1192 80.8826 10.7238 75.2124 7.41289C69.5422 4.10194 63.2754 1.94025 56.7698 1.05124C51.7666 0.367541 46.6976 0.446843 41.7345 1.27873C39.2613 1.69328 37.813 4.19778 38.4501 6.62326C39.0873 9.04874 41.5694 10.4717 44.0505 10.1071C47.8511 9.54855 51.7191 9.52689 55.5402 10.0491C60.8642 10.7766 65.9928 12.5457 70.6331 15.2552C75.2735 17.9648 79.3347 21.5619 82.5849 25.841C84.9175 28.9121 86.7997 32.2913 88.1811 35.8758C89.083 38.2158 91.5421 39.6781 93.9676 39.0409Z', | |
fill: 'currentColor', | |
}), | |
], | |
}), | |
}), | |
n.liStatus ? 'Saved' : 'Save', | |
], | |
}), | |
], | |
}), | |
g.jsxs('div', { | |
children: [ | |
o.liError && | |
g.jsx('small', { className: 'text-red-600', children: o.liError }), | |
n.liStatus && | |
!o.liError && | |
g.jsx('small', { | |
className: 'text-gray-600 hover:text-gray-900 cursor-pointer', | |
onClick: h, | |
children: 'Click to edit license', | |
}), | |
], | |
}), | |
], | |
}), | |
n.liStatus && | |
!s && | |
g.jsxs('form', { | |
className: 'w-[450px]', | |
children: [ | |
g.jsxs('div', { | |
className: 'mb-2 text-left', | |
children: [ | |
g.jsx('span', { className: 'font-medium text-md', children: 'OpenAI key' }), | |
' (', | |
g.jsx('a', { | |
href: 'https://platform.openai.com/account/api-keys', | |
target: '_blank', | |
className: 'text-blue-500 hover:text-blue-600 text-sm', | |
rel: 'noreferrer', | |
children: 'Get key here', | |
}), | |
')', | |
], | |
}), | |
g.jsxs('div', { | |
className: 'flex justify-between gap-4', | |
children: [ | |
g.jsx('input', { | |
type: 'text', | |
className: | |
' bg-gray-50 border border-gray-300 text-gray-800 rounded-lg focus:ring-blue-400 focus:ring-2 block w-full p-2.5 py-2 focus:outline-none disabled:bg-gray-200', | |
placeholder: 'sk-xxxxxxxxxxxxxxx', | |
value: e.openAIkey, | |
onChange: (x) => t((b) => ({ ...b, openAIkey: x.target.value })), | |
disabled: n.keyStatus && !i, | |
spellCheck: !1, | |
autoComplete: 'off', | |
autoCorrect: 'off', | |
autoCapitalize: 'off', | |
}), | |
g.jsxs('button', { | |
type: 'submit', | |
className: `transform rounded-lg ${ | |
d.keyLoading === 'success' || (!i && n.keyStatus) | |
? 'bg-green-500' | |
: 'bg-blue-600/95 hover:bg-blue-700' | |
} px-10 py-2 font-medium text-white transition-colors duration-200 w-28 whitespace-nowrap flex items-center justify-center gap-2 disabled:bg-gray-400`, | |
onClick: m, | |
disabled: n.keyStatus && !i, | |
children: [ | |
d.keyLoading === 'yes' && | |
g.jsx('span', { | |
className: 'flex items-center', | |
children: g.jsxs('svg', { | |
'aria-hidden': 'true', | |
role: 'status', | |
className: 'inline w-4 h-4 text-white animate-spin', | |
viewBox: '0 0 100 101', | |
fill: 'none', | |
xmlns: 'http://www.w3.org/2000/svg', | |
children: [ | |
g.jsx('path', { | |
d: 'M100 50.5908C100 78.2051 77.6142 100.591 50 100.591C22.3858 100.591 0 78.2051 0 50.5908C0 22.9766 22.3858 0.59082 50 0.59082C77.6142 0.59082 100 22.9766 100 50.5908ZM9.08144 50.5908C9.08144 73.1895 27.4013 91.5094 50 91.5094C72.5987 91.5094 90.9186 73.1895 90.9186 50.5908C90.9186 27.9921 72.5987 9.67226 50 9.67226C27.4013 9.67226 9.08144 27.9921 9.08144 50.5908Z', | |
fill: '#E5E7EB', | |
}), | |
g.jsx('path', { | |
d: 'M93.9676 39.0409C96.393 38.4038 97.8624 35.9116 97.0079 33.5539C95.2932 28.8227 92.871 24.3692 89.8167 20.348C85.8452 15.1192 80.8826 10.7238 75.2124 7.41289C69.5422 4.10194 63.2754 1.94025 56.7698 1.05124C51.7666 0.367541 46.6976 0.446843 41.7345 1.27873C39.2613 1.69328 37.813 4.19778 38.4501 6.62326C39.0873 9.04874 41.5694 10.4717 44.0505 10.1071C47.8511 9.54855 51.7191 9.52689 55.5402 10.0491C60.8642 10.7766 65.9928 12.5457 70.6331 15.2552C75.2735 17.9648 79.3347 21.5619 82.5849 25.841C84.9175 28.9121 86.7997 32.2913 88.1811 35.8758C89.083 38.2158 91.5421 39.6781 93.9676 39.0409Z', | |
fill: 'currentColor', | |
}), | |
], | |
}), | |
}), | |
g.jsx('span', { | |
children: | |
d.keyLoading === 'success' || (n.keyStatus && !i) | |
? 'Saved' | |
: 'Save', | |
}), | |
], | |
}), | |
], | |
}), | |
g.jsxs('div', { | |
children: [ | |
o.keyError && | |
g.jsx('small', { className: 'text-red-600', children: o.keyError }), | |
n.keyStatus && | |
!i && | |
g.jsx('small', { | |
className: 'text-gray-600 hover:text-gray-900 cursor-pointer', | |
onClick: f, | |
children: 'Click to edit key', | |
}), | |
], | |
}), | |
], | |
}), | |
], | |
}), | |
}), | |
g.jsx('div', { className: 'bso-container' }), | |
], | |
}) | |
); | |
} | |
function Fr(e, t) { | |
return ( | |
(Fr = Object.setPrototypeOf | |
? Object.setPrototypeOf.bind() | |
: function (r, i) { | |
return (r.__proto__ = i), r; | |
}), | |
Fr(e, t) | |
); | |
} | |
function xo(e, t) { | |
(e.prototype = Object.create(t.prototype)), (e.prototype.constructor = e), Fr(e, t); | |
} | |
function j() { | |
return ( | |
(j = Object.assign | |
? Object.assign.bind() | |
: function (e) { | |
for (var t = 1; t < arguments.length; t++) { | |
var n = arguments[t]; | |
for (var r in n) Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r]); | |
} | |
return e; | |
}), | |
j.apply(this, arguments) | |
); | |
} | |
function qt(e) { | |
return ( | |
(qt = | |
typeof Symbol == 'function' && typeof Symbol.iterator == 'symbol' | |
? function (t) { | |
return typeof t; | |
} | |
: function (t) { | |
return t && | |
typeof Symbol == 'function' && | |
t.constructor === Symbol && | |
t !== Symbol.prototype | |
? 'symbol' | |
: typeof t; | |
}), | |
qt(e) | |
); | |
} | |
function As(e, t) { | |
if (qt(e) !== 'object' || e === null) return e; | |
var n = e[Symbol.toPrimitive]; | |
if (n !== void 0) { | |
var r = n.call(e, t || 'default'); | |
if (qt(r) !== 'object') return r; | |
throw new TypeError('@@toPrimitive must return a primitive value.'); | |
} | |
return (t === 'string' ? String : Number)(e); | |
} | |
function Ns(e) { | |
var t = As(e, 'string'); | |
return qt(t) === 'symbol' ? t : String(t); | |
} | |
function Os(e, t, n) { | |
return ( | |
(t = Ns(t)), | |
t in e | |
? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) | |
: (e[t] = n), | |
e | |
); | |
} | |
function Hi(e, t) { | |
var n = Object.keys(e); | |
if (Object.getOwnPropertySymbols) { | |
var r = Object.getOwnPropertySymbols(e); | |
t && | |
(r = r.filter(function (i) { | |
return Object.getOwnPropertyDescriptor(e, i).enumerable; | |
})), | |
n.push.apply(n, r); | |
} | |
return n; | |
} | |
function Ui(e) { | |
for (var t = 1; t < arguments.length; t++) { | |
var n = arguments[t] != null ? arguments[t] : {}; | |
t % 2 | |
? Hi(Object(n), !0).forEach(function (r) { | |
Os(e, r, n[r]); | |
}) | |
: Object.getOwnPropertyDescriptors | |
? Object.defineProperties(e, Object.getOwnPropertyDescriptors(n)) | |
: Hi(Object(n)).forEach(function (r) { | |
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(n, r)); | |
}); | |
} | |
return e; | |
} | |
function ke(e) { | |
return ( | |
'Minified Redux error #' + | |
e + | |
'; visit https://redux.js.org/Errors?code=' + | |
e + | |
' for the full message or use the non-minified dev environment for full errors. ' | |
); | |
} | |
var Gi = (function () { | |
return (typeof Symbol == 'function' && Symbol.observable) || '@@observable'; | |
})(), | |
pr = function () { | |
return Math.random().toString(36).substring(7).split('').join('.'); | |
}, | |
Wi = { | |
INIT: '@@redux/INIT' + pr(), | |
REPLACE: '@@redux/REPLACE' + pr(), | |
PROBE_UNKNOWN_ACTION: function () { | |
return '@@redux/PROBE_UNKNOWN_ACTION' + pr(); | |
}, | |
}; | |
function Ts(e) { | |
if (typeof e != 'object' || e === null) return !1; | |
for (var t = e; Object.getPrototypeOf(t) !== null; ) t = Object.getPrototypeOf(t); | |
return Object.getPrototypeOf(e) === t; | |
} | |
function wo(e, t, n) { | |
var r; | |
if ( | |
(typeof t == 'function' && typeof n == 'function') || | |
(typeof n == 'function' && typeof arguments[3] == 'function') | |
) | |
throw new Error(ke(0)); | |
if ((typeof t == 'function' && typeof n > 'u' && ((n = t), (t = void 0)), typeof n < 'u')) { | |
if (typeof n != 'function') throw new Error(ke(1)); | |
return n(wo)(e, t); | |
} | |
if (typeof e != 'function') throw new Error(ke(2)); | |
var i = e, | |
a = t, | |
o = [], | |
l = o, | |
s = !1; | |
function c() { | |
l === o && (l = o.slice()); | |
} | |
function d() { | |
if (s) throw new Error(ke(3)); | |
return a; | |
} | |
function u(h) { | |
if (typeof h != 'function') throw new Error(ke(4)); | |
if (s) throw new Error(ke(5)); | |
var x = !0; | |
return ( | |
c(), | |
l.push(h), | |
function () { | |
if (x) { | |
if (s) throw new Error(ke(6)); | |
(x = !1), c(); | |
var C = l.indexOf(h); | |
l.splice(C, 1), (o = null); | |
} | |
} | |
); | |
} | |
function f(h) { | |
if (!Ts(h)) throw new Error(ke(7)); | |
if (typeof h.type > 'u') throw new Error(ke(8)); | |
if (s) throw new Error(ke(9)); | |
try { | |
(s = !0), (a = i(a, h)); | |
} finally { | |
s = !1; | |
} | |
for (var x = (o = l), b = 0; b < x.length; b++) { | |
var C = x[b]; | |
C(); | |
} | |
return h; | |
} | |
function p(h) { | |
if (typeof h != 'function') throw new Error(ke(10)); | |
(i = h), f({ type: Wi.REPLACE }); | |
} | |
function m() { | |
var h, | |
x = u; | |
return ( | |
(h = { | |
subscribe: function (C) { | |
if (typeof C != 'object' || C === null) throw new Error(ke(11)); | |
function S() { | |
C.next && C.next(d()); | |
} | |
S(); | |
var D = x(S); | |
return { unsubscribe: D }; | |
}, | |
}), | |
(h[Gi] = function () { | |
return this; | |
}), | |
h | |
); | |
} | |
return ( | |
f({ type: Wi.INIT }), | |
(r = { dispatch: f, subscribe: u, getState: d, replaceReducer: p }), | |
(r[Gi] = m), | |
r | |
); | |
} | |
function qi(e, t) { | |
return function () { | |
return t(e.apply(this, arguments)); | |
}; | |
} | |
function Vi(e, t) { | |
if (typeof e == 'function') return qi(e, t); | |
if (typeof e != 'object' || e === null) throw new Error(ke(16)); | |
var n = {}; | |
for (var r in e) { | |
var i = e[r]; | |
typeof i == 'function' && (n[r] = qi(i, t)); | |
} | |
return n; | |
} | |
function So() { | |
for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++) t[n] = arguments[n]; | |
return t.length === 0 | |
? function (r) { | |
return r; | |
} | |
: t.length === 1 | |
? t[0] | |
: t.reduce(function (r, i) { | |
return function () { | |
return r(i.apply(void 0, arguments)); | |
}; | |
}); | |
} | |
function Bs() { | |
for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++) t[n] = arguments[n]; | |
return function (r) { | |
return function () { | |
var i = r.apply(void 0, arguments), | |
a = function () { | |
throw new Error(ke(15)); | |
}, | |
o = { | |
getState: i.getState, | |
dispatch: function () { | |
return a.apply(void 0, arguments); | |
}, | |
}, | |
l = t.map(function (s) { | |
return s(o); | |
}); | |
return (a = So.apply(void 0, l)(i.dispatch)), Ui(Ui({}, i), {}, { dispatch: a }); | |
}; | |
}; | |
} | |
var W = {}, | |
Rs = { | |
get exports() { | |
return W; | |
}, | |
set exports(e) { | |
W = e; | |
}, | |
}, | |
Fs = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED', | |
Ls = Fs, | |
Ms = Ls; | |
function Co() {} | |
function Do() {} | |
Do.resetWarningCache = Co; | |
var js = function () { | |
function e(r, i, a, o, l, s) { | |
if (s !== Ms) { | |
var c = new Error( | |
'Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types' | |
); | |
throw ((c.name = 'Invariant Violation'), c); | |
} | |
} | |
e.isRequired = e; | |
function t() { | |
return e; | |
} | |
var n = { | |
array: e, | |
bigint: e, | |
bool: e, | |
func: e, | |
number: e, | |
object: e, | |
string: e, | |
symbol: e, | |
any: e, | |
arrayOf: t, | |
element: e, | |
elementType: e, | |
instanceOf: t, | |
node: e, | |
objectOf: t, | |
oneOf: t, | |
oneOfType: t, | |
shape: t, | |
exact: t, | |
checkPropTypes: Do, | |
resetWarningCache: Co, | |
}; | |
return (n.PropTypes = n), n; | |
}; | |
Rs.exports = js(); | |
var Io = _.createContext(null); | |
function zs(e) { | |
e(); | |
} | |
var ko = zs, | |
$s = function (t) { | |
return (ko = t); | |
}, | |
Hs = function () { | |
return ko; | |
}; | |
function Us() { | |
var e = Hs(), | |
t = null, | |
n = null; | |
return { | |
clear: function () { | |
(t = null), (n = null); | |
}, | |
notify: function () { | |
e(function () { | |
for (var i = t; i; ) i.callback(), (i = i.next); | |
}); | |
}, | |
get: function () { | |
for (var i = [], a = t; a; ) i.push(a), (a = a.next); | |
return i; | |
}, | |
subscribe: function (i) { | |
var a = !0, | |
o = (n = { callback: i, next: null, prev: n }); | |
return ( | |
o.prev ? (o.prev.next = o) : (t = o), | |
function () { | |
!a || | |
t === null || | |
((a = !1), | |
o.next ? (o.next.prev = o.prev) : (n = o.prev), | |
o.prev ? (o.prev.next = o.next) : (t = o.next)); | |
} | |
); | |
}, | |
}; | |
} | |
var Ki = { | |
notify: function () {}, | |
get: function () { | |
return []; | |
}, | |
}; | |
function Eo(e, t) { | |
var n, | |
r = Ki; | |
function i(u) { | |
return s(), r.subscribe(u); | |
} | |
function a() { | |
r.notify(); | |
} | |
function o() { | |
d.onStateChange && d.onStateChange(); | |
} | |
function l() { | |
return !!n; | |
} | |
function s() { | |
n || ((n = t ? t.addNestedSub(o) : e.subscribe(o)), (r = Us())); | |
} | |
function c() { | |
n && (n(), (n = void 0), r.clear(), (r = Ki)); | |
} | |
var d = { | |
addNestedSub: i, | |
notifyNestedSubs: a, | |
handleChangeWrapper: o, | |
isSubscribed: l, | |
trySubscribe: s, | |
tryUnsubscribe: c, | |
getListeners: function () { | |
return r; | |
}, | |
}; | |
return d; | |
} | |
var Po = | |
typeof window < 'u' && typeof window.document < 'u' && typeof window.document.createElement < 'u' | |
? N.useLayoutEffect | |
: N.useEffect; | |
function Gs(e) { | |
var t = e.store, | |
n = e.context, | |
r = e.children, | |
i = N.useMemo( | |
function () { | |
var l = Eo(t); | |
return { store: t, subscription: l }; | |
}, | |
[t] | |
), | |
a = N.useMemo( | |
function () { | |
return t.getState(); | |
}, | |
[t] | |
); | |
Po( | |
function () { | |
var l = i.subscription; | |
return ( | |
(l.onStateChange = l.notifyNestedSubs), | |
l.trySubscribe(), | |
a !== t.getState() && l.notifyNestedSubs(), | |
function () { | |
l.tryUnsubscribe(), (l.onStateChange = null); | |
} | |
); | |
}, | |
[i, a] | |
); | |
var o = n || Io; | |
return _.createElement(o.Provider, { value: i }, r); | |
} | |
function Dn(e, t) { | |
if (e == null) return {}; | |
var n = {}, | |
r = Object.keys(e), | |
i, | |
a; | |
for (a = 0; a < r.length; a++) (i = r[a]), !(t.indexOf(i) >= 0) && (n[i] = e[i]); | |
return n; | |
} | |
var Lr = {}, | |
Ws = { | |
get exports() { | |
return Lr; | |
}, | |
set exports(e) { | |
Lr = e; | |
}, | |
}, | |
te = {}; | |
/** @license React v16.13.1 | |
* react-is.production.min.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. | |
*/ var ye = typeof Symbol == 'function' && Symbol.for, | |
ei = ye ? Symbol.for('react.element') : 60103, | |
ti = ye ? Symbol.for('react.portal') : 60106, | |
Fn = ye ? Symbol.for('react.fragment') : 60107, | |
Ln = ye ? Symbol.for('react.strict_mode') : 60108, | |
Mn = ye ? Symbol.for('react.profiler') : 60114, | |
jn = ye ? Symbol.for('react.provider') : 60109, | |
zn = ye ? Symbol.for('react.context') : 60110, | |
ni = ye ? Symbol.for('react.async_mode') : 60111, | |
$n = ye ? Symbol.for('react.concurrent_mode') : 60111, | |
Hn = ye ? Symbol.for('react.forward_ref') : 60112, | |
Un = ye ? Symbol.for('react.suspense') : 60113, | |
qs = ye ? Symbol.for('react.suspense_list') : 60120, | |
Gn = ye ? Symbol.for('react.memo') : 60115, | |
Wn = ye ? Symbol.for('react.lazy') : 60116, | |
Vs = ye ? Symbol.for('react.block') : 60121, | |
Ks = ye ? Symbol.for('react.fundamental') : 60117, | |
Ys = ye ? Symbol.for('react.responder') : 60118, | |
Qs = ye ? Symbol.for('react.scope') : 60119; | |
function Fe(e) { | |
if (typeof e == 'object' && e !== null) { | |
var t = e.$$typeof; | |
switch (t) { | |
case ei: | |
switch (((e = e.type), e)) { | |
case ni: | |
case $n: | |
case Fn: | |
case Mn: | |
case Ln: | |
case Un: | |
return e; | |
default: | |
switch (((e = e && e.$$typeof), e)) { | |
case zn: | |
case Hn: | |
case Wn: | |
case Gn: | |
case jn: | |
return e; | |
default: | |
return t; | |
} | |
} | |
case ti: | |
return t; | |
} | |
} | |
} | |
function Ao(e) { | |
return Fe(e) === $n; | |
} | |
te.AsyncMode = ni; | |
te.ConcurrentMode = $n; | |
te.ContextConsumer = zn; | |
te.ContextProvider = jn; | |
te.Element = ei; | |
te.ForwardRef = Hn; | |
te.Fragment = Fn; | |
te.Lazy = Wn; | |
te.Memo = Gn; | |
te.Portal = ti; | |
te.Profiler = Mn; | |
te.StrictMode = Ln; | |
te.Suspense = Un; | |
te.isAsyncMode = function (e) { | |
return Ao(e) || Fe(e) === ni; | |
}; | |
te.isConcurrentMode = Ao; | |
te.isContextConsumer = function (e) { | |
return Fe(e) === zn; | |
}; | |
te.isContextProvider = function (e) { | |
return Fe(e) === jn; | |
}; | |
te.isElement = function (e) { | |
return typeof e == 'object' && e !== null && e.$$typeof === ei; | |
}; | |
te.isForwardRef = function (e) { | |
return Fe(e) === Hn; | |
}; | |
te.isFragment = function (e) { | |
return Fe(e) === Fn; | |
}; | |
te.isLazy = function (e) { | |
return Fe(e) === Wn; | |
}; | |
te.isMemo = function (e) { | |
return Fe(e) === Gn; | |
}; | |
te.isPortal = function (e) { | |
return Fe(e) === ti; | |
}; | |
te.isProfiler = function (e) { | |
return Fe(e) === Mn; | |
}; | |
te.isStrictMode = function (e) { | |
return Fe(e) === Ln; | |
}; | |
te.isSuspense = function (e) { | |
return Fe(e) === Un; | |
}; | |
te.isValidElementType = function (e) { | |
return ( | |
typeof e == 'string' || | |
typeof e == 'function' || | |
e === Fn || | |
e === $n || | |
e === Mn || | |
e === Ln || | |
e === Un || | |
e === qs || | |
(typeof e == 'object' && | |
e !== null && | |
(e.$$typeof === Wn || | |
e.$$typeof === Gn || | |
e.$$typeof === jn || | |
e.$$typeof === zn || | |
e.$$typeof === Hn || | |
e.$$typeof === Ks || | |
e.$$typeof === Ys || | |
e.$$typeof === Qs || | |
e.$$typeof === Vs)) | |
); | |
}; | |
te.typeOf = Fe; | |
(function (e) { | |
e.exports = te; | |
})(Ws); | |
var ri = Lr, | |
Xs = { | |
childContextTypes: !0, | |
contextType: !0, | |
contextTypes: !0, | |
defaultProps: !0, | |
displayName: !0, | |
getDefaultProps: !0, | |
getDerivedStateFromError: !0, | |
getDerivedStateFromProps: !0, | |
mixins: !0, | |
propTypes: !0, | |
type: !0, | |
}, | |
Js = { name: !0, length: !0, prototype: !0, caller: !0, callee: !0, arguments: !0, arity: !0 }, | |
_s = { $$typeof: !0, render: !0, defaultProps: !0, displayName: !0, propTypes: !0 }, | |
No = { $$typeof: !0, compare: !0, defaultProps: !0, displayName: !0, propTypes: !0, type: !0 }, | |
ii = {}; | |
ii[ri.ForwardRef] = _s; | |
ii[ri.Memo] = No; | |
function Yi(e) { | |
return ri.isMemo(e) ? No : ii[e.$$typeof] || Xs; | |
} | |
var Zs = Object.defineProperty, | |
eu = Object.getOwnPropertyNames, | |
Qi = Object.getOwnPropertySymbols, | |
tu = Object.getOwnPropertyDescriptor, | |
nu = Object.getPrototypeOf, | |
Xi = Object.prototype; | |
function Oo(e, t, n) { | |
if (typeof t != 'string') { | |
if (Xi) { | |
var r = nu(t); | |
r && r !== Xi && Oo(e, r, n); | |
} | |
var i = eu(t); | |
Qi && (i = i.concat(Qi(t))); | |
for (var a = Yi(e), o = Yi(t), l = 0; l < i.length; ++l) { | |
var s = i[l]; | |
if (!Js[s] && !(n && n[s]) && !(o && o[s]) && !(a && a[s])) { | |
var c = tu(t, s); | |
try { | |
Zs(e, s, c); | |
} catch {} | |
} | |
} | |
} | |
return e; | |
} | |
var Ji = Oo, | |
Mr = {}, | |
ru = { | |
get exports() { | |
return Mr; | |
}, | |
set exports(e) { | |
Mr = e; | |
}, | |
}, | |
re = {}; | |
/** @license React v17.0.2 | |
* react-is.production.min.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. | |
*/ var qn = 60103, | |
Vn = 60106, | |
Jt = 60107, | |
_t = 60108, | |
Zt = 60114, | |
en = 60109, | |
tn = 60110, | |
nn = 60112, | |
rn = 60113, | |
ai = 60120, | |
an = 60115, | |
on = 60116, | |
To = 60121, | |
Bo = 60122, | |
Ro = 60117, | |
Fo = 60129, | |
Lo = 60131; | |
if (typeof Symbol == 'function' && Symbol.for) { | |
var xe = Symbol.for; | |
(qn = xe('react.element')), | |
(Vn = xe('react.portal')), | |
(Jt = xe('react.fragment')), | |
(_t = xe('react.strict_mode')), | |
(Zt = xe('react.profiler')), | |
(en = xe('react.provider')), | |
(tn = xe('react.context')), | |
(nn = xe('react.forward_ref')), | |
(rn = xe('react.suspense')), | |
(ai = xe('react.suspense_list')), | |
(an = xe('react.memo')), | |
(on = xe('react.lazy')), | |
(To = xe('react.block')), | |
(Bo = xe('react.server.block')), | |
(Ro = xe('react.fundamental')), | |
(Fo = xe('react.debug_trace_mode')), | |
(Lo = xe('react.legacy_hidden')); | |
} | |
function qe(e) { | |
if (typeof e == 'object' && e !== null) { | |
var t = e.$$typeof; | |
switch (t) { | |
case qn: | |
switch (((e = e.type), e)) { | |
case Jt: | |
case Zt: | |
case _t: | |
case rn: | |
case ai: | |
return e; | |
default: | |
switch (((e = e && e.$$typeof), e)) { | |
case tn: | |
case nn: | |
case on: | |
case an: | |
case en: | |
return e; | |
default: | |
return t; | |
} | |
} | |
case Vn: | |
return t; | |
} | |
} | |
} | |
var iu = en, | |
au = qn, | |
ou = nn, | |
lu = Jt, | |
su = on, | |
uu = an, | |
cu = Vn, | |
du = Zt, | |
pu = _t, | |
fu = rn; | |
re.ContextConsumer = tn; | |
re.ContextProvider = iu; | |
re.Element = au; | |
re.ForwardRef = ou; | |
re.Fragment = lu; | |
re.Lazy = su; | |
re.Memo = uu; | |
re.Portal = cu; | |
re.Profiler = du; | |
re.StrictMode = pu; | |
re.Suspense = fu; | |
re.isAsyncMode = function () { | |
return !1; | |
}; | |
re.isConcurrentMode = function () { | |
return !1; | |
}; | |
re.isContextConsumer = function (e) { | |
return qe(e) === tn; | |
}; | |
re.isContextProvider = function (e) { | |
return qe(e) === en; | |
}; | |
re.isElement = function (e) { | |
return typeof e == 'object' && e !== null && e.$$typeof === qn; | |
}; | |
re.isForwardRef = function (e) { | |
return qe(e) === nn; | |
}; | |
re.isFragment = function (e) { | |
return qe(e) === Jt; | |
}; | |
re.isLazy = function (e) { | |
return qe(e) === on; | |
}; | |
re.isMemo = function (e) { | |
return qe(e) === an; | |
}; | |
re.isPortal = function (e) { | |
return qe(e) === Vn; | |
}; | |
re.isProfiler = function (e) { | |
return qe(e) === Zt; | |
}; | |
re.isStrictMode = function (e) { | |
return qe(e) === _t; | |
}; | |
re.isSuspense = function (e) { | |
return qe(e) === rn; | |
}; | |
re.isValidElementType = function (e) { | |
return ( | |
typeof e == 'string' || | |
typeof e == 'function' || | |
e === Jt || | |
e === Zt || | |
e === Fo || | |
e === _t || | |
e === rn || | |
e === ai || | |
e === Lo || | |
(typeof e == 'object' && | |
e !== null && | |
(e.$$typeof === on || | |
e.$$typeof === an || | |
e.$$typeof === en || | |
e.$$typeof === tn || | |
e.$$typeof === nn || | |
e.$$typeof === Ro || | |
e.$$typeof === To || | |
e[0] === Bo)) | |
); | |
}; | |
re.typeOf = qe; | |
(function (e) { | |
e.exports = re; | |
})(ru); | |
var gu = [ | |
'getDisplayName', | |
'methodName', | |
'renderCountProp', | |
'shouldHandleStateChanges', | |
'storeKey', | |
'withRef', | |
'forwardRef', | |
'context', | |
], | |
mu = ['reactReduxForwardedRef'], | |
hu = [], | |
vu = [null, null]; | |
function bu(e, t) { | |
var n = e[1]; | |
return [t.payload, n + 1]; | |
} | |
function _i(e, t, n) { | |
Po(function () { | |
return e.apply(void 0, t); | |
}, n); | |
} | |
function yu(e, t, n, r, i, a, o) { | |
(e.current = r), (t.current = i), (n.current = !1), a.current && ((a.current = null), o()); | |
} | |
function xu(e, t, n, r, i, a, o, l, s, c) { | |
if (e) { | |
var d = !1, | |
u = null, | |
f = function () { | |
if (!d) { | |
var h = t.getState(), | |
x, | |
b; | |
try { | |
x = r(h, i.current); | |
} catch (C) { | |
(b = C), (u = C); | |
} | |
b || (u = null), | |
x === a.current | |
? o.current || s() | |
: ((a.current = x), | |
(l.current = x), | |
(o.current = !0), | |
c({ type: 'STORE_UPDATED', payload: { error: b } })); | |
} | |
}; | |
(n.onStateChange = f), n.trySubscribe(), f(); | |
var p = function () { | |
if (((d = !0), n.tryUnsubscribe(), (n.onStateChange = null), u)) throw u; | |
}; | |
return p; | |
} | |
} | |
var wu = function () { | |
return [null, 0]; | |
}; | |
function Su(e, t) { | |
t === void 0 && (t = {}); | |
var n = t, | |
r = n.getDisplayName, | |
i = | |
r === void 0 | |
? function (S) { | |
return 'ConnectAdvanced(' + S + ')'; | |
} | |
: r, | |
a = n.methodName, | |
o = a === void 0 ? 'connectAdvanced' : a, | |
l = n.renderCountProp, | |
s = l === void 0 ? void 0 : l, | |
c = n.shouldHandleStateChanges, | |
d = c === void 0 ? !0 : c, | |
u = n.storeKey, | |
f = u === void 0 ? 'store' : u; | |
n.withRef; | |
var p = n.forwardRef, | |
m = p === void 0 ? !1 : p, | |
h = n.context, | |
x = h === void 0 ? Io : h, | |
b = Dn(n, gu), | |
C = x; | |
return function (D) { | |
var E = D.displayName || D.name || 'Component', | |
w = i(E), | |
O = j({}, b, { | |
getDisplayName: i, | |
methodName: o, | |
renderCountProp: s, | |
shouldHandleStateChanges: d, | |
storeKey: f, | |
displayName: w, | |
wrappedComponentName: E, | |
WrappedComponent: D, | |
}), | |
L = b.pure; | |
function F(q) { | |
return e(q.dispatch, O); | |
} | |
var V = L | |
? N.useMemo | |
: function (q) { | |
return q(); | |
}; | |
function A(q) { | |
var $ = N.useMemo( | |
function () { | |
var Ke = q.reactReduxForwardedRef, | |
it = Dn(q, mu); | |
return [q.context, Ke, it]; | |
}, | |
[q] | |
), | |
J = $[0], | |
ie = $[1], | |
ce = $[2], | |
me = N.useMemo( | |
function () { | |
return J && J.Consumer && Mr.isContextConsumer(_.createElement(J.Consumer, null)) | |
? J | |
: C; | |
}, | |
[J, C] | |
), | |
y = N.useContext(me), | |
pe = !!q.store && !!q.store.getState && !!q.store.dispatch; | |
y && y.store; | |
var k = pe ? q.store : y.store, | |
v = N.useMemo( | |
function () { | |
return F(k); | |
}, | |
[k] | |
), | |
Q = N.useMemo( | |
function () { | |
if (!d) return vu; | |
var Ke = Eo(k, pe ? null : y.subscription), | |
it = Ke.notifyNestedSubs.bind(Ke); | |
return [Ke, it]; | |
}, | |
[k, pe, y] | |
), | |
oe = Q[0], | |
ee = Q[1], | |
he = N.useMemo( | |
function () { | |
return pe ? y : j({}, y, { subscription: oe }); | |
}, | |
[pe, y, oe] | |
), | |
fe = N.useReducer(bu, hu, wu), | |
Le = fe[0], | |
Se = Le[0], | |
Ve = fe[1]; | |
if (Se && Se.error) throw Se.error; | |
var et = N.useRef(), | |
ft = N.useRef(ce), | |
tt = N.useRef(), | |
Je = N.useRef(!1), | |
nt = V( | |
function () { | |
return tt.current && ce === ft.current ? tt.current : v(k.getState(), ce); | |
}, | |
[k, Se, ce] | |
); | |
_i(yu, [ft, et, Je, ce, nt, tt, ee]), | |
_i(xu, [d, k, oe, v, ft, et, Je, tt, ee, Ve], [k, oe, v]); | |
var rt = N.useMemo( | |
function () { | |
return _.createElement(D, j({}, nt, { ref: ie })); | |
}, | |
[ie, D, nt] | |
), | |
Ft = N.useMemo( | |
function () { | |
return d ? _.createElement(me.Provider, { value: he }, rt) : rt; | |
}, | |
[me, rt, he] | |
); | |
return Ft; | |
} | |
var R = L ? _.memo(A) : A; | |
if (((R.WrappedComponent = D), (R.displayName = A.displayName = w), m)) { | |
var Y = _.forwardRef(function ($, J) { | |
return _.createElement(R, j({}, $, { reactReduxForwardedRef: J })); | |
}); | |
return (Y.displayName = w), (Y.WrappedComponent = D), Ji(Y, D); | |
} | |
return Ji(R, D); | |
}; | |
} | |
function Zi(e, t) { | |
return e === t ? e !== 0 || t !== 0 || 1 / e === 1 / t : e !== e && t !== t; | |
} | |
function fr(e, t) { | |
if (Zi(e, t)) return !0; | |
if (typeof e != 'object' || e === null || typeof t != 'object' || t === null) return !1; | |
var n = Object.keys(e), | |
r = Object.keys(t); | |
if (n.length !== r.length) return !1; | |
for (var i = 0; i < n.length; i++) | |
if (!Object.prototype.hasOwnProperty.call(t, n[i]) || !Zi(e[n[i]], t[n[i]])) return !1; | |
return !0; | |
} | |
function Cu(e, t) { | |
var n = {}, | |
r = function (o) { | |
var l = e[o]; | |
typeof l == 'function' && | |
(n[o] = function () { | |
return t(l.apply(void 0, arguments)); | |
}); | |
}; | |
for (var i in e) r(i); | |
return n; | |
} | |
function oi(e) { | |
return function (n, r) { | |
var i = e(n, r); | |
function a() { | |
return i; | |
} | |
return (a.dependsOnOwnProps = !1), a; | |
}; | |
} | |
function ea(e) { | |
return e.dependsOnOwnProps !== null && e.dependsOnOwnProps !== void 0 | |
? !!e.dependsOnOwnProps | |
: e.length !== 1; | |
} | |
function Mo(e, t) { | |
return function (r, i) { | |
i.displayName; | |
var a = function (l, s) { | |
return a.dependsOnOwnProps ? a.mapToProps(l, s) : a.mapToProps(l); | |
}; | |
return ( | |
(a.dependsOnOwnProps = !0), | |
(a.mapToProps = function (l, s) { | |
(a.mapToProps = e), (a.dependsOnOwnProps = ea(e)); | |
var c = a(l, s); | |
return ( | |
typeof c == 'function' && | |
((a.mapToProps = c), (a.dependsOnOwnProps = ea(c)), (c = a(l, s))), | |
c | |
); | |
}), | |
a | |
); | |
}; | |
} | |
function Du(e) { | |
return typeof e == 'function' ? Mo(e) : void 0; | |
} | |
function Iu(e) { | |
return e | |
? void 0 | |
: oi(function (t) { | |
return { dispatch: t }; | |
}); | |
} | |
function ku(e) { | |
return e && typeof e == 'object' | |
? oi(function (t) { | |
return Cu(e, t); | |
}) | |
: void 0; | |
} | |
const Eu = [Du, Iu, ku]; | |
function Pu(e) { | |
return typeof e == 'function' ? Mo(e) : void 0; | |
} | |
function Au(e) { | |
return e | |
? void 0 | |
: oi(function () { | |
return {}; | |
}); | |
} | |
const Nu = [Pu, Au]; | |
function Ou(e, t, n) { | |
return j({}, n, e, t); | |
} | |
function Tu(e) { | |
return function (n, r) { | |
r.displayName; | |
var i = r.pure, | |
a = r.areMergedPropsEqual, | |
o = !1, | |
l; | |
return function (c, d, u) { | |
var f = e(c, d, u); | |
return o ? (!i || !a(f, l)) && (l = f) : ((o = !0), (l = f)), l; | |
}; | |
}; | |
} | |
function Bu(e) { | |
return typeof e == 'function' ? Tu(e) : void 0; | |
} | |
function Ru(e) { | |
return e | |
? void 0 | |
: function () { | |
return Ou; | |
}; | |
} | |
const Fu = [Bu, Ru]; | |
var Lu = ['initMapStateToProps', 'initMapDispatchToProps', 'initMergeProps']; | |
function Mu(e, t, n, r) { | |
return function (a, o) { | |
return n(e(a, o), t(r, o), o); | |
}; | |
} | |
function ju(e, t, n, r, i) { | |
var a = i.areStatesEqual, | |
o = i.areOwnPropsEqual, | |
l = i.areStatePropsEqual, | |
s = !1, | |
c, | |
d, | |
u, | |
f, | |
p; | |
function m(S, D) { | |
return (c = S), (d = D), (u = e(c, d)), (f = t(r, d)), (p = n(u, f, d)), (s = !0), p; | |
} | |
function h() { | |
return (u = e(c, d)), t.dependsOnOwnProps && (f = t(r, d)), (p = n(u, f, d)), p; | |
} | |
function x() { | |
return ( | |
e.dependsOnOwnProps && (u = e(c, d)), | |
t.dependsOnOwnProps && (f = t(r, d)), | |
(p = n(u, f, d)), | |
p | |
); | |
} | |
function b() { | |
var S = e(c, d), | |
D = !l(S, u); | |
return (u = S), D && (p = n(u, f, d)), p; | |
} | |
function C(S, D) { | |
var E = !o(D, d), | |
w = !a(S, c, D, d); | |
return (c = S), (d = D), E && w ? h() : E ? x() : w ? b() : p; | |
} | |
return function (D, E) { | |
return s ? C(D, E) : m(D, E); | |
}; | |
} | |
function zu(e, t) { | |
var n = t.initMapStateToProps, | |
r = t.initMapDispatchToProps, | |
i = t.initMergeProps, | |
a = Dn(t, Lu), | |
o = n(e, a), | |
l = r(e, a), | |
s = i(e, a), | |
c = a.pure ? ju : Mu; | |
return c(o, l, s, e, a); | |
} | |
var $u = [ | |
'pure', | |
'areStatesEqual', | |
'areOwnPropsEqual', | |
'areStatePropsEqual', | |
'areMergedPropsEqual', | |
]; | |
function gr(e, t, n) { | |
for (var r = t.length - 1; r >= 0; r--) { | |
var i = t[r](e); | |
if (i) return i; | |
} | |
return function (a, o) { | |
throw new Error( | |
'Invalid value of type ' + | |
typeof e + | |
' for ' + | |
n + | |
' argument when connecting component ' + | |
o.wrappedComponentName + | |
'.' | |
); | |
}; | |
} | |
function Hu(e, t) { | |
return e === t; | |
} | |
function Uu(e) { | |
var t = e === void 0 ? {} : e, | |
n = t.connectHOC, | |
r = n === void 0 ? Su : n, | |
i = t.mapStateToPropsFactories, | |
a = i === void 0 ? Nu : i, | |
o = t.mapDispatchToPropsFactories, | |
l = o === void 0 ? Eu : o, | |
s = t.mergePropsFactories, | |
c = s === void 0 ? Fu : s, | |
d = t.selectorFactory, | |
u = d === void 0 ? zu : d; | |
return function (p, m, h, x) { | |
x === void 0 && (x = {}); | |
var b = x, | |
C = b.pure, | |
S = C === void 0 ? !0 : C, | |
D = b.areStatesEqual, | |
E = D === void 0 ? Hu : D, | |
w = b.areOwnPropsEqual, | |
O = w === void 0 ? fr : w, | |
L = b.areStatePropsEqual, | |
F = L === void 0 ? fr : L, | |
V = b.areMergedPropsEqual, | |
A = V === void 0 ? fr : V, | |
R = Dn(b, $u), | |
Y = gr(p, a, 'mapStateToProps'), | |
q = gr(m, l, 'mapDispatchToProps'), | |
$ = gr(h, c, 'mergeProps'); | |
return r( | |
u, | |
j( | |
{ | |
methodName: 'connect', | |
getDisplayName: function (ie) { | |
return 'Connect(' + ie + ')'; | |
}, | |
shouldHandleStateChanges: !!p, | |
initMapStateToProps: Y, | |
initMapDispatchToProps: q, | |
initMergeProps: $, | |
pure: S, | |
areStatesEqual: E, | |
areOwnPropsEqual: O, | |
areStatePropsEqual: F, | |
areMergedPropsEqual: A, | |
}, | |
R | |
) | |
); | |
}; | |
} | |
const jo = Uu(); | |
$s(ws.unstable_batchedUpdates); | |
function Gu(e, t) { | |
if (e.length !== t.length) return !1; | |
for (var n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1; | |
return !0; | |
} | |
function zo(e, t) { | |
var n = N.useState(function () { | |
return { inputs: t, result: e() }; | |
})[0], | |
r = N.useRef(!0), | |
i = N.useRef(n), | |
a = r.current || !!(t && i.current.inputs && Gu(t, i.current.inputs)), | |
o = a ? i.current : { inputs: t, result: e() }; | |
return ( | |
N.useEffect( | |
function () { | |
(r.current = !1), (i.current = o); | |
}, | |
[o] | |
), | |
o.result | |
); | |
} | |
function Wu(e, t) { | |
return zo(function () { | |
return e; | |
}, t); | |
} | |
var X = zo, | |
M = Wu, | |
qu = !0, | |
mr = 'Invariant failed'; | |
function Vu(e, t) { | |
if (!e) { | |
if (qu) throw new Error(mr); | |
var n = typeof t == 'function' ? t() : t, | |
r = n ? ''.concat(mr, ': ').concat(n) : mr; | |
throw new Error(r); | |
} | |
} | |
var We = function (t) { | |
var n = t.top, | |
r = t.right, | |
i = t.bottom, | |
a = t.left, | |
o = r - a, | |
l = i - n, | |
s = { | |
top: n, | |
right: r, | |
bottom: i, | |
left: a, | |
width: o, | |
height: l, | |
x: a, | |
y: n, | |
center: { x: (r + a) / 2, y: (i + n) / 2 }, | |
}; | |
return s; | |
}, | |
li = function (t, n) { | |
return { | |
top: t.top - n.top, | |
left: t.left - n.left, | |
bottom: t.bottom + n.bottom, | |
right: t.right + n.right, | |
}; | |
}, | |
ta = function (t, n) { | |
return { | |
top: t.top + n.top, | |
left: t.left + n.left, | |
bottom: t.bottom - n.bottom, | |
right: t.right - n.right, | |
}; | |
}, | |
Ku = function (t, n) { | |
return { top: t.top + n.y, left: t.left + n.x, bottom: t.bottom + n.y, right: t.right + n.x }; | |
}, | |
hr = { top: 0, right: 0, bottom: 0, left: 0 }, | |
si = function (t) { | |
var n = t.borderBox, | |
r = t.margin, | |
i = r === void 0 ? hr : r, | |
a = t.border, | |
o = a === void 0 ? hr : a, | |
l = t.padding, | |
s = l === void 0 ? hr : l, | |
c = We(li(n, i)), | |
d = We(ta(n, o)), | |
u = We(ta(d, s)); | |
return { | |
marginBox: c, | |
borderBox: We(n), | |
paddingBox: d, | |
contentBox: u, | |
margin: i, | |
border: o, | |
padding: s, | |
}; | |
}, | |
Me = function (t) { | |
var n = t.slice(0, -2), | |
r = t.slice(-2); | |
if (r !== 'px') return 0; | |
var i = Number(n); | |
return isNaN(i) && Vu(!1), i; | |
}, | |
Yu = function () { | |
return { x: window.pageXOffset, y: window.pageYOffset }; | |
}, | |
In = function (t, n) { | |
var r = t.borderBox, | |
i = t.border, | |
a = t.margin, | |
o = t.padding, | |
l = Ku(r, n); | |
return si({ borderBox: l, border: i, margin: a, padding: o }); | |
}, | |
kn = function (t, n) { | |
return n === void 0 && (n = Yu()), In(t, n); | |
}, | |
$o = function (t, n) { | |
var r = { | |
top: Me(n.marginTop), | |
right: Me(n.marginRight), | |
bottom: Me(n.marginBottom), | |
left: Me(n.marginLeft), | |
}, | |
i = { | |
top: Me(n.paddingTop), | |
right: Me(n.paddingRight), | |
bottom: Me(n.paddingBottom), | |
left: Me(n.paddingLeft), | |
}, | |
a = { | |
top: Me(n.borderTopWidth), | |
right: Me(n.borderRightWidth), | |
bottom: Me(n.borderBottomWidth), | |
left: Me(n.borderLeftWidth), | |
}; | |
return si({ borderBox: t, margin: r, padding: i, border: a }); | |
}, | |
Ho = function (t) { | |
var n = t.getBoundingClientRect(), | |
r = window.getComputedStyle(t); | |
return $o(n, r); | |
}, | |
na = | |
Number.isNaN || | |
function (t) { | |
return typeof t == 'number' && t !== t; | |
}; | |
function Qu(e, t) { | |
return !!(e === t || (na(e) && na(t))); | |
} | |
function Xu(e, t) { | |
if (e.length !== t.length) return !1; | |
for (var n = 0; n < e.length; n++) if (!Qu(e[n], t[n])) return !1; | |
return !0; | |
} | |
function ve(e, t) { | |
t === void 0 && (t = Xu); | |
var n, | |
r = [], | |
i, | |
a = !1; | |
function o() { | |
for (var l = [], s = 0; s < arguments.length; s++) l[s] = arguments[s]; | |
return ( | |
(a && n === this && t(l, r)) || ((i = e.apply(this, l)), (a = !0), (n = this), (r = l)), i | |
); | |
} | |
return o; | |
} | |
var Ju = function (t) { | |
var n = [], | |
r = null, | |
i = function () { | |
for (var o = arguments.length, l = new Array(o), s = 0; s < o; s++) l[s] = arguments[s]; | |
(n = l), | |
!r && | |
(r = requestAnimationFrame(function () { | |
(r = null), t.apply(void 0, n); | |
})); | |
}; | |
return ( | |
(i.cancel = function () { | |
r && (cancelAnimationFrame(r), (r = null)); | |
}), | |
i | |
); | |
}; | |
const Vt = Ju; | |
function Uo(e, t) {} | |
Uo.bind(null, 'warn'); | |
Uo.bind(null, 'error'); | |
function lt() {} | |
function _u(e, t) { | |
return j({}, e, {}, t); | |
} | |
function ze(e, t, n) { | |
var r = t.map(function (i) { | |
var a = _u(n, i.options); | |
return ( | |
e.addEventListener(i.eventName, i.fn, a), | |
function () { | |
e.removeEventListener(i.eventName, i.fn, a); | |
} | |
); | |
}); | |
return function () { | |
r.forEach(function (a) { | |
a(); | |
}); | |
}; | |
} | |
var Zu = 'Invariant failed'; | |
function En(e) { | |
this.message = e; | |
} | |
En.prototype.toString = function () { | |
return this.message; | |
}; | |
function B(e, t) { | |
if (!e) throw new En(Zu); | |
} | |
var ec = (function (e) { | |
xo(t, e); | |
function t() { | |
for (var r, i = arguments.length, a = new Array(i), o = 0; o < i; o++) a[o] = arguments[o]; | |
return ( | |
(r = e.call.apply(e, [this].concat(a)) || this), | |
(r.callbacks = null), | |
(r.unbind = lt), | |
(r.onWindowError = function (l) { | |
var s = r.getCallbacks(); | |
s.isDragging() && s.tryAbort(); | |
var c = l.error; | |
c instanceof En && l.preventDefault(); | |
}), | |
(r.getCallbacks = function () { | |
if (!r.callbacks) throw new Error('Unable to find AppCallbacks in <ErrorBoundary/>'); | |
return r.callbacks; | |
}), | |
(r.setCallbacks = function (l) { | |
r.callbacks = l; | |
}), | |
r | |
); | |
} | |
var n = t.prototype; | |
return ( | |
(n.componentDidMount = function () { | |
this.unbind = ze(window, [{ eventName: 'error', fn: this.onWindowError }]); | |
}), | |
(n.componentDidCatch = function (i) { | |
if (i instanceof En) { | |
this.setState({}); | |
return; | |
} | |
throw i; | |
}), | |
(n.componentWillUnmount = function () { | |
this.unbind(); | |
}), | |
(n.render = function () { | |
return this.props.children(this.setCallbacks); | |
}), | |
t | |
); | |
})(_.Component), | |
tc = ` | |
Press space bar to start a drag. | |
When dragging you can use the arrow keys to move the item around and escape to cancel. | |
Some screen readers may require you to be in focus mode or to use your pass through key | |
`, | |
Pn = function (t) { | |
return t + 1; | |
}, | |
nc = function (t) { | |
return ( | |
` | |
You have lifted an item in position ` + | |
Pn(t.source.index) + | |
` | |
` | |
); | |
}, | |
Go = function (t, n) { | |
var r = t.droppableId === n.droppableId, | |
i = Pn(t.index), | |
a = Pn(n.index); | |
return r | |
? ` | |
You have moved the item from position ` + | |
i + | |
` | |
to position ` + | |
a + | |
` | |
` | |
: ` | |
You have moved the item from position ` + | |
i + | |
` | |
in list ` + | |
t.droppableId + | |
` | |
to list ` + | |
n.droppableId + | |
` | |
in position ` + | |
a + | |
` | |
`; | |
}, | |
Wo = function (t, n, r) { | |
var i = n.droppableId === r.droppableId; | |
return i | |
? ` | |
The item ` + | |
t + | |
` | |
has been combined with ` + | |
r.draggableId | |
: ` | |
The item ` + | |
t + | |
` | |
in list ` + | |
n.droppableId + | |
` | |
has been combined with ` + | |
r.draggableId + | |
` | |
in list ` + | |
r.droppableId + | |
` | |
`; | |
}, | |
rc = function (t) { | |
var n = t.destination; | |
if (n) return Go(t.source, n); | |
var r = t.combine; | |
return r ? Wo(t.draggableId, t.source, r) : 'You are over an area that cannot be dropped on'; | |
}, | |
ra = function (t) { | |
return ( | |
` | |
The item has returned to its starting position | |
of ` + | |
Pn(t.index) + | |
` | |
` | |
); | |
}, | |
ic = function (t) { | |
if (t.reason === 'CANCEL') | |
return ( | |
` | |
Movement cancelled. | |
` + | |
ra(t.source) + | |
` | |
` | |
); | |
var n = t.destination, | |
r = t.combine; | |
return n | |
? ` | |
You have dropped the item. | |
` + | |
Go(t.source, n) + | |
` | |
` | |
: r | |
? ` | |
You have dropped the item. | |
` + | |
Wo(t.draggableId, t.source, r) + | |
` | |
` | |
: ` | |
The item has been dropped while not over a drop area. | |
` + | |
ra(t.source) + | |
` | |
`; | |
}, | |
wn = { dragHandleUsageInstructions: tc, onDragStart: nc, onDragUpdate: rc, onDragEnd: ic }, | |
be = { x: 0, y: 0 }, | |
we = function (t, n) { | |
return { x: t.x + n.x, y: t.y + n.y }; | |
}, | |
Oe = function (t, n) { | |
return { x: t.x - n.x, y: t.y - n.y }; | |
}, | |
st = function (t, n) { | |
return t.x === n.x && t.y === n.y; | |
}, | |
Nt = function (t) { | |
return { x: t.x !== 0 ? -t.x : 0, y: t.y !== 0 ? -t.y : 0 }; | |
}, | |
wt = function (t, n, r) { | |
var i; | |
return r === void 0 && (r = 0), (i = {}), (i[t] = n), (i[t === 'x' ? 'y' : 'x'] = r), i; | |
}, | |
Kt = function (t, n) { | |
return Math.sqrt(Math.pow(n.x - t.x, 2) + Math.pow(n.y - t.y, 2)); | |
}, | |
ia = function (t, n) { | |
return Math.min.apply( | |
Math, | |
n.map(function (r) { | |
return Kt(t, r); | |
}) | |
); | |
}, | |
qo = function (t) { | |
return function (n) { | |
return { x: t(n.x), y: t(n.y) }; | |
}; | |
}, | |
ac = function (e, t) { | |
var n = We({ | |
top: Math.max(t.top, e.top), | |
right: Math.min(t.right, e.right), | |
bottom: Math.min(t.bottom, e.bottom), | |
left: Math.max(t.left, e.left), | |
}); | |
return n.width <= 0 || n.height <= 0 ? null : n; | |
}, | |
ln = function (t, n) { | |
return { top: t.top + n.y, left: t.left + n.x, bottom: t.bottom + n.y, right: t.right + n.x }; | |
}, | |
aa = function (t) { | |
return [ | |
{ x: t.left, y: t.top }, | |
{ x: t.right, y: t.top }, | |
{ x: t.left, y: t.bottom }, | |
{ x: t.right, y: t.bottom }, | |
]; | |
}, | |
oc = { top: 0, right: 0, bottom: 0, left: 0 }, | |
lc = function (t, n) { | |
return n ? ln(t, n.scroll.diff.displacement) : t; | |
}, | |
sc = function (t, n, r) { | |
if (r && r.increasedBy) { | |
var i; | |
return j({}, t, ((i = {}), (i[n.end] = t[n.end] + r.increasedBy[n.line]), i)); | |
} | |
return t; | |
}, | |
uc = function (t, n) { | |
return n && n.shouldClipSubject ? ac(n.pageMarginBox, t) : We(t); | |
}, | |
Et = function (e) { | |
var t = e.page, | |
n = e.withPlaceholder, | |
r = e.axis, | |
i = e.frame, | |
a = lc(t.marginBox, i), | |
o = sc(a, r, n), | |
l = uc(o, i); | |
return { page: t, withPlaceholder: n, active: l }; | |
}, | |
ui = function (e, t) { | |
e.frame || B(!1); | |
var n = e.frame, | |
r = Oe(t, n.scroll.initial), | |
i = Nt(r), | |
a = j({}, n, { | |
scroll: { | |
initial: n.scroll.initial, | |
current: t, | |
diff: { value: r, displacement: i }, | |
max: n.scroll.max, | |
}, | |
}), | |
o = Et({ | |
page: e.subject.page, | |
withPlaceholder: e.subject.withPlaceholder, | |
axis: e.axis, | |
frame: a, | |
}), | |
l = j({}, e, { frame: a, subject: o }); | |
return l; | |
}; | |
function An(e) { | |
return Object.values | |
? Object.values(e) | |
: Object.keys(e).map(function (t) { | |
return e[t]; | |
}); | |
} | |
function ci(e, t) { | |
if (e.findIndex) return e.findIndex(t); | |
for (var n = 0; n < e.length; n++) if (t(e[n])) return n; | |
return -1; | |
} | |
function dt(e, t) { | |
if (e.find) return e.find(t); | |
var n = ci(e, t); | |
if (n !== -1) return e[n]; | |
} | |
function Vo(e) { | |
return Array.prototype.slice.call(e); | |
} | |
var Ko = ve(function (e) { | |
return e.reduce(function (t, n) { | |
return (t[n.descriptor.id] = n), t; | |
}, {}); | |
}), | |
Yo = ve(function (e) { | |
return e.reduce(function (t, n) { | |
return (t[n.descriptor.id] = n), t; | |
}, {}); | |
}), | |
Kn = ve(function (e) { | |
return An(e); | |
}), | |
cc = ve(function (e) { | |
return An(e); | |
}), | |
Ot = ve(function (e, t) { | |
var n = cc(t) | |
.filter(function (r) { | |
return e === r.descriptor.droppableId; | |
}) | |
.sort(function (r, i) { | |
return r.descriptor.index - i.descriptor.index; | |
}); | |
return n; | |
}); | |
function di(e) { | |
return e.at && e.at.type === 'REORDER' ? e.at.destination : null; | |
} | |
function Yn(e) { | |
return e.at && e.at.type === 'COMBINE' ? e.at.combine : null; | |
} | |
var Qn = ve(function (e, t) { | |
return t.filter(function (n) { | |
return n.descriptor.id !== e.descriptor.id; | |
}); | |
}), | |
dc = function (e) { | |
var t = e.isMovingForward, | |
n = e.draggable, | |
r = e.destination, | |
i = e.insideDestination, | |
a = e.previousImpact; | |
if (!r.isCombineEnabled) return null; | |
var o = di(a); | |
if (!o) return null; | |
function l(h) { | |
var x = { type: 'COMBINE', combine: { draggableId: h, droppableId: r.descriptor.id } }; | |
return j({}, a, { at: x }); | |
} | |
var s = a.displaced.all, | |
c = s.length ? s[0] : null; | |
if (t) return c ? l(c) : null; | |
var d = Qn(n, i); | |
if (!c) { | |
if (!d.length) return null; | |
var u = d[d.length - 1]; | |
return l(u.descriptor.id); | |
} | |
var f = ci(d, function (h) { | |
return h.descriptor.id === c; | |
}); | |
f === -1 && B(!1); | |
var p = f - 1; | |
if (p < 0) return null; | |
var m = d[p]; | |
return l(m.descriptor.id); | |
}, | |
Tt = function (e, t) { | |
return e.descriptor.droppableId === t.descriptor.id; | |
}, | |
Qo = { point: be, value: 0 }, | |
Yt = { invisible: {}, visible: {}, all: [] }, | |
pc = { displaced: Yt, displacedBy: Qo, at: null }, | |
$e = function (e, t) { | |
return function (n) { | |
return e <= n && n <= t; | |
}; | |
}, | |
Xo = function (e) { | |
var t = $e(e.top, e.bottom), | |
n = $e(e.left, e.right); | |
return function (r) { | |
var i = t(r.top) && t(r.bottom) && n(r.left) && n(r.right); | |
if (i) return !0; | |
var a = t(r.top) || t(r.bottom), | |
o = n(r.left) || n(r.right), | |
l = a && o; | |
if (l) return !0; | |
var s = r.top < e.top && r.bottom > e.bottom, | |
c = r.left < e.left && r.right > e.right, | |
d = s && c; | |
if (d) return !0; | |
var u = (s && o) || (c && a); | |
return u; | |
}; | |
}, | |
fc = function (e) { | |
var t = $e(e.top, e.bottom), | |
n = $e(e.left, e.right); | |
return function (r) { | |
var i = t(r.top) && t(r.bottom) && n(r.left) && n(r.right); | |
return i; | |
}; | |
}, | |
pi = { | |
direction: 'vertical', | |
line: 'y', | |
crossAxisLine: 'x', | |
start: 'top', | |
end: 'bottom', | |
size: 'height', | |
crossAxisStart: 'left', | |
crossAxisEnd: 'right', | |
crossAxisSize: 'width', | |
}, | |
Jo = { | |
direction: 'horizontal', | |
line: 'x', | |
crossAxisLine: 'y', | |
start: 'left', | |
end: 'right', | |
size: 'width', | |
crossAxisStart: 'top', | |
crossAxisEnd: 'bottom', | |
crossAxisSize: 'height', | |
}, | |
gc = function (e) { | |
return function (t) { | |
var n = $e(t.top, t.bottom), | |
r = $e(t.left, t.right); | |
return function (i) { | |
return e === pi ? n(i.top) && n(i.bottom) : r(i.left) && r(i.right); | |
}; | |
}; | |
}, | |
mc = function (t, n) { | |
var r = n.frame ? n.frame.scroll.diff.displacement : be; | |
return ln(t, r); | |
}, | |
hc = function (t, n, r) { | |
return n.subject.active ? r(n.subject.active)(t) : !1; | |
}, | |
vc = function (t, n, r) { | |
return r(n)(t); | |
}, | |
fi = function (t) { | |
var n = t.target, | |
r = t.destination, | |
i = t.viewport, | |
a = t.withDroppableDisplacement, | |
o = t.isVisibleThroughFrameFn, | |
l = a ? mc(n, r) : n; | |
return hc(l, r, o) && vc(l, i, o); | |
}, | |
bc = function (t) { | |
return fi(j({}, t, { isVisibleThroughFrameFn: Xo })); | |
}, | |
_o = function (t) { | |
return fi(j({}, t, { isVisibleThroughFrameFn: fc })); | |
}, | |
yc = function (t) { | |
return fi(j({}, t, { isVisibleThroughFrameFn: gc(t.destination.axis) })); | |
}, | |
xc = function (t, n, r) { | |
if (typeof r == 'boolean') return r; | |
if (!n) return !0; | |
var i = n.invisible, | |
a = n.visible; | |
if (i[t]) return !1; | |
var o = a[t]; | |
return o ? o.shouldAnimate : !0; | |
}; | |
function wc(e, t) { | |
var n = e.page.marginBox, | |
r = { top: t.point.y, right: 0, bottom: 0, left: t.point.x }; | |
return We(li(n, r)); | |
} | |
function Qt(e) { | |
var t = e.afterDragging, | |
n = e.destination, | |
r = e.displacedBy, | |
i = e.viewport, | |
a = e.forceShouldAnimate, | |
o = e.last; | |
return t.reduce( | |
function (s, c) { | |
var d = wc(c, r), | |
u = c.descriptor.id; | |
s.all.push(u); | |
var f = bc({ target: d, destination: n, viewport: i, withDroppableDisplacement: !0 }); | |
if (!f) return (s.invisible[c.descriptor.id] = !0), s; | |
var p = xc(u, o, a), | |
m = { draggableId: u, shouldAnimate: p }; | |
return (s.visible[u] = m), s; | |
}, | |
{ all: [], visible: {}, invisible: {} } | |
); | |
} | |
function Sc(e, t) { | |
if (!e.length) return 0; | |
var n = e[e.length - 1].descriptor.index; | |
return t.inHomeList ? n : n + 1; | |
} | |
function oa(e) { | |
var t = e.insideDestination, | |
n = e.inHomeList, | |
r = e.displacedBy, | |
i = e.destination, | |
a = Sc(t, { inHomeList: n }); | |
return { | |
displaced: Yt, | |
displacedBy: r, | |
at: { type: 'REORDER', destination: { droppableId: i.descriptor.id, index: a } }, | |
}; | |
} | |
function Nn(e) { | |
var t = e.draggable, | |
n = e.insideDestination, | |
r = e.destination, | |
i = e.viewport, | |
a = e.displacedBy, | |
o = e.last, | |
l = e.index, | |
s = e.forceShouldAnimate, | |
c = Tt(t, r); | |
if (l == null) return oa({ insideDestination: n, inHomeList: c, displacedBy: a, destination: r }); | |
var d = dt(n, function (h) { | |
return h.descriptor.index === l; | |
}); | |
if (!d) return oa({ insideDestination: n, inHomeList: c, displacedBy: a, destination: r }); | |
var u = Qn(t, n), | |
f = n.indexOf(d), | |
p = u.slice(f), | |
m = Qt({ | |
afterDragging: p, | |
destination: r, | |
displacedBy: a, | |
last: o, | |
viewport: i.frame, | |
forceShouldAnimate: s, | |
}); | |
return { | |
displaced: m, | |
displacedBy: a, | |
at: { type: 'REORDER', destination: { droppableId: r.descriptor.id, index: l } }, | |
}; | |
} | |
function ct(e, t) { | |
return !!t.effected[e]; | |
} | |
var Cc = function (e) { | |
var t = e.isMovingForward, | |
n = e.destination, | |
r = e.draggables, | |
i = e.combine, | |
a = e.afterCritical; | |
if (!n.isCombineEnabled) return null; | |
var o = i.draggableId, | |
l = r[o], | |
s = l.descriptor.index, | |
c = ct(o, a); | |
return c ? (t ? s : s - 1) : t ? s + 1 : s; | |
}, | |
Dc = function (e) { | |
var t = e.isMovingForward, | |
n = e.isInHomeList, | |
r = e.insideDestination, | |
i = e.location; | |
if (!r.length) return null; | |
var a = i.index, | |
o = t ? a + 1 : a - 1, | |
l = r[0].descriptor.index, | |
s = r[r.length - 1].descriptor.index, | |
c = n ? s : s + 1; | |
return o < l || o > c ? null : o; | |
}, | |
Ic = function (e) { | |
var t = e.isMovingForward, | |
n = e.isInHomeList, | |
r = e.draggable, | |
i = e.draggables, | |
a = e.destination, | |
o = e.insideDestination, | |
l = e.previousImpact, | |
s = e.viewport, | |
c = e.afterCritical, | |
d = l.at; | |
if ((d || B(!1), d.type === 'REORDER')) { | |
var u = Dc({ | |
isMovingForward: t, | |
isInHomeList: n, | |
location: d.destination, | |
insideDestination: o, | |
}); | |
return u == null | |
? null | |
: Nn({ | |
draggable: r, | |
insideDestination: o, | |
destination: a, | |
viewport: s, | |
last: l.displaced, | |
displacedBy: l.displacedBy, | |
index: u, | |
}); | |
} | |
var f = Cc({ | |
isMovingForward: t, | |
destination: a, | |
displaced: l.displaced, | |
draggables: i, | |
combine: d.combine, | |
afterCritical: c, | |
}); | |
return f == null | |
? null | |
: Nn({ | |
draggable: r, | |
insideDestination: o, | |
destination: a, | |
viewport: s, | |
last: l.displaced, | |
displacedBy: l.displacedBy, | |
index: f, | |
}); | |
}, | |
kc = function (e) { | |
var t = e.displaced, | |
n = e.afterCritical, | |
r = e.combineWith, | |
i = e.displacedBy, | |
a = !!(t.visible[r] || t.invisible[r]); | |
return ct(r, n) ? (a ? be : Nt(i.point)) : a ? i.point : be; | |
}, | |
Ec = function (e) { | |
var t = e.afterCritical, | |
n = e.impact, | |
r = e.draggables, | |
i = Yn(n); | |
i || B(!1); | |
var a = i.draggableId, | |
o = r[a].page.borderBox.center, | |
l = kc({ | |
displaced: n.displaced, | |
afterCritical: t, | |
combineWith: a, | |
displacedBy: n.displacedBy, | |
}); | |
return we(o, l); | |
}, | |
Zo = function (t, n) { | |
return n.margin[t.start] + n.borderBox[t.size] / 2; | |
}, | |
Pc = function (t, n) { | |
return n.margin[t.end] + n.borderBox[t.size] / 2; | |
}, | |
gi = function (t, n, r) { | |
return n[t.crossAxisStart] + r.margin[t.crossAxisStart] + r.borderBox[t.crossAxisSize] / 2; | |
}, | |
la = function (t) { | |
var n = t.axis, | |
r = t.moveRelativeTo, | |
i = t.isMoving; | |
return wt(n.line, r.marginBox[n.end] + Zo(n, i), gi(n, r.marginBox, i)); | |
}, | |
sa = function (t) { | |
var n = t.axis, | |
r = t.moveRelativeTo, | |
i = t.isMoving; | |
return wt(n.line, r.marginBox[n.start] - Pc(n, i), gi(n, r.marginBox, i)); | |
}, | |
Ac = function (t) { | |
var n = t.axis, | |
r = t.moveInto, | |
i = t.isMoving; | |
return wt(n.line, r.contentBox[n.start] + Zo(n, i), gi(n, r.contentBox, i)); | |
}, | |
Nc = function (e) { | |
var t = e.impact, | |
n = e.draggable, | |
r = e.draggables, | |
i = e.droppable, | |
a = e.afterCritical, | |
o = Ot(i.descriptor.id, r), | |
l = n.page, | |
s = i.axis; | |
if (!o.length) return Ac({ axis: s, moveInto: i.page, isMoving: l }); | |
var c = t.displaced, | |
d = t.displacedBy, | |
u = c.all[0]; | |
if (u) { | |
var f = r[u]; | |
if (ct(u, a)) return sa({ axis: s, moveRelativeTo: f.page, isMoving: l }); | |
var p = In(f.page, d.point); | |
return sa({ axis: s, moveRelativeTo: p, isMoving: l }); | |
} | |
var m = o[o.length - 1]; | |
if (m.descriptor.id === n.descriptor.id) return l.borderBox.center; | |
if (ct(m.descriptor.id, a)) { | |
var h = In(m.page, Nt(a.displacedBy.point)); | |
return la({ axis: s, moveRelativeTo: h, isMoving: l }); | |
} | |
return la({ axis: s, moveRelativeTo: m.page, isMoving: l }); | |
}, | |
jr = function (e, t) { | |
var n = e.frame; | |
return n ? we(t, n.scroll.diff.displacement) : t; | |
}, | |
Oc = function (t) { | |
var n = t.impact, | |
r = t.draggable, | |
i = t.droppable, | |
a = t.draggables, | |
o = t.afterCritical, | |
l = r.page.borderBox.center, | |
s = n.at; | |
return !i || !s | |
? l | |
: s.type === 'REORDER' | |
? Nc({ impact: n, draggable: r, draggables: a, droppable: i, afterCritical: o }) | |
: Ec({ impact: n, draggables: a, afterCritical: o }); | |
}, | |
Xn = function (e) { | |
var t = Oc(e), | |
n = e.droppable, | |
r = n ? jr(n, t) : t; | |
return r; | |
}, | |
el = function (e, t) { | |
var n = Oe(t, e.scroll.initial), | |
r = Nt(n), | |
i = We({ top: t.y, bottom: t.y + e.frame.height, left: t.x, right: t.x + e.frame.width }), | |
a = { | |
frame: i, | |
scroll: { | |
initial: e.scroll.initial, | |
max: e.scroll.max, | |
current: t, | |
diff: { value: n, displacement: r }, | |
}, | |
}; | |
return a; | |
}; | |
function ua(e, t) { | |
return e.map(function (n) { | |
return t[n]; | |
}); | |
} | |
function Tc(e, t) { | |
for (var n = 0; n < t.length; n++) { | |
var r = t[n].visible[e]; | |
if (r) return r; | |
} | |
return null; | |
} | |
var Bc = function (e) { | |
var t = e.impact, | |
n = e.viewport, | |
r = e.destination, | |
i = e.draggables, | |
a = e.maxScrollChange, | |
o = el(n, we(n.scroll.current, a)), | |
l = r.frame ? ui(r, we(r.frame.scroll.current, a)) : r, | |
s = t.displaced, | |
c = Qt({ | |
afterDragging: ua(s.all, i), | |
destination: r, | |
displacedBy: t.displacedBy, | |
viewport: o.frame, | |
last: s, | |
forceShouldAnimate: !1, | |
}), | |
d = Qt({ | |
afterDragging: ua(s.all, i), | |
destination: l, | |
displacedBy: t.displacedBy, | |
viewport: n.frame, | |
last: s, | |
forceShouldAnimate: !1, | |
}), | |
u = {}, | |
f = {}, | |
p = [s, c, d]; | |
s.all.forEach(function (h) { | |
var x = Tc(h, p); | |
if (x) { | |
f[h] = x; | |
return; | |
} | |
u[h] = !0; | |
}); | |
var m = j({}, t, { displaced: { all: s.all, invisible: u, visible: f } }); | |
return m; | |
}, | |
Rc = function (e, t) { | |
return we(e.scroll.diff.displacement, t); | |
}, | |
mi = function (e) { | |
var t = e.pageBorderBoxCenter, | |
n = e.draggable, | |
r = e.viewport, | |
i = Rc(r, t), | |
a = Oe(i, n.page.borderBox.center); | |
return we(n.client.borderBox.center, a); | |
}, | |
tl = function (e) { | |
var t = e.draggable, | |
n = e.destination, | |
r = e.newPageBorderBoxCenter, | |
i = e.viewport, | |
a = e.withDroppableDisplacement, | |
o = e.onlyOnMainAxis, | |
l = o === void 0 ? !1 : o, | |
s = Oe(r, t.page.borderBox.center), | |
c = ln(t.page.borderBox, s), | |
d = { target: c, destination: n, withDroppableDisplacement: a, viewport: i }; | |
return l ? yc(d) : _o(d); | |
}, | |
Fc = function (e) { | |
var t = e.isMovingForward, | |
n = e.draggable, | |
r = e.destination, | |
i = e.draggables, | |
a = e.previousImpact, | |
o = e.viewport, | |
l = e.previousPageBorderBoxCenter, | |
s = e.previousClientSelection, | |
c = e.afterCritical; | |
if (!r.isEnabled) return null; | |
var d = Ot(r.descriptor.id, i), | |
u = Tt(n, r), | |
f = | |
dc({ | |
isMovingForward: t, | |
draggable: n, | |
destination: r, | |
insideDestination: d, | |
previousImpact: a, | |
}) || | |
Ic({ | |
isMovingForward: t, | |
isInHomeList: u, | |
draggable: n, | |
draggables: i, | |
destination: r, | |
insideDestination: d, | |
previousImpact: a, | |
viewport: o, | |
afterCritical: c, | |
}); | |
if (!f) return null; | |
var p = Xn({ impact: f, draggable: n, droppable: r, draggables: i, afterCritical: c }), | |
m = tl({ | |
draggable: n, | |
destination: r, | |
newPageBorderBoxCenter: p, | |
viewport: o.frame, | |
withDroppableDisplacement: !1, | |
onlyOnMainAxis: !0, | |
}); | |
if (m) { | |
var h = mi({ pageBorderBoxCenter: p, draggable: n, viewport: o }); | |
return { clientSelection: h, impact: f, scrollJumpRequest: null }; | |
} | |
var x = Oe(p, l), | |
b = Bc({ impact: f, viewport: o, destination: r, draggables: i, maxScrollChange: x }); | |
return { clientSelection: s, impact: b, scrollJumpRequest: x }; | |
}, | |
Ce = function (t) { | |
var n = t.subject.active; | |
return n || B(!1), n; | |
}, | |
Lc = function (e) { | |
var t = e.isMovingForward, | |
n = e.pageBorderBoxCenter, | |
r = e.source, | |
i = e.droppables, | |
a = e.viewport, | |
o = r.subject.active; | |
if (!o) return null; | |
var l = r.axis, | |
s = $e(o[l.start], o[l.end]), | |
c = Kn(i) | |
.filter(function (u) { | |
return u !== r; | |
}) | |
.filter(function (u) { | |
return u.isEnabled; | |
}) | |
.filter(function (u) { | |
return !!u.subject.active; | |
}) | |
.filter(function (u) { | |
return Xo(a.frame)(Ce(u)); | |
}) | |
.filter(function (u) { | |
var f = Ce(u); | |
return t | |
? o[l.crossAxisEnd] < f[l.crossAxisEnd] | |
: f[l.crossAxisStart] < o[l.crossAxisStart]; | |
}) | |
.filter(function (u) { | |
var f = Ce(u), | |
p = $e(f[l.start], f[l.end]); | |
return s(f[l.start]) || s(f[l.end]) || p(o[l.start]) || p(o[l.end]); | |
}) | |
.sort(function (u, f) { | |
var p = Ce(u)[l.crossAxisStart], | |
m = Ce(f)[l.crossAxisStart]; | |
return t ? p - m : m - p; | |
}) | |
.filter(function (u, f, p) { | |
return Ce(u)[l.crossAxisStart] === Ce(p[0])[l.crossAxisStart]; | |
}); | |
if (!c.length) return null; | |
if (c.length === 1) return c[0]; | |
var d = c.filter(function (u) { | |
var f = $e(Ce(u)[l.start], Ce(u)[l.end]); | |
return f(n[l.line]); | |
}); | |
return d.length === 1 | |
? d[0] | |
: d.length > 1 | |
? d.sort(function (u, f) { | |
return Ce(u)[l.start] - Ce(f)[l.start]; | |
})[0] | |
: c.sort(function (u, f) { | |
var p = ia(n, aa(Ce(u))), | |
m = ia(n, aa(Ce(f))); | |
return p !== m ? p - m : Ce(u)[l.start] - Ce(f)[l.start]; | |
})[0]; | |
}, | |
ca = function (t, n) { | |
var r = t.page.borderBox.center; | |
return ct(t.descriptor.id, n) ? Oe(r, n.displacedBy.point) : r; | |
}, | |
Mc = function (t, n) { | |
var r = t.page.borderBox; | |
return ct(t.descriptor.id, n) ? ln(r, Nt(n.displacedBy.point)) : r; | |
}, | |
jc = function (e) { | |
var t = e.pageBorderBoxCenter, | |
n = e.viewport, | |
r = e.destination, | |
i = e.insideDestination, | |
a = e.afterCritical, | |
o = i | |
.filter(function (l) { | |
return _o({ | |
target: Mc(l, a), | |
destination: r, | |
viewport: n.frame, | |
withDroppableDisplacement: !0, | |
}); | |
}) | |
.sort(function (l, s) { | |
var c = Kt(t, jr(r, ca(l, a))), | |
d = Kt(t, jr(r, ca(s, a))); | |
return c < d ? -1 : d < c ? 1 : l.descriptor.index - s.descriptor.index; | |
}); | |
return o[0] || null; | |
}, | |
sn = ve(function (t, n) { | |
var r = n[t.line]; | |
return { value: r, point: wt(t.line, r) }; | |
}), | |
zc = function (t, n, r) { | |
var i = t.axis; | |
if (t.descriptor.mode === 'virtual') return wt(i.line, n[i.line]); | |
var a = t.subject.page.contentBox[i.size], | |
o = Ot(t.descriptor.id, r), | |
l = o.reduce(function (d, u) { | |
return d + u.client.marginBox[i.size]; | |
}, 0), | |
s = l + n[i.line], | |
c = s - a; | |
return c <= 0 ? null : wt(i.line, c); | |
}, | |
nl = function (t, n) { | |
return j({}, t, { scroll: j({}, t.scroll, { max: n }) }); | |
}, | |
rl = function (t, n, r) { | |
var i = t.frame; | |
Tt(n, t) && B(!1), t.subject.withPlaceholder && B(!1); | |
var a = sn(t.axis, n.displaceBy).point, | |
o = zc(t, a, r), | |
l = { | |
placeholderSize: a, | |
increasedBy: o, | |
oldFrameMaxScroll: t.frame ? t.frame.scroll.max : null, | |
}; | |
if (!i) { | |
var s = Et({ page: t.subject.page, withPlaceholder: l, axis: t.axis, frame: t.frame }); | |
return j({}, t, { subject: s }); | |
} | |
var c = o ? we(i.scroll.max, o) : i.scroll.max, | |
d = nl(i, c), | |
u = Et({ page: t.subject.page, withPlaceholder: l, axis: t.axis, frame: d }); | |
return j({}, t, { subject: u, frame: d }); | |
}, | |
$c = function (t) { | |
var n = t.subject.withPlaceholder; | |
n || B(!1); | |
var r = t.frame; | |
if (!r) { | |
var i = Et({ page: t.subject.page, axis: t.axis, frame: null, withPlaceholder: null }); | |
return j({}, t, { subject: i }); | |
} | |
var a = n.oldFrameMaxScroll; | |
a || B(!1); | |
var o = nl(r, a), | |
l = Et({ page: t.subject.page, axis: t.axis, frame: o, withPlaceholder: null }); | |
return j({}, t, { subject: l, frame: o }); | |
}, | |
Hc = function (e) { | |
var t = e.previousPageBorderBoxCenter, | |
n = e.moveRelativeTo, | |
r = e.insideDestination, | |
i = e.draggable, | |
a = e.draggables, | |
o = e.destination, | |
l = e.viewport, | |
s = e.afterCritical; | |
if (!n) { | |
if (r.length) return null; | |
var c = { | |
displaced: Yt, | |
displacedBy: Qo, | |
at: { type: 'REORDER', destination: { droppableId: o.descriptor.id, index: 0 } }, | |
}, | |
d = Xn({ impact: c, draggable: i, droppable: o, draggables: a, afterCritical: s }), | |
u = Tt(i, o) ? o : rl(o, i, a), | |
f = tl({ | |
draggable: i, | |
destination: u, | |
newPageBorderBoxCenter: d, | |
viewport: l.frame, | |
withDroppableDisplacement: !1, | |
onlyOnMainAxis: !0, | |
}); | |
return f ? c : null; | |
} | |
var p = t[o.axis.line] <= n.page.borderBox.center[o.axis.line], | |
m = (function () { | |
var x = n.descriptor.index; | |
return n.descriptor.id === i.descriptor.id || p ? x : x + 1; | |
})(), | |
h = sn(o.axis, i.displaceBy); | |
return Nn({ | |
draggable: i, | |
insideDestination: r, | |
destination: o, | |
viewport: l, | |
displacedBy: h, | |
last: Yt, | |
index: m, | |
}); | |
}, | |
Uc = function (e) { | |
var t = e.isMovingForward, | |
n = e.previousPageBorderBoxCenter, | |
r = e.draggable, | |
i = e.isOver, | |
a = e.draggables, | |
o = e.droppables, | |
l = e.viewport, | |
s = e.afterCritical, | |
c = Lc({ isMovingForward: t, pageBorderBoxCenter: n, source: i, droppables: o, viewport: l }); | |
if (!c) return null; | |
var d = Ot(c.descriptor.id, a), | |
u = jc({ | |
pageBorderBoxCenter: n, | |
viewport: l, | |
destination: c, | |
insideDestination: d, | |
afterCritical: s, | |
}), | |
f = Hc({ | |
previousPageBorderBoxCenter: n, | |
destination: c, | |
draggable: r, | |
draggables: a, | |
moveRelativeTo: u, | |
insideDestination: d, | |
viewport: l, | |
afterCritical: s, | |
}); | |
if (!f) return null; | |
var p = Xn({ impact: f, draggable: r, droppable: c, draggables: a, afterCritical: s }), | |
m = mi({ pageBorderBoxCenter: p, draggable: r, viewport: l }); | |
return { clientSelection: m, impact: f, scrollJumpRequest: null }; | |
}, | |
Be = function (e) { | |
var t = e.at; | |
return t ? (t.type === 'REORDER' ? t.destination.droppableId : t.combine.droppableId) : null; | |
}, | |
Gc = function (t, n) { | |
var r = Be(t); | |
return r ? n[r] : null; | |
}, | |
Wc = function (e) { | |
var t = e.state, | |
n = e.type, | |
r = Gc(t.impact, t.dimensions.droppables), | |
i = !!r, | |
a = t.dimensions.droppables[t.critical.droppable.id], | |
o = r || a, | |
l = o.axis.direction, | |
s = | |
(l === 'vertical' && (n === 'MOVE_UP' || n === 'MOVE_DOWN')) || | |
(l === 'horizontal' && (n === 'MOVE_LEFT' || n === 'MOVE_RIGHT')); | |
if (s && !i) return null; | |
var c = n === 'MOVE_DOWN' || n === 'MOVE_RIGHT', | |
d = t.dimensions.draggables[t.critical.draggable.id], | |
u = t.current.page.borderBoxCenter, | |
f = t.dimensions, | |
p = f.draggables, | |
m = f.droppables; | |
return s | |
? Fc({ | |
isMovingForward: c, | |
previousPageBorderBoxCenter: u, | |
draggable: d, | |
destination: o, | |
draggables: p, | |
viewport: t.viewport, | |
previousClientSelection: t.current.client.selection, | |
previousImpact: t.impact, | |
afterCritical: t.afterCritical, | |
}) | |
: Uc({ | |
isMovingForward: c, | |
previousPageBorderBoxCenter: u, | |
draggable: d, | |
isOver: o, | |
draggables: p, | |
droppables: m, | |
viewport: t.viewport, | |
afterCritical: t.afterCritical, | |
}); | |
}; | |
function yt(e) { | |
return e.phase === 'DRAGGING' || e.phase === 'COLLECTING'; | |
} | |
function il(e) { | |
var t = $e(e.top, e.bottom), | |
n = $e(e.left, e.right); | |
return function (i) { | |
return t(i.y) && n(i.x); | |
}; | |
} | |
function qc(e, t) { | |
return e.left < t.right && e.right > t.left && e.top < t.bottom && e.bottom > t.top; | |
} | |
function Vc(e) { | |
var t = e.pageBorderBox, | |
n = e.draggable, | |
r = e.candidates, | |
i = n.page.borderBox.center, | |
a = r | |
.map(function (o) { | |
var l = o.axis, | |
s = wt(o.axis.line, t.center[l.line], o.page.borderBox.center[l.crossAxisLine]); | |
return { id: o.descriptor.id, distance: Kt(i, s) }; | |
}) | |
.sort(function (o, l) { | |
return l.distance - o.distance; | |
}); | |
return a[0] ? a[0].id : null; | |
} | |
function Kc(e) { | |
var t = e.pageBorderBox, | |
n = e.draggable, | |
r = e.droppables, | |
i = Kn(r).filter(function (a) { | |
if (!a.isEnabled) return !1; | |
var o = a.subject.active; | |
if (!o || !qc(t, o)) return !1; | |
if (il(o)(t.center)) return !0; | |
var l = a.axis, | |
s = o.center[l.crossAxisLine], | |
c = t[l.crossAxisStart], | |
d = t[l.crossAxisEnd], | |
u = $e(o[l.crossAxisStart], o[l.crossAxisEnd]), | |
f = u(c), | |
p = u(d); | |
return !f && !p ? !0 : f ? c < s : d > s; | |
}); | |
return i.length | |
? i.length === 1 | |
? i[0].descriptor.id | |
: Vc({ pageBorderBox: t, draggable: n, candidates: i }) | |
: null; | |
} | |
var al = function (t, n) { | |
return We(ln(t, n)); | |
}, | |
Yc = function (e, t) { | |
var n = e.frame; | |
return n ? al(t, n.scroll.diff.value) : t; | |
}; | |
function ol(e) { | |
var t = e.displaced, | |
n = e.id; | |
return !!(t.visible[n] || t.invisible[n]); | |
} | |
function Qc(e) { | |
var t = e.draggable, | |
n = e.closest, | |
r = e.inHomeList; | |
return n | |
? r && n.descriptor.index > t.descriptor.index | |
? n.descriptor.index - 1 | |
: n.descriptor.index | |
: null; | |
} | |
var Xc = function (e) { | |
var t = e.pageBorderBoxWithDroppableScroll, | |
n = e.draggable, | |
r = e.destination, | |
i = e.insideDestination, | |
a = e.last, | |
o = e.viewport, | |
l = e.afterCritical, | |
s = r.axis, | |
c = sn(r.axis, n.displaceBy), | |
d = c.value, | |
u = t[s.start], | |
f = t[s.end], | |
p = Qn(n, i), | |
m = dt(p, function (x) { | |
var b = x.descriptor.id, | |
C = x.page.borderBox.center[s.line], | |
S = ct(b, l), | |
D = ol({ displaced: a, id: b }); | |
return S ? (D ? f <= C : u < C - d) : D ? f <= C + d : u < C; | |
}), | |
h = Qc({ draggable: n, closest: m, inHomeList: Tt(n, r) }); | |
return Nn({ | |
draggable: n, | |
insideDestination: i, | |
destination: r, | |
viewport: o, | |
last: a, | |
displacedBy: c, | |
index: h, | |
}); | |
}, | |
Jc = 4, | |
_c = function (e) { | |
var t = e.draggable, | |
n = e.pageBorderBoxWithDroppableScroll, | |
r = e.previousImpact, | |
i = e.destination, | |
a = e.insideDestination, | |
o = e.afterCritical; | |
if (!i.isCombineEnabled) return null; | |
var l = i.axis, | |
s = sn(i.axis, t.displaceBy), | |
c = s.value, | |
d = n[l.start], | |
u = n[l.end], | |
f = Qn(t, a), | |
p = dt(f, function (h) { | |
var x = h.descriptor.id, | |
b = h.page.borderBox, | |
C = b[l.size], | |
S = C / Jc, | |
D = ct(x, o), | |
E = ol({ displaced: r.displaced, id: x }); | |
return D | |
? E | |
? u > b[l.start] + S && u < b[l.end] - S | |
: d > b[l.start] - c + S && d < b[l.end] - c - S | |
: E | |
? u > b[l.start] + c + S && u < b[l.end] + c - S | |
: d > b[l.start] + S && d < b[l.end] - S; | |
}); | |
if (!p) return null; | |
var m = { | |
displacedBy: s, | |
displaced: r.displaced, | |
at: { | |
type: 'COMBINE', | |
combine: { draggableId: p.descriptor.id, droppableId: i.descriptor.id }, | |
}, | |
}; | |
return m; | |
}, | |
ll = function (e) { | |
var t = e.pageOffset, | |
n = e.draggable, | |
r = e.draggables, | |
i = e.droppables, | |
a = e.previousImpact, | |
o = e.viewport, | |
l = e.afterCritical, | |
s = al(n.page.borderBox, t), | |
c = Kc({ pageBorderBox: s, draggable: n, droppables: i }); | |
if (!c) return pc; | |
var d = i[c], | |
u = Ot(d.descriptor.id, r), | |
f = Yc(d, s); | |
return ( | |
_c({ | |
pageBorderBoxWithDroppableScroll: f, | |
draggable: n, | |
previousImpact: a, | |
destination: d, | |
insideDestination: u, | |
afterCritical: l, | |
}) || | |
Xc({ | |
pageBorderBoxWithDroppableScroll: f, | |
draggable: n, | |
destination: d, | |
insideDestination: u, | |
last: a.displaced, | |
viewport: o, | |
afterCritical: l, | |
}) | |
); | |
}, | |
hi = function (e, t) { | |
var n; | |
return j({}, e, ((n = {}), (n[t.descriptor.id] = t), n)); | |
}, | |
Zc = function (t) { | |
var n = t.previousImpact, | |
r = t.impact, | |
i = t.droppables, | |
a = Be(n), | |
o = Be(r); | |
if (!a || a === o) return i; | |
var l = i[a]; | |
if (!l.subject.withPlaceholder) return i; | |
var s = $c(l); | |
return hi(i, s); | |
}, | |
ed = function (e) { | |
var t = e.draggable, | |
n = e.draggables, | |
r = e.droppables, | |
i = e.previousImpact, | |
a = e.impact, | |
o = Zc({ previousImpact: i, impact: a, droppables: r }), | |
l = Be(a); | |
if (!l) return o; | |
var s = r[l]; | |
if (Tt(t, s) || s.subject.withPlaceholder) return o; | |
var c = rl(s, t, n); | |
return hi(o, c); | |
}, | |
Ht = function (e) { | |
var t = e.state, | |
n = e.clientSelection, | |
r = e.dimensions, | |
i = e.viewport, | |
a = e.impact, | |
o = e.scrollJumpRequest, | |
l = i || t.viewport, | |
s = r || t.dimensions, | |
c = n || t.current.client.selection, | |
d = Oe(c, t.initial.client.selection), | |
u = { offset: d, selection: c, borderBoxCenter: we(t.initial.client.borderBoxCenter, d) }, | |
f = { | |
selection: we(u.selection, l.scroll.current), | |
borderBoxCenter: we(u.borderBoxCenter, l.scroll.current), | |
offset: we(u.offset, l.scroll.diff.value), | |
}, | |
p = { client: u, page: f }; | |
if (t.phase === 'COLLECTING') | |
return j({ phase: 'COLLECTING' }, t, { dimensions: s, viewport: l, current: p }); | |
var m = s.draggables[t.critical.draggable.id], | |
h = | |
a || | |
ll({ | |
pageOffset: f.offset, | |
draggable: m, | |
draggables: s.draggables, | |
droppables: s.droppables, | |
previousImpact: t.impact, | |
viewport: l, | |
afterCritical: t.afterCritical, | |
}), | |
x = ed({ | |
draggable: m, | |
impact: h, | |
previousImpact: t.impact, | |
draggables: s.draggables, | |
droppables: s.droppables, | |
}), | |
b = j({}, t, { | |
current: p, | |
dimensions: { draggables: s.draggables, droppables: x }, | |
impact: h, | |
viewport: l, | |
scrollJumpRequest: o || null, | |
forceShouldAnimate: o ? !1 : null, | |
}); | |
return b; | |
}; | |
function td(e, t) { | |
return e.map(function (n) { | |
return t[n]; | |
}); | |
} | |
var sl = function (e) { | |
var t = e.impact, | |
n = e.viewport, | |
r = e.draggables, | |
i = e.destination, | |
a = e.forceShouldAnimate, | |
o = t.displaced, | |
l = td(o.all, r), | |
s = Qt({ | |
afterDragging: l, | |
destination: i, | |
displacedBy: t.displacedBy, | |
viewport: n.frame, | |
forceShouldAnimate: a, | |
last: o, | |
}); | |
return j({}, t, { displaced: s }); | |
}, | |
ul = function (e) { | |
var t = e.impact, | |
n = e.draggable, | |
r = e.droppable, | |
i = e.draggables, | |
a = e.viewport, | |
o = e.afterCritical, | |
l = Xn({ impact: t, draggable: n, draggables: i, droppable: r, afterCritical: o }); | |
return mi({ pageBorderBoxCenter: l, draggable: n, viewport: a }); | |
}, | |
cl = function (e) { | |
var t = e.state, | |
n = e.dimensions, | |
r = e.viewport; | |
t.movementMode !== 'SNAP' && B(!1); | |
var i = t.impact, | |
a = r || t.viewport, | |
o = n || t.dimensions, | |
l = o.draggables, | |
s = o.droppables, | |
c = l[t.critical.draggable.id], | |
d = Be(i); | |
d || B(!1); | |
var u = s[d], | |
f = sl({ impact: i, viewport: a, destination: u, draggables: l }), | |
p = ul({ | |
impact: f, | |
draggable: c, | |
droppable: u, | |
draggables: l, | |
viewport: a, | |
afterCritical: t.afterCritical, | |
}); | |
return Ht({ impact: f, clientSelection: p, state: t, dimensions: o, viewport: a }); | |
}, | |
nd = function (e) { | |
return { index: e.index, droppableId: e.droppableId }; | |
}, | |
dl = function (e) { | |
var t = e.draggable, | |
n = e.home, | |
r = e.draggables, | |
i = e.viewport, | |
a = sn(n.axis, t.displaceBy), | |
o = Ot(n.descriptor.id, r), | |
l = o.indexOf(t); | |
l === -1 && B(!1); | |
var s = o.slice(l + 1), | |
c = s.reduce(function (p, m) { | |
return (p[m.descriptor.id] = !0), p; | |
}, {}), | |
d = { inVirtualList: n.descriptor.mode === 'virtual', displacedBy: a, effected: c }, | |
u = Qt({ | |
afterDragging: s, | |
destination: n, | |
displacedBy: a, | |
last: null, | |
viewport: i.frame, | |
forceShouldAnimate: !1, | |
}), | |
f = { displaced: u, displacedBy: a, at: { type: 'REORDER', destination: nd(t.descriptor) } }; | |
return { impact: f, afterCritical: d }; | |
}, | |
rd = function (e, t) { | |
return { draggables: e.draggables, droppables: hi(e.droppables, t) }; | |
}, | |
id = function (e) { | |
var t = e.draggable, | |
n = e.offset, | |
r = e.initialWindowScroll, | |
i = In(t.client, n), | |
a = kn(i, r), | |
o = j({}, t, { placeholder: j({}, t.placeholder, { client: i }), client: i, page: a }); | |
return o; | |
}, | |
ad = function (e) { | |
var t = e.frame; | |
return t || B(!1), t; | |
}, | |
od = function (e) { | |
var t = e.additions, | |
n = e.updatedDroppables, | |
r = e.viewport, | |
i = r.scroll.diff.value; | |
return t.map(function (a) { | |
var o = a.descriptor.droppableId, | |
l = n[o], | |
s = ad(l), | |
c = s.scroll.diff.value, | |
d = we(i, c), | |
u = id({ draggable: a, offset: d, initialWindowScroll: r.scroll.initial }); | |
return u; | |
}); | |
}, | |
ld = function (e) { | |
var t = e.state, | |
n = e.published, | |
r = n.modified.map(function (S) { | |
var D = t.dimensions.droppables[S.droppableId], | |
E = ui(D, S.scroll); | |
return E; | |
}), | |
i = j({}, t.dimensions.droppables, {}, Ko(r)), | |
a = Yo(od({ additions: n.additions, updatedDroppables: i, viewport: t.viewport })), | |
o = j({}, t.dimensions.draggables, {}, a); | |
n.removals.forEach(function (S) { | |
delete o[S]; | |
}); | |
var l = { droppables: i, draggables: o }, | |
s = Be(t.impact), | |
c = s ? l.droppables[s] : null, | |
d = l.draggables[t.critical.draggable.id], | |
u = l.droppables[t.critical.droppable.id], | |
f = dl({ draggable: d, home: u, draggables: o, viewport: t.viewport }), | |
p = f.impact, | |
m = f.afterCritical, | |
h = c && c.isCombineEnabled ? t.impact : p, | |
x = ll({ | |
pageOffset: t.current.page.offset, | |
draggable: l.draggables[t.critical.draggable.id], | |
draggables: l.draggables, | |
droppables: l.droppables, | |
previousImpact: h, | |
viewport: t.viewport, | |
afterCritical: m, | |
}), | |
b = j({ phase: 'DRAGGING' }, t, { | |
phase: 'DRAGGING', | |
impact: x, | |
onLiftImpact: p, | |
dimensions: l, | |
afterCritical: m, | |
forceShouldAnimate: !1, | |
}); | |
if (t.phase === 'COLLECTING') return b; | |
var C = j({ phase: 'DROP_PENDING' }, b, { | |
phase: 'DROP_PENDING', | |
reason: t.reason, | |
isWaiting: !1, | |
}); | |
return C; | |
}, | |
zr = function (t) { | |
return t.movementMode === 'SNAP'; | |
}, | |
vr = function (t, n, r) { | |
var i = rd(t.dimensions, n); | |
return !zr(t) || r ? Ht({ state: t, dimensions: i }) : cl({ state: t, dimensions: i }); | |
}; | |
function br(e) { | |
return e.isDragging && e.movementMode === 'SNAP' | |
? j({ phase: 'DRAGGING' }, e, { scrollJumpRequest: null }) | |
: e; | |
} | |
var da = { phase: 'IDLE', completed: null, shouldFlush: !1 }, | |
sd = function (e, t) { | |
if ((e === void 0 && (e = da), t.type === 'FLUSH')) return j({}, da, { shouldFlush: !0 }); | |
if (t.type === 'INITIAL_PUBLISH') { | |
e.phase !== 'IDLE' && B(!1); | |
var n = t.payload, | |
r = n.critical, | |
i = n.clientSelection, | |
a = n.viewport, | |
o = n.dimensions, | |
l = n.movementMode, | |
s = o.draggables[r.draggable.id], | |
c = o.droppables[r.droppable.id], | |
d = { selection: i, borderBoxCenter: s.client.borderBox.center, offset: be }, | |
u = { | |
client: d, | |
page: { | |
selection: we(d.selection, a.scroll.initial), | |
borderBoxCenter: we(d.selection, a.scroll.initial), | |
offset: we(d.selection, a.scroll.diff.value), | |
}, | |
}, | |
f = Kn(o.droppables).every(function (Ve) { | |
return !Ve.isFixedOnPage; | |
}), | |
p = dl({ draggable: s, home: c, draggables: o.draggables, viewport: a }), | |
m = p.impact, | |
h = p.afterCritical, | |
x = { | |
phase: 'DRAGGING', | |
isDragging: !0, | |
critical: r, | |
movementMode: l, | |
dimensions: o, | |
initial: u, | |
current: u, | |
isWindowScrollAllowed: f, | |
impact: m, | |
afterCritical: h, | |
onLiftImpact: m, | |
viewport: a, | |
scrollJumpRequest: null, | |
forceShouldAnimate: null, | |
}; | |
return x; | |
} | |
if (t.type === 'COLLECTION_STARTING') { | |
if (e.phase === 'COLLECTING' || e.phase === 'DROP_PENDING') return e; | |
e.phase !== 'DRAGGING' && B(!1); | |
var b = j({ phase: 'COLLECTING' }, e, { phase: 'COLLECTING' }); | |
return b; | |
} | |
if (t.type === 'PUBLISH_WHILE_DRAGGING') | |
return ( | |
e.phase === 'COLLECTING' || e.phase === 'DROP_PENDING' || B(!1), | |
ld({ state: e, published: t.payload }) | |
); | |
if (t.type === 'MOVE') { | |
if (e.phase === 'DROP_PENDING') return e; | |
yt(e) || B(!1); | |
var C = t.payload.client; | |
return st(C, e.current.client.selection) | |
? e | |
: Ht({ state: e, clientSelection: C, impact: zr(e) ? e.impact : null }); | |
} | |
if (t.type === 'UPDATE_DROPPABLE_SCROLL') { | |
if (e.phase === 'DROP_PENDING' || e.phase === 'COLLECTING') return br(e); | |
yt(e) || B(!1); | |
var S = t.payload, | |
D = S.id, | |
E = S.newScroll, | |
w = e.dimensions.droppables[D]; | |
if (!w) return e; | |
var O = ui(w, E); | |
return vr(e, O, !1); | |
} | |
if (t.type === 'UPDATE_DROPPABLE_IS_ENABLED') { | |
if (e.phase === 'DROP_PENDING') return e; | |
yt(e) || B(!1); | |
var L = t.payload, | |
F = L.id, | |
V = L.isEnabled, | |
A = e.dimensions.droppables[F]; | |
A || B(!1), A.isEnabled === V && B(!1); | |
var R = j({}, A, { isEnabled: V }); | |
return vr(e, R, !0); | |
} | |
if (t.type === 'UPDATE_DROPPABLE_IS_COMBINE_ENABLED') { | |
if (e.phase === 'DROP_PENDING') return e; | |
yt(e) || B(!1); | |
var Y = t.payload, | |
q = Y.id, | |
$ = Y.isCombineEnabled, | |
J = e.dimensions.droppables[q]; | |
J || B(!1), J.isCombineEnabled === $ && B(!1); | |
var ie = j({}, J, { isCombineEnabled: $ }); | |
return vr(e, ie, !0); | |
} | |
if (t.type === 'MOVE_BY_WINDOW_SCROLL') { | |
if (e.phase === 'DROP_PENDING' || e.phase === 'DROP_ANIMATING') return e; | |
yt(e) || B(!1), e.isWindowScrollAllowed || B(!1); | |
var ce = t.payload.newScroll; | |
if (st(e.viewport.scroll.current, ce)) return br(e); | |
var me = el(e.viewport, ce); | |
return zr(e) ? cl({ state: e, viewport: me }) : Ht({ state: e, viewport: me }); | |
} | |
if (t.type === 'UPDATE_VIEWPORT_MAX_SCROLL') { | |
if (!yt(e)) return e; | |
var y = t.payload.maxScroll; | |
if (st(y, e.viewport.scroll.max)) return e; | |
var pe = j({}, e.viewport, { scroll: j({}, e.viewport.scroll, { max: y }) }); | |
return j({ phase: 'DRAGGING' }, e, { viewport: pe }); | |
} | |
if ( | |
t.type === 'MOVE_UP' || | |
t.type === 'MOVE_DOWN' || | |
t.type === 'MOVE_LEFT' || | |
t.type === 'MOVE_RIGHT' | |
) { | |
if (e.phase === 'COLLECTING' || e.phase === 'DROP_PENDING') return e; | |
e.phase !== 'DRAGGING' && B(!1); | |
var k = Wc({ state: e, type: t.type }); | |
return k | |
? Ht({ | |
state: e, | |
impact: k.impact, | |
clientSelection: k.clientSelection, | |
scrollJumpRequest: k.scrollJumpRequest, | |
}) | |
: e; | |
} | |
if (t.type === 'DROP_PENDING') { | |
var v = t.payload.reason; | |
e.phase !== 'COLLECTING' && B(!1); | |
var Q = j({ phase: 'DROP_PENDING' }, e, { phase: 'DROP_PENDING', isWaiting: !0, reason: v }); | |
return Q; | |
} | |
if (t.type === 'DROP_ANIMATE') { | |
var oe = t.payload, | |
ee = oe.completed, | |
he = oe.dropDuration, | |
fe = oe.newHomeClientOffset; | |
e.phase === 'DRAGGING' || e.phase === 'DROP_PENDING' || B(!1); | |
var Le = { | |
phase: 'DROP_ANIMATING', | |
completed: ee, | |
dropDuration: he, | |
newHomeClientOffset: fe, | |
dimensions: e.dimensions, | |
}; | |
return Le; | |
} | |
if (t.type === 'DROP_COMPLETE') { | |
var Se = t.payload.completed; | |
return { phase: 'IDLE', completed: Se, shouldFlush: !1 }; | |
} | |
return e; | |
}, | |
ud = function (t) { | |
return { type: 'BEFORE_INITIAL_CAPTURE', payload: t }; | |
}, | |
cd = function (t) { | |
return { type: 'LIFT', payload: t }; | |
}, | |
dd = function (t) { | |
return { type: 'INITIAL_PUBLISH', payload: t }; | |
}, | |
pd = function (t) { | |
return { type: 'PUBLISH_WHILE_DRAGGING', payload: t }; | |
}, | |
fd = function () { | |
return { type: 'COLLECTION_STARTING', payload: null }; | |
}, | |
gd = function (t) { | |
return { type: 'UPDATE_DROPPABLE_SCROLL', payload: t }; | |
}, | |
md = function (t) { | |
return { type: 'UPDATE_DROPPABLE_IS_ENABLED', payload: t }; | |
}, | |
hd = function (t) { | |
return { type: 'UPDATE_DROPPABLE_IS_COMBINE_ENABLED', payload: t }; | |
}, | |
pl = function (t) { | |
return { type: 'MOVE', payload: t }; | |
}, | |
vd = function (t) { | |
return { type: 'MOVE_BY_WINDOW_SCROLL', payload: t }; | |
}, | |
bd = function (t) { | |
return { type: 'UPDATE_VIEWPORT_MAX_SCROLL', payload: t }; | |
}, | |
yd = function () { | |
return { type: 'MOVE_UP', payload: null }; | |
}, | |
xd = function () { | |
return { type: 'MOVE_DOWN', payload: null }; | |
}, | |
wd = function () { | |
return { type: 'MOVE_RIGHT', payload: null }; | |
}, | |
Sd = function () { | |
return { type: 'MOVE_LEFT', payload: null }; | |
}, | |
vi = function () { | |
return { type: 'FLUSH', payload: null }; | |
}, | |
Cd = function (t) { | |
return { type: 'DROP_ANIMATE', payload: t }; | |
}, | |
bi = function (t) { | |
return { type: 'DROP_COMPLETE', payload: t }; | |
}, | |
fl = function (t) { | |
return { type: 'DROP', payload: t }; | |
}, | |
Dd = function (t) { | |
return { type: 'DROP_PENDING', payload: t }; | |
}, | |
gl = function () { | |
return { type: 'DROP_ANIMATION_FINISHED', payload: null }; | |
}, | |
Id = function (e) { | |
return function (t) { | |
var n = t.getState, | |
r = t.dispatch; | |
return function (i) { | |
return function (a) { | |
if (a.type !== 'LIFT') { | |
i(a); | |
return; | |
} | |
var o = a.payload, | |
l = o.id, | |
s = o.clientSelection, | |
c = o.movementMode, | |
d = n(); | |
d.phase === 'DROP_ANIMATING' && r(bi({ completed: d.completed })), | |
n().phase !== 'IDLE' && B(!1), | |
r(vi()), | |
r(ud({ draggableId: l, movementMode: c })); | |
var u = { shouldPublishImmediately: c === 'SNAP' }, | |
f = { draggableId: l, scrollOptions: u }, | |
p = e.startPublishing(f), | |
m = p.critical, | |
h = p.dimensions, | |
x = p.viewport; | |
r(dd({ critical: m, dimensions: h, clientSelection: s, movementMode: c, viewport: x })); | |
}; | |
}; | |
}; | |
}, | |
kd = function (e) { | |
return function () { | |
return function (t) { | |
return function (n) { | |
n.type === 'INITIAL_PUBLISH' && e.dragging(), | |
n.type === 'DROP_ANIMATE' && e.dropping(n.payload.completed.result.reason), | |
(n.type === 'FLUSH' || n.type === 'DROP_COMPLETE') && e.resting(), | |
t(n); | |
}; | |
}; | |
}; | |
}, | |
yi = { outOfTheWay: 'cubic-bezier(0.2, 0, 0, 1)', drop: 'cubic-bezier(.2,1,.1,1)' }, | |
Xt = { opacity: { drop: 0, combining: 0.7 }, scale: { drop: 0.75 } }, | |
xi = { outOfTheWay: 0.2, minDropTime: 0.33, maxDropTime: 0.55 }, | |
vt = xi.outOfTheWay + 's ' + yi.outOfTheWay, | |
Ut = { | |
fluid: 'opacity ' + vt, | |
snap: 'transform ' + vt + ', opacity ' + vt, | |
drop: function (t) { | |
var n = t + 's ' + yi.drop; | |
return 'transform ' + n + ', opacity ' + n; | |
}, | |
outOfTheWay: 'transform ' + vt, | |
placeholder: 'height ' + vt + ', width ' + vt + ', margin ' + vt, | |
}, | |
pa = function (t) { | |
return st(t, be) ? null : 'translate(' + t.x + 'px, ' + t.y + 'px)'; | |
}, | |
$r = { | |
moveTo: pa, | |
drop: function (t, n) { | |
var r = pa(t); | |
return r ? (n ? r + ' scale(' + Xt.scale.drop + ')' : r) : null; | |
}, | |
}, | |
Hr = xi.minDropTime, | |
ml = xi.maxDropTime, | |
Ed = ml - Hr, | |
fa = 1500, | |
Pd = 0.6, | |
Ad = function (e) { | |
var t = e.current, | |
n = e.destination, | |
r = e.reason, | |
i = Kt(t, n); | |
if (i <= 0) return Hr; | |
if (i >= fa) return ml; | |
var a = i / fa, | |
o = Hr + Ed * a, | |
l = r === 'CANCEL' ? o * Pd : o; | |
return Number(l.toFixed(2)); | |
}, | |
Nd = function (e) { | |
var t = e.impact, | |
n = e.draggable, | |
r = e.dimensions, | |
i = e.viewport, | |
a = e.afterCritical, | |
o = r.draggables, | |
l = r.droppables, | |
s = Be(t), | |
c = s ? l[s] : null, | |
d = l[n.descriptor.droppableId], | |
u = ul({ | |
impact: t, | |
draggable: n, | |
draggables: o, | |
afterCritical: a, | |
droppable: c || d, | |
viewport: i, | |
}), | |
f = Oe(u, n.client.borderBox.center); | |
return f; | |
}, | |
Od = function (e) { | |
var t = e.draggables, | |
n = e.reason, | |
r = e.lastImpact, | |
i = e.home, | |
a = e.viewport, | |
o = e.onLiftImpact; | |
if (!r.at || n !== 'DROP') { | |
var l = sl({ draggables: t, impact: o, destination: i, viewport: a, forceShouldAnimate: !0 }); | |
return { impact: l, didDropInsideDroppable: !1 }; | |
} | |
if (r.at.type === 'REORDER') return { impact: r, didDropInsideDroppable: !0 }; | |
var s = j({}, r, { displaced: Yt }); | |
return { impact: s, didDropInsideDroppable: !0 }; | |
}, | |
Td = function (e) { | |
var t = e.getState, | |
n = e.dispatch; | |
return function (r) { | |
return function (i) { | |
if (i.type !== 'DROP') { | |
r(i); | |
return; | |
} | |
var a = t(), | |
o = i.payload.reason; | |
if (a.phase === 'COLLECTING') { | |
n(Dd({ reason: o })); | |
return; | |
} | |
if (a.phase !== 'IDLE') { | |
var l = a.phase === 'DROP_PENDING' && a.isWaiting; | |
l && B(!1), a.phase === 'DRAGGING' || a.phase === 'DROP_PENDING' || B(!1); | |
var s = a.critical, | |
c = a.dimensions, | |
d = c.draggables[a.critical.draggable.id], | |
u = Od({ | |
reason: o, | |
lastImpact: a.impact, | |
afterCritical: a.afterCritical, | |
onLiftImpact: a.onLiftImpact, | |
home: a.dimensions.droppables[a.critical.droppable.id], | |
viewport: a.viewport, | |
draggables: a.dimensions.draggables, | |
}), | |
f = u.impact, | |
p = u.didDropInsideDroppable, | |
m = p ? di(f) : null, | |
h = p ? Yn(f) : null, | |
x = { index: s.draggable.index, droppableId: s.droppable.id }, | |
b = { | |
draggableId: d.descriptor.id, | |
type: d.descriptor.type, | |
source: x, | |
reason: o, | |
mode: a.movementMode, | |
destination: m, | |
combine: h, | |
}, | |
C = Nd({ | |
impact: f, | |
draggable: d, | |
dimensions: c, | |
viewport: a.viewport, | |
afterCritical: a.afterCritical, | |
}), | |
S = { critical: a.critical, afterCritical: a.afterCritical, result: b, impact: f }, | |
D = !st(a.current.client.offset, C) || !!b.combine; | |
if (!D) { | |
n(bi({ completed: S })); | |
return; | |
} | |
var E = Ad({ current: a.current.client.offset, destination: C, reason: o }), | |
w = { newHomeClientOffset: C, dropDuration: E, completed: S }; | |
n(Cd(w)); | |
} | |
}; | |
}; | |
}, | |
hl = function () { | |
return { x: window.pageXOffset, y: window.pageYOffset }; | |
}; | |
function Bd(e) { | |
return { | |
eventName: 'scroll', | |
options: { passive: !0, capture: !1 }, | |
fn: function (n) { | |
(n.target !== window && n.target !== window.document) || e(); | |
}, | |
}; | |
} | |
function Rd(e) { | |
var t = e.onWindowScroll; | |
function n() { | |
t(hl()); | |
} | |
var r = Vt(n), | |
i = Bd(r), | |
a = lt; | |
function o() { | |
return a !== lt; | |
} | |
function l() { | |
o() && B(!1), (a = ze(window, [i])); | |
} | |
function s() { | |
o() || B(!1), r.cancel(), a(), (a = lt); | |
} | |
return { start: l, stop: s, isActive: o }; | |
} | |
var Fd = function (t) { | |
return t.type === 'DROP_COMPLETE' || t.type === 'DROP_ANIMATE' || t.type === 'FLUSH'; | |
}, | |
Ld = function (e) { | |
var t = Rd({ | |
onWindowScroll: function (r) { | |
e.dispatch(vd({ newScroll: r })); | |
}, | |
}); | |
return function (n) { | |
return function (r) { | |
!t.isActive() && r.type === 'INITIAL_PUBLISH' && t.start(), | |
t.isActive() && Fd(r) && t.stop(), | |
n(r); | |
}; | |
}; | |
}, | |
Md = function (e) { | |
var t = !1, | |
n = !1, | |
r = setTimeout(function () { | |
n = !0; | |
}), | |
i = function (o) { | |
t || n || ((t = !0), e(o), clearTimeout(r)); | |
}; | |
return ( | |
(i.wasCalled = function () { | |
return t; | |
}), | |
i | |
); | |
}, | |
jd = function () { | |
var e = [], | |
t = function (a) { | |
var o = ci(e, function (c) { | |
return c.timerId === a; | |
}); | |
o === -1 && B(!1); | |
var l = e.splice(o, 1), | |
s = l[0]; | |
s.callback(); | |
}, | |
n = function (a) { | |
var o = setTimeout(function () { | |
return t(o); | |
}), | |
l = { timerId: o, callback: a }; | |
e.push(l); | |
}, | |
r = function () { | |
if (e.length) { | |
var a = [].concat(e); | |
(e.length = 0), | |
a.forEach(function (o) { | |
clearTimeout(o.timerId), o.callback(); | |
}); | |
} | |
}; | |
return { add: n, flush: r }; | |
}, | |
zd = function (t, n) { | |
return t == null && n == null | |
? !0 | |
: t == null || n == null | |
? !1 | |
: t.droppableId === n.droppableId && t.index === n.index; | |
}, | |
$d = function (t, n) { | |
return t == null && n == null | |
? !0 | |
: t == null || n == null | |
? !1 | |
: t.draggableId === n.draggableId && t.droppableId === n.droppableId; | |
}, | |
Hd = function (t, n) { | |
if (t === n) return !0; | |
var r = | |
t.draggable.id === n.draggable.id && | |
t.draggable.droppableId === n.draggable.droppableId && | |
t.draggable.type === n.draggable.type && | |
t.draggable.index === n.draggable.index, | |
i = t.droppable.id === n.droppable.id && t.droppable.type === n.droppable.type; | |
return r && i; | |
}, | |
Mt = function (t, n) { | |
n(); | |
}, | |
gn = function (t, n) { | |
return { | |
draggableId: t.draggable.id, | |
type: t.droppable.type, | |
source: { droppableId: t.droppable.id, index: t.draggable.index }, | |
mode: n, | |
}; | |
}, | |
yr = function (t, n, r, i) { | |
if (!t) { | |
r(i(n)); | |
return; | |
} | |
var a = Md(r), | |
o = { announce: a }; | |
t(n, o), a.wasCalled() || r(i(n)); | |
}, | |
Ud = function (e, t) { | |
var n = jd(), | |
r = null, | |
i = function (f, p) { | |
r && B(!1), | |
Mt('onBeforeCapture', function () { | |
var m = e().onBeforeCapture; | |
if (m) { | |
var h = { draggableId: f, mode: p }; | |
m(h); | |
} | |
}); | |
}, | |
a = function (f, p) { | |
r && B(!1), | |
Mt('onBeforeDragStart', function () { | |
var m = e().onBeforeDragStart; | |
m && m(gn(f, p)); | |
}); | |
}, | |
o = function (f, p) { | |
r && B(!1); | |
var m = gn(f, p); | |
(r = { mode: p, lastCritical: f, lastLocation: m.source, lastCombine: null }), | |
n.add(function () { | |
Mt('onDragStart', function () { | |
return yr(e().onDragStart, m, t, wn.onDragStart); | |
}); | |
}); | |
}, | |
l = function (f, p) { | |
var m = di(p), | |
h = Yn(p); | |
r || B(!1); | |
var x = !Hd(f, r.lastCritical); | |
x && (r.lastCritical = f); | |
var b = !zd(r.lastLocation, m); | |
b && (r.lastLocation = m); | |
var C = !$d(r.lastCombine, h); | |
if ((C && (r.lastCombine = h), !(!x && !b && !C))) { | |
var S = j({}, gn(f, r.mode), { combine: h, destination: m }); | |
n.add(function () { | |
Mt('onDragUpdate', function () { | |
return yr(e().onDragUpdate, S, t, wn.onDragUpdate); | |
}); | |
}); | |
} | |
}, | |
s = function () { | |
r || B(!1), n.flush(); | |
}, | |
c = function (f) { | |
r || B(!1), | |
(r = null), | |
Mt('onDragEnd', function () { | |
return yr(e().onDragEnd, f, t, wn.onDragEnd); | |
}); | |
}, | |
d = function () { | |
if (r) { | |
var f = j({}, gn(r.lastCritical, r.mode), { | |
combine: null, | |
destination: null, | |
reason: 'CANCEL', | |
}); | |
c(f); | |
} | |
}; | |
return { beforeCapture: i, beforeStart: a, start: o, update: l, flush: s, drop: c, abort: d }; | |
}, | |
Gd = function (e, t) { | |
var n = Ud(e, t); | |
return function (r) { | |
return function (i) { | |
return function (a) { | |
if (a.type === 'BEFORE_INITIAL_CAPTURE') { | |
n.beforeCapture(a.payload.draggableId, a.payload.movementMode); | |
return; | |
} | |
if (a.type === 'INITIAL_PUBLISH') { | |
var o = a.payload.critical; | |
n.beforeStart(o, a.payload.movementMode), i(a), n.start(o, a.payload.movementMode); | |
return; | |
} | |
if (a.type === 'DROP_COMPLETE') { | |
var l = a.payload.completed.result; | |
n.flush(), i(a), n.drop(l); | |
return; | |
} | |
if ((i(a), a.type === 'FLUSH')) { | |
n.abort(); | |
return; | |
} | |
var s = r.getState(); | |
s.phase === 'DRAGGING' && n.update(s.critical, s.impact); | |
}; | |
}; | |
}; | |
}, | |
Wd = function (e) { | |
return function (t) { | |
return function (n) { | |
if (n.type !== 'DROP_ANIMATION_FINISHED') { | |
t(n); | |
return; | |
} | |
var r = e.getState(); | |
r.phase !== 'DROP_ANIMATING' && B(!1), e.dispatch(bi({ completed: r.completed })); | |
}; | |
}; | |
}, | |
qd = function (e) { | |
var t = null, | |
n = null; | |
function r() { | |
n && (cancelAnimationFrame(n), (n = null)), t && (t(), (t = null)); | |
} | |
return function (i) { | |
return function (a) { | |
if ( | |
((a.type === 'FLUSH' || | |
a.type === 'DROP_COMPLETE' || | |
a.type === 'DROP_ANIMATION_FINISHED') && | |
r(), | |
i(a), | |
a.type === 'DROP_ANIMATE') | |
) { | |
var o = { | |
eventName: 'scroll', | |
options: { capture: !0, passive: !1, once: !0 }, | |
fn: function () { | |
var s = e.getState(); | |
s.phase === 'DROP_ANIMATING' && e.dispatch(gl()); | |
}, | |
}; | |
n = requestAnimationFrame(function () { | |
(n = null), (t = ze(window, [o])); | |
}); | |
} | |
}; | |
}; | |
}, | |
Vd = function (e) { | |
return function () { | |
return function (t) { | |
return function (n) { | |
(n.type === 'DROP_COMPLETE' || n.type === 'FLUSH' || n.type === 'DROP_ANIMATE') && | |
e.stopPublishing(), | |
t(n); | |
}; | |
}; | |
}; | |
}, | |
Kd = function (e) { | |
var t = !1; | |
return function () { | |
return function (n) { | |
return function (r) { | |
if (r.type === 'INITIAL_PUBLISH') { | |
(t = !0), | |
e.tryRecordFocus(r.payload.critical.draggable.id), | |
n(r), | |
e.tryRestoreFocusRecorded(); | |
return; | |
} | |
if ((n(r), !!t)) { | |
if (r.type === 'FLUSH') { | |
(t = !1), e.tryRestoreFocusRecorded(); | |
return; | |
} | |
if (r.type === 'DROP_COMPLETE') { | |
t = !1; | |
var i = r.payload.completed.result; | |
i.combine && e.tryShiftRecord(i.draggableId, i.combine.draggableId), | |
e.tryRestoreFocusRecorded(); | |
} | |
} | |
}; | |
}; | |
}; | |
}, | |
Yd = function (t) { | |
return t.type === 'DROP_COMPLETE' || t.type === 'DROP_ANIMATE' || t.type === 'FLUSH'; | |
}, | |
Qd = function (e) { | |
return function (t) { | |
return function (n) { | |
return function (r) { | |
if (Yd(r)) { | |
e.stop(), n(r); | |
return; | |
} | |
if (r.type === 'INITIAL_PUBLISH') { | |
n(r); | |
var i = t.getState(); | |
i.phase !== 'DRAGGING' && B(!1), e.start(i); | |
return; | |
} | |
n(r), e.scroll(t.getState()); | |
}; | |
}; | |
}; | |
}, | |
Xd = function (e) { | |
return function (t) { | |
return function (n) { | |
if ((t(n), n.type === 'PUBLISH_WHILE_DRAGGING')) { | |
var r = e.getState(); | |
r.phase === 'DROP_PENDING' && (r.isWaiting || e.dispatch(fl({ reason: r.reason }))); | |
} | |
}; | |
}; | |
}, | |
Jd = So, | |
_d = function (e) { | |
var t = e.dimensionMarshal, | |
n = e.focusMarshal, | |
r = e.styleMarshal, | |
i = e.getResponders, | |
a = e.announce, | |
o = e.autoScroller; | |
return wo(sd, Jd(Bs(kd(r), Vd(t), Id(t), Td, Wd, qd, Xd, Qd(o), Ld, Kd(n), Gd(i, a)))); | |
}, | |
xr = function () { | |
return { additions: {}, removals: {}, modified: {} }; | |
}; | |
function Zd(e) { | |
var t = e.registry, | |
n = e.callbacks, | |
r = xr(), | |
i = null, | |
a = function () { | |
i || | |
(n.collectionStarting(), | |
(i = requestAnimationFrame(function () { | |
i = null; | |
var d = r, | |
u = d.additions, | |
f = d.removals, | |
p = d.modified, | |
m = Object.keys(u) | |
.map(function (b) { | |
return t.draggable.getById(b).getDimension(be); | |
}) | |
.sort(function (b, C) { | |
return b.descriptor.index - C.descriptor.index; | |
}), | |
h = Object.keys(p).map(function (b) { | |
var C = t.droppable.getById(b), | |
S = C.callbacks.getScrollWhileDragging(); | |
return { droppableId: b, scroll: S }; | |
}), | |
x = { additions: m, removals: Object.keys(f), modified: h }; | |
(r = xr()), n.publish(x); | |
}))); | |
}, | |
o = function (d) { | |
var u = d.descriptor.id; | |
(r.additions[u] = d), | |
(r.modified[d.descriptor.droppableId] = !0), | |
r.removals[u] && delete r.removals[u], | |
a(); | |
}, | |
l = function (d) { | |
var u = d.descriptor; | |
(r.removals[u.id] = !0), | |
(r.modified[u.droppableId] = !0), | |
r.additions[u.id] && delete r.additions[u.id], | |
a(); | |
}, | |
s = function () { | |
i && (cancelAnimationFrame(i), (i = null), (r = xr())); | |
}; | |
return { add: o, remove: l, stop: s }; | |
} | |
var vl = function (e) { | |
var t = e.scrollHeight, | |
n = e.scrollWidth, | |
r = e.height, | |
i = e.width, | |
a = Oe({ x: n, y: t }, { x: i, y: r }), | |
o = { x: Math.max(0, a.x), y: Math.max(0, a.y) }; | |
return o; | |
}, | |
bl = function () { | |
var e = document.documentElement; | |
return e || B(!1), e; | |
}, | |
yl = function () { | |
var e = bl(), | |
t = vl({ | |
scrollHeight: e.scrollHeight, | |
scrollWidth: e.scrollWidth, | |
width: e.clientWidth, | |
height: e.clientHeight, | |
}); | |
return t; | |
}, | |
ep = function () { | |
var e = hl(), | |
t = yl(), | |
n = e.y, | |
r = e.x, | |
i = bl(), | |
a = i.clientWidth, | |
o = i.clientHeight, | |
l = r + a, | |
s = n + o, | |
c = We({ top: n, left: r, right: l, bottom: s }), | |
d = { | |
frame: c, | |
scroll: { initial: e, current: e, max: t, diff: { value: be, displacement: be } }, | |
}; | |
return d; | |
}, | |
tp = function (e) { | |
var t = e.critical, | |
n = e.scrollOptions, | |
r = e.registry, | |
i = ep(), | |
a = i.scroll.current, | |
o = t.droppable, | |
l = r.droppable.getAllByType(o.type).map(function (u) { | |
return u.callbacks.getDimensionAndWatchScroll(a, n); | |
}), | |
s = r.draggable.getAllByType(t.draggable.type).map(function (u) { | |
return u.getDimension(a); | |
}), | |
c = { draggables: Yo(s), droppables: Ko(l) }, | |
d = { dimensions: c, critical: t, viewport: i }; | |
return d; | |
}; | |
function ga(e, t, n) { | |
if (n.descriptor.id === t.id || n.descriptor.type !== t.type) return !1; | |
var r = e.droppable.getById(n.descriptor.droppableId); | |
return r.descriptor.mode === 'virtual'; | |
} | |
var np = function (e, t) { | |
var n = null, | |
r = Zd({ | |
callbacks: { publish: t.publishWhileDragging, collectionStarting: t.collectionStarting }, | |
registry: e, | |
}), | |
i = function (p, m) { | |
e.droppable.exists(p) || B(!1), n && t.updateDroppableIsEnabled({ id: p, isEnabled: m }); | |
}, | |
a = function (p, m) { | |
n && | |
(e.droppable.exists(p) || B(!1), | |
t.updateDroppableIsCombineEnabled({ id: p, isCombineEnabled: m })); | |
}, | |
o = function (p, m) { | |
n && (e.droppable.exists(p) || B(!1), t.updateDroppableScroll({ id: p, newScroll: m })); | |
}, | |
l = function (p, m) { | |
n && e.droppable.getById(p).callbacks.scroll(m); | |
}, | |
s = function () { | |
if (n) { | |
r.stop(); | |
var p = n.critical.droppable; | |
e.droppable.getAllByType(p.type).forEach(function (m) { | |
return m.callbacks.dragStopped(); | |
}), | |
n.unsubscribe(), | |
(n = null); | |
} | |
}, | |
c = function (p) { | |
n || B(!1); | |
var m = n.critical.draggable; | |
p.type === 'ADDITION' && ga(e, m, p.value) && r.add(p.value), | |
p.type === 'REMOVAL' && ga(e, m, p.value) && r.remove(p.value); | |
}, | |
d = function (p) { | |
n && B(!1); | |
var m = e.draggable.getById(p.draggableId), | |
h = e.droppable.getById(m.descriptor.droppableId), | |
x = { draggable: m.descriptor, droppable: h.descriptor }, | |
b = e.subscribe(c); | |
return ( | |
(n = { critical: x, unsubscribe: b }), | |
tp({ critical: x, registry: e, scrollOptions: p.scrollOptions }) | |
); | |
}, | |
u = { | |
updateDroppableIsEnabled: i, | |
updateDroppableIsCombineEnabled: a, | |
scrollDroppable: l, | |
updateDroppableScroll: o, | |
startPublishing: d, | |
stopPublishing: s, | |
}; | |
return u; | |
}, | |
xl = function (e, t) { | |
return e.phase === 'IDLE' | |
? !0 | |
: e.phase !== 'DROP_ANIMATING' || e.completed.result.draggableId === t | |
? !1 | |
: e.completed.result.reason === 'DROP'; | |
}, | |
rp = function (e) { | |
window.scrollBy(e.x, e.y); | |
}, | |
ip = ve(function (e) { | |
return Kn(e).filter(function (t) { | |
return !(!t.isEnabled || !t.frame); | |
}); | |
}), | |
ap = function (t, n) { | |
var r = dt(ip(n), function (i) { | |
return i.frame || B(!1), il(i.frame.pageMarginBox)(t); | |
}); | |
return r; | |
}, | |
op = function (e) { | |
var t = e.center, | |
n = e.destination, | |
r = e.droppables; | |
if (n) { | |
var i = r[n]; | |
return i.frame ? i : null; | |
} | |
var a = ap(t, r); | |
return a; | |
}, | |
ut = { | |
startFromPercentage: 0.25, | |
maxScrollAtPercentage: 0.05, | |
maxPixelScroll: 28, | |
ease: function (t) { | |
return Math.pow(t, 2); | |
}, | |
durationDampening: { stopDampeningAt: 1200, accelerateAt: 360 }, | |
}, | |
lp = function (e, t) { | |
var n = e[t.size] * ut.startFromPercentage, | |
r = e[t.size] * ut.maxScrollAtPercentage, | |
i = { startScrollingFrom: n, maxScrollValueAt: r }; | |
return i; | |
}, | |
wl = function (e) { | |
var t = e.startOfRange, | |
n = e.endOfRange, | |
r = e.current, | |
i = n - t; | |
if (i === 0) return 0; | |
var a = r - t, | |
o = a / i; | |
return o; | |
}, | |
wi = 1, | |
sp = function (e, t) { | |
if (e > t.startScrollingFrom) return 0; | |
if (e <= t.maxScrollValueAt) return ut.maxPixelScroll; | |
if (e === t.startScrollingFrom) return wi; | |
var n = wl({ startOfRange: t.maxScrollValueAt, endOfRange: t.startScrollingFrom, current: e }), | |
r = 1 - n, | |
i = ut.maxPixelScroll * ut.ease(r); | |
return Math.ceil(i); | |
}, | |
ma = ut.durationDampening.accelerateAt, | |
ha = ut.durationDampening.stopDampeningAt, | |
up = function (e, t) { | |
var n = t, | |
r = ha, | |
i = Date.now(), | |
a = i - n; | |
if (a >= ha) return e; | |
if (a < ma) return wi; | |
var o = wl({ startOfRange: ma, endOfRange: r, current: a }), | |
l = e * ut.ease(o); | |
return Math.ceil(l); | |
}, | |
va = function (e) { | |
var t = e.distanceToEdge, | |
n = e.thresholds, | |
r = e.dragStartTime, | |
i = e.shouldUseTimeDampening, | |
a = sp(t, n); | |
return a === 0 ? 0 : i ? Math.max(up(a, r), wi) : a; | |
}, | |
ba = function (e) { | |
var t = e.container, | |
n = e.distanceToEdges, | |
r = e.dragStartTime, | |
i = e.axis, | |
a = e.shouldUseTimeDampening, | |
o = lp(t, i), | |
l = n[i.end] < n[i.start]; | |
return l | |
? va({ distanceToEdge: n[i.end], thresholds: o, dragStartTime: r, shouldUseTimeDampening: a }) | |
: -1 * | |
va({ | |
distanceToEdge: n[i.start], | |
thresholds: o, | |
dragStartTime: r, | |
shouldUseTimeDampening: a, | |
}); | |
}, | |
cp = function (e) { | |
var t = e.container, | |
n = e.subject, | |
r = e.proposedScroll, | |
i = n.height > t.height, | |
a = n.width > t.width; | |
return !a && !i ? r : a && i ? null : { x: a ? 0 : r.x, y: i ? 0 : r.y }; | |
}, | |
dp = qo(function (e) { | |
return e === 0 ? 0 : e; | |
}), | |
Sl = function (e) { | |
var t = e.dragStartTime, | |
n = e.container, | |
r = e.subject, | |
i = e.center, | |
a = e.shouldUseTimeDampening, | |
o = { top: i.y - n.top, right: n.right - i.x, bottom: n.bottom - i.y, left: i.x - n.left }, | |
l = ba({ | |
container: n, | |
distanceToEdges: o, | |
dragStartTime: t, | |
axis: pi, | |
shouldUseTimeDampening: a, | |
}), | |
s = ba({ | |
container: n, | |
distanceToEdges: o, | |
dragStartTime: t, | |
axis: Jo, | |
shouldUseTimeDampening: a, | |
}), | |
c = dp({ x: s, y: l }); | |
if (st(c, be)) return null; | |
var d = cp({ container: n, subject: r, proposedScroll: c }); | |
return d ? (st(d, be) ? null : d) : null; | |
}, | |
pp = qo(function (e) { | |
return e === 0 ? 0 : e > 0 ? 1 : -1; | |
}), | |
Si = (function () { | |
var e = function (n, r) { | |
return n < 0 ? n : n > r ? n - r : 0; | |
}; | |
return function (t) { | |
var n = t.current, | |
r = t.max, | |
i = t.change, | |
a = we(n, i), | |
o = { x: e(a.x, r.x), y: e(a.y, r.y) }; | |
return st(o, be) ? null : o; | |
}; | |
})(), | |
Cl = function (t) { | |
var n = t.max, | |
r = t.current, | |
i = t.change, | |
a = { x: Math.max(r.x, n.x), y: Math.max(r.y, n.y) }, | |
o = pp(i), | |
l = Si({ max: a, current: r, change: o }); | |
return !l || (o.x !== 0 && l.x === 0) || (o.y !== 0 && l.y === 0); | |
}, | |
Ci = function (t, n) { | |
return Cl({ current: t.scroll.current, max: t.scroll.max, change: n }); | |
}, | |
fp = function (t, n) { | |
if (!Ci(t, n)) return null; | |
var r = t.scroll.max, | |
i = t.scroll.current; | |
return Si({ current: i, max: r, change: n }); | |
}, | |
Di = function (t, n) { | |
var r = t.frame; | |
return r ? Cl({ current: r.scroll.current, max: r.scroll.max, change: n }) : !1; | |
}, | |
gp = function (t, n) { | |
var r = t.frame; | |
return !r || !Di(t, n) ? null : Si({ current: r.scroll.current, max: r.scroll.max, change: n }); | |
}, | |
mp = function (e) { | |
var t = e.viewport, | |
n = e.subject, | |
r = e.center, | |
i = e.dragStartTime, | |
a = e.shouldUseTimeDampening, | |
o = Sl({ | |
dragStartTime: i, | |
container: t.frame, | |
subject: n, | |
center: r, | |
shouldUseTimeDampening: a, | |
}); | |
return o && Ci(t, o) ? o : null; | |
}, | |
hp = function (e) { | |
var t = e.droppable, | |
n = e.subject, | |
r = e.center, | |
i = e.dragStartTime, | |
a = e.shouldUseTimeDampening, | |
o = t.frame; | |
if (!o) return null; | |
var l = Sl({ | |
dragStartTime: i, | |
container: o.pageMarginBox, | |
subject: n, | |
center: r, | |
shouldUseTimeDampening: a, | |
}); | |
return l && Di(t, l) ? l : null; | |
}, | |
ya = function (e) { | |
var t = e.state, | |
n = e.dragStartTime, | |
r = e.shouldUseTimeDampening, | |
i = e.scrollWindow, | |
a = e.scrollDroppable, | |
o = t.current.page.borderBoxCenter, | |
l = t.dimensions.draggables[t.critical.draggable.id], | |
s = l.page.marginBox; | |
if (t.isWindowScrollAllowed) { | |
var c = t.viewport, | |
d = mp({ dragStartTime: n, viewport: c, subject: s, center: o, shouldUseTimeDampening: r }); | |
if (d) { | |
i(d); | |
return; | |
} | |
} | |
var u = op({ center: o, destination: Be(t.impact), droppables: t.dimensions.droppables }); | |
if (u) { | |
var f = hp({ | |
dragStartTime: n, | |
droppable: u, | |
subject: s, | |
center: o, | |
shouldUseTimeDampening: r, | |
}); | |
f && a(u.descriptor.id, f); | |
} | |
}, | |
vp = function (e) { | |
var t = e.scrollWindow, | |
n = e.scrollDroppable, | |
r = Vt(t), | |
i = Vt(n), | |
a = null, | |
o = function (d) { | |
a || B(!1); | |
var u = a, | |
f = u.shouldUseTimeDampening, | |
p = u.dragStartTime; | |
ya({ | |
state: d, | |
scrollWindow: r, | |
scrollDroppable: i, | |
dragStartTime: p, | |
shouldUseTimeDampening: f, | |
}); | |
}, | |
l = function (d) { | |
a && B(!1); | |
var u = Date.now(), | |
f = !1, | |
p = function () { | |
f = !0; | |
}; | |
ya({ | |
state: d, | |
dragStartTime: 0, | |
shouldUseTimeDampening: !1, | |
scrollWindow: p, | |
scrollDroppable: p, | |
}), | |
(a = { dragStartTime: u, shouldUseTimeDampening: f }), | |
f && o(d); | |
}, | |
s = function () { | |
a && (r.cancel(), i.cancel(), (a = null)); | |
}; | |
return { start: l, stop: s, scroll: o }; | |
}, | |
bp = function (e) { | |
var t = e.move, | |
n = e.scrollDroppable, | |
r = e.scrollWindow, | |
i = function (c, d) { | |
var u = we(c.current.client.selection, d); | |
t({ client: u }); | |
}, | |
a = function (c, d) { | |
if (!Di(c, d)) return d; | |
var u = gp(c, d); | |
if (!u) return n(c.descriptor.id, d), null; | |
var f = Oe(d, u); | |
n(c.descriptor.id, f); | |
var p = Oe(d, f); | |
return p; | |
}, | |
o = function (c, d, u) { | |
if (!c || !Ci(d, u)) return u; | |
var f = fp(d, u); | |
if (!f) return r(u), null; | |
var p = Oe(u, f); | |
r(p); | |
var m = Oe(u, p); | |
return m; | |
}, | |
l = function (c) { | |
var d = c.scrollJumpRequest; | |
if (d) { | |
var u = Be(c.impact); | |
u || B(!1); | |
var f = a(c.dimensions.droppables[u], d); | |
if (f) { | |
var p = c.viewport, | |
m = o(c.isWindowScrollAllowed, p, f); | |
m && i(c, m); | |
} | |
} | |
}; | |
return l; | |
}, | |
yp = function (e) { | |
var t = e.scrollDroppable, | |
n = e.scrollWindow, | |
r = e.move, | |
i = vp({ scrollWindow: n, scrollDroppable: t }), | |
a = bp({ move: r, scrollWindow: n, scrollDroppable: t }), | |
o = function (c) { | |
if (c.phase === 'DRAGGING') { | |
if (c.movementMode === 'FLUID') { | |
i.scroll(c); | |
return; | |
} | |
c.scrollJumpRequest && a(c); | |
} | |
}, | |
l = { scroll: o, start: i.start, stop: i.stop }; | |
return l; | |
}, | |
Pt = 'data-rbd', | |
At = (function () { | |
var e = Pt + '-drag-handle'; | |
return { base: e, draggableId: e + '-draggable-id', contextId: e + '-context-id' }; | |
})(), | |
Ur = (function () { | |
var e = Pt + '-draggable'; | |
return { base: e, contextId: e + '-context-id', id: e + '-id' }; | |
})(), | |
xp = (function () { | |
var e = Pt + '-droppable'; | |
return { base: e, contextId: e + '-context-id', id: e + '-id' }; | |
})(), | |
xa = { contextId: Pt + '-scroll-container-context-id' }, | |
wp = function (t) { | |
return function (n) { | |
return '[' + n + '="' + t + '"]'; | |
}; | |
}, | |
jt = function (t, n) { | |
return t | |
.map(function (r) { | |
var i = r.styles[n]; | |
return i ? r.selector + ' { ' + i + ' }' : ''; | |
}) | |
.join(' '); | |
}, | |
Sp = 'pointer-events: none;', | |
Cp = function (e) { | |
var t = wp(e), | |
n = (function () { | |
var l = ` | |
cursor: -webkit-grab; | |
cursor: grab; | |
`; | |
return { | |
selector: t(At.contextId), | |
styles: { | |
always: ` | |
-webkit-touch-callout: none; | |
-webkit-tap-highlight-color: rgba(0,0,0,0); | |
touch-action: manipulation; | |
`, | |
resting: l, | |
dragging: Sp, | |
dropAnimating: l, | |
}, | |
}; | |
})(), | |
r = (function () { | |
var l = | |
` | |
transition: ` + | |
Ut.outOfTheWay + | |
`; | |
`; | |
return { | |
selector: t(Ur.contextId), | |
styles: { dragging: l, dropAnimating: l, userCancel: l }, | |
}; | |
})(), | |
i = { selector: t(xp.contextId), styles: { always: 'overflow-anchor: none;' } }, | |
a = { | |
selector: 'body', | |
styles: { | |
dragging: ` | |
cursor: grabbing; | |
cursor: -webkit-grabbing; | |
user-select: none; | |
-webkit-user-select: none; | |
-moz-user-select: none; | |
-ms-user-select: none; | |
overflow-anchor: none; | |
`, | |
}, | |
}, | |
o = [r, n, i, a]; | |
return { | |
always: jt(o, 'always'), | |
resting: jt(o, 'resting'), | |
dragging: jt(o, 'dragging'), | |
dropAnimating: jt(o, 'dropAnimating'), | |
userCancel: jt(o, 'userCancel'), | |
}; | |
}, | |
Re = | |
typeof window < 'u' && | |
typeof window.document < 'u' && | |
typeof window.document.createElement < 'u' | |
? N.useLayoutEffect | |
: N.useEffect, | |
wr = function () { | |
var t = document.querySelector('head'); | |
return t || B(!1), t; | |
}, | |
wa = function (t) { | |
var n = document.createElement('style'); | |
return t && n.setAttribute('nonce', t), (n.type = 'text/css'), n; | |
}; | |
function Dp(e, t) { | |
var n = X( | |
function () { | |
return Cp(e); | |
}, | |
[e] | |
), | |
r = N.useRef(null), | |
i = N.useRef(null), | |
a = M( | |
ve(function (u) { | |
var f = i.current; | |
f || B(!1), (f.textContent = u); | |
}), | |
[] | |
), | |
o = M(function (u) { | |
var f = r.current; | |
f || B(!1), (f.textContent = u); | |
}, []); | |
Re( | |
function () { | |
(!r.current && !i.current) || B(!1); | |
var u = wa(t), | |
f = wa(t); | |
return ( | |
(r.current = u), | |
(i.current = f), | |
u.setAttribute(Pt + '-always', e), | |
f.setAttribute(Pt + '-dynamic', e), | |
wr().appendChild(u), | |
wr().appendChild(f), | |
o(n.always), | |
a(n.resting), | |
function () { | |
var p = function (h) { | |
var x = h.current; | |
x || B(!1), wr().removeChild(x), (h.current = null); | |
}; | |
p(r), p(i); | |
} | |
); | |
}, | |
[t, o, a, n.always, n.resting, e] | |
); | |
var l = M( | |
function () { | |
return a(n.dragging); | |
}, | |
[a, n.dragging] | |
), | |
s = M( | |
function (u) { | |
if (u === 'DROP') { | |
a(n.dropAnimating); | |
return; | |
} | |
a(n.userCancel); | |
}, | |
[a, n.dropAnimating, n.userCancel] | |
), | |
c = M( | |
function () { | |
i.current && a(n.resting); | |
}, | |
[a, n.resting] | |
), | |
d = X( | |
function () { | |
return { dragging: l, dropping: s, resting: c }; | |
}, | |
[l, s, c] | |
); | |
return d; | |
} | |
var Dl = function (e) { | |
return e && e.ownerDocument ? e.ownerDocument.defaultView : window; | |
}; | |
function Jn(e) { | |
return e instanceof Dl(e).HTMLElement; | |
} | |
function Ip(e, t) { | |
var n = '[' + At.contextId + '="' + e + '"]', | |
r = Vo(document.querySelectorAll(n)); | |
if (!r.length) return null; | |
var i = dt(r, function (a) { | |
return a.getAttribute(At.draggableId) === t; | |
}); | |
return !i || !Jn(i) ? null : i; | |
} | |
function kp(e) { | |
var t = N.useRef({}), | |
n = N.useRef(null), | |
r = N.useRef(null), | |
i = N.useRef(!1), | |
a = M(function (f, p) { | |
var m = { id: f, focus: p }; | |
return ( | |
(t.current[f] = m), | |
function () { | |
var x = t.current, | |
b = x[f]; | |
b !== m && delete x[f]; | |
} | |
); | |
}, []), | |
o = M( | |
function (f) { | |
var p = Ip(e, f); | |
p && p !== document.activeElement && p.focus(); | |
}, | |
[e] | |
), | |
l = M(function (f, p) { | |
n.current === f && (n.current = p); | |
}, []), | |
s = M( | |
function () { | |
r.current || | |
(i.current && | |
(r.current = requestAnimationFrame(function () { | |
r.current = null; | |
var f = n.current; | |
f && o(f); | |
}))); | |
}, | |
[o] | |
), | |
c = M(function (f) { | |
n.current = null; | |
var p = document.activeElement; | |
p && p.getAttribute(At.draggableId) === f && (n.current = f); | |
}, []); | |
Re(function () { | |
return ( | |
(i.current = !0), | |
function () { | |
i.current = !1; | |
var f = r.current; | |
f && cancelAnimationFrame(f); | |
} | |
); | |
}, []); | |
var d = X( | |
function () { | |
return { register: a, tryRecordFocus: c, tryRestoreFocusRecorded: s, tryShiftRecord: l }; | |
}, | |
[a, c, s, l] | |
); | |
return d; | |
} | |
function Ep() { | |
var e = { draggables: {}, droppables: {} }, | |
t = []; | |
function n(u) { | |
return ( | |
t.push(u), | |
function () { | |
var p = t.indexOf(u); | |
p !== -1 && t.splice(p, 1); | |
} | |
); | |
} | |
function r(u) { | |
t.length && | |
t.forEach(function (f) { | |
return f(u); | |
}); | |
} | |
function i(u) { | |
return e.draggables[u] || null; | |
} | |
function a(u) { | |
var f = i(u); | |
return f || B(!1), f; | |
} | |
var o = { | |
register: function (f) { | |
(e.draggables[f.descriptor.id] = f), r({ type: 'ADDITION', value: f }); | |
}, | |
update: function (f, p) { | |
var m = e.draggables[p.descriptor.id]; | |
m && | |
m.uniqueId === f.uniqueId && | |
(delete e.draggables[p.descriptor.id], (e.draggables[f.descriptor.id] = f)); | |
}, | |
unregister: function (f) { | |
var p = f.descriptor.id, | |
m = i(p); | |
m && f.uniqueId === m.uniqueId && (delete e.draggables[p], r({ type: 'REMOVAL', value: f })); | |
}, | |
getById: a, | |
findById: i, | |
exists: function (f) { | |
return !!i(f); | |
}, | |
getAllByType: function (f) { | |
return An(e.draggables).filter(function (p) { | |
return p.descriptor.type === f; | |
}); | |
}, | |
}; | |
function l(u) { | |
return e.droppables[u] || null; | |
} | |
function s(u) { | |
var f = l(u); | |
return f || B(!1), f; | |
} | |
var c = { | |
register: function (f) { | |
e.droppables[f.descriptor.id] = f; | |
}, | |
unregister: function (f) { | |
var p = l(f.descriptor.id); | |
p && f.uniqueId === p.uniqueId && delete e.droppables[f.descriptor.id]; | |
}, | |
getById: s, | |
findById: l, | |
exists: function (f) { | |
return !!l(f); | |
}, | |
getAllByType: function (f) { | |
return An(e.droppables).filter(function (p) { | |
return p.descriptor.type === f; | |
}); | |
}, | |
}; | |
function d() { | |
(e.draggables = {}), (e.droppables = {}), (t.length = 0); | |
} | |
return { draggable: o, droppable: c, subscribe: n, clean: d }; | |
} | |
function Pp() { | |
var e = X(Ep, []); | |
return ( | |
N.useEffect( | |
function () { | |
return function () { | |
requestAnimationFrame(e.clean); | |
}; | |
}, | |
[e] | |
), | |
e | |
); | |
} | |
var Ii = _.createContext(null), | |
On = function () { | |
var e = document.body; | |
return e || B(!1), e; | |
}, | |
Ap = { | |
position: 'absolute', | |
width: '1px', | |
height: '1px', | |
margin: '-1px', | |
border: '0', | |
padding: '0', | |
overflow: 'hidden', | |
clip: 'rect(0 0 0 0)', | |
'clip-path': 'inset(100%)', | |
}, | |
Np = function (t) { | |
return 'rbd-announcement-' + t; | |
}; | |
function Op(e) { | |
var t = X( | |
function () { | |
return Np(e); | |
}, | |
[e] | |
), | |
n = N.useRef(null); | |
N.useEffect( | |
function () { | |
var a = document.createElement('div'); | |
return ( | |
(n.current = a), | |
(a.id = t), | |
a.setAttribute('aria-live', 'assertive'), | |
a.setAttribute('aria-atomic', 'true'), | |
j(a.style, Ap), | |
On().appendChild(a), | |
function () { | |
setTimeout(function () { | |
var s = On(); | |
s.contains(a) && s.removeChild(a), a === n.current && (n.current = null); | |
}); | |
} | |
); | |
}, | |
[t] | |
); | |
var r = M(function (i) { | |
var a = n.current; | |
if (a) { | |
a.textContent = i; | |
return; | |
} | |
}, []); | |
return r; | |
} | |
var Tp = 0, | |
Bp = { separator: '::' }; | |
function ki(e, t) { | |
return ( | |
t === void 0 && (t = Bp), | |
X( | |
function () { | |
return '' + e + t.separator + Tp++; | |
}, | |
[t.separator, e] | |
) | |
); | |
} | |
function Rp(e) { | |
var t = e.contextId, | |
n = e.uniqueId; | |
return 'rbd-hidden-text-' + t + '-' + n; | |
} | |
function Fp(e) { | |
var t = e.contextId, | |
n = e.text, | |
r = ki('hidden-text', { separator: '-' }), | |
i = X( | |
function () { | |
return Rp({ contextId: t, uniqueId: r }); | |
}, | |
[r, t] | |
); | |
return ( | |
N.useEffect( | |
function () { | |
var o = document.createElement('div'); | |
return ( | |
(o.id = i), | |
(o.textContent = n), | |
(o.style.display = 'none'), | |
On().appendChild(o), | |
function () { | |
var s = On(); | |
s.contains(o) && s.removeChild(o); | |
} | |
); | |
}, | |
[i, n] | |
), | |
i | |
); | |
} | |
var _n = _.createContext(null); | |
function Il(e) { | |
var t = N.useRef(e); | |
return ( | |
N.useEffect(function () { | |
t.current = e; | |
}), | |
t | |
); | |
} | |
function Lp() { | |
var e = null; | |
function t() { | |
return !!e; | |
} | |
function n(o) { | |
return o === e; | |
} | |
function r(o) { | |
e && B(!1); | |
var l = { abandon: o }; | |
return (e = l), l; | |
} | |
function i() { | |
e || B(!1), (e = null); | |
} | |
function a() { | |
e && (e.abandon(), i()); | |
} | |
return { isClaimed: t, isActive: n, claim: r, release: i, tryAbandon: a }; | |
} | |
var Mp = 9, | |
jp = 13, | |
Ei = 27, | |
kl = 32, | |
zp = 33, | |
$p = 34, | |
Hp = 35, | |
Up = 36, | |
Gp = 37, | |
Wp = 38, | |
qp = 39, | |
Vp = 40, | |
mn, | |
Kp = ((mn = {}), (mn[jp] = !0), (mn[Mp] = !0), mn), | |
El = function (e) { | |
Kp[e.keyCode] && e.preventDefault(); | |
}, | |
Zn = (function () { | |
var e = 'visibilitychange'; | |
if (typeof document > 'u') return e; | |
var t = [e, 'ms' + e, 'webkit' + e, 'moz' + e, 'o' + e], | |
n = dt(t, function (r) { | |
return 'on' + r in document; | |
}); | |
return n || e; | |
})(), | |
Pl = 0, | |
Sa = 5; | |
function Yp(e, t) { | |
return Math.abs(t.x - e.x) >= Sa || Math.abs(t.y - e.y) >= Sa; | |
} | |
var Ca = { type: 'IDLE' }; | |
function Qp(e) { | |
var t = e.cancel, | |
n = e.completed, | |
r = e.getPhase, | |
i = e.setPhase; | |
return [ | |
{ | |
eventName: 'mousemove', | |
fn: function (o) { | |
var l = o.button, | |
s = o.clientX, | |
c = o.clientY; | |
if (l === Pl) { | |
var d = { x: s, y: c }, | |
u = r(); | |
if (u.type === 'DRAGGING') { | |
o.preventDefault(), u.actions.move(d); | |
return; | |
} | |
u.type !== 'PENDING' && B(!1); | |
var f = u.point; | |
if (Yp(f, d)) { | |
o.preventDefault(); | |
var p = u.actions.fluidLift(d); | |
i({ type: 'DRAGGING', actions: p }); | |
} | |
} | |
}, | |
}, | |
{ | |
eventName: 'mouseup', | |
fn: function (o) { | |
var l = r(); | |
if (l.type !== 'DRAGGING') { | |
t(); | |
return; | |
} | |
o.preventDefault(), l.actions.drop({ shouldBlockNextClick: !0 }), n(); | |
}, | |
}, | |
{ | |
eventName: 'mousedown', | |
fn: function (o) { | |
r().type === 'DRAGGING' && o.preventDefault(), t(); | |
}, | |
}, | |
{ | |
eventName: 'keydown', | |
fn: function (o) { | |
var l = r(); | |
if (l.type === 'PENDING') { | |
t(); | |
return; | |
} | |
if (o.keyCode === Ei) { | |
o.preventDefault(), t(); | |
return; | |
} | |
El(o); | |
}, | |
}, | |
{ eventName: 'resize', fn: t }, | |
{ | |
eventName: 'scroll', | |
options: { passive: !0, capture: !1 }, | |
fn: function () { | |
r().type === 'PENDING' && t(); | |
}, | |
}, | |
{ | |
eventName: 'webkitmouseforcedown', | |
fn: function (o) { | |
var l = r(); | |
if ((l.type === 'IDLE' && B(!1), l.actions.shouldRespectForcePress())) { | |
t(); | |
return; | |
} | |
o.preventDefault(); | |
}, | |
}, | |
{ eventName: Zn, fn: t }, | |
]; | |
} | |
function Xp(e) { | |
var t = N.useRef(Ca), | |
n = N.useRef(lt), | |
r = X( | |
function () { | |
return { | |
eventName: 'mousedown', | |
fn: function (u) { | |
if ( | |
!u.defaultPrevented && | |
u.button === Pl && | |
!(u.ctrlKey || u.metaKey || u.shiftKey || u.altKey) | |
) { | |
var f = e.findClosestDraggableId(u); | |
if (f) { | |
var p = e.tryGetLock(f, o, { sourceEvent: u }); | |
if (p) { | |
u.preventDefault(); | |
var m = { x: u.clientX, y: u.clientY }; | |
n.current(), c(p, m); | |
} | |
} | |
} | |
}, | |
}; | |
}, | |
[e] | |
), | |
i = X( | |
function () { | |
return { | |
eventName: 'webkitmouseforcewillbegin', | |
fn: function (u) { | |
if (!u.defaultPrevented) { | |
var f = e.findClosestDraggableId(u); | |
if (f) { | |
var p = e.findOptionsForDraggable(f); | |
p && (p.shouldRespectForcePress || (e.canGetLock(f) && u.preventDefault())); | |
} | |
} | |
}, | |
}; | |
}, | |
[e] | |
), | |
a = M( | |
function () { | |
var u = { passive: !1, capture: !0 }; | |
n.current = ze(window, [i, r], u); | |
}, | |
[i, r] | |
), | |
o = M( | |
function () { | |
var d = t.current; | |
d.type !== 'IDLE' && ((t.current = Ca), n.current(), a()); | |
}, | |
[a] | |
), | |
l = M( | |
function () { | |
var d = t.current; | |
o(), | |
d.type === 'DRAGGING' && d.actions.cancel({ shouldBlockNextClick: !0 }), | |
d.type === 'PENDING' && d.actions.abort(); | |
}, | |
[o] | |
), | |
s = M( | |
function () { | |
var u = { capture: !0, passive: !1 }, | |
f = Qp({ | |
cancel: l, | |
completed: o, | |
getPhase: function () { | |
return t.current; | |
}, | |
setPhase: function (m) { | |
t.current = m; | |
}, | |
}); | |
n.current = ze(window, f, u); | |
}, | |
[l, o] | |
), | |
c = M( | |
function (u, f) { | |
t.current.type !== 'IDLE' && B(!1), | |
(t.current = { type: 'PENDING', point: f, actions: u }), | |
s(); | |
}, | |
[s] | |
); | |
Re( | |
function () { | |
return ( | |
a(), | |
function () { | |
n.current(); | |
} | |
); | |
}, | |
[a] | |
); | |
} | |
var Dt; | |
function Jp() {} | |
var _p = ((Dt = {}), (Dt[$p] = !0), (Dt[zp] = !0), (Dt[Up] = !0), (Dt[Hp] = !0), Dt); | |
function Zp(e, t) { | |
function n() { | |
t(), e.cancel(); | |
} | |
function r() { | |
t(), e.drop(); | |
} | |
return [ | |
{ | |
eventName: 'keydown', | |
fn: function (a) { | |
if (a.keyCode === Ei) { | |
a.preventDefault(), n(); | |
return; | |
} | |
if (a.keyCode === kl) { | |
a.preventDefault(), r(); | |
return; | |
} | |
if (a.keyCode === Vp) { | |
a.preventDefault(), e.moveDown(); | |
return; | |
} | |
if (a.keyCode === Wp) { | |
a.preventDefault(), e.moveUp(); | |
return; | |
} | |
if (a.keyCode === qp) { | |
a.preventDefault(), e.moveRight(); | |
return; | |
} | |
if (a.keyCode === Gp) { | |
a.preventDefault(), e.moveLeft(); | |
return; | |
} | |
if (_p[a.keyCode]) { | |
a.preventDefault(); | |
return; | |
} | |
El(a); | |
}, | |
}, | |
{ eventName: 'mousedown', fn: n }, | |
{ eventName: 'mouseup', fn: n }, | |
{ eventName: 'click', fn: n }, | |
{ eventName: 'touchstart', fn: n }, | |
{ eventName: 'resize', fn: n }, | |
{ eventName: 'wheel', fn: n, options: { passive: !0 } }, | |
{ eventName: Zn, fn: n }, | |
]; | |
} | |
function ef(e) { | |
var t = N.useRef(Jp), | |
n = X( | |
function () { | |
return { | |
eventName: 'keydown', | |
fn: function (a) { | |
if (a.defaultPrevented || a.keyCode !== kl) return; | |
var o = e.findClosestDraggableId(a); | |
if (!o) return; | |
var l = e.tryGetLock(o, d, { sourceEvent: a }); | |
if (!l) return; | |
a.preventDefault(); | |
var s = !0, | |
c = l.snapLift(); | |
t.current(); | |
function d() { | |
s || B(!1), (s = !1), t.current(), r(); | |
} | |
t.current = ze(window, Zp(c, d), { capture: !0, passive: !1 }); | |
}, | |
}; | |
}, | |
[e] | |
), | |
r = M( | |
function () { | |
var a = { passive: !1, capture: !0 }; | |
t.current = ze(window, [n], a); | |
}, | |
[n] | |
); | |
Re( | |
function () { | |
return ( | |
r(), | |
function () { | |
t.current(); | |
} | |
); | |
}, | |
[r] | |
); | |
} | |
var Sr = { type: 'IDLE' }, | |
tf = 120, | |
nf = 0.15; | |
function rf(e) { | |
var t = e.cancel, | |
n = e.getPhase; | |
return [ | |
{ eventName: 'orientationchange', fn: t }, | |
{ eventName: 'resize', fn: t }, | |
{ | |
eventName: 'contextmenu', | |
fn: function (i) { | |
i.preventDefault(); | |
}, | |
}, | |
{ | |
eventName: 'keydown', | |
fn: function (i) { | |
if (n().type !== 'DRAGGING') { | |
t(); | |
return; | |
} | |
i.keyCode === Ei && i.preventDefault(), t(); | |
}, | |
}, | |
{ eventName: Zn, fn: t }, | |
]; | |
} | |
function af(e) { | |
var t = e.cancel, | |
n = e.completed, | |
r = e.getPhase; | |
return [ | |
{ | |
eventName: 'touchmove', | |
options: { capture: !1 }, | |
fn: function (a) { | |
var o = r(); | |
if (o.type !== 'DRAGGING') { | |
t(); | |
return; | |
} | |
o.hasMoved = !0; | |
var l = a.touches[0], | |
s = l.clientX, | |
c = l.clientY, | |
d = { x: s, y: c }; | |
a.preventDefault(), o.actions.move(d); | |
}, | |
}, | |
{ | |
eventName: 'touchend', | |
fn: function (a) { | |
var o = r(); | |
if (o.type !== 'DRAGGING') { | |
t(); | |
return; | |
} | |
a.preventDefault(), o.actions.drop({ shouldBlockNextClick: !0 }), n(); | |
}, | |
}, | |
{ | |
eventName: 'touchcancel', | |
fn: function (a) { | |
if (r().type !== 'DRAGGING') { | |
t(); | |
return; | |
} | |
a.preventDefault(), t(); | |
}, | |
}, | |
{ | |
eventName: 'touchforcechange', | |
fn: function (a) { | |
var o = r(); | |
o.type === 'IDLE' && B(!1); | |
var l = a.touches[0]; | |
if (l) { | |
var s = l.force >= nf; | |
if (s) { | |
var c = o.actions.shouldRespectForcePress(); | |
if (o.type === 'PENDING') { | |
c && t(); | |
return; | |
} | |
if (c) { | |
if (o.hasMoved) { | |
a.preventDefault(); | |
return; | |
} | |
t(); | |
return; | |
} | |
a.preventDefault(); | |
} | |
} | |
}, | |
}, | |
{ eventName: Zn, fn: t }, | |
]; | |
} | |
function of(e) { | |
var t = N.useRef(Sr), | |
n = N.useRef(lt), | |
r = M(function () { | |
return t.current; | |
}, []), | |
i = M(function (p) { | |
t.current = p; | |
}, []), | |
a = X( | |
function () { | |
return { | |
eventName: 'touchstart', | |
fn: function (p) { | |
if (!p.defaultPrevented) { | |
var m = e.findClosestDraggableId(p); | |
if (m) { | |
var h = e.tryGetLock(m, l, { sourceEvent: p }); | |
if (h) { | |
var x = p.touches[0], | |
b = x.clientX, | |
C = x.clientY, | |
S = { x: b, y: C }; | |
n.current(), u(h, S); | |
} | |
} | |
} | |
}, | |
}; | |
}, | |
[e] | |
), | |
o = M( | |
function () { | |
var p = { capture: !0, passive: !1 }; | |
n.current = ze(window, [a], p); | |
}, | |
[a] | |
), | |
l = M( | |
function () { | |
var f = t.current; | |
f.type !== 'IDLE' && | |
(f.type === 'PENDING' && clearTimeout(f.longPressTimerId), i(Sr), n.current(), o()); | |
}, | |
[o, i] | |
), | |
s = M( | |
function () { | |
var f = t.current; | |
l(), | |
f.type === 'DRAGGING' && f.actions.cancel({ shouldBlockNextClick: !0 }), | |
f.type === 'PENDING' && f.actions.abort(); | |
}, | |
[l] | |
), | |
c = M( | |
function () { | |
var p = { capture: !0, passive: !1 }, | |
m = { cancel: s, completed: l, getPhase: r }, | |
h = ze(window, af(m), p), | |
x = ze(window, rf(m), p); | |
n.current = function () { | |
h(), x(); | |
}; | |
}, | |
[s, r, l] | |
), | |
d = M( | |
function () { | |
var p = r(); | |
p.type !== 'PENDING' && B(!1); | |
var m = p.actions.fluidLift(p.point); | |
i({ type: 'DRAGGING', actions: m, hasMoved: !1 }); | |
}, | |
[r, i] | |
), | |
u = M( | |
function (p, m) { | |
r().type !== 'IDLE' && B(!1); | |
var h = setTimeout(d, tf); | |
i({ type: 'PENDING', point: m, actions: p, longPressTimerId: h }), c(); | |
}, | |
[c, r, i, d] | |
); | |
Re( | |
function () { | |
return ( | |
o(), | |
function () { | |
n.current(); | |
var m = r(); | |
m.type === 'PENDING' && (clearTimeout(m.longPressTimerId), i(Sr)); | |
} | |
); | |
}, | |
[r, o, i] | |
), | |
Re(function () { | |
var p = ze(window, [ | |
{ eventName: 'touchmove', fn: function () {}, options: { capture: !1, passive: !1 } }, | |
]); | |
return p; | |
}, []); | |
} | |
var lf = { | |
input: !0, | |
button: !0, | |
textarea: !0, | |
select: !0, | |
option: !0, | |
optgroup: !0, | |
video: !0, | |
audio: !0, | |
}; | |
function Al(e, t) { | |
if (t == null) return !1; | |
var n = !!lf[t.tagName.toLowerCase()]; | |
if (n) return !0; | |
var r = t.getAttribute('contenteditable'); | |
return r === 'true' || r === '' ? !0 : t === e ? !1 : Al(e, t.parentElement); | |
} | |
function sf(e, t) { | |
var n = t.target; | |
return Jn(n) ? Al(e, n) : !1; | |
} | |
var uf = function (e) { | |
return We(e.getBoundingClientRect()).center; | |
}; | |
function cf(e) { | |
return e instanceof Dl(e).Element; | |
} | |
var df = (function () { | |
var e = 'matches'; | |
if (typeof document > 'u') return e; | |
var t = [e, 'msMatchesSelector', 'webkitMatchesSelector'], | |
n = dt(t, function (r) { | |
return r in Element.prototype; | |
}); | |
return n || e; | |
})(); | |
function Nl(e, t) { | |
return e == null ? null : e[df](t) ? e : Nl(e.parentElement, t); | |
} | |
function pf(e, t) { | |
return e.closest ? e.closest(t) : Nl(e, t); | |
} | |
function ff(e) { | |
return '[' + At.contextId + '="' + e + '"]'; | |
} | |
function gf(e, t) { | |
var n = t.target; | |
if (!cf(n)) return null; | |
var r = ff(e), | |
i = pf(n, r); | |
return !i || !Jn(i) ? null : i; | |
} | |
function mf(e, t) { | |
var n = gf(e, t); | |
return n ? n.getAttribute(At.draggableId) : null; | |
} | |
function hf(e, t) { | |
var n = '[' + Ur.contextId + '="' + e + '"]', | |
r = Vo(document.querySelectorAll(n)), | |
i = dt(r, function (a) { | |
return a.getAttribute(Ur.id) === t; | |
}); | |
return !i || !Jn(i) ? null : i; | |
} | |
function vf(e) { | |
e.preventDefault(); | |
} | |
function hn(e) { | |
var t = e.expected, | |
n = e.phase, | |
r = e.isLockActive; | |
return e.shouldWarn, !(!r() || t !== n); | |
} | |
function Ol(e) { | |
var t = e.lockAPI, | |
n = e.store, | |
r = e.registry, | |
i = e.draggableId; | |
if (t.isClaimed()) return !1; | |
var a = r.draggable.findById(i); | |
return !(!a || !a.options.isEnabled || !xl(n.getState(), i)); | |
} | |
function bf(e) { | |
var t = e.lockAPI, | |
n = e.contextId, | |
r = e.store, | |
i = e.registry, | |
a = e.draggableId, | |
o = e.forceSensorStop, | |
l = e.sourceEvent, | |
s = Ol({ lockAPI: t, store: r, registry: i, draggableId: a }); | |
if (!s) return null; | |
var c = i.draggable.getById(a), | |
d = hf(n, c.descriptor.id); | |
if (!d || (l && !c.options.canDragInteractiveElements && sf(d, l))) return null; | |
var u = t.claim(o || lt), | |
f = 'PRE_DRAG'; | |
function p() { | |
return c.options.shouldRespectForcePress; | |
} | |
function m() { | |
return t.isActive(u); | |
} | |
function h(w, O) { | |
hn({ expected: w, phase: f, isLockActive: m, shouldWarn: !0 }) && r.dispatch(O()); | |
} | |
var x = h.bind(null, 'DRAGGING'); | |
function b(w) { | |
function O() { | |
t.release(), (f = 'COMPLETED'); | |
} | |
f !== 'PRE_DRAG' && (O(), f !== 'PRE_DRAG' && B(!1)), | |
r.dispatch(cd(w.liftActionArgs)), | |
(f = 'DRAGGING'); | |
function L(F, V) { | |
if ( | |
(V === void 0 && (V = { shouldBlockNextClick: !1 }), w.cleanup(), V.shouldBlockNextClick) | |
) { | |
var A = ze(window, [ | |
{ eventName: 'click', fn: vf, options: { once: !0, passive: !1, capture: !0 } }, | |
]); | |
setTimeout(A); | |
} | |
O(), r.dispatch(fl({ reason: F })); | |
} | |
return j( | |
{ | |
isActive: function () { | |
return hn({ expected: 'DRAGGING', phase: f, isLockActive: m, shouldWarn: !1 }); | |
}, | |
shouldRespectForcePress: p, | |
drop: function (V) { | |
return L('DROP', V); | |
}, | |
cancel: function (V) { | |
return L('CANCEL', V); | |
}, | |
}, | |
w.actions | |
); | |
} | |
function C(w) { | |
var O = Vt(function (F) { | |
x(function () { | |
return pl({ client: F }); | |
}); | |
}), | |
L = b({ | |
liftActionArgs: { id: a, clientSelection: w, movementMode: 'FLUID' }, | |
cleanup: function () { | |
return O.cancel(); | |
}, | |
actions: { move: O }, | |
}); | |
return j({}, L, { move: O }); | |
} | |
function S() { | |
var w = { | |
moveUp: function () { | |
return x(yd); | |
}, | |
moveRight: function () { | |
return x(wd); | |
}, | |
moveDown: function () { | |
return x(xd); | |
}, | |
moveLeft: function () { | |
return x(Sd); | |
}, | |
}; | |
return b({ | |
liftActionArgs: { id: a, clientSelection: uf(d), movementMode: 'SNAP' }, | |
cleanup: lt, | |
actions: w, | |
}); | |
} | |
function D() { | |
var w = hn({ expected: 'PRE_DRAG', phase: f, isLockActive: m, shouldWarn: !0 }); | |
w && t.release(); | |
} | |
var E = { | |
isActive: function () { | |
return hn({ expected: 'PRE_DRAG', phase: f, isLockActive: m, shouldWarn: !1 }); | |
}, | |
shouldRespectForcePress: p, | |
fluidLift: C, | |
snapLift: S, | |
abort: D, | |
}; | |
return E; | |
} | |
var yf = [Xp, ef, of]; | |
function xf(e) { | |
var t = e.contextId, | |
n = e.store, | |
r = e.registry, | |
i = e.customSensors, | |
a = e.enableDefaultSensors, | |
o = [].concat(a ? yf : [], i || []), | |
l = N.useState(function () { | |
return Lp(); | |
})[0], | |
s = M( | |
function (C, S) { | |
C.isDragging && !S.isDragging && l.tryAbandon(); | |
}, | |
[l] | |
); | |
Re( | |
function () { | |
var C = n.getState(), | |
S = n.subscribe(function () { | |
var D = n.getState(); | |
s(C, D), (C = D); | |
}); | |
return S; | |
}, | |
[l, n, s] | |
), | |
Re( | |
function () { | |
return l.tryAbandon; | |
}, | |
[l.tryAbandon] | |
); | |
for ( | |
var c = M( | |
function (b) { | |
return Ol({ lockAPI: l, registry: r, store: n, draggableId: b }); | |
}, | |
[l, r, n] | |
), | |
d = M( | |
function (b, C, S) { | |
return bf({ | |
lockAPI: l, | |
registry: r, | |
contextId: t, | |
store: n, | |
draggableId: b, | |
forceSensorStop: C, | |
sourceEvent: S && S.sourceEvent ? S.sourceEvent : null, | |
}); | |
}, | |
[t, l, r, n] | |
), | |
u = M( | |
function (b) { | |
return mf(t, b); | |
}, | |
[t] | |
), | |
f = M( | |
function (b) { | |
var C = r.draggable.findById(b); | |
return C ? C.options : null; | |
}, | |
[r.draggable] | |
), | |
p = M( | |
function () { | |
l.isClaimed() && (l.tryAbandon(), n.getState().phase !== 'IDLE' && n.dispatch(vi())); | |
}, | |
[l, n] | |
), | |
m = M(l.isClaimed, [l]), | |
h = X( | |
function () { | |
return { | |
canGetLock: c, | |
tryGetLock: d, | |
findClosestDraggableId: u, | |
findOptionsForDraggable: f, | |
tryReleaseLock: p, | |
isLockClaimed: m, | |
}; | |
}, | |
[c, d, u, f, p, m] | |
), | |
x = 0; | |
x < o.length; | |
x++ | |
) | |
o[x](h); | |
} | |
var wf = function (t) { | |
return { | |
onBeforeCapture: t.onBeforeCapture, | |
onBeforeDragStart: t.onBeforeDragStart, | |
onDragStart: t.onDragStart, | |
onDragEnd: t.onDragEnd, | |
onDragUpdate: t.onDragUpdate, | |
}; | |
}; | |
function zt(e) { | |
return e.current || B(!1), e.current; | |
} | |
function Sf(e) { | |
var t = e.contextId, | |
n = e.setCallbacks, | |
r = e.sensors, | |
i = e.nonce, | |
a = e.dragHandleUsageInstructions, | |
o = N.useRef(null), | |
l = Il(e), | |
s = M( | |
function () { | |
return wf(l.current); | |
}, | |
[l] | |
), | |
c = Op(t), | |
d = Fp({ contextId: t, text: a }), | |
u = Dp(t, i), | |
f = M(function (F) { | |
zt(o).dispatch(F); | |
}, []), | |
p = X( | |
function () { | |
return Vi( | |
{ | |
publishWhileDragging: pd, | |
updateDroppableScroll: gd, | |
updateDroppableIsEnabled: md, | |
updateDroppableIsCombineEnabled: hd, | |
collectionStarting: fd, | |
}, | |
f | |
); | |
}, | |
[f] | |
), | |
m = Pp(), | |
h = X( | |
function () { | |
return np(m, p); | |
}, | |
[m, p] | |
), | |
x = X( | |
function () { | |
return yp(j({ scrollWindow: rp, scrollDroppable: h.scrollDroppable }, Vi({ move: pl }, f))); | |
}, | |
[h.scrollDroppable, f] | |
), | |
b = kp(t), | |
C = X( | |
function () { | |
return _d({ | |
announce: c, | |
autoScroller: x, | |
dimensionMarshal: h, | |
focusMarshal: b, | |
getResponders: s, | |
styleMarshal: u, | |
}); | |
}, | |
[c, x, h, b, s, u] | |
); | |
o.current = C; | |
var S = M(function () { | |
var F = zt(o), | |
V = F.getState(); | |
V.phase !== 'IDLE' && F.dispatch(vi()); | |
}, []), | |
D = M(function () { | |
var F = zt(o).getState(); | |
return F.isDragging || F.phase === 'DROP_ANIMATING'; | |
}, []), | |
E = X( | |
function () { | |
return { isDragging: D, tryAbort: S }; | |
}, | |
[D, S] | |
); | |
n(E); | |
var w = M(function (F) { | |
return xl(zt(o).getState(), F); | |
}, []), | |
O = M(function () { | |
return yt(zt(o).getState()); | |
}, []), | |
L = X( | |
function () { | |
return { | |
marshal: h, | |
focus: b, | |
contextId: t, | |
canLift: w, | |
isMovementAllowed: O, | |
dragHandleUsageInstructionsId: d, | |
registry: m, | |
}; | |
}, | |
[t, h, d, b, w, O, m] | |
); | |
return ( | |
xf({ | |
contextId: t, | |
store: C, | |
registry: m, | |
customSensors: r, | |
enableDefaultSensors: e.enableDefaultSensors !== !1, | |
}), | |
N.useEffect( | |
function () { | |
return S; | |
}, | |
[S] | |
), | |
_.createElement( | |
_n.Provider, | |
{ value: L }, | |
_.createElement(Gs, { context: Ii, store: C }, e.children) | |
) | |
); | |
} | |
var Cf = 0; | |
function Df() { | |
return X(function () { | |
return '' + Cf++; | |
}, []); | |
} | |
function If(e) { | |
var t = Df(), | |
n = e.dragHandleUsageInstructions || wn.dragHandleUsageInstructions; | |
return _.createElement(ec, null, function (r) { | |
return _.createElement( | |
Sf, | |
{ | |
nonce: e.nonce, | |
contextId: t, | |
setCallbacks: r, | |
dragHandleUsageInstructions: n, | |
enableDefaultSensors: e.enableDefaultSensors, | |
sensors: e.sensors, | |
onBeforeCapture: e.onBeforeCapture, | |
onBeforeDragStart: e.onBeforeDragStart, | |
onDragStart: e.onDragStart, | |
onDragUpdate: e.onDragUpdate, | |
onDragEnd: e.onDragEnd, | |
}, | |
e.children | |
); | |
}); | |
} | |
var Tl = function (t) { | |
return function (n) { | |
return t === n; | |
}; | |
}, | |
kf = Tl('scroll'), | |
Ef = Tl('auto'), | |
Da = function (t, n) { | |
return n(t.overflowX) || n(t.overflowY); | |
}, | |
Pf = function (t) { | |
var n = window.getComputedStyle(t), | |
r = { overflowX: n.overflowX, overflowY: n.overflowY }; | |
return Da(r, kf) || Da(r, Ef); | |
}, | |
Af = function () { | |
return !1; | |
}, | |
Nf = function e(t) { | |
return t == null | |
? null | |
: t === document.body | |
? Af() | |
? t | |
: null | |
: t === document.documentElement | |
? null | |
: Pf(t) | |
? t | |
: e(t.parentElement); | |
}, | |
Gr = function (e) { | |
return { x: e.scrollLeft, y: e.scrollTop }; | |
}, | |
Of = function e(t) { | |
if (!t) return !1; | |
var n = window.getComputedStyle(t); | |
return n.position === 'fixed' ? !0 : e(t.parentElement); | |
}, | |
Tf = function (e) { | |
var t = Nf(e), | |
n = Of(e); | |
return { closestScrollable: t, isFixedOnPage: n }; | |
}, | |
Bf = function (e) { | |
var t = e.descriptor, | |
n = e.isEnabled, | |
r = e.isCombineEnabled, | |
i = e.isFixedOnPage, | |
a = e.direction, | |
o = e.client, | |
l = e.page, | |
s = e.closest, | |
c = (function () { | |
if (!s) return null; | |
var p = s.scrollSize, | |
m = s.client, | |
h = vl({ | |
scrollHeight: p.scrollHeight, | |
scrollWidth: p.scrollWidth, | |
height: m.paddingBox.height, | |
width: m.paddingBox.width, | |
}); | |
return { | |
pageMarginBox: s.page.marginBox, | |
frameClient: m, | |
scrollSize: p, | |
shouldClipSubject: s.shouldClipSubject, | |
scroll: { | |
initial: s.scroll, | |
current: s.scroll, | |
max: h, | |
diff: { value: be, displacement: be }, | |
}, | |
}; | |
})(), | |
d = a === 'vertical' ? pi : Jo, | |
u = Et({ page: l, withPlaceholder: null, axis: d, frame: c }), | |
f = { | |
descriptor: t, | |
isCombineEnabled: r, | |
isFixedOnPage: i, | |
axis: d, | |
isEnabled: n, | |
client: o, | |
page: l, | |
frame: c, | |
subject: u, | |
}; | |
return f; | |
}, | |
Rf = function (t, n) { | |
var r = Ho(t); | |
if (!n || t !== n) return r; | |
var i = r.paddingBox.top - n.scrollTop, | |
a = r.paddingBox.left - n.scrollLeft, | |
o = i + n.scrollHeight, | |
l = a + n.scrollWidth, | |
s = { top: i, right: l, bottom: o, left: a }, | |
c = li(s, r.border), | |
d = si({ borderBox: c, margin: r.margin, border: r.border, padding: r.padding }); | |
return d; | |
}, | |
Ff = function (e) { | |
var t = e.ref, | |
n = e.descriptor, | |
r = e.env, | |
i = e.windowScroll, | |
a = e.direction, | |
o = e.isDropDisabled, | |
l = e.isCombineEnabled, | |
s = e.shouldClipSubject, | |
c = r.closestScrollable, | |
d = Rf(t, c), | |
u = kn(d, i), | |
f = (function () { | |
if (!c) return null; | |
var m = Ho(c), | |
h = { scrollHeight: c.scrollHeight, scrollWidth: c.scrollWidth }; | |
return { client: m, page: kn(m, i), scroll: Gr(c), scrollSize: h, shouldClipSubject: s }; | |
})(), | |
p = Bf({ | |
descriptor: n, | |
isEnabled: !o, | |
isCombineEnabled: l, | |
isFixedOnPage: r.isFixedOnPage, | |
direction: a, | |
client: d, | |
page: u, | |
closest: f, | |
}); | |
return p; | |
}, | |
Lf = { passive: !1 }, | |
Mf = { passive: !0 }, | |
Ia = function (e) { | |
return e.shouldPublishImmediately ? Lf : Mf; | |
}; | |
function Tn(e) { | |
var t = N.useContext(e); | |
return t || B(!1), t; | |
} | |
var vn = function (t) { | |
return (t && t.env.closestScrollable) || null; | |
}; | |
function jf(e) { | |
var t = N.useRef(null), | |
n = Tn(_n), | |
r = ki('droppable'), | |
i = n.registry, | |
a = n.marshal, | |
o = Il(e), | |
l = X( | |
function () { | |
return { id: e.droppableId, type: e.type, mode: e.mode }; | |
}, | |
[e.droppableId, e.mode, e.type] | |
), | |
s = N.useRef(l), | |
c = X( | |
function () { | |
return ve(function (D, E) { | |
t.current || B(!1); | |
var w = { x: D, y: E }; | |
a.updateDroppableScroll(l.id, w); | |
}); | |
}, | |
[l.id, a] | |
), | |
d = M(function () { | |
var D = t.current; | |
return !D || !D.env.closestScrollable ? be : Gr(D.env.closestScrollable); | |
}, []), | |
u = M( | |
function () { | |
var D = d(); | |
c(D.x, D.y); | |
}, | |
[d, c] | |
), | |
f = X( | |
function () { | |
return Vt(u); | |
}, | |
[u] | |
), | |
p = M( | |
function () { | |
var D = t.current, | |
E = vn(D); | |
(D && E) || B(!1); | |
var w = D.scrollOptions; | |
if (w.shouldPublishImmediately) { | |
u(); | |
return; | |
} | |
f(); | |
}, | |
[f, u] | |
), | |
m = M( | |
function (D, E) { | |
t.current && B(!1); | |
var w = o.current, | |
O = w.getDroppableRef(); | |
O || B(!1); | |
var L = Tf(O), | |
F = { ref: O, descriptor: l, env: L, scrollOptions: E }; | |
t.current = F; | |
var V = Ff({ | |
ref: O, | |
descriptor: l, | |
env: L, | |
windowScroll: D, | |
direction: w.direction, | |
isDropDisabled: w.isDropDisabled, | |
isCombineEnabled: w.isCombineEnabled, | |
shouldClipSubject: !w.ignoreContainerClipping, | |
}), | |
A = L.closestScrollable; | |
return ( | |
A && | |
(A.setAttribute(xa.contextId, n.contextId), | |
A.addEventListener('scroll', p, Ia(F.scrollOptions))), | |
V | |
); | |
}, | |
[n.contextId, l, p, o] | |
), | |
h = M(function () { | |
var D = t.current, | |
E = vn(D); | |
return (D && E) || B(!1), Gr(E); | |
}, []), | |
x = M( | |
function () { | |
var D = t.current; | |
D || B(!1); | |
var E = vn(D); | |
(t.current = null), | |
E && | |
(f.cancel(), | |
E.removeAttribute(xa.contextId), | |
E.removeEventListener('scroll', p, Ia(D.scrollOptions))); | |
}, | |
[p, f] | |
), | |
b = M(function (D) { | |
var E = t.current; | |
E || B(!1); | |
var w = vn(E); | |
w || B(!1), (w.scrollTop += D.y), (w.scrollLeft += D.x); | |
}, []), | |
C = X( | |
function () { | |
return { | |
getDimensionAndWatchScroll: m, | |
getScrollWhileDragging: h, | |
dragStopped: x, | |
scroll: b, | |
}; | |
}, | |
[x, m, h, b] | |
), | |
S = X( | |
function () { | |
return { uniqueId: r, descriptor: l, callbacks: C }; | |
}, | |
[C, l, r] | |
); | |
Re( | |
function () { | |
return ( | |
(s.current = S.descriptor), | |
i.droppable.register(S), | |
function () { | |
t.current && x(), i.droppable.unregister(S); | |
} | |
); | |
}, | |
[C, l, x, S, a, i.droppable] | |
), | |
Re( | |
function () { | |
t.current && a.updateDroppableIsEnabled(s.current.id, !e.isDropDisabled); | |
}, | |
[e.isDropDisabled, a] | |
), | |
Re( | |
function () { | |
t.current && a.updateDroppableIsCombineEnabled(s.current.id, e.isCombineEnabled); | |
}, | |
[e.isCombineEnabled, a] | |
); | |
} | |
function Cr() {} | |
var ka = { width: 0, height: 0, margin: oc }, | |
zf = function (t) { | |
var n = t.isAnimatingOpenOnMount, | |
r = t.placeholder, | |
i = t.animate; | |
return n || i === 'close' | |
? ka | |
: { | |
height: r.client.borderBox.height, | |
width: r.client.borderBox.width, | |
margin: r.client.margin, | |
}; | |
}, | |
$f = function (t) { | |
var n = t.isAnimatingOpenOnMount, | |
r = t.placeholder, | |
i = t.animate, | |
a = zf({ isAnimatingOpenOnMount: n, placeholder: r, animate: i }); | |
return { | |
display: r.display, | |
boxSizing: 'border-box', | |
width: a.width, | |
height: a.height, | |
marginTop: a.margin.top, | |
marginRight: a.margin.right, | |
marginBottom: a.margin.bottom, | |
marginLeft: a.margin.left, | |
flexShrink: '0', | |
flexGrow: '0', | |
pointerEvents: 'none', | |
transition: i !== 'none' ? Ut.placeholder : null, | |
}; | |
}; | |
function Hf(e) { | |
var t = N.useRef(null), | |
n = M(function () { | |
t.current && (clearTimeout(t.current), (t.current = null)); | |
}, []), | |
r = e.animate, | |
i = e.onTransitionEnd, | |
a = e.onClose, | |
o = e.contextId, | |
l = N.useState(e.animate === 'open'), | |
s = l[0], | |
c = l[1]; | |
N.useEffect( | |
function () { | |
return s | |
? r !== 'open' | |
? (n(), c(!1), Cr) | |
: t.current | |
? Cr | |
: ((t.current = setTimeout(function () { | |
(t.current = null), c(!1); | |
})), | |
n) | |
: Cr; | |
}, | |
[r, s, n] | |
); | |
var d = M( | |
function (f) { | |
f.propertyName === 'height' && (i(), r === 'close' && a()); | |
}, | |
[r, a, i] | |
), | |
u = $f({ isAnimatingOpenOnMount: s, animate: e.animate, placeholder: e.placeholder }); | |
return _.createElement(e.placeholder.tagName, { | |
style: u, | |
'data-rbd-placeholder-context-id': o, | |
onTransitionEnd: d, | |
ref: e.innerRef, | |
}); | |
} | |
var Uf = _.memo(Hf), | |
Pi = _.createContext(null), | |
Gf = (function (e) { | |
xo(t, e); | |
function t() { | |
for (var r, i = arguments.length, a = new Array(i), o = 0; o < i; o++) a[o] = arguments[o]; | |
return ( | |
(r = e.call.apply(e, [this].concat(a)) || this), | |
(r.state = { | |
isVisible: !!r.props.on, | |
data: r.props.on, | |
animate: r.props.shouldAnimate && r.props.on ? 'open' : 'none', | |
}), | |
(r.onClose = function () { | |
r.state.animate === 'close' && r.setState({ isVisible: !1 }); | |
}), | |
r | |
); | |
} | |
t.getDerivedStateFromProps = function (i, a) { | |
return i.shouldAnimate | |
? i.on | |
? { isVisible: !0, data: i.on, animate: 'open' } | |
: a.isVisible | |
? { isVisible: !0, data: a.data, animate: 'close' } | |
: { isVisible: !1, animate: 'close', data: null } | |
: { isVisible: !!i.on, data: i.on, animate: 'none' }; | |
}; | |
var n = t.prototype; | |
return ( | |
(n.render = function () { | |
if (!this.state.isVisible) return null; | |
var i = { onClose: this.onClose, data: this.state.data, animate: this.state.animate }; | |
return this.props.children(i); | |
}), | |
t | |
); | |
})(_.PureComponent), | |
Ea = { dragging: 5e3, dropAnimating: 4500 }, | |
Wf = function (t, n) { | |
return n ? Ut.drop(n.duration) : t ? Ut.snap : Ut.fluid; | |
}, | |
qf = function (t, n) { | |
return t ? (n ? Xt.opacity.drop : Xt.opacity.combining) : null; | |
}, | |
Vf = function (t) { | |
return t.forceShouldAnimate != null ? t.forceShouldAnimate : t.mode === 'SNAP'; | |
}; | |
function Kf(e) { | |
var t = e.dimension, | |
n = t.client, | |
r = e.offset, | |
i = e.combineWith, | |
a = e.dropping, | |
o = !!i, | |
l = Vf(e), | |
s = !!a, | |
c = s ? $r.drop(r, o) : $r.moveTo(r), | |
d = { | |
position: 'fixed', | |
top: n.marginBox.top, | |
left: n.marginBox.left, | |
boxSizing: 'border-box', | |
width: n.borderBox.width, | |
height: n.borderBox.height, | |
transition: Wf(l, a), | |
transform: c, | |
opacity: qf(o, s), | |
zIndex: s ? Ea.dropAnimating : Ea.dragging, | |
pointerEvents: 'none', | |
}; | |
return d; | |
} | |
function Yf(e) { | |
return { | |
transform: $r.moveTo(e.offset), | |
transition: e.shouldAnimateDisplacement ? null : 'none', | |
}; | |
} | |
function Qf(e) { | |
return e.type === 'DRAGGING' ? Kf(e) : Yf(e); | |
} | |
function Xf(e, t, n) { | |
n === void 0 && (n = be); | |
var r = window.getComputedStyle(t), | |
i = t.getBoundingClientRect(), | |
a = $o(i, r), | |
o = kn(a, n), | |
l = { client: a, tagName: t.tagName.toLowerCase(), display: r.display }, | |
s = { x: a.marginBox.width, y: a.marginBox.height }, | |
c = { descriptor: e, placeholder: l, displaceBy: s, client: a, page: o }; | |
return c; | |
} | |
function Jf(e) { | |
var t = ki('draggable'), | |
n = e.descriptor, | |
r = e.registry, | |
i = e.getDraggableRef, | |
a = e.canDragInteractiveElements, | |
o = e.shouldRespectForcePress, | |
l = e.isEnabled, | |
s = X( | |
function () { | |
return { canDragInteractiveElements: a, shouldRespectForcePress: o, isEnabled: l }; | |
}, | |
[a, l, o] | |
), | |
c = M( | |
function (p) { | |
var m = i(); | |
return m || B(!1), Xf(n, m, p); | |
}, | |
[n, i] | |
), | |
d = X( | |
function () { | |
return { uniqueId: t, descriptor: n, options: s, getDimension: c }; | |
}, | |
[n, c, s, t] | |
), | |
u = N.useRef(d), | |
f = N.useRef(!0); | |
Re( | |
function () { | |
return ( | |
r.draggable.register(u.current), | |
function () { | |
return r.draggable.unregister(u.current); | |
} | |
); | |
}, | |
[r.draggable] | |
), | |
Re( | |
function () { | |
if (f.current) { | |
f.current = !1; | |
return; | |
} | |
var p = u.current; | |
(u.current = d), r.draggable.update(d, p); | |
}, | |
[d, r.draggable] | |
); | |
} | |
function _f(e) { | |
e.preventDefault(); | |
} | |
function Zf(e) { | |
var t = N.useRef(null), | |
n = M(function (F) { | |
t.current = F; | |
}, []), | |
r = M(function () { | |
return t.current; | |
}, []), | |
i = Tn(_n), | |
a = i.contextId, | |
o = i.dragHandleUsageInstructionsId, | |
l = i.registry, | |
s = Tn(Pi), | |
c = s.type, | |
d = s.droppableId, | |
u = X( | |
function () { | |
return { id: e.draggableId, index: e.index, type: c, droppableId: d }; | |
}, | |
[e.draggableId, e.index, c, d] | |
), | |
f = e.children, | |
p = e.draggableId, | |
m = e.isEnabled, | |
h = e.shouldRespectForcePress, | |
x = e.canDragInteractiveElements, | |
b = e.isClone, | |
C = e.mapped, | |
S = e.dropAnimationFinished; | |
if (!b) { | |
var D = X( | |
function () { | |
return { | |
descriptor: u, | |
registry: l, | |
getDraggableRef: r, | |
canDragInteractiveElements: x, | |
shouldRespectForcePress: h, | |
isEnabled: m, | |
}; | |
}, | |
[u, l, r, x, h, m] | |
); | |
Jf(D); | |
} | |
var E = X( | |
function () { | |
return m | |
? { | |
tabIndex: 0, | |
role: 'button', | |
'aria-describedby': o, | |
'data-rbd-drag-handle-draggable-id': p, | |
'data-rbd-drag-handle-context-id': a, | |
draggable: !1, | |
onDragStart: _f, | |
} | |
: null; | |
}, | |
[a, o, p, m] | |
), | |
w = M( | |
function (F) { | |
C.type === 'DRAGGING' && C.dropping && F.propertyName === 'transform' && S(); | |
}, | |
[S, C] | |
), | |
O = X( | |
function () { | |
var F = Qf(C), | |
V = C.type === 'DRAGGING' && C.dropping ? w : null, | |
A = { | |
innerRef: n, | |
draggableProps: { | |
'data-rbd-draggable-context-id': a, | |
'data-rbd-draggable-id': p, | |
style: F, | |
onTransitionEnd: V, | |
}, | |
dragHandleProps: E, | |
}; | |
return A; | |
}, | |
[a, E, p, C, w, n] | |
), | |
L = X( | |
function () { | |
return { | |
draggableId: u.id, | |
type: u.type, | |
source: { index: u.index, droppableId: u.droppableId }, | |
}; | |
}, | |
[u.droppableId, u.id, u.index, u.type] | |
); | |
return f(O, C.snapshot, L); | |
} | |
var Bl = function (e, t) { | |
return e === t; | |
}, | |
Rl = function (e) { | |
var t = e.combine, | |
n = e.destination; | |
return n ? n.droppableId : t ? t.droppableId : null; | |
}, | |
eg = function (t) { | |
return t.combine ? t.combine.draggableId : null; | |
}, | |
tg = function (t) { | |
return t.at && t.at.type === 'COMBINE' ? t.at.combine.draggableId : null; | |
}; | |
function ng() { | |
var e = ve(function (i, a) { | |
return { x: i, y: a }; | |
}), | |
t = ve(function (i, a, o, l, s) { | |
return { | |
isDragging: !0, | |
isClone: a, | |
isDropAnimating: !!s, | |
dropAnimation: s, | |
mode: i, | |
draggingOver: o, | |
combineWith: l, | |
combineTargetFor: null, | |
}; | |
}), | |
n = ve(function (i, a, o, l, s, c, d) { | |
return { | |
mapped: { | |
type: 'DRAGGING', | |
dropping: null, | |
draggingOver: s, | |
combineWith: c, | |
mode: a, | |
offset: i, | |
dimension: o, | |
forceShouldAnimate: d, | |
snapshot: t(a, l, s, c, null), | |
}, | |
}; | |
}), | |
r = function (a, o) { | |
if (a.isDragging) { | |
if (a.critical.draggable.id !== o.draggableId) return null; | |
var l = a.current.client.offset, | |
s = a.dimensions.draggables[o.draggableId], | |
c = Be(a.impact), | |
d = tg(a.impact), | |
u = a.forceShouldAnimate; | |
return n(e(l.x, l.y), a.movementMode, s, o.isClone, c, d, u); | |
} | |
if (a.phase === 'DROP_ANIMATING') { | |
var f = a.completed; | |
if (f.result.draggableId !== o.draggableId) return null; | |
var p = o.isClone, | |
m = a.dimensions.draggables[o.draggableId], | |
h = f.result, | |
x = h.mode, | |
b = Rl(h), | |
C = eg(h), | |
S = a.dropDuration, | |
D = { | |
duration: S, | |
curve: yi.drop, | |
moveTo: a.newHomeClientOffset, | |
opacity: C ? Xt.opacity.drop : null, | |
scale: C ? Xt.scale.drop : null, | |
}; | |
return { | |
mapped: { | |
type: 'DRAGGING', | |
offset: a.newHomeClientOffset, | |
dimension: m, | |
dropping: D, | |
draggingOver: b, | |
combineWith: C, | |
mode: x, | |
forceShouldAnimate: null, | |
snapshot: t(x, p, b, C, D), | |
}, | |
}; | |
} | |
return null; | |
}; | |
return r; | |
} | |
function Fl(e) { | |
return { | |
isDragging: !1, | |
isDropAnimating: !1, | |
isClone: !1, | |
dropAnimation: null, | |
mode: null, | |
draggingOver: null, | |
combineTargetFor: e, | |
combineWith: null, | |
}; | |
} | |
var rg = { | |
mapped: { | |
type: 'SECONDARY', | |
offset: be, | |
combineTargetFor: null, | |
shouldAnimateDisplacement: !0, | |
snapshot: Fl(null), | |
}, | |
}; | |
function ig() { | |
var e = ve(function (o, l) { | |
return { x: o, y: l }; | |
}), | |
t = ve(Fl), | |
n = ve(function (o, l, s) { | |
return ( | |
l === void 0 && (l = null), | |
{ | |
mapped: { | |
type: 'SECONDARY', | |
offset: o, | |
combineTargetFor: l, | |
shouldAnimateDisplacement: s, | |
snapshot: t(l), | |
}, | |
} | |
); | |
}), | |
r = function (l) { | |
return l ? n(be, l, !0) : null; | |
}, | |
i = function (l, s, c, d) { | |
var u = c.displaced.visible[l], | |
f = !!(d.inVirtualList && d.effected[l]), | |
p = Yn(c), | |
m = p && p.draggableId === l ? s : null; | |
if (!u) { | |
if (!f) return r(m); | |
if (c.displaced.invisible[l]) return null; | |
var h = Nt(d.displacedBy.point), | |
x = e(h.x, h.y); | |
return n(x, m, !0); | |
} | |
if (f) return r(m); | |
var b = c.displacedBy.point, | |
C = e(b.x, b.y); | |
return n(C, m, u.shouldAnimate); | |
}, | |
a = function (l, s) { | |
if (l.isDragging) | |
return l.critical.draggable.id === s.draggableId | |
? null | |
: i(s.draggableId, l.critical.draggable.id, l.impact, l.afterCritical); | |
if (l.phase === 'DROP_ANIMATING') { | |
var c = l.completed; | |
return c.result.draggableId === s.draggableId | |
? null | |
: i(s.draggableId, c.result.draggableId, c.impact, c.afterCritical); | |
} | |
return null; | |
}; | |
return a; | |
} | |
var ag = function () { | |
var t = ng(), | |
n = ig(), | |
r = function (a, o) { | |
return t(a, o) || n(a, o) || rg; | |
}; | |
return r; | |
}, | |
og = { dropAnimationFinished: gl }, | |
lg = jo(ag, og, null, { context: Ii, pure: !0, areStatePropsEqual: Bl })(Zf); | |
function Ll(e) { | |
var t = Tn(Pi), | |
n = t.isUsingCloneFor; | |
return n === e.draggableId && !e.isClone ? null : _.createElement(lg, e); | |
} | |
function sg(e) { | |
var t = typeof e.isDragDisabled == 'boolean' ? !e.isDragDisabled : !0, | |
n = !!e.disableInteractiveElementBlocking, | |
r = !!e.shouldRespectForcePress; | |
return _.createElement( | |
Ll, | |
j({}, e, { | |
isClone: !1, | |
isEnabled: t, | |
canDragInteractiveElements: n, | |
shouldRespectForcePress: r, | |
}) | |
); | |
} | |
function ug(e) { | |
var t = N.useContext(_n); | |
t || B(!1); | |
var n = t.contextId, | |
r = t.isMovementAllowed, | |
i = N.useRef(null), | |
a = N.useRef(null), | |
o = e.children, | |
l = e.droppableId, | |
s = e.type, | |
c = e.mode, | |
d = e.direction, | |
u = e.ignoreContainerClipping, | |
f = e.isDropDisabled, | |
p = e.isCombineEnabled, | |
m = e.snapshot, | |
h = e.useClone, | |
x = e.updateViewportMaxScroll, | |
b = e.getContainerForClone, | |
C = M(function () { | |
return i.current; | |
}, []), | |
S = M(function (A) { | |
i.current = A; | |
}, []); | |
M(function () { | |
return a.current; | |
}, []); | |
var D = M(function (A) { | |
a.current = A; | |
}, []), | |
E = M( | |
function () { | |
r() && x({ maxScroll: yl() }); | |
}, | |
[r, x] | |
); | |
jf({ | |
droppableId: l, | |
type: s, | |
mode: c, | |
direction: d, | |
isDropDisabled: f, | |
isCombineEnabled: p, | |
ignoreContainerClipping: u, | |
getDroppableRef: C, | |
}); | |
var w = _.createElement( | |
Gf, | |
{ on: e.placeholder, shouldAnimate: e.shouldAnimatePlaceholder }, | |
function (A) { | |
var R = A.onClose, | |
Y = A.data, | |
q = A.animate; | |
return _.createElement(Uf, { | |
placeholder: Y, | |
onClose: R, | |
innerRef: D, | |
animate: q, | |
contextId: n, | |
onTransitionEnd: E, | |
}); | |
} | |
), | |
O = X( | |
function () { | |
return { | |
innerRef: S, | |
placeholder: w, | |
droppableProps: { 'data-rbd-droppable-id': l, 'data-rbd-droppable-context-id': n }, | |
}; | |
}, | |
[n, l, w, S] | |
), | |
L = h ? h.dragging.draggableId : null, | |
F = X( | |
function () { | |
return { droppableId: l, type: s, isUsingCloneFor: L }; | |
}, | |
[l, L, s] | |
); | |
function V() { | |
if (!h) return null; | |
var A = h.dragging, | |
R = h.render, | |
Y = _.createElement( | |
Ll, | |
{ | |
draggableId: A.draggableId, | |
index: A.source.index, | |
isClone: !0, | |
isEnabled: !0, | |
shouldRespectForcePress: !1, | |
canDragInteractiveElements: !0, | |
}, | |
function (q, $) { | |
return R(q, $, A); | |
} | |
); | |
return Ss.createPortal(Y, b()); | |
} | |
return _.createElement(Pi.Provider, { value: F }, o(O, m), V()); | |
} | |
var Dr = function (t, n) { | |
return t === n.droppable.type; | |
}, | |
Pa = function (t, n) { | |
return n.draggables[t.draggable.id]; | |
}, | |
cg = function () { | |
var t = { | |
placeholder: null, | |
shouldAnimatePlaceholder: !0, | |
snapshot: { | |
isDraggingOver: !1, | |
draggingOverWith: null, | |
draggingFromThisWith: null, | |
isUsingPlaceholder: !1, | |
}, | |
useClone: null, | |
}, | |
n = j({}, t, { shouldAnimatePlaceholder: !1 }), | |
r = ve(function (o) { | |
return { | |
draggableId: o.id, | |
type: o.type, | |
source: { index: o.index, droppableId: o.droppableId }, | |
}; | |
}), | |
i = ve(function (o, l, s, c, d, u) { | |
var f = d.descriptor.id, | |
p = d.descriptor.droppableId === o; | |
if (p) { | |
var m = u ? { render: u, dragging: r(d.descriptor) } : null, | |
h = { | |
isDraggingOver: s, | |
draggingOverWith: s ? f : null, | |
draggingFromThisWith: f, | |
isUsingPlaceholder: !0, | |
}; | |
return { | |
placeholder: d.placeholder, | |
shouldAnimatePlaceholder: !1, | |
snapshot: h, | |
useClone: m, | |
}; | |
} | |
if (!l) return n; | |
if (!c) return t; | |
var x = { | |
isDraggingOver: s, | |
draggingOverWith: f, | |
draggingFromThisWith: null, | |
isUsingPlaceholder: !0, | |
}; | |
return { | |
placeholder: d.placeholder, | |
shouldAnimatePlaceholder: !0, | |
snapshot: x, | |
useClone: null, | |
}; | |
}), | |
a = function (l, s) { | |
var c = s.droppableId, | |
d = s.type, | |
u = !s.isDropDisabled, | |
f = s.renderClone; | |
if (l.isDragging) { | |
var p = l.critical; | |
if (!Dr(d, p)) return n; | |
var m = Pa(p, l.dimensions), | |
h = Be(l.impact) === c; | |
return i(c, u, h, h, m, f); | |
} | |
if (l.phase === 'DROP_ANIMATING') { | |
var x = l.completed; | |
if (!Dr(d, x.critical)) return n; | |
var b = Pa(x.critical, l.dimensions); | |
return i(c, u, Rl(x.result) === c, Be(x.impact) === c, b, f); | |
} | |
if (l.phase === 'IDLE' && l.completed && !l.shouldFlush) { | |
var C = l.completed; | |
if (!Dr(d, C.critical)) return n; | |
var S = Be(C.impact) === c, | |
D = !!(C.impact.at && C.impact.at.type === 'COMBINE'), | |
E = C.critical.droppable.id === c; | |
return S ? (D ? t : n) : E ? t : n; | |
} | |
return n; | |
}; | |
return a; | |
}, | |
dg = { updateViewportMaxScroll: bd }; | |
function pg() { | |
return document.body || B(!1), document.body; | |
} | |
var fg = { | |
mode: 'standard', | |
type: 'DEFAULT', | |
direction: 'vertical', | |
isDropDisabled: !1, | |
isCombineEnabled: !1, | |
ignoreContainerClipping: !1, | |
renderClone: null, | |
getContainerForClone: pg, | |
}, | |
Ml = jo(cg, dg, null, { context: Ii, pure: !0, areStatePropsEqual: Bl })(ug); | |
Ml.defaultProps = fg; | |
const gg = () => Math.random().toString(36).slice(2, 5), | |
bn = { id: '', name: '', prompt: '' }, | |
mg = () => { | |
const [e, t] = N.useState([]), | |
[n, r] = N.useState(bn), | |
[i, a] = N.useState(!1); | |
N.useEffect(() => { | |
chrome.storage.sync.get(['rolesList'], (f) => { | |
const p = f.rolesList; | |
p.length > 0 && t(p); | |
}); | |
}, []); | |
const o = (f) => { | |
const { name: p, value: m } = f.target; | |
r((h) => ({ ...h, [p]: m })); | |
}, | |
l = () => { | |
if (!n.name) return; | |
const f = [...e, { ...n, id: gg() }]; | |
t(f), r(bn); | |
const p = { rolesList: f }; | |
chrome.storage.sync.set(p); | |
}, | |
s = () => { | |
const f = e.findIndex((h) => h.id === n.id), | |
p = [...e]; | |
(p[f] = n), t(p), r(bn), a(!1); | |
const m = { rolesList: p }; | |
chrome.storage.sync.set(m); | |
}, | |
c = (f) => { | |
const p = e.filter((h) => h.id !== f); | |
t(p), r(bn); | |
const m = { rolesList: p }; | |
chrome.storage.sync.set(m); | |
}, | |
d = (f) => { | |
const p = e.find((m) => m.id === f); | |
p && (r(p), a(!0), window.scrollTo(0, 0)); | |
}, | |
u = (f) => { | |
if (!f.destination) return; | |
const p = Array.from(e), | |
[m] = p.splice(f.source.index, 1); | |
p.splice(f.destination.index, 0, m), t(p); | |
const h = { rolesList: p }; | |
chrome.storage.sync.set(h); | |
}; | |
return g.jsxs('div', { | |
className: 'mx-auto pb-20 px-6 max-w-[86rem]', | |
children: [ | |
g.jsxs('div', { | |
className: 'my-6', | |
children: [ | |
g.jsx('h1', { className: 'text-3xl font-semibold', children: 'Customize prompts' }), | |
g.jsxs('div', { | |
className: 'mt-6', | |
children: [ | |
g.jsxs('div', { | |
className: 'flex items-center space-x-4 mb-4', | |
children: [ | |
g.jsx('input', { | |
type: 'text', | |
name: 'name', | |
value: n.name, | |
onChange: o, | |
placeholder: 'Name of the prompt', | |
className: | |
'w-1/3 px-3 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-purple-500 text-base', | |
}), | |
g.jsx('input', { | |
type: 'text', | |
name: 'prompt', | |
value: n.prompt, | |
onChange: o, | |
placeholder: 'Enter the prompt', | |
className: | |
'w-2/3 px-3 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-purple-500 text-base', | |
}), | |
g.jsx('button', { | |
onClick: i ? s : l, | |
className: | |
'px-6 py-2 bg-green-500 hover:bg-green-600 text-white text-base rounded-lg', | |
children: i ? 'Update' : 'Add', | |
}), | |
], | |
}), | |
g.jsx('div', { | |
className: '', | |
children: g.jsx(If, { | |
onDragEnd: u, | |
children: g.jsxs('table', { | |
className: 'w-full rounded-lg shadow-lg overflow-hidden', | |
children: [ | |
g.jsx('thead', { | |
children: g.jsxs('tr', { | |
className: 'bg-blue-500', | |
children: [ | |
g.jsx('th', { | |
className: | |
'px-6 py-3 text-left text-base font-medium text-gray-50 tracking-wider w-1/5', | |
children: 'Name', | |
}), | |
g.jsx('th', { | |
className: | |
'px-6 py-3 text-left text-base font-medium text-gray-50 tracking-wider w-3/5 max-w-xl', | |
children: 'Prompt', | |
}), | |
g.jsx('th', { | |
className: | |
'px-6 py-3 text-center text-base font-medium text-gray-50 tracking-wider w-1/5', | |
children: 'Actions', | |
}), | |
], | |
}), | |
}), | |
g.jsx(Ml, { | |
droppableId: 'prompts', | |
direction: 'vertical', | |
children: (f) => | |
g.jsx('tbody', { | |
className: 'bg-white divide-y divide-gray-200', | |
...f.droppableProps, | |
ref: f.innerRef, | |
children: e.map((p, m) => | |
g.jsx( | |
sg, | |
{ | |
draggableId: p.id.toString(), | |
index: m, | |
children: (h) => | |
g.jsxs( | |
'tr', | |
{ | |
ref: h.innerRef, | |
...h.draggableProps, | |
...h.dragHandleProps, | |
children: [ | |
g.jsx('td', { | |
className: | |
'px-6 py-4 whitespace-nowrap text-base font-medium text-gray-900 w-1/5', | |
children: p.name, | |
}), | |
g.jsx('td', { | |
className: | |
'px-6 py-4 text-base text-gray-800 max-w-xl', | |
children: p.prompt, | |
}), | |
g.jsxs('td', { | |
className: | |
'px-6 py-4 whitespace-nowrap text-center text-sm font-medium w-1/5', | |
children: [ | |
g.jsx('button', { | |
onClick: () => d(p.id), | |
className: | |
'px-3 py-1 bg-purple-500 hover:bg-purple-600 text-white rounded-lg mr-2', | |
children: 'Edit', | |
}), | |
g.jsx('button', { | |
onClick: () => c(p.id), | |
className: | |
'px-3 py-1 bg-red-400 hover:bg-red-500 text-white rounded-lg', | |
children: 'Delete', | |
}), | |
], | |
}), | |
], | |
}, | |
p.id | |
), | |
}, | |
p.id | |
) | |
), | |
}), | |
}), | |
], | |
}), | |
}), | |
}), | |
], | |
}), | |
], | |
}), | |
g.jsx('div', { | |
className: 'text-base font-medium text-gray-800', | |
children: '* Drag rows to sort the order of prompts', | |
}), | |
], | |
}); | |
}; | |
function hg({ children: e }) { | |
return g.jsx('kbd', { | |
className: | |
'px-2 py-0.5 text-sm font-semibold text-gray-800 bg-blue-100/90 font-code shadow-sm rounded-md border border-gray-300 border-b-[3px]', | |
children: e, | |
}); | |
} | |
function vg() { | |
const [e, t] = N.useState([]), | |
n = { name: 'Escape', shortcut: 'Esc', description: 'To close the response window' }; | |
N.useEffect(() => { | |
chrome.commands.getAll((i) => { | |
t([...i, n]); | |
}); | |
}, []); | |
const r = () => { | |
chrome.tabs.create({ url: 'chrome://extensions/shortcuts' }); | |
}; | |
return g.jsxs('div', { | |
className: 'px-20 mx-auto pb-20 max-w-4xl', | |
children: [ | |
g.jsx('h1', { | |
className: 'text-3xl font-semibold text-center font-sans mt-6', | |
children: 'Shortcuts', | |
}), | |
g.jsxs('div', { | |
className: 'p-8 pb-6 bg-white shadow mt-6 rounded-lg border border-gray-200', | |
children: [ | |
e.map((i, a) => | |
g.jsxs( | |
'div', | |
{ | |
className: 'flex items-center gap-4 mb-5', | |
children: [ | |
g.jsx('div', { | |
className: 'flex items-center w-[40%]', | |
children: i.shortcut | |
.split('+') | |
.map((o, l, s) => | |
g.jsxs( | |
'span', | |
{ | |
className: 'flex items-center', | |
children: [ | |
g.jsx(hg, { children: o || '-' }), | |
' ', | |
l < s.length - 1 && | |
g.jsx('span', { className: 'px-2 font-bold', children: '+' }), | |
], | |
}, | |
l | |
) | |
), | |
}), | |
g.jsx('div', { | |
className: 'text-base w-[60%]', | |
children: | |
i.name === '_execute_action' | |
? 'Activate/open extension popup' | |
: i.description, | |
}), | |
], | |
}, | |
a | |
) | |
), | |
g.jsx('div', { | |
className: 'flex justify-end', | |
children: g.jsx('button', { | |
onClick: r, | |
className: 'text-gray-600 hover:text-gray-900 text-base', | |
children: '↬ Update the shortcuts here', | |
}), | |
}), | |
], | |
}), | |
], | |
}); | |
} | |
function bg() { | |
const e = () => { | |
chrome.tabs.create({ url: 'chrome://extensions/shortcuts' }); | |
}; | |
return g.jsxs('div', { | |
className: 'px-6 mx-auto pb-20 max-w-4xl', | |
children: [ | |
g.jsx('h1', { | |
className: 'text-3xl font-semibold text-center font-sans mt-6', | |
children: 'QuickyAI guide', | |
}), | |
g.jsxs('div', { | |
className: 'p-6 bg-white shadow mt-6 rounded-lg border border-gray-200', | |
children: [ | |
g.jsxs('div', { | |
className: 'text-base', | |
children: [ | |
g.jsx('h2', { className: 'text-2xl font-medium', children: 'Getting started' }), | |
g.jsx('p', { | |
children: | |
"First setup the extension with License and OpenAI keys(API key is not required for Subscribers). Once they are set, you can see the green colored key with text 'Keys added' in the bottom left of extension popup.", | |
}), | |
' ', | |
g.jsx('p', { | |
className: 'text-lg font-medium', | |
children: 'There are 3 ways to use QuickyAI:', | |
}), | |
g.jsx('h3', { children: '1. Using right click' }), | |
g.jsx('p', { | |
children: | |
'→ Visit any web page right click to see the "Trigger QuickyAI" option with QuickyAI logo', | |
}), | |
g.jsx('p', { | |
children: `→ Once you click the "Trigger QuickyAI", you can start typing your query in the response window that gets opened and click "Trigger QuickyAI" from right click context menu by keeeping the cursor in the text to get the AI response.(Hence, it's called response window)`, | |
}), | |
g.jsx('h3', { children: '2. Using selection menu' }), | |
g.jsxs('p', { | |
children: [ | |
'→ Enable selection menu from the extension popup or use the shortcut you set (', | |
g.jsx('button', { | |
onClick: e, | |
className: 'text-blue-500 hover:text-blue-600', | |
children: 'Update shortcuts here', | |
}), | |
')', | |
], | |
}), | |
g.jsx('p', { | |
children: | |
'→ You can select text on any website and select a suitable default prompt and length of the response and click the Trigger icon (⚡) to get the response', | |
}), | |
g.jsx('h3', { children: '3. Using shortcut' }), | |
g.jsxs('p', { | |
children: [ | |
"→ In the extension popup you can find the shortcut to Trigger AI, if it doesn't exists, you can", | |
' ', | |
g.jsx('button', { | |
onClick: e, | |
className: 'text-blue-500 hover:text-blue-600', | |
children: 'set one here', | |
}), | |
], | |
}), | |
g.jsx('p', { | |
children: | |
'→ Visit any webpage, click the Trigger AI shortcut to open the response window and after typing text, keep the cursor within the textbox and enter the shortcut to get the response', | |
}), | |
g.jsxs('p', { | |
children: [ | |
g.jsx('b', { children: 'Note' }), | |
': You can use the above three methods interchangeably anywhere you want.', | |
], | |
}), | |
g.jsx('h3', { children: 'Direct trigger without selection' }), | |
g.jsx('p', { | |
children: | |
'→ You can get AI response without selecting the text if you are in the response window or in any text box where you enter text, such that you put your cursor after your text', | |
}), | |
g.jsxs('p', { | |
children: [ | |
'→ You can choose default prompt and length directly in the text(', | |
g.jsx('span', { className: 'font-semibold', children: 'which are optional' }), | |
'). To set the default prompt append ', | |
g.jsx('span', { className: 'font-bold', children: "'/'" }), | |
' ', | |
'followed by the prompt name and to set the length append', | |
' ', | |
g.jsx('span', { className: 'font-bold', children: "'#'" }), | |
' followed by a number or length', | |
], | |
}), | |
g.jsxs('p', { | |
children: [ | |
g.jsx('b', { children: 'Note' }), | |
': You can open any number of response windows on a page and close them easily just by pressing ', | |
g.jsx('b', { children: 'Escape' }), | |
' key.', | |
], | |
}), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'text-base', | |
children: [ | |
g.jsx('h2', { className: 'text-2xl font-medium', children: 'Customized query' }), | |
g.jsx('img', { | |
src: '/guide.png', | |
draggable: 'false', | |
className: 'select-none', | |
alt: 'Quicky AI text guide', | |
}), | |
g.jsx('p', { children: 'Text or query → any text that that you ask AI' }), | |
g.jsxs('p', { | |
children: [ | |
'Prompt name → any prompt name listed in the default prompts (', | |
g.jsx('a', { | |
href: chrome.runtime.getURL('/src/pages/options/index.html?id=prompts'), | |
className: 'text-blue-500 hover:text-blue-600', | |
children: 'add new prompts here', | |
}), | |
')', | |
], | |
}), | |
g.jsx('p', { | |
children: | |
'Limit on tokens → to get answers under the given limit (any number, s, small, l, long, ll, longer)', | |
}), | |
g.jsxs('div', { | |
className: 'text-black', | |
children: [ | |
g.jsx('h3', { children: 'Examples:' }), | |
g.jsxs('p', { | |
children: [ | |
'→ What is global warming/ask#s ', | |
g.jsx('br', {}), | |
g.jsx('span', { | |
className: 'text-gray-600', | |
children: "(For response based on prompt: 'ask' & length: 'small')", | |
}), | |
], | |
}), | |
g.jsxs('p', { | |
children: [ | |
'→ Give me a story about elephants/reply#medium ', | |
g.jsx('br', {}), | |
g.jsx('span', { | |
className: 'text-gray-600', | |
children: "(For response based on prompt: 'reply' & length: 'medium')", | |
}), | |
], | |
}), | |
g.jsxs('p', { | |
children: [ | |
'→ How to learn marketing?/explain#100 ', | |
g.jsx('br', {}), | |
g.jsx('span', { | |
className: 'text-gray-600', | |
children: | |
"(For response based on prompt: 'explain' & length: under 100 tokens or words)", | |
}), | |
], | |
}), | |
g.jsxs('p', { | |
children: [ | |
'→ why roses are red#50 ', | |
g.jsx('br', {}), | |
g.jsxs('span', { | |
className: 'text-gray-600', | |
children: [ | |
' ', | |
'(For response under 50 tokens or words, based on selected prompt)', | |
], | |
}), | |
], | |
}), | |
g.jsxs('p', { | |
children: [ | |
'→ why apples are red', | |
g.jsx('br', {}), | |
g.jsxs('span', { | |
className: 'text-gray-600', | |
children: [' ', '(For response based on selected prompt and length)'], | |
}), | |
], | |
}), | |
], | |
}), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'text-base mt-10', | |
children: [ | |
'For more guides check the', | |
' ', | |
g.jsx('a', { | |
href: 'https://quickyai.com/demo?ref=guide', | |
target: '_blank', | |
className: 'text-blue-400 hover:text-blue-500', | |
rel: 'noreferrer', | |
children: '🎥 demos', | |
}), | |
], | |
}), | |
], | |
}), | |
], | |
}); | |
} | |
function yg({ isOpen: e, onDelete: t, onClose: n }) { | |
return g.jsx('div', { | |
className: | |
'fixed z-50 p-4 overflow-x-hidden overflow-y-auto inset-0 h-[100vh] max-h-full bg-gray-700/50 flex justify-center items-center', | |
onClick: n, | |
style: { display: e ? 'flex' : 'none' }, | |
children: g.jsx('div', { | |
className: 'relative w-full max-w-md max-h-full -mt-32', | |
onClick: (r) => r.stopPropagation(), | |
children: g.jsxs('div', { | |
className: 'relative bg-white rounded-lg shadow dark:bg-gray-700', | |
children: [ | |
g.jsxs('button', { | |
type: 'button', | |
className: | |
'absolute top-3 right-2.5 text-gray-400 bg-transparent hover:bg-gray-200 hover:text-gray-900 rounded-lg text-sm p-1.5 ml-auto inline-flex items-center dark:hover:bg-gray-800 dark:hover:text-white', | |
onClick: n, | |
children: [ | |
g.jsx('svg', { | |
'aria-hidden': 'true', | |
className: 'w-5 h-5', | |
fill: 'currentColor', | |
viewBox: '0 0 20 20', | |
xmlns: 'http://www.w3.org/2000/svg', | |
children: g.jsx('path', { | |
fillRule: 'evenodd', | |
d: 'M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z', | |
clipRule: 'evenodd', | |
}), | |
}), | |
g.jsx('span', { className: 'sr-only', children: 'Close modal' }), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'p-6 text-center', | |
children: [ | |
g.jsx('svg', { | |
'aria-hidden': 'true', | |
className: 'mx-auto mb-4 text-gray-400 w-14 h-14 dark:text-gray-200', | |
fill: 'none', | |
stroke: 'currentColor', | |
viewBox: '0 0 24 24', | |
xmlns: 'http://www.w3.org/2000/svg', | |
children: g.jsx('path', { | |
strokeLinecap: 'round', | |
strokeLinejoin: 'round', | |
strokeWidth: '2', | |
d: 'M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z', | |
}), | |
}), | |
g.jsx('h3', { | |
className: 'text-lg font-normal text-gray-500 dark:text-gray-400 mb-1', | |
children: 'Are you sure you want to delete all chat history?', | |
}), | |
g.jsx('h4', { | |
className: 'text-center mb-5 text-gray-600', | |
children: '(You can backup using export button)', | |
}), | |
g.jsx('button', { | |
'data-modal-hide': 'popup-modal', | |
type: 'button', | |
className: | |
'text-white bg-red-600 hover:bg-red-800 focus:ring-4 focus:outline-none focus:ring-red-300 dark:focus:ring-red-800 font-medium rounded-lg text-sm inline-flex items-center px-5 py-2.5 text-center mr-2', | |
onClick: t, | |
children: "Yes, I'm sure", | |
}), | |
g.jsx('button', { | |
'data-modal-hide': 'popup-modal', | |
type: 'button', | |
className: | |
'text-gray-500 bg-white hover:bg-gray-100 focus:ring-4 focus:outline-none focus:ring-gray-200 rounded-lg border border-gray-200 text-sm font-medium px-5 py-2.5 hover:text-gray-900 focus:z-10 dark:bg-gray-700 dark:text-gray-300 dark:border-gray-500 dark:hover:text-white dark:hover:bg-gray-600 dark:focus:ring-gray-600', | |
onClick: n, | |
children: 'No, cancel', | |
}), | |
], | |
}), | |
], | |
}), | |
}), | |
}); | |
} | |
const Aa = ['http', 'https', 'mailto', 'tel']; | |
function xg(e) { | |
const t = (e || '').trim(), | |
n = t.charAt(0); | |
if (n === '#' || n === '/') return t; | |
const r = t.indexOf(':'); | |
if (r === -1) return t; | |
let i = -1; | |
for (; ++i < Aa.length; ) { | |
const a = Aa[i]; | |
if (r === a.length && t.slice(0, a.length).toLowerCase() === a) return t; | |
} | |
return ( | |
(i = t.indexOf('?')), | |
(i !== -1 && r > i) || ((i = t.indexOf('#')), i !== -1 && r > i) ? t : 'javascript:void(0)' | |
); | |
} | |
/*! | |
* Determine if an object is a Buffer | |
* | |
* @author Feross Aboukhadijeh <https://feross.org> | |
* @license MIT | |
*/ var wg = function (t) { | |
return ( | |
t != null && | |
t.constructor != null && | |
typeof t.constructor.isBuffer == 'function' && | |
t.constructor.isBuffer(t) | |
); | |
}; | |
const jl = wg; | |
function Gt(e) { | |
return !e || typeof e != 'object' | |
? '' | |
: 'position' in e || 'type' in e | |
? Na(e.position) | |
: 'start' in e || 'end' in e | |
? Na(e) | |
: 'line' in e || 'column' in e | |
? Wr(e) | |
: ''; | |
} | |
function Wr(e) { | |
return Oa(e && e.line) + ':' + Oa(e && e.column); | |
} | |
function Na(e) { | |
return Wr(e && e.start) + '-' + Wr(e && e.end); | |
} | |
function Oa(e) { | |
return e && typeof e == 'number' ? e : 1; | |
} | |
class He extends Error { | |
constructor(t, n, r) { | |
const i = [null, null]; | |
let a = { start: { line: null, column: null }, end: { line: null, column: null } }; | |
if ((super(), typeof n == 'string' && ((r = n), (n = void 0)), typeof r == 'string')) { | |
const o = r.indexOf(':'); | |
o === -1 ? (i[1] = r) : ((i[0] = r.slice(0, o)), (i[1] = r.slice(o + 1))); | |
} | |
n && | |
('type' in n || 'position' in n | |
? n.position && (a = n.position) | |
: 'start' in n || 'end' in n | |
? (a = n) | |
: ('line' in n || 'column' in n) && (a.start = n)), | |
(this.name = Gt(n) || '1:1'), | |
(this.message = typeof t == 'object' ? t.message : t), | |
(this.stack = ''), | |
typeof t == 'object' && t.stack && (this.stack = t.stack), | |
(this.reason = this.message), | |
this.fatal, | |
(this.line = a.start.line), | |
(this.column = a.start.column), | |
(this.position = a), | |
(this.source = i[0]), | |
(this.ruleId = i[1]), | |
this.file, | |
this.actual, | |
this.expected, | |
this.url, | |
this.note; | |
} | |
} | |
He.prototype.file = ''; | |
He.prototype.name = ''; | |
He.prototype.reason = ''; | |
He.prototype.message = ''; | |
He.prototype.stack = ''; | |
He.prototype.fatal = null; | |
He.prototype.column = null; | |
He.prototype.line = null; | |
He.prototype.source = null; | |
He.prototype.ruleId = null; | |
He.prototype.position = null; | |
const Ye = { basename: Sg, dirname: Cg, extname: Dg, join: Ig, sep: '/' }; | |
function Sg(e, t) { | |
if (t !== void 0 && typeof t != 'string') throw new TypeError('"ext" argument must be a string'); | |
un(e); | |
let n = 0, | |
r = -1, | |
i = e.length, | |
a; | |
if (t === void 0 || t.length === 0 || t.length > e.length) { | |
for (; i--; ) | |
if (e.charCodeAt(i) === 47) { | |
if (a) { | |
n = i + 1; | |
break; | |
} | |
} else r < 0 && ((a = !0), (r = i + 1)); | |
return r < 0 ? '' : e.slice(n, r); | |
} | |
if (t === e) return ''; | |
let o = -1, | |
l = t.length - 1; | |
for (; i--; ) | |
if (e.charCodeAt(i) === 47) { | |
if (a) { | |
n = i + 1; | |
break; | |
} | |
} else | |
o < 0 && ((a = !0), (o = i + 1)), | |
l > -1 && (e.charCodeAt(i) === t.charCodeAt(l--) ? l < 0 && (r = i) : ((l = -1), (r = o))); | |
return n === r ? (r = o) : r < 0 && (r = e.length), e.slice(n, r); | |
} | |
function Cg(e) { | |
if ((un(e), e.length === 0)) return '.'; | |
let t = -1, | |
n = e.length, | |
r; | |
for (; --n; ) | |
if (e.charCodeAt(n) === 47) { | |
if (r) { | |
t = n; | |
break; | |
} | |
} else r || (r = !0); | |
return t < 0 | |
? e.charCodeAt(0) === 47 | |
? '/' | |
: '.' | |
: t === 1 && e.charCodeAt(0) === 47 | |
? '//' | |
: e.slice(0, t); | |
} | |
function Dg(e) { | |
un(e); | |
let t = e.length, | |
n = -1, | |
r = 0, | |
i = -1, | |
a = 0, | |
o; | |
for (; t--; ) { | |
const l = e.charCodeAt(t); | |
if (l === 47) { | |
if (o) { | |
r = t + 1; | |
break; | |
} | |
continue; | |
} | |
n < 0 && ((o = !0), (n = t + 1)), | |
l === 46 ? (i < 0 ? (i = t) : a !== 1 && (a = 1)) : i > -1 && (a = -1); | |
} | |
return i < 0 || n < 0 || a === 0 || (a === 1 && i === n - 1 && i === r + 1) ? '' : e.slice(i, n); | |
} | |
function Ig(...e) { | |
let t = -1, | |
n; | |
for (; ++t < e.length; ) un(e[t]), e[t] && (n = n === void 0 ? e[t] : n + '/' + e[t]); | |
return n === void 0 ? '.' : kg(n); | |
} | |
function kg(e) { | |
un(e); | |
const t = e.charCodeAt(0) === 47; | |
let n = Eg(e, !t); | |
return ( | |
n.length === 0 && !t && (n = '.'), | |
n.length > 0 && e.charCodeAt(e.length - 1) === 47 && (n += '/'), | |
t ? '/' + n : n | |
); | |
} | |
function Eg(e, t) { | |
let n = '', | |
r = 0, | |
i = -1, | |
a = 0, | |
o = -1, | |
l, | |
s; | |
for (; ++o <= e.length; ) { | |
if (o < e.length) l = e.charCodeAt(o); | |
else { | |
if (l === 47) break; | |
l = 47; | |
} | |
if (l === 47) { | |
if (!(i === o - 1 || a === 1)) | |
if (i !== o - 1 && a === 2) { | |
if ( | |
n.length < 2 || | |
r !== 2 || | |
n.charCodeAt(n.length - 1) !== 46 || | |
n.charCodeAt(n.length - 2) !== 46 | |
) { | |
if (n.length > 2) { | |
if (((s = n.lastIndexOf('/')), s !== n.length - 1)) { | |
s < 0 | |
? ((n = ''), (r = 0)) | |
: ((n = n.slice(0, s)), (r = n.length - 1 - n.lastIndexOf('/'))), | |
(i = o), | |
(a = 0); | |
continue; | |
} | |
} else if (n.length > 0) { | |
(n = ''), (r = 0), (i = o), (a = 0); | |
continue; | |
} | |
} | |
t && ((n = n.length > 0 ? n + '/..' : '..'), (r = 2)); | |
} else | |
n.length > 0 ? (n += '/' + e.slice(i + 1, o)) : (n = e.slice(i + 1, o)), (r = o - i - 1); | |
(i = o), (a = 0); | |
} else l === 46 && a > -1 ? a++ : (a = -1); | |
} | |
return n; | |
} | |
function un(e) { | |
if (typeof e != 'string') | |
throw new TypeError('Path must be a string. Received ' + JSON.stringify(e)); | |
} | |
const Pg = { cwd: Ag }; | |
function Ag() { | |
return '/'; | |
} | |
function qr(e) { | |
return e !== null && typeof e == 'object' && e.href && e.origin; | |
} | |
function Ng(e) { | |
if (typeof e == 'string') e = new URL(e); | |
else if (!qr(e)) { | |
const t = new TypeError( | |
'The "path" argument must be of type string or an instance of URL. Received `' + e + '`' | |
); | |
throw ((t.code = 'ERR_INVALID_ARG_TYPE'), t); | |
} | |
if (e.protocol !== 'file:') { | |
const t = new TypeError('The URL must be of scheme file'); | |
throw ((t.code = 'ERR_INVALID_URL_SCHEME'), t); | |
} | |
return Og(e); | |
} | |
function Og(e) { | |
if (e.hostname !== '') { | |
const r = new TypeError('File URL host must be "localhost" or empty on darwin'); | |
throw ((r.code = 'ERR_INVALID_FILE_URL_HOST'), r); | |
} | |
const t = e.pathname; | |
let n = -1; | |
for (; ++n < t.length; ) | |
if (t.charCodeAt(n) === 37 && t.charCodeAt(n + 1) === 50) { | |
const r = t.charCodeAt(n + 2); | |
if (r === 70 || r === 102) { | |
const i = new TypeError('File URL path must not include encoded / characters'); | |
throw ((i.code = 'ERR_INVALID_FILE_URL_PATH'), i); | |
} | |
} | |
return decodeURIComponent(t); | |
} | |
const Ir = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']; | |
class zl { | |
constructor(t) { | |
let n; | |
t | |
? typeof t == 'string' || Tg(t) | |
? (n = { value: t }) | |
: qr(t) | |
? (n = { path: t }) | |
: (n = t) | |
: (n = {}), | |
(this.data = {}), | |
(this.messages = []), | |
(this.history = []), | |
(this.cwd = Pg.cwd()), | |
this.value, | |
this.stored, | |
this.result, | |
this.map; | |
let r = -1; | |
for (; ++r < Ir.length; ) { | |
const a = Ir[r]; | |
a in n && n[a] !== void 0 && n[a] !== null && (this[a] = a === 'history' ? [...n[a]] : n[a]); | |
} | |
let i; | |
for (i in n) Ir.includes(i) || (this[i] = n[i]); | |
} | |
get path() { | |
return this.history[this.history.length - 1]; | |
} | |
set path(t) { | |
qr(t) && (t = Ng(t)), Er(t, 'path'), this.path !== t && this.history.push(t); | |
} | |
get dirname() { | |
return typeof this.path == 'string' ? Ye.dirname(this.path) : void 0; | |
} | |
set dirname(t) { | |
Ta(this.basename, 'dirname'), (this.path = Ye.join(t || '', this.basename)); | |
} | |
get basename() { | |
return typeof this.path == 'string' ? Ye.basename(this.path) : void 0; | |
} | |
set basename(t) { | |
Er(t, 'basename'), kr(t, 'basename'), (this.path = Ye.join(this.dirname || '', t)); | |
} | |
get extname() { | |
return typeof this.path == 'string' ? Ye.extname(this.path) : void 0; | |
} | |
set extname(t) { | |
if ((kr(t, 'extname'), Ta(this.dirname, 'extname'), t)) { | |
if (t.charCodeAt(0) !== 46) throw new Error('`extname` must start with `.`'); | |
if (t.includes('.', 1)) throw new Error('`extname` cannot contain multiple dots'); | |
} | |
this.path = Ye.join(this.dirname, this.stem + (t || '')); | |
} | |
get stem() { | |
return typeof this.path == 'string' ? Ye.basename(this.path, this.extname) : void 0; | |
} | |
set stem(t) { | |
Er(t, 'stem'), | |
kr(t, 'stem'), | |
(this.path = Ye.join(this.dirname || '', t + (this.extname || ''))); | |
} | |
toString(t) { | |
return (this.value || '').toString(t || void 0); | |
} | |
message(t, n, r) { | |
const i = new He(t, n, r); | |
return ( | |
this.path && ((i.name = this.path + ':' + i.name), (i.file = this.path)), | |
(i.fatal = !1), | |
this.messages.push(i), | |
i | |
); | |
} | |
info(t, n, r) { | |
const i = this.message(t, n, r); | |
return (i.fatal = null), i; | |
} | |
fail(t, n, r) { | |
const i = this.message(t, n, r); | |
throw ((i.fatal = !0), i); | |
} | |
} | |
function kr(e, t) { | |
if (e && e.includes(Ye.sep)) | |
throw new Error('`' + t + '` cannot be a path: did not expect `' + Ye.sep + '`'); | |
} | |
function Er(e, t) { | |
if (!e) throw new Error('`' + t + '` cannot be empty'); | |
} | |
function Ta(e, t) { | |
if (!e) throw new Error('Setting `' + t + '` requires `path` to be set too'); | |
} | |
function Tg(e) { | |
return jl(e); | |
} | |
function Ba(e) { | |
if (e) throw e; | |
} | |
var Sn = Object.prototype.hasOwnProperty, | |
$l = Object.prototype.toString, | |
Ra = Object.defineProperty, | |
Fa = Object.getOwnPropertyDescriptor, | |
La = function (t) { | |
return typeof Array.isArray == 'function' ? Array.isArray(t) : $l.call(t) === '[object Array]'; | |
}, | |
Ma = function (t) { | |
if (!t || $l.call(t) !== '[object Object]') return !1; | |
var n = Sn.call(t, 'constructor'), | |
r = | |
t.constructor && | |
t.constructor.prototype && | |
Sn.call(t.constructor.prototype, 'isPrototypeOf'); | |
if (t.constructor && !n && !r) return !1; | |
var i; | |
for (i in t); | |
return typeof i > 'u' || Sn.call(t, i); | |
}, | |
ja = function (t, n) { | |
Ra && n.name === '__proto__' | |
? Ra(t, n.name, { enumerable: !0, configurable: !0, value: n.newValue, writable: !0 }) | |
: (t[n.name] = n.newValue); | |
}, | |
za = function (t, n) { | |
if (n === '__proto__') | |
if (Sn.call(t, n)) { | |
if (Fa) return Fa(t, n).value; | |
} else return; | |
return t[n]; | |
}, | |
$a = function e() { | |
var t, | |
n, | |
r, | |
i, | |
a, | |
o, | |
l = arguments[0], | |
s = 1, | |
c = arguments.length, | |
d = !1; | |
for ( | |
typeof l == 'boolean' && ((d = l), (l = arguments[1] || {}), (s = 2)), | |
(l == null || (typeof l != 'object' && typeof l != 'function')) && (l = {}); | |
s < c; | |
++s | |
) | |
if (((t = arguments[s]), t != null)) | |
for (n in t) | |
(r = za(l, n)), | |
(i = za(t, n)), | |
l !== i && | |
(d && i && (Ma(i) || (a = La(i))) | |
? (a ? ((a = !1), (o = r && La(r) ? r : [])) : (o = r && Ma(r) ? r : {}), | |
ja(l, { name: n, newValue: e(d, o, i) })) | |
: typeof i < 'u' && ja(l, { name: n, newValue: i })); | |
return l; | |
}; | |
function Vr(e) { | |
if (typeof e != 'object' || e === null) return !1; | |
const t = Object.getPrototypeOf(e); | |
return ( | |
(t === null || t === Object.prototype || Object.getPrototypeOf(t) === null) && | |
!(Symbol.toStringTag in e) && | |
!(Symbol.iterator in e) | |
); | |
} | |
function Bg() { | |
const e = [], | |
t = { run: n, use: r }; | |
return t; | |
function n(...i) { | |
let a = -1; | |
const o = i.pop(); | |
if (typeof o != 'function') throw new TypeError('Expected function as last argument, not ' + o); | |
l(null, ...i); | |
function l(s, ...c) { | |
const d = e[++a]; | |
let u = -1; | |
if (s) { | |
o(s); | |
return; | |
} | |
for (; ++u < i.length; ) (c[u] === null || c[u] === void 0) && (c[u] = i[u]); | |
(i = c), d ? Rg(d, l)(...c) : o(null, ...c); | |
} | |
} | |
function r(i) { | |
if (typeof i != 'function') | |
throw new TypeError('Expected `middelware` to be a function, not ' + i); | |
return e.push(i), t; | |
} | |
} | |
function Rg(e, t) { | |
let n; | |
return r; | |
function r(...o) { | |
const l = e.length > o.length; | |
let s; | |
l && o.push(i); | |
try { | |
s = e.apply(this, o); | |
} catch (c) { | |
const d = c; | |
if (l && n) throw d; | |
return i(d); | |
} | |
l || (s instanceof Promise ? s.then(a, i) : s instanceof Error ? i(s) : a(s)); | |
} | |
function i(o, ...l) { | |
n || ((n = !0), t(o, ...l)); | |
} | |
function a(o) { | |
i(null, o); | |
} | |
} | |
const Fg = Ul().freeze(), | |
Hl = {}.hasOwnProperty; | |
function Ul() { | |
const e = Bg(), | |
t = []; | |
let n = {}, | |
r, | |
i = -1; | |
return ( | |
(a.data = o), | |
(a.Parser = void 0), | |
(a.Compiler = void 0), | |
(a.freeze = l), | |
(a.attachers = t), | |
(a.use = s), | |
(a.parse = c), | |
(a.stringify = d), | |
(a.run = u), | |
(a.runSync = f), | |
(a.process = p), | |
(a.processSync = m), | |
a | |
); | |
function a() { | |
const h = Ul(); | |
let x = -1; | |
for (; ++x < t.length; ) h.use(...t[x]); | |
return h.data($a(!0, {}, n)), h; | |
} | |
function o(h, x) { | |
return typeof h == 'string' | |
? arguments.length === 2 | |
? (Nr('data', r), (n[h] = x), a) | |
: (Hl.call(n, h) && n[h]) || null | |
: h | |
? (Nr('data', r), (n = h), a) | |
: n; | |
} | |
function l() { | |
if (r) return a; | |
for (; ++i < t.length; ) { | |
const [h, ...x] = t[i]; | |
if (x[0] === !1) continue; | |
x[0] === !0 && (x[0] = void 0); | |
const b = h.call(a, ...x); | |
typeof b == 'function' && e.use(b); | |
} | |
return (r = !0), (i = Number.POSITIVE_INFINITY), a; | |
} | |
function s(h, ...x) { | |
let b; | |
if ((Nr('use', r), h != null)) | |
if (typeof h == 'function') E(h, ...x); | |
else if (typeof h == 'object') Array.isArray(h) ? D(h) : S(h); | |
else throw new TypeError('Expected usable value, not `' + h + '`'); | |
return b && (n.settings = Object.assign(n.settings || {}, b)), a; | |
function C(w) { | |
if (typeof w == 'function') E(w); | |
else if (typeof w == 'object') | |
if (Array.isArray(w)) { | |
const [O, ...L] = w; | |
E(O, ...L); | |
} else S(w); | |
else throw new TypeError('Expected usable value, not `' + w + '`'); | |
} | |
function S(w) { | |
D(w.plugins), w.settings && (b = Object.assign(b || {}, w.settings)); | |
} | |
function D(w) { | |
let O = -1; | |
if (w != null) | |
if (Array.isArray(w)) | |
for (; ++O < w.length; ) { | |
const L = w[O]; | |
C(L); | |
} | |
else throw new TypeError('Expected a list of plugins, not `' + w + '`'); | |
} | |
function E(w, O) { | |
let L = -1, | |
F; | |
for (; ++L < t.length; ) | |
if (t[L][0] === w) { | |
F = t[L]; | |
break; | |
} | |
F ? (Vr(F[1]) && Vr(O) && (O = $a(!0, F[1], O)), (F[1] = O)) : t.push([...arguments]); | |
} | |
} | |
function c(h) { | |
a.freeze(); | |
const x = $t(h), | |
b = a.Parser; | |
return Pr('parse', b), Ha(b, 'parse') ? new b(String(x), x).parse() : b(String(x), x); | |
} | |
function d(h, x) { | |
a.freeze(); | |
const b = $t(x), | |
C = a.Compiler; | |
return Ar('stringify', C), Ua(h), Ha(C, 'compile') ? new C(h, b).compile() : C(h, b); | |
} | |
function u(h, x, b) { | |
if ((Ua(h), a.freeze(), !b && typeof x == 'function' && ((b = x), (x = void 0)), !b)) | |
return new Promise(C); | |
C(null, b); | |
function C(S, D) { | |
e.run(h, $t(x), E); | |
function E(w, O, L) { | |
(O = O || h), w ? D(w) : S ? S(O) : b(null, O, L); | |
} | |
} | |
} | |
function f(h, x) { | |
let b, C; | |
return a.run(h, x, S), Ga('runSync', 'run', C), b; | |
function S(D, E) { | |
Ba(D), (b = E), (C = !0); | |
} | |
} | |
function p(h, x) { | |
if ((a.freeze(), Pr('process', a.Parser), Ar('process', a.Compiler), !x)) return new Promise(b); | |
b(null, x); | |
function b(C, S) { | |
const D = $t(h); | |
a.run(a.parse(D), D, (w, O, L) => { | |
if (w || !O || !L) E(w); | |
else { | |
const F = a.stringify(O, L); | |
F == null || (jg(F) ? (L.value = F) : (L.result = F)), E(w, L); | |
} | |
}); | |
function E(w, O) { | |
w || !O ? S(w) : C ? C(O) : x(null, O); | |
} | |
} | |
} | |
function m(h) { | |
let x; | |
a.freeze(), Pr('processSync', a.Parser), Ar('processSync', a.Compiler); | |
const b = $t(h); | |
return a.process(b, C), Ga('processSync', 'process', x), b; | |
function C(S) { | |
(x = !0), Ba(S); | |
} | |
} | |
} | |
function Ha(e, t) { | |
return typeof e == 'function' && e.prototype && (Lg(e.prototype) || t in e.prototype); | |
} | |
function Lg(e) { | |
let t; | |
for (t in e) if (Hl.call(e, t)) return !0; | |
return !1; | |
} | |
function Pr(e, t) { | |
if (typeof t != 'function') throw new TypeError('Cannot `' + e + '` without `Parser`'); | |
} | |
function Ar(e, t) { | |
if (typeof t != 'function') throw new TypeError('Cannot `' + e + '` without `Compiler`'); | |
} | |
function Nr(e, t) { | |
if (t) | |
throw new Error( | |
'Cannot call `' + | |
e + | |
'` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.' | |
); | |
} | |
function Ua(e) { | |
if (!Vr(e) || typeof e.type != 'string') throw new TypeError('Expected node, got `' + e + '`'); | |
} | |
function Ga(e, t, n) { | |
if (!n) throw new Error('`' + e + '` finished async. Use `' + t + '` instead'); | |
} | |
function $t(e) { | |
return Mg(e) ? e : new zl(e); | |
} | |
function Mg(e) { | |
return !!(e && typeof e == 'object' && 'message' in e && 'messages' in e); | |
} | |
function jg(e) { | |
return typeof e == 'string' || jl(e); | |
} | |
const zg = {}; | |
function $g(e, t) { | |
const n = t || zg, | |
r = typeof n.includeImageAlt == 'boolean' ? n.includeImageAlt : !0, | |
i = typeof n.includeHtml == 'boolean' ? n.includeHtml : !0; | |
return Gl(e, r, i); | |
} | |
function Gl(e, t, n) { | |
if (Hg(e)) { | |
if ('value' in e) return e.type === 'html' && !n ? '' : e.value; | |
if (t && 'alt' in e && e.alt) return e.alt; | |
if ('children' in e) return Wa(e.children, t, n); | |
} | |
return Array.isArray(e) ? Wa(e, t, n) : ''; | |
} | |
function Wa(e, t, n) { | |
const r = []; | |
let i = -1; | |
for (; ++i < e.length; ) r[i] = Gl(e[i], t, n); | |
return r.join(''); | |
} | |
function Hg(e) { | |
return !!(e && typeof e == 'object'); | |
} | |
function Xe(e, t, n, r) { | |
const i = e.length; | |
let a = 0, | |
o; | |
if ((t < 0 ? (t = -t > i ? 0 : i + t) : (t = t > i ? i : t), (n = n > 0 ? n : 0), r.length < 1e4)) | |
(o = Array.from(r)), o.unshift(t, n), e.splice(...o); | |
else | |
for (n && e.splice(t, n); a < r.length; ) | |
(o = r.slice(a, a + 1e4)), o.unshift(t, 0), e.splice(...o), (a += 1e4), (t += 1e4); | |
} | |
function je(e, t) { | |
return e.length > 0 ? (Xe(e, e.length, 0, t), e) : t; | |
} | |
const qa = {}.hasOwnProperty; | |
function Ug(e) { | |
const t = {}; | |
let n = -1; | |
for (; ++n < e.length; ) Gg(t, e[n]); | |
return t; | |
} | |
function Gg(e, t) { | |
let n; | |
for (n in t) { | |
const i = (qa.call(e, n) ? e[n] : void 0) || (e[n] = {}), | |
a = t[n]; | |
let o; | |
if (a) | |
for (o in a) { | |
qa.call(i, o) || (i[o] = []); | |
const l = a[o]; | |
Wg(i[o], Array.isArray(l) ? l : l ? [l] : []); | |
} | |
} | |
} | |
function Wg(e, t) { | |
let n = -1; | |
const r = []; | |
for (; ++n < t.length; ) (t[n].add === 'after' ? e : r).push(t[n]); | |
Xe(e, 0, 0, r); | |
} | |
const qg = | |
/[!-\/:-@\[-`\{-~\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061D-\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1B7D\u1B7E\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52-\u2E5D\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/, | |
Qe = pt(/[A-Za-z]/), | |
Te = pt(/[\dA-Za-z]/), | |
Vg = pt(/[#-'*+\--9=?A-Z^-~]/); | |
function Kr(e) { | |
return e !== null && (e < 32 || e === 127); | |
} | |
const Yr = pt(/\d/), | |
Kg = pt(/[\dA-Fa-f]/), | |
Yg = pt(/[!-/:-@[-`{-~]/); | |
function G(e) { | |
return e !== null && e < -2; | |
} | |
function Ee(e) { | |
return e !== null && (e < 0 || e === 32); | |
} | |
function Z(e) { | |
return e === -2 || e === -1 || e === 32; | |
} | |
const Qg = pt(qg), | |
Xg = pt(/\s/); | |
function pt(e) { | |
return t; | |
function t(n) { | |
return n !== null && e.test(String.fromCharCode(n)); | |
} | |
} | |
function ae(e, t, n, r) { | |
const i = r ? r - 1 : Number.POSITIVE_INFINITY; | |
let a = 0; | |
return o; | |
function o(s) { | |
return Z(s) ? (e.enter(n), l(s)) : t(s); | |
} | |
function l(s) { | |
return Z(s) && a++ < i ? (e.consume(s), l) : (e.exit(n), t(s)); | |
} | |
} | |
const Jg = { tokenize: _g }; | |
function _g(e) { | |
const t = e.attempt(this.parser.constructs.contentInitial, r, i); | |
let n; | |
return t; | |
function r(l) { | |
if (l === null) { | |
e.consume(l); | |
return; | |
} | |
return e.enter('lineEnding'), e.consume(l), e.exit('lineEnding'), ae(e, t, 'linePrefix'); | |
} | |
function i(l) { | |
return e.enter('paragraph'), a(l); | |
} | |
function a(l) { | |
const s = e.enter('chunkText', { contentType: 'text', previous: n }); | |
return n && (n.next = s), (n = s), o(l); | |
} | |
function o(l) { | |
if (l === null) { | |
e.exit('chunkText'), e.exit('paragraph'), e.consume(l); | |
return; | |
} | |
return G(l) ? (e.consume(l), e.exit('chunkText'), a) : (e.consume(l), o); | |
} | |
} | |
const Zg = { tokenize: em }, | |
Va = { tokenize: tm }; | |
function em(e) { | |
const t = this, | |
n = []; | |
let r = 0, | |
i, | |
a, | |
o; | |
return l; | |
function l(S) { | |
if (r < n.length) { | |
const D = n[r]; | |
return (t.containerState = D[1]), e.attempt(D[0].continuation, s, c)(S); | |
} | |
return c(S); | |
} | |
function s(S) { | |
if ((r++, t.containerState._closeFlow)) { | |
(t.containerState._closeFlow = void 0), i && C(); | |
const D = t.events.length; | |
let E = D, | |
w; | |
for (; E--; ) | |
if (t.events[E][0] === 'exit' && t.events[E][1].type === 'chunkFlow') { | |
w = t.events[E][1].end; | |
break; | |
} | |
b(r); | |
let O = D; | |
for (; O < t.events.length; ) (t.events[O][1].end = Object.assign({}, w)), O++; | |
return Xe(t.events, E + 1, 0, t.events.slice(D)), (t.events.length = O), c(S); | |
} | |
return l(S); | |
} | |
function c(S) { | |
if (r === n.length) { | |
if (!i) return f(S); | |
if (i.currentConstruct && i.currentConstruct.concrete) return m(S); | |
t.interrupt = !!(i.currentConstruct && !i._gfmTableDynamicInterruptHack); | |
} | |
return (t.containerState = {}), e.check(Va, d, u)(S); | |
} | |
function d(S) { | |
return i && C(), b(r), f(S); | |
} | |
function u(S) { | |
return (t.parser.lazy[t.now().line] = r !== n.length), (o = t.now().offset), m(S); | |
} | |
function f(S) { | |
return (t.containerState = {}), e.attempt(Va, p, m)(S); | |
} | |
function p(S) { | |
return r++, n.push([t.currentConstruct, t.containerState]), f(S); | |
} | |
function m(S) { | |
if (S === null) { | |
i && C(), b(0), e.consume(S); | |
return; | |
} | |
return ( | |
(i = i || t.parser.flow(t.now())), | |
e.enter('chunkFlow', { contentType: 'flow', previous: a, _tokenizer: i }), | |
h(S) | |
); | |
} | |
function h(S) { | |
if (S === null) { | |
x(e.exit('chunkFlow'), !0), b(0), e.consume(S); | |
return; | |
} | |
return G(S) | |
? (e.consume(S), x(e.exit('chunkFlow')), (r = 0), (t.interrupt = void 0), l) | |
: (e.consume(S), h); | |
} | |
function x(S, D) { | |
const E = t.sliceStream(S); | |
if ( | |
(D && E.push(null), | |
(S.previous = a), | |
a && (a.next = S), | |
(a = S), | |
i.defineSkip(S.start), | |
i.write(E), | |
t.parser.lazy[S.start.line]) | |
) { | |
let w = i.events.length; | |
for (; w--; ) | |
if ( | |
i.events[w][1].start.offset < o && | |
(!i.events[w][1].end || i.events[w][1].end.offset > o) | |
) | |
return; | |
const O = t.events.length; | |
let L = O, | |
F, | |
V; | |
for (; L--; ) | |
if (t.events[L][0] === 'exit' && t.events[L][1].type === 'chunkFlow') { | |
if (F) { | |
V = t.events[L][1].end; | |
break; | |
} | |
F = !0; | |
} | |
for (b(r), w = O; w < t.events.length; ) (t.events[w][1].end = Object.assign({}, V)), w++; | |
Xe(t.events, L + 1, 0, t.events.slice(O)), (t.events.length = w); | |
} | |
} | |
function b(S) { | |
let D = n.length; | |
for (; D-- > S; ) { | |
const E = n[D]; | |
(t.containerState = E[1]), E[0].exit.call(t, e); | |
} | |
n.length = S; | |
} | |
function C() { | |
i.write([null]), (a = void 0), (i = void 0), (t.containerState._closeFlow = void 0); | |
} | |
} | |
function tm(e, t, n) { | |
return ae( | |
e, | |
e.attempt(this.parser.constructs.document, t, n), | |
'linePrefix', | |
this.parser.constructs.disable.null.includes('codeIndented') ? void 0 : 4 | |
); | |
} | |
function Ka(e) { | |
if (e === null || Ee(e) || Xg(e)) return 1; | |
if (Qg(e)) return 2; | |
} | |
function Ai(e, t, n) { | |
const r = []; | |
let i = -1; | |
for (; ++i < e.length; ) { | |
const a = e[i].resolveAll; | |
a && !r.includes(a) && ((t = a(t, n)), r.push(a)); | |
} | |
return t; | |
} | |
const Qr = { name: 'attention', tokenize: rm, resolveAll: nm }; | |
function nm(e, t) { | |
let n = -1, | |
r, | |
i, | |
a, | |
o, | |
l, | |
s, | |
c, | |
d; | |
for (; ++n < e.length; ) | |
if (e[n][0] === 'enter' && e[n][1].type === 'attentionSequence' && e[n][1]._close) { | |
for (r = n; r--; ) | |
if ( | |
e[r][0] === 'exit' && | |
e[r][1].type === 'attentionSequence' && | |
e[r][1]._open && | |
t.sliceSerialize(e[r][1]).charCodeAt(0) === t.sliceSerialize(e[n][1]).charCodeAt(0) | |
) { | |
if ( | |
(e[r][1]._close || e[n][1]._open) && | |
(e[n][1].end.offset - e[n][1].start.offset) % 3 && | |
!( | |
(e[r][1].end.offset - | |
e[r][1].start.offset + | |
e[n][1].end.offset - | |
e[n][1].start.offset) % | |
3 | |
) | |
) | |
continue; | |
s = | |
e[r][1].end.offset - e[r][1].start.offset > 1 && | |
e[n][1].end.offset - e[n][1].start.offset > 1 | |
? 2 | |
: 1; | |
const u = Object.assign({}, e[r][1].end), | |
f = Object.assign({}, e[n][1].start); | |
Ya(u, -s), | |
Ya(f, s), | |
(o = { | |
type: s > 1 ? 'strongSequence' : 'emphasisSequence', | |
start: u, | |
end: Object.assign({}, e[r][1].end), | |
}), | |
(l = { | |
type: s > 1 ? 'strongSequence' : 'emphasisSequence', | |
start: Object.assign({}, e[n][1].start), | |
end: f, | |
}), | |
(a = { | |
type: s > 1 ? 'strongText' : 'emphasisText', | |
start: Object.assign({}, e[r][1].end), | |
end: Object.assign({}, e[n][1].start), | |
}), | |
(i = { | |
type: s > 1 ? 'strong' : 'emphasis', | |
start: Object.assign({}, o.start), | |
end: Object.assign({}, l.end), | |
}), | |
(e[r][1].end = Object.assign({}, o.start)), | |
(e[n][1].start = Object.assign({}, l.end)), | |
(c = []), | |
e[r][1].end.offset - e[r][1].start.offset && | |
(c = je(c, [ | |
['enter', e[r][1], t], | |
['exit', e[r][1], t], | |
])), | |
(c = je(c, [ | |
['enter', i, t], | |
['enter', o, t], | |
['exit', o, t], | |
['enter', a, t], | |
])), | |
(c = je(c, Ai(t.parser.constructs.insideSpan.null, e.slice(r + 1, n), t))), | |
(c = je(c, [ | |
['exit', a, t], | |
['enter', l, t], | |
['exit', l, t], | |
['exit', i, t], | |
])), | |
e[n][1].end.offset - e[n][1].start.offset | |
? ((d = 2), | |
(c = je(c, [ | |
['enter', e[n][1], t], | |
['exit', e[n][1], t], | |
]))) | |
: (d = 0), | |
Xe(e, r - 1, n - r + 3, c), | |
(n = r + c.length - d - 2); | |
break; | |
} | |
} | |
for (n = -1; ++n < e.length; ) e[n][1].type === 'attentionSequence' && (e[n][1].type = 'data'); | |
return e; | |
} | |
function rm(e, t) { | |
const n = this.parser.constructs.attentionMarkers.null, | |
r = this.previous, | |
i = Ka(r); | |
let a; | |
return o; | |
function o(s) { | |
return (a = s), e.enter('attentionSequence'), l(s); | |
} | |
function l(s) { | |
if (s === a) return e.consume(s), l; | |
const c = e.exit('attentionSequence'), | |
d = Ka(s), | |
u = !d || (d === 2 && i) || n.includes(s), | |
f = !i || (i === 2 && d) || n.includes(r); | |
return ( | |
(c._open = !!(a === 42 ? u : u && (i || !f))), | |
(c._close = !!(a === 42 ? f : f && (d || !u))), | |
t(s) | |
); | |
} | |
} | |
function Ya(e, t) { | |
(e.column += t), (e.offset += t), (e._bufferIndex += t); | |
} | |
const im = { name: 'autolink', tokenize: am }; | |
function am(e, t, n) { | |
let r = 0; | |
return i; | |
function i(p) { | |
return ( | |
e.enter('autolink'), | |
e.enter('autolinkMarker'), | |
e.consume(p), | |
e.exit('autolinkMarker'), | |
e.enter('autolinkProtocol'), | |
a | |
); | |
} | |
function a(p) { | |
return Qe(p) ? (e.consume(p), o) : c(p); | |
} | |
function o(p) { | |
return p === 43 || p === 45 || p === 46 || Te(p) ? ((r = 1), l(p)) : c(p); | |
} | |
function l(p) { | |
return p === 58 | |
? (e.consume(p), (r = 0), s) | |
: (p === 43 || p === 45 || p === 46 || Te(p)) && r++ < 32 | |
? (e.consume(p), l) | |
: ((r = 0), c(p)); | |
} | |
function s(p) { | |
return p === 62 | |
? (e.exit('autolinkProtocol'), | |
e.enter('autolinkMarker'), | |
e.consume(p), | |
e.exit('autolinkMarker'), | |
e.exit('autolink'), | |
t) | |
: p === null || p === 32 || p === 60 || Kr(p) | |
? n(p) | |
: (e.consume(p), s); | |
} | |
function c(p) { | |
return p === 64 ? (e.consume(p), d) : Vg(p) ? (e.consume(p), c) : n(p); | |
} | |
function d(p) { | |
return Te(p) ? u(p) : n(p); | |
} | |
function u(p) { | |
return p === 46 | |
? (e.consume(p), (r = 0), d) | |
: p === 62 | |
? ((e.exit('autolinkProtocol').type = 'autolinkEmail'), | |
e.enter('autolinkMarker'), | |
e.consume(p), | |
e.exit('autolinkMarker'), | |
e.exit('autolink'), | |
t) | |
: f(p); | |
} | |
function f(p) { | |
if ((p === 45 || Te(p)) && r++ < 63) { | |
const m = p === 45 ? f : u; | |
return e.consume(p), m; | |
} | |
return n(p); | |
} | |
} | |
const er = { tokenize: om, partial: !0 }; | |
function om(e, t, n) { | |
return r; | |
function r(a) { | |
return Z(a) ? ae(e, i, 'linePrefix')(a) : i(a); | |
} | |
function i(a) { | |
return a === null || G(a) ? t(a) : n(a); | |
} | |
} | |
const Wl = { name: 'blockQuote', tokenize: lm, continuation: { tokenize: sm }, exit: um }; | |
function lm(e, t, n) { | |
const r = this; | |
return i; | |
function i(o) { | |
if (o === 62) { | |
const l = r.containerState; | |
return ( | |
l.open || (e.enter('blockQuote', { _container: !0 }), (l.open = !0)), | |
e.enter('blockQuotePrefix'), | |
e.enter('blockQuoteMarker'), | |
e.consume(o), | |
e.exit('blockQuoteMarker'), | |
a | |
); | |
} | |
return n(o); | |
} | |
function a(o) { | |
return Z(o) | |
? (e.enter('blockQuotePrefixWhitespace'), | |
e.consume(o), | |
e.exit('blockQuotePrefixWhitespace'), | |
e.exit('blockQuotePrefix'), | |
t) | |
: (e.exit('blockQuotePrefix'), t(o)); | |
} | |
} | |
function sm(e, t, n) { | |
const r = this; | |
return i; | |
function i(o) { | |
return Z(o) | |
? ae( | |
e, | |
a, | |
'linePrefix', | |
r.parser.constructs.disable.null.includes('codeIndented') ? void 0 : 4 | |
)(o) | |
: a(o); | |
} | |
function a(o) { | |
return e.attempt(Wl, t, n)(o); | |
} | |
} | |
function um(e) { | |
e.exit('blockQuote'); | |
} | |
const ql = { name: 'characterEscape', tokenize: cm }; | |
function cm(e, t, n) { | |
return r; | |
function r(a) { | |
return ( | |
e.enter('characterEscape'), e.enter('escapeMarker'), e.consume(a), e.exit('escapeMarker'), i | |
); | |
} | |
function i(a) { | |
return Yg(a) | |
? (e.enter('characterEscapeValue'), | |
e.consume(a), | |
e.exit('characterEscapeValue'), | |
e.exit('characterEscape'), | |
t) | |
: n(a); | |
} | |
} | |
const Qa = document.createElement('i'); | |
function Ni(e) { | |
const t = '&' + e + ';'; | |
Qa.innerHTML = t; | |
const n = Qa.textContent; | |
return (n.charCodeAt(n.length - 1) === 59 && e !== 'semi') || n === t ? !1 : n; | |
} | |
const Vl = { name: 'characterReference', tokenize: dm }; | |
function dm(e, t, n) { | |
const r = this; | |
let i = 0, | |
a, | |
o; | |
return l; | |
function l(u) { | |
return ( | |
e.enter('characterReference'), | |
e.enter('characterReferenceMarker'), | |
e.consume(u), | |
e.exit('characterReferenceMarker'), | |
s | |
); | |
} | |
function s(u) { | |
return u === 35 | |
? (e.enter('characterReferenceMarkerNumeric'), | |
e.consume(u), | |
e.exit('characterReferenceMarkerNumeric'), | |
c) | |
: (e.enter('characterReferenceValue'), (a = 31), (o = Te), d(u)); | |
} | |
function c(u) { | |
return u === 88 || u === 120 | |
? (e.enter('characterReferenceMarkerHexadecimal'), | |
e.consume(u), | |
e.exit('characterReferenceMarkerHexadecimal'), | |
e.enter('characterReferenceValue'), | |
(a = 6), | |
(o = Kg), | |
d) | |
: (e.enter('characterReferenceValue'), (a = 7), (o = Yr), d(u)); | |
} | |
function d(u) { | |
if (u === 59 && i) { | |
const f = e.exit('characterReferenceValue'); | |
return o === Te && !Ni(r.sliceSerialize(f)) | |
? n(u) | |
: (e.enter('characterReferenceMarker'), | |
e.consume(u), | |
e.exit('characterReferenceMarker'), | |
e.exit('characterReference'), | |
t); | |
} | |
return o(u) && i++ < a ? (e.consume(u), d) : n(u); | |
} | |
} | |
const Xa = { tokenize: fm, partial: !0 }, | |
Ja = { name: 'codeFenced', tokenize: pm, concrete: !0 }; | |
function pm(e, t, n) { | |
const r = this, | |
i = { tokenize: E, partial: !0 }; | |
let a = 0, | |
o = 0, | |
l; | |
return s; | |
function s(w) { | |
return c(w); | |
} | |
function c(w) { | |
const O = r.events[r.events.length - 1]; | |
return ( | |
(a = O && O[1].type === 'linePrefix' ? O[2].sliceSerialize(O[1], !0).length : 0), | |
(l = w), | |
e.enter('codeFenced'), | |
e.enter('codeFencedFence'), | |
e.enter('codeFencedFenceSequence'), | |
d(w) | |
); | |
} | |
function d(w) { | |
return w === l | |
? (o++, e.consume(w), d) | |
: o < 3 | |
? n(w) | |
: (e.exit('codeFencedFenceSequence'), Z(w) ? ae(e, u, 'whitespace')(w) : u(w)); | |
} | |
function u(w) { | |
return w === null || G(w) | |
? (e.exit('codeFencedFence'), r.interrupt ? t(w) : e.check(Xa, h, D)(w)) | |
: (e.enter('codeFencedFenceInfo'), e.enter('chunkString', { contentType: 'string' }), f(w)); | |
} | |
function f(w) { | |
return w === null || G(w) | |
? (e.exit('chunkString'), e.exit('codeFencedFenceInfo'), u(w)) | |
: Z(w) | |
? (e.exit('chunkString'), e.exit('codeFencedFenceInfo'), ae(e, p, 'whitespace')(w)) | |
: w === 96 && w === l | |
? n(w) | |
: (e.consume(w), f); | |
} | |
function p(w) { | |
return w === null || G(w) | |
? u(w) | |
: (e.enter('codeFencedFenceMeta'), e.enter('chunkString', { contentType: 'string' }), m(w)); | |
} | |
function m(w) { | |
return w === null || G(w) | |
? (e.exit('chunkString'), e.exit('codeFencedFenceMeta'), u(w)) | |
: w === 96 && w === l | |
? n(w) | |
: (e.consume(w), m); | |
} | |
function h(w) { | |
return e.attempt(i, D, x)(w); | |
} | |
function x(w) { | |
return e.enter('lineEnding'), e.consume(w), e.exit('lineEnding'), b; | |
} | |
function b(w) { | |
return a > 0 && Z(w) ? ae(e, C, 'linePrefix', a + 1)(w) : C(w); | |
} | |
function C(w) { | |
return w === null || G(w) ? e.check(Xa, h, D)(w) : (e.enter('codeFlowValue'), S(w)); | |
} | |
function S(w) { | |
return w === null || G(w) ? (e.exit('codeFlowValue'), C(w)) : (e.consume(w), S); | |
} | |
function D(w) { | |
return e.exit('codeFenced'), t(w); | |
} | |
function E(w, O, L) { | |
let F = 0; | |
return V; | |
function V($) { | |
return w.enter('lineEnding'), w.consume($), w.exit('lineEnding'), A; | |
} | |
function A($) { | |
return ( | |
w.enter('codeFencedFence'), | |
Z($) | |
? ae( | |
w, | |
R, | |
'linePrefix', | |
r.parser.constructs.disable.null.includes('codeIndented') ? void 0 : 4 | |
)($) | |
: R($) | |
); | |
} | |
function R($) { | |
return $ === l ? (w.enter('codeFencedFenceSequence'), Y($)) : L($); | |
} | |
function Y($) { | |
return $ === l | |
? (F++, w.consume($), Y) | |
: F >= o | |
? (w.exit('codeFencedFenceSequence'), Z($) ? ae(w, q, 'whitespace')($) : q($)) | |
: L($); | |
} | |
function q($) { | |
return $ === null || G($) ? (w.exit('codeFencedFence'), O($)) : L($); | |
} | |
} | |
} | |
function fm(e, t, n) { | |
const r = this; | |
return i; | |
function i(o) { | |
return o === null ? n(o) : (e.enter('lineEnding'), e.consume(o), e.exit('lineEnding'), a); | |
} | |
function a(o) { | |
return r.parser.lazy[r.now().line] ? n(o) : t(o); | |
} | |
} | |
const Or = { name: 'codeIndented', tokenize: mm }, | |
gm = { tokenize: hm, partial: !0 }; | |
function mm(e, t, n) { | |
const r = this; | |
return i; | |
function i(c) { | |
return e.enter('codeIndented'), ae(e, a, 'linePrefix', 4 + 1)(c); | |
} | |
function a(c) { | |
const d = r.events[r.events.length - 1]; | |
return d && d[1].type === 'linePrefix' && d[2].sliceSerialize(d[1], !0).length >= 4 | |
? o(c) | |
: n(c); | |
} | |
function o(c) { | |
return c === null ? s(c) : G(c) ? e.attempt(gm, o, s)(c) : (e.enter('codeFlowValue'), l(c)); | |
} | |
function l(c) { | |
return c === null || G(c) ? (e.exit('codeFlowValue'), o(c)) : (e.consume(c), l); | |
} | |
function s(c) { | |
return e.exit('codeIndented'), t(c); | |
} | |
} | |
function hm(e, t, n) { | |
const r = this; | |
return i; | |
function i(o) { | |
return r.parser.lazy[r.now().line] | |
? n(o) | |
: G(o) | |
? (e.enter('lineEnding'), e.consume(o), e.exit('lineEnding'), i) | |
: ae(e, a, 'linePrefix', 4 + 1)(o); | |
} | |
function a(o) { | |
const l = r.events[r.events.length - 1]; | |
return l && l[1].type === 'linePrefix' && l[2].sliceSerialize(l[1], !0).length >= 4 | |
? t(o) | |
: G(o) | |
? i(o) | |
: n(o); | |
} | |
} | |
const vm = { name: 'codeText', tokenize: xm, resolve: bm, previous: ym }; | |
function bm(e) { | |
let t = e.length - 4, | |
n = 3, | |
r, | |
i; | |
if ( | |
(e[n][1].type === 'lineEnding' || e[n][1].type === 'space') && | |
(e[t][1].type === 'lineEnding' || e[t][1].type === 'space') | |
) { | |
for (r = n; ++r < t; ) | |
if (e[r][1].type === 'codeTextData') { | |
(e[n][1].type = 'codeTextPadding'), (e[t][1].type = 'codeTextPadding'), (n += 2), (t -= 2); | |
break; | |
} | |
} | |
for (r = n - 1, t++; ++r <= t; ) | |
i === void 0 | |
? r !== t && e[r][1].type !== 'lineEnding' && (i = r) | |
: (r === t || e[r][1].type === 'lineEnding') && | |
((e[i][1].type = 'codeTextData'), | |
r !== i + 2 && | |
((e[i][1].end = e[r - 1][1].end), | |
e.splice(i + 2, r - i - 2), | |
(t -= r - i - 2), | |
(r = i + 2)), | |
(i = void 0)); | |
return e; | |
} | |
function ym(e) { | |
return e !== 96 || this.events[this.events.length - 1][1].type === 'characterEscape'; | |
} | |
function xm(e, t, n) { | |
let r = 0, | |
i, | |
a; | |
return o; | |
function o(u) { | |
return e.enter('codeText'), e.enter('codeTextSequence'), l(u); | |
} | |
function l(u) { | |
return u === 96 ? (e.consume(u), r++, l) : (e.exit('codeTextSequence'), s(u)); | |
} | |
function s(u) { | |
return u === null | |
? n(u) | |
: u === 32 | |
? (e.enter('space'), e.consume(u), e.exit('space'), s) | |
: u === 96 | |
? ((a = e.enter('codeTextSequence')), (i = 0), d(u)) | |
: G(u) | |
? (e.enter('lineEnding'), e.consume(u), e.exit('lineEnding'), s) | |
: (e.enter('codeTextData'), c(u)); | |
} | |
function c(u) { | |
return u === null || u === 32 || u === 96 || G(u) | |
? (e.exit('codeTextData'), s(u)) | |
: (e.consume(u), c); | |
} | |
function d(u) { | |
return u === 96 | |
? (e.consume(u), i++, d) | |
: i === r | |
? (e.exit('codeTextSequence'), e.exit('codeText'), t(u)) | |
: ((a.type = 'codeTextData'), c(u)); | |
} | |
} | |
function Kl(e) { | |
const t = {}; | |
let n = -1, | |
r, | |
i, | |
a, | |
o, | |
l, | |
s, | |
c; | |
for (; ++n < e.length; ) { | |
for (; n in t; ) n = t[n]; | |
if ( | |
((r = e[n]), | |
n && | |
r[1].type === 'chunkFlow' && | |
e[n - 1][1].type === 'listItemPrefix' && | |
((s = r[1]._tokenizer.events), | |
(a = 0), | |
a < s.length && s[a][1].type === 'lineEndingBlank' && (a += 2), | |
a < s.length && s[a][1].type === 'content')) | |
) | |
for (; ++a < s.length && s[a][1].type !== 'content'; ) | |
s[a][1].type === 'chunkText' && ((s[a][1]._isInFirstContentOfListItem = !0), a++); | |
if (r[0] === 'enter') r[1].contentType && (Object.assign(t, wm(e, n)), (n = t[n]), (c = !0)); | |
else if (r[1]._container) { | |
for ( | |
a = n, i = void 0; | |
a-- && ((o = e[a]), o[1].type === 'lineEnding' || o[1].type === 'lineEndingBlank'); | |
) | |
o[0] === 'enter' && | |
(i && (e[i][1].type = 'lineEndingBlank'), (o[1].type = 'lineEnding'), (i = a)); | |
i && | |
((r[1].end = Object.assign({}, e[i][1].start)), | |
(l = e.slice(i, n)), | |
l.unshift(r), | |
Xe(e, i, n - i + 1, l)); | |
} | |
} | |
return !c; | |
} | |
function wm(e, t) { | |
const n = e[t][1], | |
r = e[t][2]; | |
let i = t - 1; | |
const a = [], | |
o = n._tokenizer || r.parser[n.contentType](n.start), | |
l = o.events, | |
s = [], | |
c = {}; | |
let d, | |
u, | |
f = -1, | |
p = n, | |
m = 0, | |
h = 0; | |
const x = [h]; | |
for (; p; ) { | |
for (; e[++i][1] !== p; ); | |
a.push(i), | |
p._tokenizer || | |
((d = r.sliceStream(p)), | |
p.next || d.push(null), | |
u && o.defineSkip(p.start), | |
p._isInFirstContentOfListItem && (o._gfmTasklistFirstContentOfListItem = !0), | |
o.write(d), | |
p._isInFirstContentOfListItem && (o._gfmTasklistFirstContentOfListItem = void 0)), | |
(u = p), | |
(p = p.next); | |
} | |
for (p = n; ++f < l.length; ) | |
l[f][0] === 'exit' && | |
l[f - 1][0] === 'enter' && | |
l[f][1].type === l[f - 1][1].type && | |
l[f][1].start.line !== l[f][1].end.line && | |
((h = f + 1), x.push(h), (p._tokenizer = void 0), (p.previous = void 0), (p = p.next)); | |
for ( | |
o.events = [], p ? ((p._tokenizer = void 0), (p.previous = void 0)) : x.pop(), f = x.length; | |
f--; | |
) { | |
const b = l.slice(x[f], x[f + 1]), | |
C = a.pop(); | |
s.unshift([C, C + b.length - 1]), Xe(e, C, 2, b); | |
} | |
for (f = -1; ++f < s.length; ) (c[m + s[f][0]] = m + s[f][1]), (m += s[f][1] - s[f][0] - 1); | |
return c; | |
} | |
const Sm = { tokenize: Im, resolve: Dm }, | |
Cm = { tokenize: km, partial: !0 }; | |
function Dm(e) { | |
return Kl(e), e; | |
} | |
function Im(e, t) { | |
let n; | |
return r; | |
function r(l) { | |
return e.enter('content'), (n = e.enter('chunkContent', { contentType: 'content' })), i(l); | |
} | |
function i(l) { | |
return l === null ? a(l) : G(l) ? e.check(Cm, o, a)(l) : (e.consume(l), i); | |
} | |
function a(l) { | |
return e.exit('chunkContent'), e.exit('content'), t(l); | |
} | |
function o(l) { | |
return ( | |
e.consume(l), | |
e.exit('chunkContent'), | |
(n.next = e.enter('chunkContent', { contentType: 'content', previous: n })), | |
(n = n.next), | |
i | |
); | |
} | |
} | |
function km(e, t, n) { | |
const r = this; | |
return i; | |
function i(o) { | |
return ( | |
e.exit('chunkContent'), | |
e.enter('lineEnding'), | |
e.consume(o), | |
e.exit('lineEnding'), | |
ae(e, a, 'linePrefix') | |
); | |
} | |
function a(o) { | |
if (o === null || G(o)) return n(o); | |
const l = r.events[r.events.length - 1]; | |
return !r.parser.constructs.disable.null.includes('codeIndented') && | |
l && | |
l[1].type === 'linePrefix' && | |
l[2].sliceSerialize(l[1], !0).length >= 4 | |
? t(o) | |
: e.interrupt(r.parser.constructs.flow, n, t)(o); | |
} | |
} | |
function Yl(e, t, n, r, i, a, o, l, s) { | |
const c = s || Number.POSITIVE_INFINITY; | |
let d = 0; | |
return u; | |
function u(b) { | |
return b === 60 | |
? (e.enter(r), e.enter(i), e.enter(a), e.consume(b), e.exit(a), f) | |
: b === null || b === 32 || b === 41 || Kr(b) | |
? n(b) | |
: (e.enter(r), | |
e.enter(o), | |
e.enter(l), | |
e.enter('chunkString', { contentType: 'string' }), | |
h(b)); | |
} | |
function f(b) { | |
return b === 62 | |
? (e.enter(a), e.consume(b), e.exit(a), e.exit(i), e.exit(r), t) | |
: (e.enter(l), e.enter('chunkString', { contentType: 'string' }), p(b)); | |
} | |
function p(b) { | |
return b === 62 | |
? (e.exit('chunkString'), e.exit(l), f(b)) | |
: b === null || b === 60 || G(b) | |
? n(b) | |
: (e.consume(b), b === 92 ? m : p); | |
} | |
function m(b) { | |
return b === 60 || b === 62 || b === 92 ? (e.consume(b), p) : p(b); | |
} | |
function h(b) { | |
return !d && (b === null || b === 41 || Ee(b)) | |
? (e.exit('chunkString'), e.exit(l), e.exit(o), e.exit(r), t(b)) | |
: d < c && b === 40 | |
? (e.consume(b), d++, h) | |
: b === 41 | |
? (e.consume(b), d--, h) | |
: b === null || b === 32 || b === 40 || Kr(b) | |
? n(b) | |
: (e.consume(b), b === 92 ? x : h); | |
} | |
function x(b) { | |
return b === 40 || b === 41 || b === 92 ? (e.consume(b), h) : h(b); | |
} | |
} | |
function Ql(e, t, n, r, i, a) { | |
const o = this; | |
let l = 0, | |
s; | |
return c; | |
function c(p) { | |
return e.enter(r), e.enter(i), e.consume(p), e.exit(i), e.enter(a), d; | |
} | |
function d(p) { | |
return l > 999 || | |
p === null || | |
p === 91 || | |
(p === 93 && !s) || | |
(p === 94 && !l && '_hiddenFootnoteSupport' in o.parser.constructs) | |
? n(p) | |
: p === 93 | |
? (e.exit(a), e.enter(i), e.consume(p), e.exit(i), e.exit(r), t) | |
: G(p) | |
? (e.enter('lineEnding'), e.consume(p), e.exit('lineEnding'), d) | |
: (e.enter('chunkString', { contentType: 'string' }), u(p)); | |
} | |
function u(p) { | |
return p === null || p === 91 || p === 93 || G(p) || l++ > 999 | |
? (e.exit('chunkString'), d(p)) | |
: (e.consume(p), s || (s = !Z(p)), p === 92 ? f : u); | |
} | |
function f(p) { | |
return p === 91 || p === 92 || p === 93 ? (e.consume(p), l++, u) : u(p); | |
} | |
} | |
function Xl(e, t, n, r, i, a) { | |
let o; | |
return l; | |
function l(f) { | |
return f === 34 || f === 39 || f === 40 | |
? (e.enter(r), e.enter(i), e.consume(f), e.exit(i), (o = f === 40 ? 41 : f), s) | |
: n(f); | |
} | |
function s(f) { | |
return f === o ? (e.enter(i), e.consume(f), e.exit(i), e.exit(r), t) : (e.enter(a), c(f)); | |
} | |
function c(f) { | |
return f === o | |
? (e.exit(a), s(o)) | |
: f === null | |
? n(f) | |
: G(f) | |
? (e.enter('lineEnding'), e.consume(f), e.exit('lineEnding'), ae(e, c, 'linePrefix')) | |
: (e.enter('chunkString', { contentType: 'string' }), d(f)); | |
} | |
function d(f) { | |
return f === o || f === null || G(f) | |
? (e.exit('chunkString'), c(f)) | |
: (e.consume(f), f === 92 ? u : d); | |
} | |
function u(f) { | |
return f === o || f === 92 ? (e.consume(f), d) : d(f); | |
} | |
} | |
function Wt(e, t) { | |
let n; | |
return r; | |
function r(i) { | |
return G(i) | |
? (e.enter('lineEnding'), e.consume(i), e.exit('lineEnding'), (n = !0), r) | |
: Z(i) | |
? ae(e, r, n ? 'linePrefix' : 'lineSuffix')(i) | |
: t(i); | |
} | |
} | |
function It(e) { | |
return e | |
.replace(/[\t\n\r ]+/g, ' ') | |
.replace(/^ | $/g, '') | |
.toLowerCase() | |
.toUpperCase(); | |
} | |
const Em = { name: 'definition', tokenize: Am }, | |
Pm = { tokenize: Nm, partial: !0 }; | |
function Am(e, t, n) { | |
const r = this; | |
let i; | |
return a; | |
function a(p) { | |
return e.enter('definition'), o(p); | |
} | |
function o(p) { | |
return Ql.call( | |
r, | |
e, | |
l, | |
n, | |
'definitionLabel', | |
'definitionLabelMarker', | |
'definitionLabelString' | |
)(p); | |
} | |
function l(p) { | |
return ( | |
(i = It(r.sliceSerialize(r.events[r.events.length - 1][1]).slice(1, -1))), | |
p === 58 ? (e.enter('definitionMarker'), e.consume(p), e.exit('definitionMarker'), s) : n(p) | |
); | |
} | |
function s(p) { | |
return Ee(p) ? Wt(e, c)(p) : c(p); | |
} | |
function c(p) { | |
return Yl( | |
e, | |
d, | |
n, | |
'definitionDestination', | |
'definitionDestinationLiteral', | |
'definitionDestinationLiteralMarker', | |
'definitionDestinationRaw', | |
'definitionDestinationString' | |
)(p); | |
} | |
function d(p) { | |
return e.attempt(Pm, u, u)(p); | |
} | |
function u(p) { | |
return Z(p) ? ae(e, f, 'whitespace')(p) : f(p); | |
} | |
function f(p) { | |
return p === null || G(p) ? (e.exit('definition'), r.parser.defined.push(i), t(p)) : n(p); | |
} | |
} | |
function Nm(e, t, n) { | |
return r; | |
function r(l) { | |
return Ee(l) ? Wt(e, i)(l) : n(l); | |
} | |
function i(l) { | |
return Xl(e, a, n, 'definitionTitle', 'definitionTitleMarker', 'definitionTitleString')(l); | |
} | |
function a(l) { | |
return Z(l) ? ae(e, o, 'whitespace')(l) : o(l); | |
} | |
function o(l) { | |
return l === null || G(l) ? t(l) : n(l); | |
} | |
} | |
const Om = { name: 'hardBreakEscape', tokenize: Tm }; | |
function Tm(e, t, n) { | |
return r; | |
function r(a) { | |
return e.enter('hardBreakEscape'), e.consume(a), i; | |
} | |
function i(a) { | |
return G(a) ? (e.exit('hardBreakEscape'), t(a)) : n(a); | |
} | |
} | |
const Bm = { name: 'headingAtx', tokenize: Fm, resolve: Rm }; | |
function Rm(e, t) { | |
let n = e.length - 2, | |
r = 3, | |
i, | |
a; | |
return ( | |
e[r][1].type === 'whitespace' && (r += 2), | |
n - 2 > r && e[n][1].type === 'whitespace' && (n -= 2), | |
e[n][1].type === 'atxHeadingSequence' && | |
(r === n - 1 || (n - 4 > r && e[n - 2][1].type === 'whitespace')) && | |
(n -= r + 1 === n ? 2 : 4), | |
n > r && | |
((i = { type: 'atxHeadingText', start: e[r][1].start, end: e[n][1].end }), | |
(a = { type: 'chunkText', start: e[r][1].start, end: e[n][1].end, contentType: 'text' }), | |
Xe(e, r, n - r + 1, [ | |
['enter', i, t], | |
['enter', a, t], | |
['exit', a, t], | |
['exit', i, t], | |
])), | |
e | |
); | |
} | |
function Fm(e, t, n) { | |
let r = 0; | |
return i; | |
function i(d) { | |
return e.enter('atxHeading'), a(d); | |
} | |
function a(d) { | |
return e.enter('atxHeadingSequence'), o(d); | |
} | |
function o(d) { | |
return d === 35 && r++ < 6 | |
? (e.consume(d), o) | |
: d === null || Ee(d) | |
? (e.exit('atxHeadingSequence'), l(d)) | |
: n(d); | |
} | |
function l(d) { | |
return d === 35 | |
? (e.enter('atxHeadingSequence'), s(d)) | |
: d === null || G(d) | |
? (e.exit('atxHeading'), t(d)) | |
: Z(d) | |
? ae(e, l, 'whitespace')(d) | |
: (e.enter('atxHeadingText'), c(d)); | |
} | |
function s(d) { | |
return d === 35 ? (e.consume(d), s) : (e.exit('atxHeadingSequence'), l(d)); | |
} | |
function c(d) { | |
return d === null || d === 35 || Ee(d) ? (e.exit('atxHeadingText'), l(d)) : (e.consume(d), c); | |
} | |
} | |
const Lm = [ | |
'address', | |
'article', | |
'aside', | |
'base', | |
'basefont', | |
'blockquote', | |
'body', | |
'caption', | |
'center', | |
'col', | |
'colgroup', | |
'dd', | |
'details', | |
'dialog', | |
'dir', | |
'div', | |
'dl', | |
'dt', | |
'fieldset', | |
'figcaption', | |
'figure', | |
'footer', | |
'form', | |
'frame', | |
'frameset', | |
'h1', | |
'h2', | |
'h3', | |
'h4', | |
'h5', | |
'h6', | |
'head', | |
'header', | |
'hr', | |
'html', | |
'iframe', | |
'legend', | |
'li', | |
'link', | |
'main', | |
'menu', | |
'menuitem', | |
'nav', | |
'noframes', | |
'ol', | |
'optgroup', | |
'option', | |
'p', | |
'param', | |
'search', | |
'section', | |
'summary', | |
'table', | |
'tbody', | |
'td', | |
'tfoot', | |
'th', | |
'thead', | |
'title', | |
'tr', | |
'track', | |
'ul', | |
], | |
_a = ['pre', 'script', 'style', 'textarea'], | |
Mm = { name: 'htmlFlow', tokenize: Hm, resolveTo: $m, concrete: !0 }, | |
jm = { tokenize: Gm, partial: !0 }, | |
zm = { tokenize: Um, partial: !0 }; | |
function $m(e) { | |
let t = e.length; | |
for (; t-- && !(e[t][0] === 'enter' && e[t][1].type === 'htmlFlow'); ); | |
return ( | |
t > 1 && | |
e[t - 2][1].type === 'linePrefix' && | |
((e[t][1].start = e[t - 2][1].start), | |
(e[t + 1][1].start = e[t - 2][1].start), | |
e.splice(t - 2, 2)), | |
e | |
); | |
} | |
function Hm(e, t, n) { | |
const r = this; | |
let i, a, o, l, s; | |
return c; | |
function c(v) { | |
return d(v); | |
} | |
function d(v) { | |
return e.enter('htmlFlow'), e.enter('htmlFlowData'), e.consume(v), u; | |
} | |
function u(v) { | |
return v === 33 | |
? (e.consume(v), f) | |
: v === 47 | |
? (e.consume(v), (a = !0), h) | |
: v === 63 | |
? (e.consume(v), (i = 3), r.interrupt ? t : y) | |
: Qe(v) | |
? (e.consume(v), (o = String.fromCharCode(v)), x) | |
: n(v); | |
} | |
function f(v) { | |
return v === 45 | |
? (e.consume(v), (i = 2), p) | |
: v === 91 | |
? (e.consume(v), (i = 5), (l = 0), m) | |
: Qe(v) | |
? (e.consume(v), (i = 4), r.interrupt ? t : y) | |
: n(v); | |
} | |
function p(v) { | |
return v === 45 ? (e.consume(v), r.interrupt ? t : y) : n(v); | |
} | |
function m(v) { | |
const Q = 'CDATA['; | |
return v === Q.charCodeAt(l++) | |
? (e.consume(v), l === Q.length ? (r.interrupt ? t : R) : m) | |
: n(v); | |
} | |
function h(v) { | |
return Qe(v) ? (e.consume(v), (o = String.fromCharCode(v)), x) : n(v); | |
} | |
function x(v) { | |
if (v === null || v === 47 || v === 62 || Ee(v)) { | |
const Q = v === 47, | |
oe = o.toLowerCase(); | |
return !Q && !a && _a.includes(oe) | |
? ((i = 1), r.interrupt ? t(v) : R(v)) | |
: Lm.includes(o.toLowerCase()) | |
? ((i = 6), Q ? (e.consume(v), b) : r.interrupt ? t(v) : R(v)) | |
: ((i = 7), r.interrupt && !r.parser.lazy[r.now().line] ? n(v) : a ? C(v) : S(v)); | |
} | |
return v === 45 || Te(v) ? (e.consume(v), (o += String.fromCharCode(v)), x) : n(v); | |
} | |
function b(v) { | |
return v === 62 ? (e.consume(v), r.interrupt ? t : R) : n(v); | |
} | |
function C(v) { | |
return Z(v) ? (e.consume(v), C) : V(v); | |
} | |
function S(v) { | |
return v === 47 | |
? (e.consume(v), V) | |
: v === 58 || v === 95 || Qe(v) | |
? (e.consume(v), D) | |
: Z(v) | |
? (e.consume(v), S) | |
: V(v); | |
} | |
function D(v) { | |
return v === 45 || v === 46 || v === 58 || v === 95 || Te(v) ? (e.consume(v), D) : E(v); | |
} | |
function E(v) { | |
return v === 61 ? (e.consume(v), w) : Z(v) ? (e.consume(v), E) : S(v); | |
} | |
function w(v) { | |
return v === null || v === 60 || v === 61 || v === 62 || v === 96 | |
? n(v) | |
: v === 34 || v === 39 | |
? (e.consume(v), (s = v), O) | |
: Z(v) | |
? (e.consume(v), w) | |
: L(v); | |
} | |
function O(v) { | |
return v === s ? (e.consume(v), (s = null), F) : v === null || G(v) ? n(v) : (e.consume(v), O); | |
} | |
function L(v) { | |
return v === null || | |
v === 34 || | |
v === 39 || | |
v === 47 || | |
v === 60 || | |
v === 61 || | |
v === 62 || | |
v === 96 || | |
Ee(v) | |
? E(v) | |
: (e.consume(v), L); | |
} | |
function F(v) { | |
return v === 47 || v === 62 || Z(v) ? S(v) : n(v); | |
} | |
function V(v) { | |
return v === 62 ? (e.consume(v), A) : n(v); | |
} | |
function A(v) { | |
return v === null || G(v) ? R(v) : Z(v) ? (e.consume(v), A) : n(v); | |
} | |
function R(v) { | |
return v === 45 && i === 2 | |
? (e.consume(v), J) | |
: v === 60 && i === 1 | |
? (e.consume(v), ie) | |
: v === 62 && i === 4 | |
? (e.consume(v), pe) | |
: v === 63 && i === 3 | |
? (e.consume(v), y) | |
: v === 93 && i === 5 | |
? (e.consume(v), me) | |
: G(v) && (i === 6 || i === 7) | |
? (e.exit('htmlFlowData'), e.check(jm, k, Y)(v)) | |
: v === null || G(v) | |
? (e.exit('htmlFlowData'), Y(v)) | |
: (e.consume(v), R); | |
} | |
function Y(v) { | |
return e.check(zm, q, k)(v); | |
} | |
function q(v) { | |
return e.enter('lineEnding'), e.consume(v), e.exit('lineEnding'), $; | |
} | |
function $(v) { | |
return v === null || G(v) ? Y(v) : (e.enter('htmlFlowData'), R(v)); | |
} | |
function J(v) { | |
return v === 45 ? (e.consume(v), y) : R(v); | |
} | |
function ie(v) { | |
return v === 47 ? (e.consume(v), (o = ''), ce) : R(v); | |
} | |
function ce(v) { | |
if (v === 62) { | |
const Q = o.toLowerCase(); | |
return _a.includes(Q) ? (e.consume(v), pe) : R(v); | |
} | |
return Qe(v) && o.length < 8 ? (e.consume(v), (o += String.fromCharCode(v)), ce) : R(v); | |
} | |
function me(v) { | |
return v === 93 ? (e.consume(v), y) : R(v); | |
} | |
function y(v) { | |
return v === 62 ? (e.consume(v), pe) : v === 45 && i === 2 ? (e.consume(v), y) : R(v); | |
} | |
function pe(v) { | |
return v === null || G(v) ? (e.exit('htmlFlowData'), k(v)) : (e.consume(v), pe); | |
} | |
function k(v) { | |
return e.exit('htmlFlow'), t(v); | |
} | |
} | |
function Um(e, t, n) { | |
const r = this; | |
return i; | |
function i(o) { | |
return G(o) ? (e.enter('lineEnding'), e.consume(o), e.exit('lineEnding'), a) : n(o); | |
} | |
function a(o) { | |
return r.parser.lazy[r.now().line] ? n(o) : t(o); | |
} | |
} | |
function Gm(e, t, n) { | |
return r; | |
function r(i) { | |
return e.enter('lineEnding'), e.consume(i), e.exit('lineEnding'), e.attempt(er, t, n); | |
} | |
} | |
const Wm = { name: 'htmlText', tokenize: qm }; | |
function qm(e, t, n) { | |
const r = this; | |
let i, a, o; | |
return l; | |
function l(y) { | |
return e.enter('htmlText'), e.enter('htmlTextData'), e.consume(y), s; | |
} | |
function s(y) { | |
return y === 33 | |
? (e.consume(y), c) | |
: y === 47 | |
? (e.consume(y), E) | |
: y === 63 | |
? (e.consume(y), S) | |
: Qe(y) | |
? (e.consume(y), L) | |
: n(y); | |
} | |
function c(y) { | |
return y === 45 | |
? (e.consume(y), d) | |
: y === 91 | |
? (e.consume(y), (a = 0), m) | |
: Qe(y) | |
? (e.consume(y), C) | |
: n(y); | |
} | |
function d(y) { | |
return y === 45 ? (e.consume(y), p) : n(y); | |
} | |
function u(y) { | |
return y === null | |
? n(y) | |
: y === 45 | |
? (e.consume(y), f) | |
: G(y) | |
? ((o = u), ie(y)) | |
: (e.consume(y), u); | |
} | |
function f(y) { | |
return y === 45 ? (e.consume(y), p) : u(y); | |
} | |
function p(y) { | |
return y === 62 ? J(y) : y === 45 ? f(y) : u(y); | |
} | |
function m(y) { | |
const pe = 'CDATA['; | |
return y === pe.charCodeAt(a++) ? (e.consume(y), a === pe.length ? h : m) : n(y); | |
} | |
function h(y) { | |
return y === null | |
? n(y) | |
: y === 93 | |
? (e.consume(y), x) | |
: G(y) | |
? ((o = h), ie(y)) | |
: (e.consume(y), h); | |
} | |
function x(y) { | |
return y === 93 ? (e.consume(y), b) : h(y); | |
} | |
function b(y) { | |
return y === 62 ? J(y) : y === 93 ? (e.consume(y), b) : h(y); | |
} | |
function C(y) { | |
return y === null || y === 62 ? J(y) : G(y) ? ((o = C), ie(y)) : (e.consume(y), C); | |
} | |
function S(y) { | |
return y === null | |
? n(y) | |
: y === 63 | |
? (e.consume(y), D) | |
: G(y) | |
? ((o = S), ie(y)) | |
: (e.consume(y), S); | |
} | |
function D(y) { | |
return y === 62 ? J(y) : S(y); | |
} | |
function E(y) { | |
return Qe(y) ? (e.consume(y), w) : n(y); | |
} | |
function w(y) { | |
return y === 45 || Te(y) ? (e.consume(y), w) : O(y); | |
} | |
function O(y) { | |
return G(y) ? ((o = O), ie(y)) : Z(y) ? (e.consume(y), O) : J(y); | |
} | |
function L(y) { | |
return y === 45 || Te(y) ? (e.consume(y), L) : y === 47 || y === 62 || Ee(y) ? F(y) : n(y); | |
} | |
function F(y) { | |
return y === 47 | |
? (e.consume(y), J) | |
: y === 58 || y === 95 || Qe(y) | |
? (e.consume(y), V) | |
: G(y) | |
? ((o = F), ie(y)) | |
: Z(y) | |
? (e.consume(y), F) | |
: J(y); | |
} | |
function V(y) { | |
return y === 45 || y === 46 || y === 58 || y === 95 || Te(y) ? (e.consume(y), V) : A(y); | |
} | |
function A(y) { | |
return y === 61 ? (e.consume(y), R) : G(y) ? ((o = A), ie(y)) : Z(y) ? (e.consume(y), A) : F(y); | |
} | |
function R(y) { | |
return y === null || y === 60 || y === 61 || y === 62 || y === 96 | |
? n(y) | |
: y === 34 || y === 39 | |
? (e.consume(y), (i = y), Y) | |
: G(y) | |
? ((o = R), ie(y)) | |
: Z(y) | |
? (e.consume(y), R) | |
: (e.consume(y), q); | |
} | |
function Y(y) { | |
return y === i | |
? (e.consume(y), (i = void 0), $) | |
: y === null | |
? n(y) | |
: G(y) | |
? ((o = Y), ie(y)) | |
: (e.consume(y), Y); | |
} | |
function q(y) { | |
return y === null || y === 34 || y === 39 || y === 60 || y === 61 || y === 96 | |
? n(y) | |
: y === 47 || y === 62 || Ee(y) | |
? F(y) | |
: (e.consume(y), q); | |
} | |
function $(y) { | |
return y === 47 || y === 62 || Ee(y) ? F(y) : n(y); | |
} | |
function J(y) { | |
return y === 62 ? (e.consume(y), e.exit('htmlTextData'), e.exit('htmlText'), t) : n(y); | |
} | |
function ie(y) { | |
return e.exit('htmlTextData'), e.enter('lineEnding'), e.consume(y), e.exit('lineEnding'), ce; | |
} | |
function ce(y) { | |
return Z(y) | |
? ae( | |
e, | |
me, | |
'linePrefix', | |
r.parser.constructs.disable.null.includes('codeIndented') ? void 0 : 4 | |
)(y) | |
: me(y); | |
} | |
function me(y) { | |
return e.enter('htmlTextData'), o(y); | |
} | |
} | |
const Oi = { name: 'labelEnd', tokenize: Jm, resolveTo: Xm, resolveAll: Qm }, | |
Vm = { tokenize: _m }, | |
Km = { tokenize: Zm }, | |
Ym = { tokenize: eh }; | |
function Qm(e) { | |
let t = -1; | |
for (; ++t < e.length; ) { | |
const n = e[t][1]; | |
(n.type === 'labelImage' || n.type === 'labelLink' || n.type === 'labelEnd') && | |
(e.splice(t + 1, n.type === 'labelImage' ? 4 : 2), (n.type = 'data'), t++); | |
} | |
return e; | |
} | |
function Xm(e, t) { | |
let n = e.length, | |
r = 0, | |
i, | |
a, | |
o, | |
l; | |
for (; n--; ) | |
if (((i = e[n][1]), a)) { | |
if (i.type === 'link' || (i.type === 'labelLink' && i._inactive)) break; | |
e[n][0] === 'enter' && i.type === 'labelLink' && (i._inactive = !0); | |
} else if (o) { | |
if ( | |
e[n][0] === 'enter' && | |
(i.type === 'labelImage' || i.type === 'labelLink') && | |
!i._balanced && | |
((a = n), i.type !== 'labelLink') | |
) { | |
r = 2; | |
break; | |
} | |
} else i.type === 'labelEnd' && (o = n); | |
const s = { | |
type: e[a][1].type === 'labelLink' ? 'link' : 'image', | |
start: Object.assign({}, e[a][1].start), | |
end: Object.assign({}, e[e.length - 1][1].end), | |
}, | |
c = { | |
type: 'label', | |
start: Object.assign({}, e[a][1].start), | |
end: Object.assign({}, e[o][1].end), | |
}, | |
d = { | |
type: 'labelText', | |
start: Object.assign({}, e[a + r + 2][1].end), | |
end: Object.assign({}, e[o - 2][1].start), | |
}; | |
return ( | |
(l = [ | |
['enter', s, t], | |
['enter', c, t], | |
]), | |
(l = je(l, e.slice(a + 1, a + r + 3))), | |
(l = je(l, [['enter', d, t]])), | |
(l = je(l, Ai(t.parser.constructs.insideSpan.null, e.slice(a + r + 4, o - 3), t))), | |
(l = je(l, [['exit', d, t], e[o - 2], e[o - 1], ['exit', c, t]])), | |
(l = je(l, e.slice(o + 1))), | |
(l = je(l, [['exit', s, t]])), | |
Xe(e, a, e.length, l), | |
e | |
); | |
} | |
function Jm(e, t, n) { | |
const r = this; | |
let i = r.events.length, | |
a, | |
o; | |
for (; i--; ) | |
if ( | |
(r.events[i][1].type === 'labelImage' || r.events[i][1].type === 'labelLink') && | |
!r.events[i][1]._balanced | |
) { | |
a = r.events[i][1]; | |
break; | |
} | |
return l; | |
function l(f) { | |
return a | |
? a._inactive | |
? u(f) | |
: ((o = r.parser.defined.includes(It(r.sliceSerialize({ start: a.end, end: r.now() })))), | |
e.enter('labelEnd'), | |
e.enter('labelMarker'), | |
e.consume(f), | |
e.exit('labelMarker'), | |
e.exit('labelEnd'), | |
s) | |
: n(f); | |
} | |
function s(f) { | |
return f === 40 | |
? e.attempt(Vm, d, o ? d : u)(f) | |
: f === 91 | |
? e.attempt(Km, d, o ? c : u)(f) | |
: o | |
? d(f) | |
: u(f); | |
} | |
function c(f) { | |
return e.attempt(Ym, d, u)(f); | |
} | |
function d(f) { | |
return t(f); | |
} | |
function u(f) { | |
return (a._balanced = !0), n(f); | |
} | |
} | |
function _m(e, t, n) { | |
return r; | |
function r(u) { | |
return ( | |
e.enter('resource'), e.enter('resourceMarker'), e.consume(u), e.exit('resourceMarker'), i | |
); | |
} | |
function i(u) { | |
return Ee(u) ? Wt(e, a)(u) : a(u); | |
} | |
function a(u) { | |
return u === 41 | |
? d(u) | |
: Yl( | |
e, | |
o, | |
l, | |
'resourceDestination', | |
'resourceDestinationLiteral', | |
'resourceDestinationLiteralMarker', | |
'resourceDestinationRaw', | |
'resourceDestinationString', | |
32 | |
)(u); | |
} | |
function o(u) { | |
return Ee(u) ? Wt(e, s)(u) : d(u); | |
} | |
function l(u) { | |
return n(u); | |
} | |
function s(u) { | |
return u === 34 || u === 39 || u === 40 | |
? Xl(e, c, n, 'resourceTitle', 'resourceTitleMarker', 'resourceTitleString')(u) | |
: d(u); | |
} | |
function c(u) { | |
return Ee(u) ? Wt(e, d)(u) : d(u); | |
} | |
function d(u) { | |
return u === 41 | |
? (e.enter('resourceMarker'), e.consume(u), e.exit('resourceMarker'), e.exit('resource'), t) | |
: n(u); | |
} | |
} | |
function Zm(e, t, n) { | |
const r = this; | |
return i; | |
function i(l) { | |
return Ql.call(r, e, a, o, 'reference', 'referenceMarker', 'referenceString')(l); | |
} | |
function a(l) { | |
return r.parser.defined.includes( | |
It(r.sliceSerialize(r.events[r.events.length - 1][1]).slice(1, -1)) | |
) | |
? t(l) | |
: n(l); | |
} | |
function o(l) { | |
return n(l); | |
} | |
} | |
function eh(e, t, n) { | |
return r; | |
function r(a) { | |
return ( | |
e.enter('reference'), e.enter('referenceMarker'), e.consume(a), e.exit('referenceMarker'), i | |
); | |
} | |
function i(a) { | |
return a === 93 | |
? (e.enter('referenceMarker'), | |
e.consume(a), | |
e.exit('referenceMarker'), | |
e.exit('reference'), | |
t) | |
: n(a); | |
} | |
} | |
const th = { name: 'labelStartImage', tokenize: nh, resolveAll: Oi.resolveAll }; | |
function nh(e, t, n) { | |
const r = this; | |
return i; | |
function i(l) { | |
return ( | |
e.enter('labelImage'), | |
e.enter('labelImageMarker'), | |
e.consume(l), | |
e.exit('labelImageMarker'), | |
a | |
); | |
} | |
function a(l) { | |
return l === 91 | |
? (e.enter('labelMarker'), e.consume(l), e.exit('labelMarker'), e.exit('labelImage'), o) | |
: n(l); | |
} | |
function o(l) { | |
return l === 94 && '_hiddenFootnoteSupport' in r.parser.constructs ? n(l) : t(l); | |
} | |
} | |
const rh = { name: 'labelStartLink', tokenize: ih, resolveAll: Oi.resolveAll }; | |
function ih(e, t, n) { | |
const r = this; | |
return i; | |
function i(o) { | |
return ( | |
e.enter('labelLink'), | |
e.enter('labelMarker'), | |
e.consume(o), | |
e.exit('labelMarker'), | |
e.exit('labelLink'), | |
a | |
); | |
} | |
function a(o) { | |
return o === 94 && '_hiddenFootnoteSupport' in r.parser.constructs ? n(o) : t(o); | |
} | |
} | |
const Tr = { name: 'lineEnding', tokenize: ah }; | |
function ah(e, t) { | |
return n; | |
function n(r) { | |
return e.enter('lineEnding'), e.consume(r), e.exit('lineEnding'), ae(e, t, 'linePrefix'); | |
} | |
} | |
const Cn = { name: 'thematicBreak', tokenize: oh }; | |
function oh(e, t, n) { | |
let r = 0, | |
i; | |
return a; | |
function a(c) { | |
return e.enter('thematicBreak'), o(c); | |
} | |
function o(c) { | |
return (i = c), l(c); | |
} | |
function l(c) { | |
return c === i | |
? (e.enter('thematicBreakSequence'), s(c)) | |
: r >= 3 && (c === null || G(c)) | |
? (e.exit('thematicBreak'), t(c)) | |
: n(c); | |
} | |
function s(c) { | |
return c === i | |
? (e.consume(c), r++, s) | |
: (e.exit('thematicBreakSequence'), Z(c) ? ae(e, l, 'whitespace')(c) : l(c)); | |
} | |
} | |
const Ie = { name: 'list', tokenize: uh, continuation: { tokenize: ch }, exit: ph }, | |
lh = { tokenize: fh, partial: !0 }, | |
sh = { tokenize: dh, partial: !0 }; | |
function uh(e, t, n) { | |
const r = this, | |
i = r.events[r.events.length - 1]; | |
let a = i && i[1].type === 'linePrefix' ? i[2].sliceSerialize(i[1], !0).length : 0, | |
o = 0; | |
return l; | |
function l(p) { | |
const m = | |
r.containerState.type || (p === 42 || p === 43 || p === 45 ? 'listUnordered' : 'listOrdered'); | |
if (m === 'listUnordered' ? !r.containerState.marker || p === r.containerState.marker : Yr(p)) { | |
if ( | |
(r.containerState.type || ((r.containerState.type = m), e.enter(m, { _container: !0 })), | |
m === 'listUnordered') | |
) | |
return e.enter('listItemPrefix'), p === 42 || p === 45 ? e.check(Cn, n, c)(p) : c(p); | |
if (!r.interrupt || p === 49) | |
return e.enter('listItemPrefix'), e.enter('listItemValue'), s(p); | |
} | |
return n(p); | |
} | |
function s(p) { | |
return Yr(p) && ++o < 10 | |
? (e.consume(p), s) | |
: (!r.interrupt || o < 2) && | |
(r.containerState.marker ? p === r.containerState.marker : p === 41 || p === 46) | |
? (e.exit('listItemValue'), c(p)) | |
: n(p); | |
} | |
function c(p) { | |
return ( | |
e.enter('listItemMarker'), | |
e.consume(p), | |
e.exit('listItemMarker'), | |
(r.containerState.marker = r.containerState.marker || p), | |
e.check(er, r.interrupt ? n : d, e.attempt(lh, f, u)) | |
); | |
} | |
function d(p) { | |
return (r.containerState.initialBlankLine = !0), a++, f(p); | |
} | |
function u(p) { | |
return Z(p) | |
? (e.enter('listItemPrefixWhitespace'), e.consume(p), e.exit('listItemPrefixWhitespace'), f) | |
: n(p); | |
} | |
function f(p) { | |
return ( | |
(r.containerState.size = a + r.sliceSerialize(e.exit('listItemPrefix'), !0).length), t(p) | |
); | |
} | |
} | |
function ch(e, t, n) { | |
const r = this; | |
return (r.containerState._closeFlow = void 0), e.check(er, i, a); | |
function i(l) { | |
return ( | |
(r.containerState.furtherBlankLines = | |
r.containerState.furtherBlankLines || r.containerState.initialBlankLine), | |
ae(e, t, 'listItemIndent', r.containerState.size + 1)(l) | |
); | |
} | |
function a(l) { | |
return r.containerState.furtherBlankLines || !Z(l) | |
? ((r.containerState.furtherBlankLines = void 0), | |
(r.containerState.initialBlankLine = void 0), | |
o(l)) | |
: ((r.containerState.furtherBlankLines = void 0), | |
(r.containerState.initialBlankLine = void 0), | |
e.attempt(sh, t, o)(l)); | |
} | |
function o(l) { | |
return ( | |
(r.containerState._closeFlow = !0), | |
(r.interrupt = void 0), | |
ae( | |
e, | |
e.attempt(Ie, t, n), | |
'linePrefix', | |
r.parser.constructs.disable.null.includes('codeIndented') ? void 0 : 4 | |
)(l) | |
); | |
} | |
} | |
function dh(e, t, n) { | |
const r = this; | |
return ae(e, i, 'listItemIndent', r.containerState.size + 1); | |
function i(a) { | |
const o = r.events[r.events.length - 1]; | |
return o && | |
o[1].type === 'listItemIndent' && | |
o[2].sliceSerialize(o[1], !0).length === r.containerState.size | |
? t(a) | |
: n(a); | |
} | |
} | |
function ph(e) { | |
e.exit(this.containerState.type); | |
} | |
function fh(e, t, n) { | |
const r = this; | |
return ae( | |
e, | |
i, | |
'listItemPrefixWhitespace', | |
r.parser.constructs.disable.null.includes('codeIndented') ? void 0 : 4 + 1 | |
); | |
function i(a) { | |
const o = r.events[r.events.length - 1]; | |
return !Z(a) && o && o[1].type === 'listItemPrefixWhitespace' ? t(a) : n(a); | |
} | |
} | |
const Za = { name: 'setextUnderline', tokenize: mh, resolveTo: gh }; | |
function gh(e, t) { | |
let n = e.length, | |
r, | |
i, | |
a; | |
for (; n--; ) | |
if (e[n][0] === 'enter') { | |
if (e[n][1].type === 'content') { | |
r = n; | |
break; | |
} | |
e[n][1].type === 'paragraph' && (i = n); | |
} else | |
e[n][1].type === 'content' && e.splice(n, 1), !a && e[n][1].type === 'definition' && (a = n); | |
const o = { | |
type: 'setextHeading', | |
start: Object.assign({}, e[i][1].start), | |
end: Object.assign({}, e[e.length - 1][1].end), | |
}; | |
return ( | |
(e[i][1].type = 'setextHeadingText'), | |
a | |
? (e.splice(i, 0, ['enter', o, t]), | |
e.splice(a + 1, 0, ['exit', e[r][1], t]), | |
(e[r][1].end = Object.assign({}, e[a][1].end))) | |
: (e[r][1] = o), | |
e.push(['exit', o, t]), | |
e | |
); | |
} | |
function mh(e, t, n) { | |
const r = this; | |
let i; | |
return a; | |
function a(c) { | |
let d = r.events.length, | |
u; | |
for (; d--; ) | |
if ( | |
r.events[d][1].type !== 'lineEnding' && | |
r.events[d][1].type !== 'linePrefix' && | |
r.events[d][1].type !== 'content' | |
) { | |
u = r.events[d][1].type === 'paragraph'; | |
break; | |
} | |
return !r.parser.lazy[r.now().line] && (r.interrupt || u) | |
? (e.enter('setextHeadingLine'), (i = c), o(c)) | |
: n(c); | |
} | |
function o(c) { | |
return e.enter('setextHeadingLineSequence'), l(c); | |
} | |
function l(c) { | |
return c === i | |
? (e.consume(c), l) | |
: (e.exit('setextHeadingLineSequence'), Z(c) ? ae(e, s, 'lineSuffix')(c) : s(c)); | |
} | |
function s(c) { | |
return c === null || G(c) ? (e.exit('setextHeadingLine'), t(c)) : n(c); | |
} | |
} | |
const hh = { tokenize: vh }; | |
function vh(e) { | |
const t = this, | |
n = e.attempt( | |
er, | |
r, | |
e.attempt( | |
this.parser.constructs.flowInitial, | |
i, | |
ae(e, e.attempt(this.parser.constructs.flow, i, e.attempt(Sm, i)), 'linePrefix') | |
) | |
); | |
return n; | |
function r(a) { | |
if (a === null) { | |
e.consume(a); | |
return; | |
} | |
return ( | |
e.enter('lineEndingBlank'), | |
e.consume(a), | |
e.exit('lineEndingBlank'), | |
(t.currentConstruct = void 0), | |
n | |
); | |
} | |
function i(a) { | |
if (a === null) { | |
e.consume(a); | |
return; | |
} | |
return ( | |
e.enter('lineEnding'), e.consume(a), e.exit('lineEnding'), (t.currentConstruct = void 0), n | |
); | |
} | |
} | |
const bh = { resolveAll: _l() }, | |
yh = Jl('string'), | |
xh = Jl('text'); | |
function Jl(e) { | |
return { tokenize: t, resolveAll: _l(e === 'text' ? wh : void 0) }; | |
function t(n) { | |
const r = this, | |
i = this.parser.constructs[e], | |
a = n.attempt(i, o, l); | |
return o; | |
function o(d) { | |
return c(d) ? a(d) : l(d); | |
} | |
function l(d) { | |
if (d === null) { | |
n.consume(d); | |
return; | |
} | |
return n.enter('data'), n.consume(d), s; | |
} | |
function s(d) { | |
return c(d) ? (n.exit('data'), a(d)) : (n.consume(d), s); | |
} | |
function c(d) { | |
if (d === null) return !0; | |
const u = i[d]; | |
let f = -1; | |
if (u) | |
for (; ++f < u.length; ) { | |
const p = u[f]; | |
if (!p.previous || p.previous.call(r, r.previous)) return !0; | |
} | |
return !1; | |
} | |
} | |
} | |
function _l(e) { | |
return t; | |
function t(n, r) { | |
let i = -1, | |
a; | |
for (; ++i <= n.length; ) | |
a === void 0 | |
? n[i] && n[i][1].type === 'data' && ((a = i), i++) | |
: (!n[i] || n[i][1].type !== 'data') && | |
(i !== a + 2 && | |
((n[a][1].end = n[i - 1][1].end), n.splice(a + 2, i - a - 2), (i = a + 2)), | |
(a = void 0)); | |
return e ? e(n, r) : n; | |
} | |
} | |
function wh(e, t) { | |
let n = 0; | |
for (; ++n <= e.length; ) | |
if ((n === e.length || e[n][1].type === 'lineEnding') && e[n - 1][1].type === 'data') { | |
const r = e[n - 1][1], | |
i = t.sliceStream(r); | |
let a = i.length, | |
o = -1, | |
l = 0, | |
s; | |
for (; a--; ) { | |
const c = i[a]; | |
if (typeof c == 'string') { | |
for (o = c.length; c.charCodeAt(o - 1) === 32; ) l++, o--; | |
if (o) break; | |
o = -1; | |
} else if (c === -2) (s = !0), l++; | |
else if (c !== -1) { | |
a++; | |
break; | |
} | |
} | |
if (l) { | |
const c = { | |
type: n === e.length || s || l < 2 ? 'lineSuffix' : 'hardBreakTrailing', | |
start: { | |
line: r.end.line, | |
column: r.end.column - l, | |
offset: r.end.offset - l, | |
_index: r.start._index + a, | |
_bufferIndex: a ? o : r.start._bufferIndex + o, | |
}, | |
end: Object.assign({}, r.end), | |
}; | |
(r.end = Object.assign({}, c.start)), | |
r.start.offset === r.end.offset | |
? Object.assign(r, c) | |
: (e.splice(n, 0, ['enter', c, t], ['exit', c, t]), (n += 2)); | |
} | |
n++; | |
} | |
return e; | |
} | |
function Sh(e, t, n) { | |
let r = Object.assign(n ? Object.assign({}, n) : { line: 1, column: 1, offset: 0 }, { | |
_index: 0, | |
_bufferIndex: -1, | |
}); | |
const i = {}, | |
a = []; | |
let o = [], | |
l = []; | |
const s = { | |
consume: C, | |
enter: S, | |
exit: D, | |
attempt: O(E), | |
check: O(w), | |
interrupt: O(w, { interrupt: !0 }), | |
}, | |
c = { | |
previous: null, | |
code: null, | |
containerState: {}, | |
events: [], | |
parser: e, | |
sliceStream: p, | |
sliceSerialize: f, | |
now: m, | |
defineSkip: h, | |
write: u, | |
}; | |
let d = t.tokenize.call(c, s); | |
return t.resolveAll && a.push(t), c; | |
function u(A) { | |
return ( | |
(o = je(o, A)), | |
x(), | |
o[o.length - 1] !== null ? [] : (L(t, 0), (c.events = Ai(a, c.events, c)), c.events) | |
); | |
} | |
function f(A, R) { | |
return Dh(p(A), R); | |
} | |
function p(A) { | |
return Ch(o, A); | |
} | |
function m() { | |
const { line: A, column: R, offset: Y, _index: q, _bufferIndex: $ } = r; | |
return { line: A, column: R, offset: Y, _index: q, _bufferIndex: $ }; | |
} | |
function h(A) { | |
(i[A.line] = A.column), V(); | |
} | |
function x() { | |
let A; | |
for (; r._index < o.length; ) { | |
const R = o[r._index]; | |
if (typeof R == 'string') | |
for ( | |
A = r._index, r._bufferIndex < 0 && (r._bufferIndex = 0); | |
r._index === A && r._bufferIndex < R.length; | |
) | |
b(R.charCodeAt(r._bufferIndex)); | |
else b(R); | |
} | |
} | |
function b(A) { | |
d = d(A); | |
} | |
function C(A) { | |
G(A) | |
? (r.line++, (r.column = 1), (r.offset += A === -3 ? 2 : 1), V()) | |
: A !== -1 && (r.column++, r.offset++), | |
r._bufferIndex < 0 | |
? r._index++ | |
: (r._bufferIndex++, | |
r._bufferIndex === o[r._index].length && ((r._bufferIndex = -1), r._index++)), | |
(c.previous = A); | |
} | |
function S(A, R) { | |
const Y = R || {}; | |
return (Y.type = A), (Y.start = m()), c.events.push(['enter', Y, c]), l.push(Y), Y; | |
} | |
function D(A) { | |
const R = l.pop(); | |
return (R.end = m()), c.events.push(['exit', R, c]), R; | |
} | |
function E(A, R) { | |
L(A, R.from); | |
} | |
function w(A, R) { | |
R.restore(); | |
} | |
function O(A, R) { | |
return Y; | |
function Y(q, $, J) { | |
let ie, ce, me, y; | |
return Array.isArray(q) ? k(q) : 'tokenize' in q ? k([q]) : pe(q); | |
function pe(ee) { | |
return he; | |
function he(fe) { | |
const Le = fe !== null && ee[fe], | |
Se = fe !== null && ee.null, | |
Ve = [ | |
...(Array.isArray(Le) ? Le : Le ? [Le] : []), | |
...(Array.isArray(Se) ? Se : Se ? [Se] : []), | |
]; | |
return k(Ve)(fe); | |
} | |
} | |
function k(ee) { | |
return (ie = ee), (ce = 0), ee.length === 0 ? J : v(ee[ce]); | |
} | |
function v(ee) { | |
return he; | |
function he(fe) { | |
return ( | |
(y = F()), | |
(me = ee), | |
ee.partial || (c.currentConstruct = ee), | |
ee.name && c.parser.constructs.disable.null.includes(ee.name) | |
? oe() | |
: ee.tokenize.call(R ? Object.assign(Object.create(c), R) : c, s, Q, oe)(fe) | |
); | |
} | |
} | |
function Q(ee) { | |
return A(me, y), $; | |
} | |
function oe(ee) { | |
return y.restore(), ++ce < ie.length ? v(ie[ce]) : J; | |
} | |
} | |
} | |
function L(A, R) { | |
A.resolveAll && !a.includes(A) && a.push(A), | |
A.resolve && Xe(c.events, R, c.events.length - R, A.resolve(c.events.slice(R), c)), | |
A.resolveTo && (c.events = A.resolveTo(c.events, c)); | |
} | |
function F() { | |
const A = m(), | |
R = c.previous, | |
Y = c.currentConstruct, | |
q = c.events.length, | |
$ = Array.from(l); | |
return { restore: J, from: q }; | |
function J() { | |
(r = A), (c.previous = R), (c.currentConstruct = Y), (c.events.length = q), (l = $), V(); | |
} | |
} | |
function V() { | |
r.line in i && r.column < 2 && ((r.column = i[r.line]), (r.offset += i[r.line] - 1)); | |
} | |
} | |
function Ch(e, t) { | |
const n = t.start._index, | |
r = t.start._bufferIndex, | |
i = t.end._index, | |
a = t.end._bufferIndex; | |
let o; | |
if (n === i) o = [e[n].slice(r, a)]; | |
else { | |
if (((o = e.slice(n, i)), r > -1)) { | |
const l = o[0]; | |
typeof l == 'string' ? (o[0] = l.slice(r)) : o.shift(); | |
} | |
a > 0 && o.push(e[i].slice(0, a)); | |
} | |
return o; | |
} | |
function Dh(e, t) { | |
let n = -1; | |
const r = []; | |
let i; | |
for (; ++n < e.length; ) { | |
const a = e[n]; | |
let o; | |
if (typeof a == 'string') o = a; | |
else | |
switch (a) { | |
case -5: { | |
o = '\r'; | |
break; | |
} | |
case -4: { | |
o = ` | |
`; | |
break; | |
} | |
case -3: { | |
o = `\r | |
`; | |
break; | |
} | |
case -2: { | |
o = t ? ' ' : ' '; | |
break; | |
} | |
case -1: { | |
if (!t && i) continue; | |
o = ' '; | |
break; | |
} | |
default: | |
o = String.fromCharCode(a); | |
} | |
(i = a === -2), r.push(o); | |
} | |
return r.join(''); | |
} | |
const Ih = { | |
[42]: Ie, | |
[43]: Ie, | |
[45]: Ie, | |
[48]: Ie, | |
[49]: Ie, | |
[50]: Ie, | |
[51]: Ie, | |
[52]: Ie, | |
[53]: Ie, | |
[54]: Ie, | |
[55]: Ie, | |
[56]: Ie, | |
[57]: Ie, | |
[62]: Wl, | |
}, | |
kh = { [91]: Em }, | |
Eh = { [-2]: Or, [-1]: Or, [32]: Or }, | |
Ph = { [35]: Bm, [42]: Cn, [45]: [Za, Cn], [60]: Mm, [61]: Za, [95]: Cn, [96]: Ja, [126]: Ja }, | |
Ah = { [38]: Vl, [92]: ql }, | |
Nh = { | |
[-5]: Tr, | |
[-4]: Tr, | |
[-3]: Tr, | |
[33]: th, | |
[38]: Vl, | |
[42]: Qr, | |
[60]: [im, Wm], | |
[91]: rh, | |
[92]: [Om, ql], | |
[93]: Oi, | |
[95]: Qr, | |
[96]: vm, | |
}, | |
Oh = { null: [Qr, bh] }, | |
Th = { null: [42, 95] }, | |
Bh = { null: [] }, | |
Rh = Object.freeze( | |
Object.defineProperty( | |
{ | |
__proto__: null, | |
attentionMarkers: Th, | |
contentInitial: kh, | |
disable: Bh, | |
document: Ih, | |
flow: Ph, | |
flowInitial: Eh, | |
insideSpan: Oh, | |
string: Ah, | |
text: Nh, | |
}, | |
Symbol.toStringTag, | |
{ value: 'Module' } | |
) | |
); | |
function Fh(e) { | |
const n = Ug([Rh, ...((e || {}).extensions || [])]), | |
r = { | |
defined: [], | |
lazy: {}, | |
constructs: n, | |
content: i(Jg), | |
document: i(Zg), | |
flow: i(hh), | |
string: i(yh), | |
text: i(xh), | |
}; | |
return r; | |
function i(a) { | |
return o; | |
function o(l) { | |
return Sh(r, a, l); | |
} | |
} | |
} | |
const eo = /[\0\t\n\r]/g; | |
function Lh() { | |
let e = 1, | |
t = '', | |
n = !0, | |
r; | |
return i; | |
function i(a, o, l) { | |
const s = []; | |
let c, d, u, f, p; | |
for ( | |
a = t + a.toString(o), u = 0, t = '', n && (a.charCodeAt(0) === 65279 && u++, (n = void 0)); | |
u < a.length; | |
) { | |
if ( | |
((eo.lastIndex = u), | |
(c = eo.exec(a)), | |
(f = c && c.index !== void 0 ? c.index : a.length), | |
(p = a.charCodeAt(f)), | |
!c) | |
) { | |
t = a.slice(u); | |
break; | |
} | |
if (p === 10 && u === f && r) s.push(-3), (r = void 0); | |
else | |
switch ( | |
(r && (s.push(-5), (r = void 0)), u < f && (s.push(a.slice(u, f)), (e += f - u)), p) | |
) { | |
case 0: { | |
s.push(65533), e++; | |
break; | |
} | |
case 9: { | |
for (d = Math.ceil(e / 4) * 4, s.push(-2); e++ < d; ) s.push(-1); | |
break; | |
} | |
case 10: { | |
s.push(-4), (e = 1); | |
break; | |
} | |
default: | |
(r = !0), (e = 1); | |
} | |
u = f + 1; | |
} | |
return l && (r && s.push(-5), t && s.push(t), s.push(null)), s; | |
} | |
} | |
function Mh(e) { | |
for (; !Kl(e); ); | |
return e; | |
} | |
function Zl(e, t) { | |
const n = Number.parseInt(e, t); | |
return n < 9 || | |
n === 11 || | |
(n > 13 && n < 32) || | |
(n > 126 && n < 160) || | |
(n > 55295 && n < 57344) || | |
(n > 64975 && n < 65008) || | |
(n & 65535) === 65535 || | |
(n & 65535) === 65534 || | |
n > 1114111 | |
? '�' | |
: String.fromCharCode(n); | |
} | |
const jh = /\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi; | |
function zh(e) { | |
return e.replace(jh, $h); | |
} | |
function $h(e, t, n) { | |
if (t) return t; | |
if (n.charCodeAt(0) === 35) { | |
const i = n.charCodeAt(1), | |
a = i === 120 || i === 88; | |
return Zl(n.slice(a ? 2 : 1), a ? 16 : 10); | |
} | |
return Ni(n) || e; | |
} | |
const es = {}.hasOwnProperty, | |
Hh = function (e, t, n) { | |
return ( | |
typeof t != 'string' && ((n = t), (t = void 0)), | |
Uh(n)(Mh(Fh(n).document().write(Lh()(e, t, !0)))) | |
); | |
}; | |
function Uh(e) { | |
const t = { | |
transforms: [], | |
canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'], | |
enter: { | |
autolink: l(it), | |
autolinkProtocol: A, | |
autolinkEmail: A, | |
atxHeading: l(nt), | |
blockQuote: l(Ve), | |
characterEscape: A, | |
characterReference: A, | |
codeFenced: l(et), | |
codeFencedFenceInfo: s, | |
codeFencedFenceMeta: s, | |
codeIndented: l(et, s), | |
codeText: l(ft, s), | |
codeTextData: A, | |
data: A, | |
codeFlowValue: A, | |
definition: l(tt), | |
definitionDestinationString: s, | |
definitionLabelString: s, | |
definitionTitleString: s, | |
emphasis: l(Je), | |
hardBreakEscape: l(rt), | |
hardBreakTrailing: l(rt), | |
htmlFlow: l(Ft, s), | |
htmlFlowData: A, | |
htmlText: l(Ft, s), | |
htmlTextData: A, | |
image: l(Ke), | |
label: s, | |
link: l(it), | |
listItem: l(gt), | |
listItemValue: m, | |
listOrdered: l(dn, p), | |
listUnordered: l(dn), | |
paragraph: l(pn), | |
reference: oe, | |
referenceString: s, | |
resourceDestinationString: s, | |
resourceTitleString: s, | |
setextHeading: l(nt), | |
strong: l(_e), | |
thematicBreak: l(Ct), | |
}, | |
exit: { | |
atxHeading: d(), | |
atxHeadingSequence: O, | |
autolink: d(), | |
autolinkEmail: Se, | |
autolinkProtocol: Le, | |
blockQuote: d(), | |
characterEscapeValue: R, | |
characterReferenceMarkerHexadecimal: he, | |
characterReferenceMarkerNumeric: he, | |
characterReferenceValue: fe, | |
codeFenced: d(C), | |
codeFencedFence: b, | |
codeFencedFenceInfo: h, | |
codeFencedFenceMeta: x, | |
codeFlowValue: R, | |
codeIndented: d(S), | |
codeText: d(ie), | |
codeTextData: R, | |
data: R, | |
definition: d(), | |
definitionDestinationString: w, | |
definitionLabelString: D, | |
definitionTitleString: E, | |
emphasis: d(), | |
hardBreakEscape: d(q), | |
hardBreakTrailing: d(q), | |
htmlFlow: d($), | |
htmlFlowData: R, | |
htmlText: d(J), | |
htmlTextData: R, | |
image: d(me), | |
label: pe, | |
labelText: y, | |
lineEnding: Y, | |
link: d(ce), | |
listItem: d(), | |
listOrdered: d(), | |
listUnordered: d(), | |
paragraph: d(), | |
referenceString: ee, | |
resourceDestinationString: k, | |
resourceTitleString: v, | |
resource: Q, | |
setextHeading: d(V), | |
setextHeadingLineSequence: F, | |
setextHeadingText: L, | |
strong: d(), | |
thematicBreak: d(), | |
}, | |
}; | |
ts(t, (e || {}).mdastExtensions || []); | |
const n = {}; | |
return r; | |
function r(I) { | |
let T = { type: 'root', children: [] }; | |
const z = { | |
stack: [T], | |
tokenStack: [], | |
config: t, | |
enter: c, | |
exit: u, | |
buffer: s, | |
resume: f, | |
setData: a, | |
getData: o, | |
}, | |
U = []; | |
let H = -1; | |
for (; ++H < I.length; ) | |
if (I[H][1].type === 'listOrdered' || I[H][1].type === 'listUnordered') | |
if (I[H][0] === 'enter') U.push(H); | |
else { | |
const de = U.pop(); | |
H = i(I, de, H); | |
} | |
for (H = -1; ++H < I.length; ) { | |
const de = t[I[H][0]]; | |
es.call(de, I[H][1].type) && | |
de[I[H][1].type].call( | |
Object.assign({ sliceSerialize: I[H][2].sliceSerialize }, z), | |
I[H][1] | |
); | |
} | |
if (z.tokenStack.length > 0) { | |
const de = z.tokenStack[z.tokenStack.length - 1]; | |
(de[1] || to).call(z, void 0, de[0]); | |
} | |
for ( | |
T.position = { | |
start: ot(I.length > 0 ? I[0][1].start : { line: 1, column: 1, offset: 0 }), | |
end: ot(I.length > 0 ? I[I.length - 2][1].end : { line: 1, column: 1, offset: 0 }), | |
}, | |
H = -1; | |
++H < t.transforms.length; | |
) | |
T = t.transforms[H](T) || T; | |
return T; | |
} | |
function i(I, T, z) { | |
let U = T - 1, | |
H = -1, | |
de = !1, | |
De, | |
Pe, | |
Ze, | |
Ae; | |
for (; ++U <= z; ) { | |
const le = I[U]; | |
if ( | |
(le[1].type === 'listUnordered' || | |
le[1].type === 'listOrdered' || | |
le[1].type === 'blockQuote' | |
? (le[0] === 'enter' ? H++ : H--, (Ae = void 0)) | |
: le[1].type === 'lineEndingBlank' | |
? le[0] === 'enter' && (De && !Ae && !H && !Ze && (Ze = U), (Ae = void 0)) | |
: le[1].type === 'linePrefix' || | |
le[1].type === 'listItemValue' || | |
le[1].type === 'listItemMarker' || | |
le[1].type === 'listItemPrefix' || | |
le[1].type === 'listItemPrefixWhitespace' || | |
(Ae = void 0), | |
(!H && le[0] === 'enter' && le[1].type === 'listItemPrefix') || | |
(H === -1 && | |
le[0] === 'exit' && | |
(le[1].type === 'listUnordered' || le[1].type === 'listOrdered'))) | |
) { | |
if (De) { | |
let ht = U; | |
for (Pe = void 0; ht--; ) { | |
const ue = I[ht]; | |
if (ue[1].type === 'lineEnding' || ue[1].type === 'lineEndingBlank') { | |
if (ue[0] === 'exit') continue; | |
Pe && ((I[Pe][1].type = 'lineEndingBlank'), (de = !0)), | |
(ue[1].type = 'lineEnding'), | |
(Pe = ht); | |
} else if ( | |
!( | |
ue[1].type === 'linePrefix' || | |
ue[1].type === 'blockQuotePrefix' || | |
ue[1].type === 'blockQuotePrefixWhitespace' || | |
ue[1].type === 'blockQuoteMarker' || | |
ue[1].type === 'listItemIndent' | |
) | |
) | |
break; | |
} | |
Ze && (!Pe || Ze < Pe) && (De._spread = !0), | |
(De.end = Object.assign({}, Pe ? I[Pe][1].start : le[1].end)), | |
I.splice(Pe || U, 0, ['exit', De, le[2]]), | |
U++, | |
z++; | |
} | |
le[1].type === 'listItemPrefix' && | |
((De = { | |
type: 'listItem', | |
_spread: !1, | |
start: Object.assign({}, le[1].start), | |
end: void 0, | |
}), | |
I.splice(U, 0, ['enter', De, le[2]]), | |
U++, | |
z++, | |
(Ze = void 0), | |
(Ae = !0)); | |
} | |
} | |
return (I[T][1]._spread = de), z; | |
} | |
function a(I, T) { | |
n[I] = T; | |
} | |
function o(I) { | |
return n[I]; | |
} | |
function l(I, T) { | |
return z; | |
function z(U) { | |
c.call(this, I(U), U), T && T.call(this, U); | |
} | |
} | |
function s() { | |
this.stack.push({ type: 'fragment', children: [] }); | |
} | |
function c(I, T, z) { | |
return ( | |
this.stack[this.stack.length - 1].children.push(I), | |
this.stack.push(I), | |
this.tokenStack.push([T, z]), | |
(I.position = { start: ot(T.start) }), | |
I | |
); | |
} | |
function d(I) { | |
return T; | |
function T(z) { | |
I && I.call(this, z), u.call(this, z); | |
} | |
} | |
function u(I, T) { | |
const z = this.stack.pop(), | |
U = this.tokenStack.pop(); | |
if (U) U[0].type !== I.type && (T ? T.call(this, I, U[0]) : (U[1] || to).call(this, I, U[0])); | |
else | |
throw new Error( | |
'Cannot close `' + I.type + '` (' + Gt({ start: I.start, end: I.end }) + '): it’s not open' | |
); | |
return (z.position.end = ot(I.end)), z; | |
} | |
function f() { | |
return $g(this.stack.pop()); | |
} | |
function p() { | |
a('expectingFirstListItemValue', !0); | |
} | |
function m(I) { | |
if (o('expectingFirstListItemValue')) { | |
const T = this.stack[this.stack.length - 2]; | |
(T.start = Number.parseInt(this.sliceSerialize(I), 10)), a('expectingFirstListItemValue'); | |
} | |
} | |
function h() { | |
const I = this.resume(), | |
T = this.stack[this.stack.length - 1]; | |
T.lang = I; | |
} | |
function x() { | |
const I = this.resume(), | |
T = this.stack[this.stack.length - 1]; | |
T.meta = I; | |
} | |
function b() { | |
o('flowCodeInside') || (this.buffer(), a('flowCodeInside', !0)); | |
} | |
function C() { | |
const I = this.resume(), | |
T = this.stack[this.stack.length - 1]; | |
(T.value = I.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, '')), a('flowCodeInside'); | |
} | |
function S() { | |
const I = this.resume(), | |
T = this.stack[this.stack.length - 1]; | |
T.value = I.replace(/(\r?\n|\r)$/g, ''); | |
} | |
function D(I) { | |
const T = this.resume(), | |
z = this.stack[this.stack.length - 1]; | |
(z.label = T), (z.identifier = It(this.sliceSerialize(I)).toLowerCase()); | |
} | |
function E() { | |
const I = this.resume(), | |
T = this.stack[this.stack.length - 1]; | |
T.title = I; | |
} | |
function w() { | |
const I = this.resume(), | |
T = this.stack[this.stack.length - 1]; | |
T.url = I; | |
} | |
function O(I) { | |
const T = this.stack[this.stack.length - 1]; | |
if (!T.depth) { | |
const z = this.sliceSerialize(I).length; | |
T.depth = z; | |
} | |
} | |
function L() { | |
a('setextHeadingSlurpLineEnding', !0); | |
} | |
function F(I) { | |
const T = this.stack[this.stack.length - 1]; | |
T.depth = this.sliceSerialize(I).charCodeAt(0) === 61 ? 1 : 2; | |
} | |
function V() { | |
a('setextHeadingSlurpLineEnding'); | |
} | |
function A(I) { | |
const T = this.stack[this.stack.length - 1]; | |
let z = T.children[T.children.length - 1]; | |
(!z || z.type !== 'text') && | |
((z = mt()), (z.position = { start: ot(I.start) }), T.children.push(z)), | |
this.stack.push(z); | |
} | |
function R(I) { | |
const T = this.stack.pop(); | |
(T.value += this.sliceSerialize(I)), (T.position.end = ot(I.end)); | |
} | |
function Y(I) { | |
const T = this.stack[this.stack.length - 1]; | |
if (o('atHardBreak')) { | |
const z = T.children[T.children.length - 1]; | |
(z.position.end = ot(I.end)), a('atHardBreak'); | |
return; | |
} | |
!o('setextHeadingSlurpLineEnding') && | |
t.canContainEols.includes(T.type) && | |
(A.call(this, I), R.call(this, I)); | |
} | |
function q() { | |
a('atHardBreak', !0); | |
} | |
function $() { | |
const I = this.resume(), | |
T = this.stack[this.stack.length - 1]; | |
T.value = I; | |
} | |
function J() { | |
const I = this.resume(), | |
T = this.stack[this.stack.length - 1]; | |
T.value = I; | |
} | |
function ie() { | |
const I = this.resume(), | |
T = this.stack[this.stack.length - 1]; | |
T.value = I; | |
} | |
function ce() { | |
const I = this.stack[this.stack.length - 1]; | |
if (o('inReference')) { | |
const T = o('referenceType') || 'shortcut'; | |
(I.type += 'Reference'), (I.referenceType = T), delete I.url, delete I.title; | |
} else delete I.identifier, delete I.label; | |
a('referenceType'); | |
} | |
function me() { | |
const I = this.stack[this.stack.length - 1]; | |
if (o('inReference')) { | |
const T = o('referenceType') || 'shortcut'; | |
(I.type += 'Reference'), (I.referenceType = T), delete I.url, delete I.title; | |
} else delete I.identifier, delete I.label; | |
a('referenceType'); | |
} | |
function y(I) { | |
const T = this.sliceSerialize(I), | |
z = this.stack[this.stack.length - 2]; | |
(z.label = zh(T)), (z.identifier = It(T).toLowerCase()); | |
} | |
function pe() { | |
const I = this.stack[this.stack.length - 1], | |
T = this.resume(), | |
z = this.stack[this.stack.length - 1]; | |
if ((a('inReference', !0), z.type === 'link')) { | |
const U = I.children; | |
z.children = U; | |
} else z.alt = T; | |
} | |
function k() { | |
const I = this.resume(), | |
T = this.stack[this.stack.length - 1]; | |
T.url = I; | |
} | |
function v() { | |
const I = this.resume(), | |
T = this.stack[this.stack.length - 1]; | |
T.title = I; | |
} | |
function Q() { | |
a('inReference'); | |
} | |
function oe() { | |
a('referenceType', 'collapsed'); | |
} | |
function ee(I) { | |
const T = this.resume(), | |
z = this.stack[this.stack.length - 1]; | |
(z.label = T), | |
(z.identifier = It(this.sliceSerialize(I)).toLowerCase()), | |
a('referenceType', 'full'); | |
} | |
function he(I) { | |
a('characterReferenceType', I.type); | |
} | |
function fe(I) { | |
const T = this.sliceSerialize(I), | |
z = o('characterReferenceType'); | |
let U; | |
z | |
? ((U = Zl(T, z === 'characterReferenceMarkerNumeric' ? 10 : 16)), | |
a('characterReferenceType')) | |
: (U = Ni(T)); | |
const H = this.stack.pop(); | |
(H.value += U), (H.position.end = ot(I.end)); | |
} | |
function Le(I) { | |
R.call(this, I); | |
const T = this.stack[this.stack.length - 1]; | |
T.url = this.sliceSerialize(I); | |
} | |
function Se(I) { | |
R.call(this, I); | |
const T = this.stack[this.stack.length - 1]; | |
T.url = 'mailto:' + this.sliceSerialize(I); | |
} | |
function Ve() { | |
return { type: 'blockquote', children: [] }; | |
} | |
function et() { | |
return { type: 'code', lang: null, meta: null, value: '' }; | |
} | |
function ft() { | |
return { type: 'inlineCode', value: '' }; | |
} | |
function tt() { | |
return { type: 'definition', identifier: '', label: null, title: null, url: '' }; | |
} | |
function Je() { | |
return { type: 'emphasis', children: [] }; | |
} | |
function nt() { | |
return { type: 'heading', depth: void 0, children: [] }; | |
} | |
function rt() { | |
return { type: 'break' }; | |
} | |
function Ft() { | |
return { type: 'html', value: '' }; | |
} | |
function Ke() { | |
return { type: 'image', title: null, url: '', alt: null }; | |
} | |
function it() { | |
return { type: 'link', title: null, url: '', children: [] }; | |
} | |
function dn(I) { | |
return { | |
type: 'list', | |
ordered: I.type === 'listOrdered', | |
start: null, | |
spread: I._spread, | |
children: [], | |
}; | |
} | |
function gt(I) { | |
return { type: 'listItem', spread: I._spread, checked: null, children: [] }; | |
} | |
function pn() { | |
return { type: 'paragraph', children: [] }; | |
} | |
function _e() { | |
return { type: 'strong', children: [] }; | |
} | |
function mt() { | |
return { type: 'text', value: '' }; | |
} | |
function Ct() { | |
return { type: 'thematicBreak' }; | |
} | |
} | |
function ot(e) { | |
return { line: e.line, column: e.column, offset: e.offset }; | |
} | |
function ts(e, t) { | |
let n = -1; | |
for (; ++n < t.length; ) { | |
const r = t[n]; | |
Array.isArray(r) ? ts(e, r) : Gh(e, r); | |
} | |
} | |
function Gh(e, t) { | |
let n; | |
for (n in t) | |
if (es.call(t, n)) { | |
if (n === 'canContainEols') { | |
const r = t[n]; | |
r && e[n].push(...r); | |
} else if (n === 'transforms') { | |
const r = t[n]; | |
r && e[n].push(...r); | |
} else if (n === 'enter' || n === 'exit') { | |
const r = t[n]; | |
r && Object.assign(e[n], r); | |
} | |
} | |
} | |
function to(e, t) { | |
throw e | |
? new Error( | |
'Cannot close `' + | |
e.type + | |
'` (' + | |
Gt({ start: e.start, end: e.end }) + | |
'): a different token (`' + | |
t.type + | |
'`, ' + | |
Gt({ start: t.start, end: t.end }) + | |
') is open' | |
) | |
: new Error( | |
'Cannot close document, a token (`' + | |
t.type + | |
'`, ' + | |
Gt({ start: t.start, end: t.end }) + | |
') is still open' | |
); | |
} | |
function Wh(e) { | |
Object.assign(this, { | |
Parser: (n) => { | |
const r = this.data('settings'); | |
return Hh( | |
n, | |
Object.assign({}, r, e, { | |
extensions: this.data('micromarkExtensions') || [], | |
mdastExtensions: this.data('fromMarkdownExtensions') || [], | |
}) | |
); | |
}, | |
}); | |
} | |
function qh(e, t) { | |
const n = { | |
type: 'element', | |
tagName: 'blockquote', | |
properties: {}, | |
children: e.wrap(e.all(t), !0), | |
}; | |
return e.patch(t, n), e.applyData(t, n); | |
} | |
function Vh(e, t) { | |
const n = { type: 'element', tagName: 'br', properties: {}, children: [] }; | |
return ( | |
e.patch(t, n), | |
[ | |
e.applyData(t, n), | |
{ | |
type: 'text', | |
value: ` | |
`, | |
}, | |
] | |
); | |
} | |
function Kh(e, t) { | |
const n = t.value | |
? t.value + | |
` | |
` | |
: '', | |
r = t.lang ? t.lang.match(/^[^ \t]+(?=[ \t]|$)/) : null, | |
i = {}; | |
r && (i.className = ['language-' + r]); | |
let a = { | |
type: 'element', | |
tagName: 'code', | |
properties: i, | |
children: [{ type: 'text', value: n }], | |
}; | |
return ( | |
t.meta && (a.data = { meta: t.meta }), | |
e.patch(t, a), | |
(a = e.applyData(t, a)), | |
(a = { type: 'element', tagName: 'pre', properties: {}, children: [a] }), | |
e.patch(t, a), | |
a | |
); | |
} | |
function Yh(e, t) { | |
const n = { type: 'element', tagName: 'del', properties: {}, children: e.all(t) }; | |
return e.patch(t, n), e.applyData(t, n); | |
} | |
function Qh(e, t) { | |
const n = { type: 'element', tagName: 'em', properties: {}, children: e.all(t) }; | |
return e.patch(t, n), e.applyData(t, n); | |
} | |
function Bt(e) { | |
const t = []; | |
let n = -1, | |
r = 0, | |
i = 0; | |
for (; ++n < e.length; ) { | |
const a = e.charCodeAt(n); | |
let o = ''; | |
if (a === 37 && Te(e.charCodeAt(n + 1)) && Te(e.charCodeAt(n + 2))) i = 2; | |
else if (a < 128) | |
/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(a)) || (o = String.fromCharCode(a)); | |
else if (a > 55295 && a < 57344) { | |
const l = e.charCodeAt(n + 1); | |
a < 56320 && l > 56319 && l < 57344 ? ((o = String.fromCharCode(a, l)), (i = 1)) : (o = '�'); | |
} else o = String.fromCharCode(a); | |
o && (t.push(e.slice(r, n), encodeURIComponent(o)), (r = n + i + 1), (o = '')), | |
i && ((n += i), (i = 0)); | |
} | |
return t.join('') + e.slice(r); | |
} | |
function ns(e, t) { | |
const n = String(t.identifier).toUpperCase(), | |
r = Bt(n.toLowerCase()), | |
i = e.footnoteOrder.indexOf(n); | |
let a; | |
i === -1 | |
? (e.footnoteOrder.push(n), (e.footnoteCounts[n] = 1), (a = e.footnoteOrder.length)) | |
: (e.footnoteCounts[n]++, (a = i + 1)); | |
const o = e.footnoteCounts[n], | |
l = { | |
type: 'element', | |
tagName: 'a', | |
properties: { | |
href: '#' + e.clobberPrefix + 'fn-' + r, | |
id: e.clobberPrefix + 'fnref-' + r + (o > 1 ? '-' + o : ''), | |
dataFootnoteRef: !0, | |
ariaDescribedBy: ['footnote-label'], | |
}, | |
children: [{ type: 'text', value: String(a) }], | |
}; | |
e.patch(t, l); | |
const s = { type: 'element', tagName: 'sup', properties: {}, children: [l] }; | |
return e.patch(t, s), e.applyData(t, s); | |
} | |
function Xh(e, t) { | |
const n = e.footnoteById; | |
let r = 1; | |
for (; r in n; ) r++; | |
const i = String(r); | |
return ( | |
(n[i] = { | |
type: 'footnoteDefinition', | |
identifier: i, | |
children: [{ type: 'paragraph', children: t.children }], | |
position: t.position, | |
}), | |
ns(e, { type: 'footnoteReference', identifier: i, position: t.position }) | |
); | |
} | |
function Jh(e, t) { | |
const n = { type: 'element', tagName: 'h' + t.depth, properties: {}, children: e.all(t) }; | |
return e.patch(t, n), e.applyData(t, n); | |
} | |
function _h(e, t) { | |
if (e.dangerous) { | |
const n = { type: 'raw', value: t.value }; | |
return e.patch(t, n), e.applyData(t, n); | |
} | |
return null; | |
} | |
function rs(e, t) { | |
const n = t.referenceType; | |
let r = ']'; | |
if ( | |
(n === 'collapsed' ? (r += '[]') : n === 'full' && (r += '[' + (t.label || t.identifier) + ']'), | |
t.type === 'imageReference') | |
) | |
return { type: 'text', value: '![' + t.alt + r }; | |
const i = e.all(t), | |
a = i[0]; | |
a && a.type === 'text' ? (a.value = '[' + a.value) : i.unshift({ type: 'text', value: '[' }); | |
const o = i[i.length - 1]; | |
return o && o.type === 'text' ? (o.value += r) : i.push({ type: 'text', value: r }), i; | |
} | |
function Zh(e, t) { | |
const n = e.definition(t.identifier); | |
if (!n) return rs(e, t); | |
const r = { src: Bt(n.url || ''), alt: t.alt }; | |
n.title !== null && n.title !== void 0 && (r.title = n.title); | |
const i = { type: 'element', tagName: 'img', properties: r, children: [] }; | |
return e.patch(t, i), e.applyData(t, i); | |
} | |
function ev(e, t) { | |
const n = { src: Bt(t.url) }; | |
t.alt !== null && t.alt !== void 0 && (n.alt = t.alt), | |
t.title !== null && t.title !== void 0 && (n.title = t.title); | |
const r = { type: 'element', tagName: 'img', properties: n, children: [] }; | |
return e.patch(t, r), e.applyData(t, r); | |
} | |
function tv(e, t) { | |
const n = { type: 'text', value: t.value.replace(/\r?\n|\r/g, ' ') }; | |
e.patch(t, n); | |
const r = { type: 'element', tagName: 'code', properties: {}, children: [n] }; | |
return e.patch(t, r), e.applyData(t, r); | |
} | |
function nv(e, t) { | |
const n = e.definition(t.identifier); | |
if (!n) return rs(e, t); | |
const r = { href: Bt(n.url || '') }; | |
n.title !== null && n.title !== void 0 && (r.title = n.title); | |
const i = { type: 'element', tagName: 'a', properties: r, children: e.all(t) }; | |
return e.patch(t, i), e.applyData(t, i); | |
} | |
function rv(e, t) { | |
const n = { href: Bt(t.url) }; | |
t.title !== null && t.title !== void 0 && (n.title = t.title); | |
const r = { type: 'element', tagName: 'a', properties: n, children: e.all(t) }; | |
return e.patch(t, r), e.applyData(t, r); | |
} | |
function iv(e, t, n) { | |
const r = e.all(t), | |
i = n ? av(n) : is(t), | |
a = {}, | |
o = []; | |
if (typeof t.checked == 'boolean') { | |
const d = r[0]; | |
let u; | |
d && d.type === 'element' && d.tagName === 'p' | |
? (u = d) | |
: ((u = { type: 'element', tagName: 'p', properties: {}, children: [] }), r.unshift(u)), | |
u.children.length > 0 && u.children.unshift({ type: 'text', value: ' ' }), | |
u.children.unshift({ | |
type: 'element', | |
tagName: 'input', | |
properties: { type: 'checkbox', checked: t.checked, disabled: !0 }, | |
children: [], | |
}), | |
(a.className = ['task-list-item']); | |
} | |
let l = -1; | |
for (; ++l < r.length; ) { | |
const d = r[l]; | |
(i || l !== 0 || d.type !== 'element' || d.tagName !== 'p') && | |
o.push({ | |
type: 'text', | |
value: ` | |
`, | |
}), | |
d.type === 'element' && d.tagName === 'p' && !i ? o.push(...d.children) : o.push(d); | |
} | |
const s = r[r.length - 1]; | |
s && | |
(i || s.type !== 'element' || s.tagName !== 'p') && | |
o.push({ | |
type: 'text', | |
value: ` | |
`, | |
}); | |
const c = { type: 'element', tagName: 'li', properties: a, children: o }; | |
return e.patch(t, c), e.applyData(t, c); | |
} | |
function av(e) { | |
let t = !1; | |
if (e.type === 'list') { | |
t = e.spread || !1; | |
const n = e.children; | |
let r = -1; | |
for (; !t && ++r < n.length; ) t = is(n[r]); | |
} | |
return t; | |
} | |
function is(e) { | |
const t = e.spread; | |
return t ?? e.children.length > 1; | |
} | |
function ov(e, t) { | |
const n = {}, | |
r = e.all(t); | |
let i = -1; | |
for (typeof t.start == 'number' && t.start !== 1 && (n.start = t.start); ++i < r.length; ) { | |
const o = r[i]; | |
if ( | |
o.type === 'element' && | |
o.tagName === 'li' && | |
o.properties && | |
Array.isArray(o.properties.className) && | |
o.properties.className.includes('task-list-item') | |
) { | |
n.className = ['contains-task-list']; | |
break; | |
} | |
} | |
const a = { | |
type: 'element', | |
tagName: t.ordered ? 'ol' : 'ul', | |
properties: n, | |
children: e.wrap(r, !0), | |
}; | |
return e.patch(t, a), e.applyData(t, a); | |
} | |
function lv(e, t) { | |
const n = { type: 'element', tagName: 'p', properties: {}, children: e.all(t) }; | |
return e.patch(t, n), e.applyData(t, n); | |
} | |
function sv(e, t) { | |
const n = { type: 'root', children: e.wrap(e.all(t)) }; | |
return e.patch(t, n), e.applyData(t, n); | |
} | |
function uv(e, t) { | |
const n = { type: 'element', tagName: 'strong', properties: {}, children: e.all(t) }; | |
return e.patch(t, n), e.applyData(t, n); | |
} | |
const Ti = as('start'), | |
Bi = as('end'); | |
function cv(e) { | |
return { start: Ti(e), end: Bi(e) }; | |
} | |
function as(e) { | |
return t; | |
function t(n) { | |
const r = (n && n.position && n.position[e]) || {}; | |
return { | |
line: r.line || null, | |
column: r.column || null, | |
offset: r.offset > -1 ? r.offset : null, | |
}; | |
} | |
} | |
function dv(e, t) { | |
const n = e.all(t), | |
r = n.shift(), | |
i = []; | |
if (r) { | |
const o = { type: 'element', tagName: 'thead', properties: {}, children: e.wrap([r], !0) }; | |
e.patch(t.children[0], o), i.push(o); | |
} | |
if (n.length > 0) { | |
const o = { type: 'element', tagName: 'tbody', properties: {}, children: e.wrap(n, !0) }, | |
l = Ti(t.children[1]), | |
s = Bi(t.children[t.children.length - 1]); | |
l.line && s.line && (o.position = { start: l, end: s }), i.push(o); | |
} | |
const a = { type: 'element', tagName: 'table', properties: {}, children: e.wrap(i, !0) }; | |
return e.patch(t, a), e.applyData(t, a); | |
} | |
function pv(e, t, n) { | |
const r = n ? n.children : void 0, | |
a = (r ? r.indexOf(t) : 1) === 0 ? 'th' : 'td', | |
o = n && n.type === 'table' ? n.align : void 0, | |
l = o ? o.length : t.children.length; | |
let s = -1; | |
const c = []; | |
for (; ++s < l; ) { | |
const u = t.children[s], | |
f = {}, | |
p = o ? o[s] : void 0; | |
p && (f.align = p); | |
let m = { type: 'element', tagName: a, properties: f, children: [] }; | |
u && ((m.children = e.all(u)), e.patch(u, m), (m = e.applyData(t, m))), c.push(m); | |
} | |
const d = { type: 'element', tagName: 'tr', properties: {}, children: e.wrap(c, !0) }; | |
return e.patch(t, d), e.applyData(t, d); | |
} | |
function fv(e, t) { | |
const n = { type: 'element', tagName: 'td', properties: {}, children: e.all(t) }; | |
return e.patch(t, n), e.applyData(t, n); | |
} | |
const no = 9, | |
ro = 32; | |
function gv(e) { | |
const t = String(e), | |
n = /\r?\n|\r/g; | |
let r = n.exec(t), | |
i = 0; | |
const a = []; | |
for (; r; ) | |
a.push(io(t.slice(i, r.index), i > 0, !0), r[0]), (i = r.index + r[0].length), (r = n.exec(t)); | |
return a.push(io(t.slice(i), i > 0, !1)), a.join(''); | |
} | |
function io(e, t, n) { | |
let r = 0, | |
i = e.length; | |
if (t) { | |
let a = e.codePointAt(r); | |
for (; a === no || a === ro; ) r++, (a = e.codePointAt(r)); | |
} | |
if (n) { | |
let a = e.codePointAt(i - 1); | |
for (; a === no || a === ro; ) i--, (a = e.codePointAt(i - 1)); | |
} | |
return i > r ? e.slice(r, i) : ''; | |
} | |
function mv(e, t) { | |
const n = { type: 'text', value: gv(String(t.value)) }; | |
return e.patch(t, n), e.applyData(t, n); | |
} | |
function hv(e, t) { | |
const n = { type: 'element', tagName: 'hr', properties: {}, children: [] }; | |
return e.patch(t, n), e.applyData(t, n); | |
} | |
const vv = { | |
blockquote: qh, | |
break: Vh, | |
code: Kh, | |
delete: Yh, | |
emphasis: Qh, | |
footnoteReference: ns, | |
footnote: Xh, | |
heading: Jh, | |
html: _h, | |
imageReference: Zh, | |
image: ev, | |
inlineCode: tv, | |
linkReference: nv, | |
link: rv, | |
listItem: iv, | |
list: ov, | |
paragraph: lv, | |
root: sv, | |
strong: uv, | |
table: dv, | |
tableCell: fv, | |
tableRow: pv, | |
text: mv, | |
thematicBreak: hv, | |
toml: yn, | |
yaml: yn, | |
definition: yn, | |
footnoteDefinition: yn, | |
}; | |
function yn() { | |
return null; | |
} | |
const os = function (e) { | |
if (e == null) return wv; | |
if (typeof e == 'string') return xv(e); | |
if (typeof e == 'object') return Array.isArray(e) ? bv(e) : yv(e); | |
if (typeof e == 'function') return tr(e); | |
throw new Error('Expected function, string, or object as test'); | |
}; | |
function bv(e) { | |
const t = []; | |
let n = -1; | |
for (; ++n < e.length; ) t[n] = os(e[n]); | |
return tr(r); | |
function r(...i) { | |
let a = -1; | |
for (; ++a < t.length; ) if (t[a].call(this, ...i)) return !0; | |
return !1; | |
} | |
} | |
function yv(e) { | |
return tr(t); | |
function t(n) { | |
let r; | |
for (r in e) if (n[r] !== e[r]) return !1; | |
return !0; | |
} | |
} | |
function xv(e) { | |
return tr(t); | |
function t(n) { | |
return n && n.type === e; | |
} | |
} | |
function tr(e) { | |
return t; | |
function t(n, ...r) { | |
return !!(n && typeof n == 'object' && 'type' in n && e.call(this, n, ...r)); | |
} | |
} | |
function wv() { | |
return !0; | |
} | |
const Sv = !0, | |
ao = !1, | |
Cv = 'skip', | |
Dv = function (e, t, n, r) { | |
typeof t == 'function' && typeof n != 'function' && ((r = n), (n = t), (t = null)); | |
const i = os(t), | |
a = r ? -1 : 1; | |
o(e, void 0, [])(); | |
function o(l, s, c) { | |
const d = l && typeof l == 'object' ? l : {}; | |
if (typeof d.type == 'string') { | |
const f = | |
typeof d.tagName == 'string' ? d.tagName : typeof d.name == 'string' ? d.name : void 0; | |
Object.defineProperty(u, 'name', { | |
value: 'node (' + (l.type + (f ? '<' + f + '>' : '')) + ')', | |
}); | |
} | |
return u; | |
function u() { | |
let f = [], | |
p, | |
m, | |
h; | |
if ((!t || i(l, s, c[c.length - 1] || null)) && ((f = Iv(n(l, c))), f[0] === ao)) return f; | |
if (l.children && f[0] !== Cv) | |
for ( | |
m = (r ? l.children.length : -1) + a, h = c.concat(l); | |
m > -1 && m < l.children.length; | |
) { | |
if (((p = o(l.children[m], m, h)()), p[0] === ao)) return p; | |
m = typeof p[1] == 'number' ? p[1] : m + a; | |
} | |
return f; | |
} | |
} | |
}; | |
function Iv(e) { | |
return Array.isArray(e) ? e : typeof e == 'number' ? [Sv, e] : [e]; | |
} | |
const Ri = function (e, t, n, r) { | |
typeof t == 'function' && typeof n != 'function' && ((r = n), (n = t), (t = null)), | |
Dv(e, t, i, r); | |
function i(a, o) { | |
const l = o[o.length - 1]; | |
return n(a, l ? l.children.indexOf(a) : null, l); | |
} | |
}; | |
function kv(e) { | |
return ( | |
!e || | |
!e.position || | |
!e.position.start || | |
!e.position.start.line || | |
!e.position.start.column || | |
!e.position.end || | |
!e.position.end.line || | |
!e.position.end.column | |
); | |
} | |
const oo = {}.hasOwnProperty; | |
function Ev(e) { | |
const t = Object.create(null); | |
if (!e || !e.type) throw new Error('mdast-util-definitions expected node'); | |
return ( | |
Ri(e, 'definition', (r) => { | |
const i = lo(r.identifier); | |
i && !oo.call(t, i) && (t[i] = r); | |
}), | |
n | |
); | |
function n(r) { | |
const i = lo(r); | |
return i && oo.call(t, i) ? t[i] : null; | |
} | |
} | |
function lo(e) { | |
return String(e || '').toUpperCase(); | |
} | |
const Bn = {}.hasOwnProperty; | |
function Pv(e, t) { | |
const n = t || {}, | |
r = n.allowDangerousHtml || !1, | |
i = {}; | |
return ( | |
(o.dangerous = r), | |
(o.clobberPrefix = | |
n.clobberPrefix === void 0 || n.clobberPrefix === null ? 'user-content-' : n.clobberPrefix), | |
(o.footnoteLabel = n.footnoteLabel || 'Footnotes'), | |
(o.footnoteLabelTagName = n.footnoteLabelTagName || 'h2'), | |
(o.footnoteLabelProperties = n.footnoteLabelProperties || { className: ['sr-only'] }), | |
(o.footnoteBackLabel = n.footnoteBackLabel || 'Back to content'), | |
(o.unknownHandler = n.unknownHandler), | |
(o.passThrough = n.passThrough), | |
(o.handlers = { ...vv, ...n.handlers }), | |
(o.definition = Ev(e)), | |
(o.footnoteById = i), | |
(o.footnoteOrder = []), | |
(o.footnoteCounts = {}), | |
(o.patch = Av), | |
(o.applyData = Nv), | |
(o.one = l), | |
(o.all = s), | |
(o.wrap = Tv), | |
(o.augment = a), | |
Ri(e, 'footnoteDefinition', (c) => { | |
const d = String(c.identifier).toUpperCase(); | |
Bn.call(i, d) || (i[d] = c); | |
}), | |
o | |
); | |
function a(c, d) { | |
if (c && 'data' in c && c.data) { | |
const u = c.data; | |
u.hName && | |
(d.type !== 'element' && | |
(d = { type: 'element', tagName: '', properties: {}, children: [] }), | |
(d.tagName = u.hName)), | |
d.type === 'element' && | |
u.hProperties && | |
(d.properties = { ...d.properties, ...u.hProperties }), | |
'children' in d && d.children && u.hChildren && (d.children = u.hChildren); | |
} | |
if (c) { | |
const u = 'type' in c ? c : { position: c }; | |
kv(u) || (d.position = { start: Ti(u), end: Bi(u) }); | |
} | |
return d; | |
} | |
function o(c, d, u, f) { | |
return ( | |
Array.isArray(u) && ((f = u), (u = {})), | |
a(c, { type: 'element', tagName: d, properties: u || {}, children: f || [] }) | |
); | |
} | |
function l(c, d) { | |
return ls(o, c, d); | |
} | |
function s(c) { | |
return Fi(o, c); | |
} | |
} | |
function Av(e, t) { | |
e.position && (t.position = cv(e)); | |
} | |
function Nv(e, t) { | |
let n = t; | |
if (e && e.data) { | |
const r = e.data.hName, | |
i = e.data.hChildren, | |
a = e.data.hProperties; | |
typeof r == 'string' && | |
(n.type === 'element' | |
? (n.tagName = r) | |
: (n = { type: 'element', tagName: r, properties: {}, children: [] })), | |
n.type === 'element' && a && (n.properties = { ...n.properties, ...a }), | |
'children' in n && n.children && i !== null && i !== void 0 && (n.children = i); | |
} | |
return n; | |
} | |
function ls(e, t, n) { | |
const r = t && t.type; | |
if (!r) throw new Error('Expected node, got `' + t + '`'); | |
return Bn.call(e.handlers, r) | |
? e.handlers[r](e, t, n) | |
: e.passThrough && e.passThrough.includes(r) | |
? 'children' in t | |
? { ...t, children: Fi(e, t) } | |
: t | |
: e.unknownHandler | |
? e.unknownHandler(e, t, n) | |
: Ov(e, t); | |
} | |
function Fi(e, t) { | |
const n = []; | |
if ('children' in t) { | |
const r = t.children; | |
let i = -1; | |
for (; ++i < r.length; ) { | |
const a = ls(e, r[i], t); | |
if (a) { | |
if ( | |
i && | |
r[i - 1].type === 'break' && | |
(!Array.isArray(a) && a.type === 'text' && (a.value = a.value.replace(/^\s+/, '')), | |
!Array.isArray(a) && a.type === 'element') | |
) { | |
const o = a.children[0]; | |
o && o.type === 'text' && (o.value = o.value.replace(/^\s+/, '')); | |
} | |
Array.isArray(a) ? n.push(...a) : n.push(a); | |
} | |
} | |
} | |
return n; | |
} | |
function Ov(e, t) { | |
const n = t.data || {}, | |
r = | |
'value' in t && !(Bn.call(n, 'hProperties') || Bn.call(n, 'hChildren')) | |
? { type: 'text', value: t.value } | |
: { type: 'element', tagName: 'div', properties: {}, children: Fi(e, t) }; | |
return e.patch(t, r), e.applyData(t, r); | |
} | |
function Tv(e, t) { | |
const n = []; | |
let r = -1; | |
for ( | |
t && | |
n.push({ | |
type: 'text', | |
value: ` | |
`, | |
}); | |
++r < e.length; | |
) | |
r && | |
n.push({ | |
type: 'text', | |
value: ` | |
`, | |
}), | |
n.push(e[r]); | |
return ( | |
t && | |
e.length > 0 && | |
n.push({ | |
type: 'text', | |
value: ` | |
`, | |
}), | |
n | |
); | |
} | |
function Bv(e) { | |
const t = []; | |
let n = -1; | |
for (; ++n < e.footnoteOrder.length; ) { | |
const r = e.footnoteById[e.footnoteOrder[n]]; | |
if (!r) continue; | |
const i = e.all(r), | |
a = String(r.identifier).toUpperCase(), | |
o = Bt(a.toLowerCase()); | |
let l = 0; | |
const s = []; | |
for (; ++l <= e.footnoteCounts[a]; ) { | |
const u = { | |
type: 'element', | |
tagName: 'a', | |
properties: { | |
href: '#' + e.clobberPrefix + 'fnref-' + o + (l > 1 ? '-' + l : ''), | |
dataFootnoteBackref: !0, | |
className: ['data-footnote-backref'], | |
ariaLabel: e.footnoteBackLabel, | |
}, | |
children: [{ type: 'text', value: '↩' }], | |
}; | |
l > 1 && | |
u.children.push({ | |
type: 'element', | |
tagName: 'sup', | |
children: [{ type: 'text', value: String(l) }], | |
}), | |
s.length > 0 && s.push({ type: 'text', value: ' ' }), | |
s.push(u); | |
} | |
const c = i[i.length - 1]; | |
if (c && c.type === 'element' && c.tagName === 'p') { | |
const u = c.children[c.children.length - 1]; | |
u && u.type === 'text' ? (u.value += ' ') : c.children.push({ type: 'text', value: ' ' }), | |
c.children.push(...s); | |
} else i.push(...s); | |
const d = { | |
type: 'element', | |
tagName: 'li', | |
properties: { id: e.clobberPrefix + 'fn-' + o }, | |
children: e.wrap(i, !0), | |
}; | |
e.patch(r, d), t.push(d); | |
} | |
if (t.length !== 0) | |
return { | |
type: 'element', | |
tagName: 'section', | |
properties: { dataFootnotes: !0, className: ['footnotes'] }, | |
children: [ | |
{ | |
type: 'element', | |
tagName: e.footnoteLabelTagName, | |
properties: { | |
...JSON.parse(JSON.stringify(e.footnoteLabelProperties)), | |
id: 'footnote-label', | |
}, | |
children: [{ type: 'text', value: e.footnoteLabel }], | |
}, | |
{ | |
type: 'text', | |
value: ` | |
`, | |
}, | |
{ type: 'element', tagName: 'ol', properties: {}, children: e.wrap(t, !0) }, | |
{ | |
type: 'text', | |
value: ` | |
`, | |
}, | |
], | |
}; | |
} | |
function ss(e, t) { | |
const n = Pv(e, t), | |
r = n.one(e, null), | |
i = Bv(n); | |
return ( | |
i && | |
r.children.push( | |
{ | |
type: 'text', | |
value: ` | |
`, | |
}, | |
i | |
), | |
Array.isArray(r) ? { type: 'root', children: r } : r | |
); | |
} | |
const Rv = function (e, t) { | |
return e && 'run' in e ? Lv(e, t) : Mv(e || t); | |
}, | |
Fv = Rv; | |
function Lv(e, t) { | |
return (n, r, i) => { | |
e.run(ss(n, t), r, (a) => { | |
i(a); | |
}); | |
}; | |
} | |
function Mv(e) { | |
return (t) => ss(t, e); | |
} | |
class cn { | |
constructor(t, n, r) { | |
(this.property = t), (this.normal = n), r && (this.space = r); | |
} | |
} | |
cn.prototype.property = {}; | |
cn.prototype.normal = {}; | |
cn.prototype.space = null; | |
function us(e, t) { | |
const n = {}, | |
r = {}; | |
let i = -1; | |
for (; ++i < e.length; ) Object.assign(n, e[i].property), Object.assign(r, e[i].normal); | |
return new cn(n, r, t); | |
} | |
function Xr(e) { | |
return e.toLowerCase(); | |
} | |
class Ue { | |
constructor(t, n) { | |
(this.property = t), (this.attribute = n); | |
} | |
} | |
Ue.prototype.space = null; | |
Ue.prototype.boolean = !1; | |
Ue.prototype.booleanish = !1; | |
Ue.prototype.overloadedBoolean = !1; | |
Ue.prototype.number = !1; | |
Ue.prototype.commaSeparated = !1; | |
Ue.prototype.spaceSeparated = !1; | |
Ue.prototype.commaOrSpaceSeparated = !1; | |
Ue.prototype.mustUseProperty = !1; | |
Ue.prototype.defined = !1; | |
let jv = 0; | |
const K = St(), | |
ge = St(), | |
cs = St(), | |
P = St(), | |
se = St(), | |
kt = St(), | |
Ne = St(); | |
function St() { | |
return 2 ** ++jv; | |
} | |
const Jr = Object.freeze( | |
Object.defineProperty( | |
{ | |
__proto__: null, | |
boolean: K, | |
booleanish: ge, | |
commaOrSpaceSeparated: Ne, | |
commaSeparated: kt, | |
number: P, | |
overloadedBoolean: cs, | |
spaceSeparated: se, | |
}, | |
Symbol.toStringTag, | |
{ value: 'Module' } | |
) | |
), | |
Br = Object.keys(Jr); | |
class Li extends Ue { | |
constructor(t, n, r, i) { | |
let a = -1; | |
if ((super(t, n), so(this, 'space', i), typeof r == 'number')) | |
for (; ++a < Br.length; ) { | |
const o = Br[a]; | |
so(this, Br[a], (r & Jr[o]) === Jr[o]); | |
} | |
} | |
} | |
Li.prototype.defined = !0; | |
function so(e, t, n) { | |
n && (e[t] = n); | |
} | |
const zv = {}.hasOwnProperty; | |
function Rt(e) { | |
const t = {}, | |
n = {}; | |
let r; | |
for (r in e.properties) | |
if (zv.call(e.properties, r)) { | |
const i = e.properties[r], | |
a = new Li(r, e.transform(e.attributes || {}, r), i, e.space); | |
e.mustUseProperty && e.mustUseProperty.includes(r) && (a.mustUseProperty = !0), | |
(t[r] = a), | |
(n[Xr(r)] = r), | |
(n[Xr(a.attribute)] = r); | |
} | |
return new cn(t, n, e.space); | |
} | |
const ds = Rt({ | |
space: 'xlink', | |
transform(e, t) { | |
return 'xlink:' + t.slice(5).toLowerCase(); | |
}, | |
properties: { | |
xLinkActuate: null, | |
xLinkArcRole: null, | |
xLinkHref: null, | |
xLinkRole: null, | |
xLinkShow: null, | |
xLinkTitle: null, | |
xLinkType: null, | |
}, | |
}), | |
ps = Rt({ | |
space: 'xml', | |
transform(e, t) { | |
return 'xml:' + t.slice(3).toLowerCase(); | |
}, | |
properties: { xmlLang: null, xmlBase: null, xmlSpace: null }, | |
}); | |
function fs(e, t) { | |
return t in e ? e[t] : t; | |
} | |
function gs(e, t) { | |
return fs(e, t.toLowerCase()); | |
} | |
const ms = Rt({ | |
space: 'xmlns', | |
attributes: { xmlnsxlink: 'xmlns:xlink' }, | |
transform: gs, | |
properties: { xmlns: null, xmlnsXLink: null }, | |
}), | |
hs = Rt({ | |
transform(e, t) { | |
return t === 'role' ? t : 'aria-' + t.slice(4).toLowerCase(); | |
}, | |
properties: { | |
ariaActiveDescendant: null, | |
ariaAtomic: ge, | |
ariaAutoComplete: null, | |
ariaBusy: ge, | |
ariaChecked: ge, | |
ariaColCount: P, | |
ariaColIndex: P, | |
ariaColSpan: P, | |
ariaControls: se, | |
ariaCurrent: null, | |
ariaDescribedBy: se, | |
ariaDetails: null, | |
ariaDisabled: ge, | |
ariaDropEffect: se, | |
ariaErrorMessage: null, | |
ariaExpanded: ge, | |
ariaFlowTo: se, | |
ariaGrabbed: ge, | |
ariaHasPopup: null, | |
ariaHidden: ge, | |
ariaInvalid: null, | |
ariaKeyShortcuts: null, | |
ariaLabel: null, | |
ariaLabelledBy: se, | |
ariaLevel: P, | |
ariaLive: null, | |
ariaModal: ge, | |
ariaMultiLine: ge, | |
ariaMultiSelectable: ge, | |
ariaOrientation: null, | |
ariaOwns: se, | |
ariaPlaceholder: null, | |
ariaPosInSet: P, | |
ariaPressed: ge, | |
ariaReadOnly: ge, | |
ariaRelevant: null, | |
ariaRequired: ge, | |
ariaRoleDescription: se, | |
ariaRowCount: P, | |
ariaRowIndex: P, | |
ariaRowSpan: P, | |
ariaSelected: ge, | |
ariaSetSize: P, | |
ariaSort: null, | |
ariaValueMax: P, | |
ariaValueMin: P, | |
ariaValueNow: P, | |
ariaValueText: null, | |
role: null, | |
}, | |
}), | |
$v = Rt({ | |
space: 'html', | |
attributes: { | |
acceptcharset: 'accept-charset', | |
classname: 'class', | |
htmlfor: 'for', | |
httpequiv: 'http-equiv', | |
}, | |
transform: gs, | |
mustUseProperty: ['checked', 'multiple', 'muted', 'selected'], | |
properties: { | |
abbr: null, | |
accept: kt, | |
acceptCharset: se, | |
accessKey: se, | |
action: null, | |
allow: null, | |
allowFullScreen: K, | |
allowPaymentRequest: K, | |
allowUserMedia: K, | |
alt: null, | |
as: null, | |
async: K, | |
autoCapitalize: null, | |
autoComplete: se, | |
autoFocus: K, | |
autoPlay: K, | |
capture: K, | |
charSet: null, | |
checked: K, | |
cite: null, | |
className: se, | |
cols: P, | |
colSpan: null, | |
content: null, | |
contentEditable: ge, | |
controls: K, | |
controlsList: se, | |
coords: P | kt, | |
crossOrigin: null, | |
data: null, | |
dateTime: null, | |
decoding: null, | |
default: K, | |
defer: K, | |
dir: null, | |
dirName: null, | |
disabled: K, | |
download: cs, | |
draggable: ge, | |
encType: null, | |
enterKeyHint: null, | |
form: null, | |
formAction: null, | |
formEncType: null, | |
formMethod: null, | |
formNoValidate: K, | |
formTarget: null, | |
headers: se, | |
height: P, | |
hidden: K, | |
high: P, | |
href: null, | |
hrefLang: null, | |
htmlFor: se, | |
httpEquiv: se, | |
id: null, | |
imageSizes: null, | |
imageSrcSet: null, | |
inputMode: null, | |
integrity: null, | |
is: null, | |
isMap: K, | |
itemId: null, | |
itemProp: se, | |
itemRef: se, | |
itemScope: K, | |
itemType: se, | |
kind: null, | |
label: null, | |
lang: null, | |
language: null, | |
list: null, | |
loading: null, | |
loop: K, | |
low: P, | |
manifest: null, | |
max: null, | |
maxLength: P, | |
media: null, | |
method: null, | |
min: null, | |
minLength: P, | |
multiple: K, | |
muted: K, | |
name: null, | |
nonce: null, | |
noModule: K, | |
noValidate: K, | |
onAbort: null, | |
onAfterPrint: null, | |
onAuxClick: null, | |
onBeforeMatch: null, | |
onBeforePrint: null, | |
onBeforeUnload: null, | |
onBlur: null, | |
onCancel: null, | |
onCanPlay: null, | |
onCanPlayThrough: null, | |
onChange: null, | |
onClick: null, | |
onClose: null, | |
onContextLost: null, | |
onContextMenu: null, | |
onContextRestored: null, | |
onCopy: null, | |
onCueChange: null, | |
onCut: null, | |
onDblClick: null, | |
onDrag: null, | |
onDragEnd: null, | |
onDragEnter: null, | |
onDragExit: null, | |
onDragLeave: null, | |
onDragOver: null, | |
onDragStart: null, | |
onDrop: null, | |
onDurationChange: null, | |
onEmptied: null, | |
onEnded: null, | |
onError: null, | |
onFocus: null, | |
onFormData: null, | |
onHashChange: null, | |
onInput: null, | |
onInvalid: null, | |
onKeyDown: null, | |
onKeyPress: null, | |
onKeyUp: null, | |
onLanguageChange: null, | |
onLoad: null, | |
onLoadedData: null, | |
onLoadedMetadata: null, | |
onLoadEnd: null, | |
onLoadStart: null, | |
onMessage: null, | |
onMessageError: null, | |
onMouseDown: null, | |
onMouseEnter: null, | |
onMouseLeave: null, | |
onMouseMove: null, | |
onMouseOut: null, | |
onMouseOver: null, | |
onMouseUp: null, | |
onOffline: null, | |
onOnline: null, | |
onPageHide: null, | |
onPageShow: null, | |
onPaste: null, | |
onPause: null, | |
onPlay: null, | |
onPlaying: null, | |
onPopState: null, | |
onProgress: null, | |
onRateChange: null, | |
onRejectionHandled: null, | |
onReset: null, | |
onResize: null, | |
onScroll: null, | |
onScrollEnd: null, | |
onSecurityPolicyViolation: null, | |
onSeeked: null, | |
onSeeking: null, | |
onSelect: null, | |
onSlotChange: null, | |
onStalled: null, | |
onStorage: null, | |
onSubmit: null, | |
onSuspend: null, | |
onTimeUpdate: null, | |
onToggle: null, | |
onUnhandledRejection: null, | |
onUnload: null, | |
onVolumeChange: null, | |
onWaiting: null, | |
onWheel: null, | |
open: K, | |
optimum: P, | |
pattern: null, | |
ping: se, | |
placeholder: null, | |
playsInline: K, | |
poster: null, | |
preload: null, | |
readOnly: K, | |
referrerPolicy: null, | |
rel: se, | |
required: K, | |
reversed: K, | |
rows: P, | |
rowSpan: P, | |
sandbox: se, | |
scope: null, | |
scoped: K, | |
seamless: K, | |
selected: K, | |
shape: null, | |
size: P, | |
sizes: null, | |
slot: null, | |
span: P, | |
spellCheck: ge, | |
src: null, | |
srcDoc: null, | |
srcLang: null, | |
srcSet: null, | |
start: P, | |
step: null, | |
style: null, | |
tabIndex: P, | |
target: null, | |
title: null, | |
translate: null, | |
type: null, | |
typeMustMatch: K, | |
useMap: null, | |
value: ge, | |
width: P, | |
wrap: null, | |
align: null, | |
aLink: null, | |
archive: se, | |
axis: null, | |
background: null, | |
bgColor: null, | |
border: P, | |
borderColor: null, | |
bottomMargin: P, | |
cellPadding: null, | |
cellSpacing: null, | |
char: null, | |
charOff: null, | |
classId: null, | |
clear: null, | |
code: null, | |
codeBase: null, | |
codeType: null, | |
color: null, | |
compact: K, | |
declare: K, | |
event: null, | |
face: null, | |
frame: null, | |
frameBorder: null, | |
hSpace: P, | |
leftMargin: P, | |
link: null, | |
longDesc: null, | |
lowSrc: null, | |
marginHeight: P, | |
marginWidth: P, | |
noResize: K, | |
noHref: K, | |
noShade: K, | |
noWrap: K, | |
object: null, | |
profile: null, | |
prompt: null, | |
rev: null, | |
rightMargin: P, | |
rules: null, | |
scheme: null, | |
scrolling: ge, | |
standby: null, | |
summary: null, | |
text: null, | |
topMargin: P, | |
valueType: null, | |
version: null, | |
vAlign: null, | |
vLink: null, | |
vSpace: P, | |
allowTransparency: null, | |
autoCorrect: null, | |
autoSave: null, | |
disablePictureInPicture: K, | |
disableRemotePlayback: K, | |
prefix: null, | |
property: null, | |
results: P, | |
security: null, | |
unselectable: null, | |
}, | |
}), | |
Hv = Rt({ | |
space: 'svg', | |
attributes: { | |
accentHeight: 'accent-height', | |
alignmentBaseline: 'alignment-baseline', | |
arabicForm: 'arabic-form', | |
baselineShift: 'baseline-shift', | |
capHeight: 'cap-height', | |
className: 'class', | |
clipPath: 'clip-path', | |
clipRule: 'clip-rule', | |
colorInterpolation: 'color-interpolation', | |
colorInterpolationFilters: 'color-interpolation-filters', | |
colorProfile: 'color-profile', | |
colorRendering: 'color-rendering', | |
crossOrigin: 'crossorigin', | |
dataType: 'datatype', | |
dominantBaseline: 'dominant-baseline', | |
enableBackground: 'enable-background', | |
fillOpacity: 'fill-opacity', | |
fillRule: 'fill-rule', | |
floodColor: 'flood-color', | |
floodOpacity: 'flood-opacity', | |
fontFamily: 'font-family', | |
fontSize: 'font-size', | |
fontSizeAdjust: 'font-size-adjust', | |
fontStretch: 'font-stretch', | |
fontStyle: 'font-style', | |
fontVariant: 'font-variant', | |
fontWeight: 'font-weight', | |
glyphName: 'glyph-name', | |
glyphOrientationHorizontal: 'glyph-orientation-horizontal', | |
glyphOrientationVertical: 'glyph-orientation-vertical', | |
hrefLang: 'hreflang', | |
horizAdvX: 'horiz-adv-x', | |
horizOriginX: 'horiz-origin-x', | |
horizOriginY: 'horiz-origin-y', | |
imageRendering: 'image-rendering', | |
letterSpacing: 'letter-spacing', | |
lightingColor: 'lighting-color', | |
markerEnd: 'marker-end', | |
markerMid: 'marker-mid', | |
markerStart: 'marker-start', | |
navDown: 'nav-down', | |
navDownLeft: 'nav-down-left', | |
navDownRight: 'nav-down-right', | |
navLeft: 'nav-left', | |
navNext: 'nav-next', | |
navPrev: 'nav-prev', | |
navRight: 'nav-right', | |
navUp: 'nav-up', | |
navUpLeft: 'nav-up-left', | |
navUpRight: 'nav-up-right', | |
onAbort: 'onabort', | |
onActivate: 'onactivate', | |
onAfterPrint: 'onafterprint', | |
onBeforePrint: 'onbeforeprint', | |
onBegin: 'onbegin', | |
onCancel: 'oncancel', | |
onCanPlay: 'oncanplay', | |
onCanPlayThrough: 'oncanplaythrough', | |
onChange: 'onchange', | |
onClick: 'onclick', | |
onClose: 'onclose', | |
onCopy: 'oncopy', | |
onCueChange: 'oncuechange', | |
onCut: 'oncut', | |
onDblClick: 'ondblclick', | |
onDrag: 'ondrag', | |
onDragEnd: 'ondragend', | |
onDragEnter: 'ondragenter', | |
onDragExit: 'ondragexit', | |
onDragLeave: 'ondragleave', | |
onDragOver: 'ondragover', | |
onDragStart: 'ondragstart', | |
onDrop: 'ondrop', | |
onDurationChange: 'ondurationchange', | |
onEmptied: 'onemptied', | |
onEnd: 'onend', | |
onEnded: 'onended', | |
onError: 'onerror', | |
onFocus: 'onfocus', | |
onFocusIn: 'onfocusin', | |
onFocusOut: 'onfocusout', | |
onHashChange: 'onhashchange', | |
onInput: 'oninput', | |
onInvalid: 'oninvalid', | |
onKeyDown: 'onkeydown', | |
onKeyPress: 'onkeypress', | |
onKeyUp: 'onkeyup', | |
onLoad: 'onload', | |
onLoadedData: 'onloadeddata', | |
onLoadedMetadata: 'onloadedmetadata', | |
onLoadStart: 'onloadstart', | |
onMessage: 'onmessage', | |
onMouseDown: 'onmousedown', | |
onMouseEnter: 'onmouseenter', | |
onMouseLeave: 'onmouseleave', | |
onMouseMove: 'onmousemove', | |
onMouseOut: 'onmouseout', | |
onMouseOver: 'onmouseover', | |
onMouseUp: 'onmouseup', | |
onMouseWheel: 'onmousewheel', | |
onOffline: 'onoffline', | |
onOnline: 'ononline', | |
onPageHide: 'onpagehide', | |
onPageShow: 'onpageshow', | |
onPaste: 'onpaste', | |
onPause: 'onpause', | |
onPlay: 'onplay', | |
onPlaying: 'onplaying', | |
onPopState: 'onpopstate', | |
onProgress: 'onprogress', | |
onRateChange: 'onratechange', | |
onRepeat: 'onrepeat', | |
onReset: 'onreset', | |
onResize: 'onresize', | |
onScroll: 'onscroll', | |
onSeeked: 'onseeked', | |
onSeeking: 'onseeking', | |
onSelect: 'onselect', | |
onShow: 'onshow', | |
onStalled: 'onstalled', | |
onStorage: 'onstorage', | |
onSubmit: 'onsubmit', | |
onSuspend: 'onsuspend', | |
onTimeUpdate: 'ontimeupdate', | |
onToggle: 'ontoggle', | |
onUnload: 'onunload', | |
onVolumeChange: 'onvolumechange', | |
onWaiting: 'onwaiting', | |
onZoom: 'onzoom', | |
overlinePosition: 'overline-position', | |
overlineThickness: 'overline-thickness', | |
paintOrder: 'paint-order', | |
panose1: 'panose-1', | |
pointerEvents: 'pointer-events', | |
referrerPolicy: 'referrerpolicy', | |
renderingIntent: 'rendering-intent', | |
shapeRendering: 'shape-rendering', | |
stopColor: 'stop-color', | |
stopOpacity: 'stop-opacity', | |
strikethroughPosition: 'strikethrough-position', | |
strikethroughThickness: 'strikethrough-thickness', | |
strokeDashArray: 'stroke-dasharray', | |
strokeDashOffset: 'stroke-dashoffset', | |
strokeLineCap: 'stroke-linecap', | |
strokeLineJoin: 'stroke-linejoin', | |
strokeMiterLimit: 'stroke-miterlimit', | |
strokeOpacity: 'stroke-opacity', | |
strokeWidth: 'stroke-width', | |
tabIndex: 'tabindex', | |
textAnchor: 'text-anchor', | |
textDecoration: 'text-decoration', | |
textRendering: 'text-rendering', | |
typeOf: 'typeof', | |
underlinePosition: 'underline-position', | |
underlineThickness: 'underline-thickness', | |
unicodeBidi: 'unicode-bidi', | |
unicodeRange: 'unicode-range', | |
unitsPerEm: 'units-per-em', | |
vAlphabetic: 'v-alphabetic', | |
vHanging: 'v-hanging', | |
vIdeographic: 'v-ideographic', | |
vMathematical: 'v-mathematical', | |
vectorEffect: 'vector-effect', | |
vertAdvY: 'vert-adv-y', | |
vertOriginX: 'vert-origin-x', | |
vertOriginY: 'vert-origin-y', | |
wordSpacing: 'word-spacing', | |
writingMode: 'writing-mode', | |
xHeight: 'x-height', | |
playbackOrder: 'playbackorder', | |
timelineBegin: 'timelinebegin', | |
}, | |
transform: fs, | |
properties: { | |
about: Ne, | |
accentHeight: P, | |
accumulate: null, | |
additive: null, | |
alignmentBaseline: null, | |
alphabetic: P, | |
amplitude: P, | |
arabicForm: null, | |
ascent: P, | |
attributeName: null, | |
attributeType: null, | |
azimuth: P, | |
bandwidth: null, | |
baselineShift: null, | |
baseFrequency: null, | |
baseProfile: null, | |
bbox: null, | |
begin: null, | |
bias: P, | |
by: null, | |
calcMode: null, | |
capHeight: P, | |
className: se, | |
clip: null, | |
clipPath: null, | |
clipPathUnits: null, | |
clipRule: null, | |
color: null, | |
colorInterpolation: null, | |
colorInterpolationFilters: null, | |
colorProfile: null, | |
colorRendering: null, | |
content: null, | |
contentScriptType: null, | |
contentStyleType: null, | |
crossOrigin: null, | |
cursor: null, | |
cx: null, | |
cy: null, | |
d: null, | |
dataType: null, | |
defaultAction: null, | |
descent: P, | |
diffuseConstant: P, | |
direction: null, | |
display: null, | |
dur: null, | |
divisor: P, | |
dominantBaseline: null, | |
download: K, | |
dx: null, | |
dy: null, | |
edgeMode: null, | |
editable: null, | |
elevation: P, | |
enableBackground: null, | |
end: null, | |
event: null, | |
exponent: P, | |
externalResourcesRequired: null, | |
fill: null, | |
fillOpacity: P, | |
fillRule: null, | |
filter: null, | |
filterRes: null, | |
filterUnits: null, | |
floodColor: null, | |
floodOpacity: null, | |
focusable: null, | |
focusHighlight: null, | |
fontFamily: null, | |
fontSize: null, | |
fontSizeAdjust: null, | |
fontStretch: null, | |
fontStyle: null, | |
fontVariant: null, | |
fontWeight: null, | |
format: null, | |
fr: null, | |
from: null, | |
fx: null, | |
fy: null, | |
g1: kt, | |
g2: kt, | |
glyphName: kt, | |
glyphOrientationHorizontal: null, | |
glyphOrientationVertical: null, | |
glyphRef: null, | |
gradientTransform: null, | |
gradientUnits: null, | |
handler: null, | |
hanging: P, | |
hatchContentUnits: null, | |
hatchUnits: null, | |
height: null, | |
href: null, | |
hrefLang: null, | |
horizAdvX: P, | |
horizOriginX: P, | |
horizOriginY: P, | |
id: null, | |
ideographic: P, | |
imageRendering: null, | |
initialVisibility: null, | |
in: null, | |
in2: null, | |
intercept: P, | |
k: P, | |
k1: P, | |
k2: P, | |
k3: P, | |
k4: P, | |
kernelMatrix: Ne, | |
kernelUnitLength: null, | |
keyPoints: null, | |
keySplines: null, | |
keyTimes: null, | |
kerning: null, | |
lang: null, | |
lengthAdjust: null, | |
letterSpacing: null, | |
lightingColor: null, | |
limitingConeAngle: P, | |
local: null, | |
markerEnd: null, | |
markerMid: null, | |
markerStart: null, | |
markerHeight: null, | |
markerUnits: null, | |
markerWidth: null, | |
mask: null, | |
maskContentUnits: null, | |
maskUnits: null, | |
mathematical: null, | |
max: null, | |
media: null, | |
mediaCharacterEncoding: null, | |
mediaContentEncodings: null, | |
mediaSize: P, | |
mediaTime: null, | |
method: null, | |
min: null, | |
mode: null, | |
name: null, | |
navDown: null, | |
navDownLeft: null, | |
navDownRight: null, | |
navLeft: null, | |
navNext: null, | |
navPrev: null, | |
navRight: null, | |
navUp: null, | |
navUpLeft: null, | |
navUpRight: null, | |
numOctaves: null, | |
observer: null, | |
offset: null, | |
onAbort: null, | |
onActivate: null, | |
onAfterPrint: null, | |
onBeforePrint: null, | |
onBegin: null, | |
onCancel: null, | |
onCanPlay: null, | |
onCanPlayThrough: null, | |
onChange: null, | |
onClick: null, | |
onClose: null, | |
onCopy: null, | |
onCueChange: null, | |
onCut: null, | |
onDblClick: null, | |
onDrag: null, | |
onDragEnd: null, | |
onDragEnter: null, | |
onDragExit: null, | |
onDragLeave: null, | |
onDragOver: null, | |
onDragStart: null, | |
onDrop: null, | |
onDurationChange: null, | |
onEmptied: null, | |
onEnd: null, | |
onEnded: null, | |
onError: null, | |
onFocus: null, | |
onFocusIn: null, | |
onFocusOut: null, | |
onHashChange: null, | |
onInput: null, | |
onInvalid: null, | |
onKeyDown: null, | |
onKeyPress: null, | |
onKeyUp: null, | |
onLoad: null, | |
onLoadedData: null, | |
onLoadedMetadata: null, | |
onLoadStart: null, | |
onMessage: null, | |
onMouseDown: null, | |
onMouseEnter: null, | |
onMouseLeave: null, | |
onMouseMove: null, | |
onMouseOut: null, | |
onMouseOver: null, | |
onMouseUp: null, | |
onMouseWheel: null, | |
onOffline: null, | |
onOnline: null, | |
onPageHide: null, | |
onPageShow: null, | |
onPaste: null, | |
onPause: null, | |
onPlay: null, | |
onPlaying: null, | |
onPopState: null, | |
onProgress: null, | |
onRateChange: null, | |
onRepeat: null, | |
onReset: null, | |
onResize: null, | |
onScroll: null, | |
onSeeked: null, | |
onSeeking: null, | |
onSelect: null, | |
onShow: null, | |
onStalled: null, | |
onStorage: null, | |
onSubmit: null, | |
onSuspend: null, | |
onTimeUpdate: null, | |
onToggle: null, | |
onUnload: null, | |
onVolumeChange: null, | |
onWaiting: null, | |
onZoom: null, | |
opacity: null, | |
operator: null, | |
order: null, | |
orient: null, | |
orientation: null, | |
origin: null, | |
overflow: null, | |
overlay: null, | |
overlinePosition: P, | |
overlineThickness: P, | |
paintOrder: null, | |
panose1: null, | |
path: null, | |
pathLength: P, | |
patternContentUnits: null, | |
patternTransform: null, | |
patternUnits: null, | |
phase: null, | |
ping: se, | |
pitch: null, | |
playbackOrder: null, | |
pointerEvents: null, | |
points: null, | |
pointsAtX: P, | |
pointsAtY: P, | |
pointsAtZ: P, | |
preserveAlpha: null, | |
preserveAspectRatio: null, | |
primitiveUnits: null, | |
propagate: null, | |
property: Ne, | |
r: null, | |
radius: null, | |
referrerPolicy: null, | |
refX: null, | |
refY: null, | |
rel: Ne, | |
rev: Ne, | |
renderingIntent: null, | |
repeatCount: null, | |
repeatDur: null, | |
requiredExtensions: Ne, | |
requiredFeatures: Ne, | |
requiredFonts: Ne, | |
requiredFormats: Ne, | |
resource: null, | |
restart: null, | |
result: null, | |
rotate: null, | |
rx: null, | |
ry: null, | |
scale: null, | |
seed: null, | |
shapeRendering: null, | |
side: null, | |
slope: null, | |
snapshotTime: null, | |
specularConstant: P, | |
specularExponent: P, | |
spreadMethod: null, | |
spacing: null, | |
startOffset: null, | |
stdDeviation: null, | |
stemh: null, | |
stemv: null, | |
stitchTiles: null, | |
stopColor: null, | |
stopOpacity: null, | |
strikethroughPosition: P, | |
strikethroughThickness: P, | |
string: null, | |
stroke: null, | |
strokeDashArray: Ne, | |
strokeDashOffset: null, | |
strokeLineCap: null, | |
strokeLineJoin: null, | |
strokeMiterLimit: P, | |
strokeOpacity: P, | |
strokeWidth: null, | |
style: null, | |
surfaceScale: P, | |
syncBehavior: null, | |
syncBehaviorDefault: null, | |
syncMaster: null, | |
syncTolerance: null, | |
syncToleranceDefault: null, | |
systemLanguage: Ne, | |
tabIndex: P, | |
tableValues: null, | |
target: null, | |
targetX: P, | |
targetY: P, | |
textAnchor: null, | |
textDecoration: null, | |
textRendering: null, | |
textLength: null, | |
timelineBegin: null, | |
title: null, | |
transformBehavior: null, | |
type: null, | |
typeOf: Ne, | |
to: null, | |
transform: null, | |
u1: null, | |
u2: null, | |
underlinePosition: P, | |
underlineThickness: P, | |
unicode: null, | |
unicodeBidi: null, | |
unicodeRange: null, | |
unitsPerEm: P, | |
values: null, | |
vAlphabetic: P, | |
vMathematical: P, | |
vectorEffect: null, | |
vHanging: P, | |
vIdeographic: P, | |
version: null, | |
vertAdvY: P, | |
vertOriginX: P, | |
vertOriginY: P, | |
viewBox: null, | |
viewTarget: null, | |
visibility: null, | |
width: null, | |
widths: null, | |
wordSpacing: null, | |
writingMode: null, | |
x: null, | |
x1: null, | |
x2: null, | |
xChannelSelector: null, | |
xHeight: P, | |
y: null, | |
y1: null, | |
y2: null, | |
yChannelSelector: null, | |
z: null, | |
zoomAndPan: null, | |
}, | |
}), | |
Uv = /^data[-\w.:]+$/i, | |
uo = /-[a-z]/g, | |
Gv = /[A-Z]/g; | |
function Wv(e, t) { | |
const n = Xr(t); | |
let r = t, | |
i = Ue; | |
if (n in e.normal) return e.property[e.normal[n]]; | |
if (n.length > 4 && n.slice(0, 4) === 'data' && Uv.test(t)) { | |
if (t.charAt(4) === '-') { | |
const a = t.slice(5).replace(uo, Vv); | |
r = 'data' + a.charAt(0).toUpperCase() + a.slice(1); | |
} else { | |
const a = t.slice(4); | |
if (!uo.test(a)) { | |
let o = a.replace(Gv, qv); | |
o.charAt(0) !== '-' && (o = '-' + o), (t = 'data' + o); | |
} | |
} | |
i = Li; | |
} | |
return new i(r, t); | |
} | |
function qv(e) { | |
return '-' + e.toLowerCase(); | |
} | |
function Vv(e) { | |
return e.charAt(1).toUpperCase(); | |
} | |
const co = { | |
classId: 'classID', | |
dataType: 'datatype', | |
itemId: 'itemID', | |
strokeDashArray: 'strokeDasharray', | |
strokeDashOffset: 'strokeDashoffset', | |
strokeLineCap: 'strokeLinecap', | |
strokeLineJoin: 'strokeLinejoin', | |
strokeMiterLimit: 'strokeMiterlimit', | |
typeOf: 'typeof', | |
xLinkActuate: 'xlinkActuate', | |
xLinkArcRole: 'xlinkArcrole', | |
xLinkHref: 'xlinkHref', | |
xLinkRole: 'xlinkRole', | |
xLinkShow: 'xlinkShow', | |
xLinkTitle: 'xlinkTitle', | |
xLinkType: 'xlinkType', | |
xmlnsXLink: 'xmlnsXlink', | |
}, | |
Kv = us([ps, ds, ms, hs, $v], 'html'), | |
Yv = us([ps, ds, ms, hs, Hv], 'svg'); | |
function Qv(e) { | |
if (e.allowedElements && e.disallowedElements) | |
throw new TypeError('Only one of `allowedElements` and `disallowedElements` should be defined'); | |
if (e.allowedElements || e.disallowedElements || e.allowElement) | |
return (t) => { | |
Ri(t, 'element', (n, r, i) => { | |
const a = i; | |
let o; | |
if ( | |
(e.allowedElements | |
? (o = !e.allowedElements.includes(n.tagName)) | |
: e.disallowedElements && (o = e.disallowedElements.includes(n.tagName)), | |
!o && e.allowElement && typeof r == 'number' && (o = !e.allowElement(n, r, a)), | |
o && typeof r == 'number') | |
) | |
return ( | |
e.unwrapDisallowed && n.children | |
? a.children.splice(r, 1, ...n.children) | |
: a.children.splice(r, 1), | |
r | |
); | |
}); | |
}; | |
} | |
var _r = {}, | |
Xv = { | |
get exports() { | |
return _r; | |
}, | |
set exports(e) { | |
_r = e; | |
}, | |
}, | |
ne = {}; | |
/** | |
* @license React | |
* react-is.production.min.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. | |
*/ var Mi = Symbol.for('react.element'), | |
ji = Symbol.for('react.portal'), | |
nr = Symbol.for('react.fragment'), | |
rr = Symbol.for('react.strict_mode'), | |
ir = Symbol.for('react.profiler'), | |
ar = Symbol.for('react.provider'), | |
or = Symbol.for('react.context'), | |
Jv = Symbol.for('react.server_context'), | |
lr = Symbol.for('react.forward_ref'), | |
sr = Symbol.for('react.suspense'), | |
ur = Symbol.for('react.suspense_list'), | |
cr = Symbol.for('react.memo'), | |
dr = Symbol.for('react.lazy'), | |
_v = Symbol.for('react.offscreen'), | |
vs; | |
vs = Symbol.for('react.module.reference'); | |
function Ge(e) { | |
if (typeof e == 'object' && e !== null) { | |
var t = e.$$typeof; | |
switch (t) { | |
case Mi: | |
switch (((e = e.type), e)) { | |
case nr: | |
case ir: | |
case rr: | |
case sr: | |
case ur: | |
return e; | |
default: | |
switch (((e = e && e.$$typeof), e)) { | |
case Jv: | |
case or: | |
case lr: | |
case dr: | |
case cr: | |
case ar: | |
return e; | |
default: | |
return t; | |
} | |
} | |
case ji: | |
return t; | |
} | |
} | |
} | |
ne.ContextConsumer = or; | |
ne.ContextProvider = ar; | |
ne.Element = Mi; | |
ne.ForwardRef = lr; | |
ne.Fragment = nr; | |
ne.Lazy = dr; | |
ne.Memo = cr; | |
ne.Portal = ji; | |
ne.Profiler = ir; | |
ne.StrictMode = rr; | |
ne.Suspense = sr; | |
ne.SuspenseList = ur; | |
ne.isAsyncMode = function () { | |
return !1; | |
}; | |
ne.isConcurrentMode = function () { | |
return !1; | |
}; | |
ne.isContextConsumer = function (e) { | |
return Ge(e) === or; | |
}; | |
ne.isContextProvider = function (e) { | |
return Ge(e) === ar; | |
}; | |
ne.isElement = function (e) { | |
return typeof e == 'object' && e !== null && e.$$typeof === Mi; | |
}; | |
ne.isForwardRef = function (e) { | |
return Ge(e) === lr; | |
}; | |
ne.isFragment = function (e) { | |
return Ge(e) === nr; | |
}; | |
ne.isLazy = function (e) { | |
return Ge(e) === dr; | |
}; | |
ne.isMemo = function (e) { | |
return Ge(e) === cr; | |
}; | |
ne.isPortal = function (e) { | |
return Ge(e) === ji; | |
}; | |
ne.isProfiler = function (e) { | |
return Ge(e) === ir; | |
}; | |
ne.isStrictMode = function (e) { | |
return Ge(e) === rr; | |
}; | |
ne.isSuspense = function (e) { | |
return Ge(e) === sr; | |
}; | |
ne.isSuspenseList = function (e) { | |
return Ge(e) === ur; | |
}; | |
ne.isValidElementType = function (e) { | |
return ( | |
typeof e == 'string' || | |
typeof e == 'function' || | |
e === nr || | |
e === ir || | |
e === rr || | |
e === sr || | |
e === ur || | |
e === _v || | |
(typeof e == 'object' && | |
e !== null && | |
(e.$$typeof === dr || | |
e.$$typeof === cr || | |
e.$$typeof === ar || | |
e.$$typeof === or || | |
e.$$typeof === lr || | |
e.$$typeof === vs || | |
e.getModuleId !== void 0)) | |
); | |
}; | |
ne.typeOf = Ge; | |
(function (e) { | |
e.exports = ne; | |
})(Xv); | |
const Zv = Cs(_r); | |
function eb(e) { | |
const t = e && typeof e == 'object' && e.type === 'text' ? e.value || '' : e; | |
return typeof t == 'string' && t.replace(/[ \t\n\f\r]/g, '') === ''; | |
} | |
function tb(e) { | |
return e.join(' ').trim(); | |
} | |
function nb(e, t) { | |
const n = t || {}; | |
return (e[e.length - 1] === '' ? [...e, ''] : e) | |
.join((n.padRight ? ' ' : '') + ',' + (n.padLeft === !1 ? '' : ' ')) | |
.trim(); | |
} | |
var Rn = {}, | |
rb = { | |
get exports() { | |
return Rn; | |
}, | |
set exports(e) { | |
Rn = e; | |
}, | |
}, | |
po = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g, | |
ib = /\n/g, | |
ab = /^\s*/, | |
ob = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/, | |
lb = /^:\s*/, | |
sb = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/, | |
ub = /^[;\s]*/, | |
cb = /^\s+|\s+$/g, | |
db = ` | |
`, | |
fo = '/', | |
go = '*', | |
xt = '', | |
pb = 'comment', | |
fb = 'declaration', | |
gb = function (e, t) { | |
if (typeof e != 'string') throw new TypeError('First argument must be a string'); | |
if (!e) return []; | |
t = t || {}; | |
var n = 1, | |
r = 1; | |
function i(m) { | |
var h = m.match(ib); | |
h && (n += h.length); | |
var x = m.lastIndexOf(db); | |
r = ~x ? m.length - x : r + m.length; | |
} | |
function a() { | |
var m = { line: n, column: r }; | |
return function (h) { | |
return (h.position = new o(m)), c(), h; | |
}; | |
} | |
function o(m) { | |
(this.start = m), (this.end = { line: n, column: r }), (this.source = t.source); | |
} | |
o.prototype.content = e; | |
function l(m) { | |
var h = new Error(t.source + ':' + n + ':' + r + ': ' + m); | |
if ( | |
((h.reason = m), | |
(h.filename = t.source), | |
(h.line = n), | |
(h.column = r), | |
(h.source = e), | |
!t.silent) | |
) | |
throw h; | |
} | |
function s(m) { | |
var h = m.exec(e); | |
if (h) { | |
var x = h[0]; | |
return i(x), (e = e.slice(x.length)), h; | |
} | |
} | |
function c() { | |
s(ab); | |
} | |
function d(m) { | |
var h; | |
for (m = m || []; (h = u()); ) h !== !1 && m.push(h); | |
return m; | |
} | |
function u() { | |
var m = a(); | |
if (!(fo != e.charAt(0) || go != e.charAt(1))) { | |
for (var h = 2; xt != e.charAt(h) && (go != e.charAt(h) || fo != e.charAt(h + 1)); ) ++h; | |
if (((h += 2), xt === e.charAt(h - 1))) return l('End of comment missing'); | |
var x = e.slice(2, h - 2); | |
return (r += 2), i(x), (e = e.slice(h)), (r += 2), m({ type: pb, comment: x }); | |
} | |
} | |
function f() { | |
var m = a(), | |
h = s(ob); | |
if (h) { | |
if ((u(), !s(lb))) return l("property missing ':'"); | |
var x = s(sb), | |
b = m({ | |
type: fb, | |
property: mo(h[0].replace(po, xt)), | |
value: x ? mo(x[0].replace(po, xt)) : xt, | |
}); | |
return s(ub), b; | |
} | |
} | |
function p() { | |
var m = []; | |
d(m); | |
for (var h; (h = f()); ) h !== !1 && (m.push(h), d(m)); | |
return m; | |
} | |
return c(), p(); | |
}; | |
function mo(e) { | |
return e ? e.replace(cb, xt) : xt; | |
} | |
var mb = gb; | |
function bs(e, t) { | |
var n = null; | |
if (!e || typeof e != 'string') return n; | |
for (var r, i = mb(e), a = typeof t == 'function', o, l, s = 0, c = i.length; s < c; s++) | |
(r = i[s]), (o = r.property), (l = r.value), a ? t(o, l, r) : l && (n || (n = {}), (n[o] = l)); | |
return n; | |
} | |
rb.exports = bs; | |
Rn.default = bs; | |
const hb = Rn, | |
Zr = {}.hasOwnProperty, | |
vb = new Set(['table', 'thead', 'tbody', 'tfoot', 'tr']); | |
function ys(e, t) { | |
const n = []; | |
let r = -1, | |
i; | |
for (; ++r < t.children.length; ) | |
(i = t.children[r]), | |
i.type === 'element' | |
? n.push(bb(e, i, r, t)) | |
: i.type === 'text' | |
? (t.type !== 'element' || !vb.has(t.tagName) || !eb(i)) && n.push(i.value) | |
: i.type === 'raw' && !e.options.skipHtml && n.push(i.value); | |
return n; | |
} | |
function bb(e, t, n, r) { | |
const i = e.options, | |
a = i.transformLinkUri === void 0 ? xg : i.transformLinkUri, | |
o = e.schema, | |
l = t.tagName, | |
s = {}; | |
let c = o, | |
d; | |
if ((o.space === 'html' && l === 'svg' && ((c = Yv), (e.schema = c)), t.properties)) | |
for (d in t.properties) Zr.call(t.properties, d) && xb(s, d, t.properties[d], e); | |
(l === 'ol' || l === 'ul') && e.listDepth++; | |
const u = ys(e, t); | |
(l === 'ol' || l === 'ul') && e.listDepth--, (e.schema = o); | |
const f = t.position || { | |
start: { line: null, column: null, offset: null }, | |
end: { line: null, column: null, offset: null }, | |
}, | |
p = i.components && Zr.call(i.components, l) ? i.components[l] : l, | |
m = typeof p == 'string' || p === _.Fragment; | |
if (!Zv.isValidElementType(p)) | |
throw new TypeError(`Component for name \`${l}\` not defined or is not renderable`); | |
if ( | |
((s.key = n), | |
l === 'a' && | |
i.linkTarget && | |
(s.target = | |
typeof i.linkTarget == 'function' | |
? i.linkTarget( | |
String(s.href || ''), | |
t.children, | |
typeof s.title == 'string' ? s.title : null | |
) | |
: i.linkTarget), | |
l === 'a' && | |
a && | |
(s.href = a(String(s.href || ''), t.children, typeof s.title == 'string' ? s.title : null)), | |
!m && l === 'code' && r.type === 'element' && r.tagName !== 'pre' && (s.inline = !0), | |
!m && | |
(l === 'h1' || l === 'h2' || l === 'h3' || l === 'h4' || l === 'h5' || l === 'h6') && | |
(s.level = Number.parseInt(l.charAt(1), 10)), | |
l === 'img' && | |
i.transformImageUri && | |
(s.src = i.transformImageUri( | |
String(s.src || ''), | |
String(s.alt || ''), | |
typeof s.title == 'string' ? s.title : null | |
)), | |
!m && l === 'li' && r.type === 'element') | |
) { | |
const h = yb(t); | |
(s.checked = h && h.properties ? !!h.properties.checked : null), | |
(s.index = Rr(r, t)), | |
(s.ordered = r.tagName === 'ol'); | |
} | |
return ( | |
!m && (l === 'ol' || l === 'ul') && ((s.ordered = l === 'ol'), (s.depth = e.listDepth)), | |
(l === 'td' || l === 'th') && | |
(s.align && (s.style || (s.style = {}), (s.style.textAlign = s.align), delete s.align), | |
m || (s.isHeader = l === 'th')), | |
!m && l === 'tr' && r.type === 'element' && (s.isHeader = r.tagName === 'thead'), | |
i.sourcePos && (s['data-sourcepos'] = Cb(f)), | |
!m && i.rawSourcePos && (s.sourcePosition = t.position), | |
!m && i.includeElementIndex && ((s.index = Rr(r, t)), (s.siblingCount = Rr(r))), | |
m || (s.node = t), | |
u.length > 0 ? _.createElement(p, s, u) : _.createElement(p, s) | |
); | |
} | |
function yb(e) { | |
let t = -1; | |
for (; ++t < e.children.length; ) { | |
const n = e.children[t]; | |
if (n.type === 'element' && n.tagName === 'input') return n; | |
} | |
return null; | |
} | |
function Rr(e, t) { | |
let n = -1, | |
r = 0; | |
for (; ++n < e.children.length && e.children[n] !== t; ) e.children[n].type === 'element' && r++; | |
return r; | |
} | |
function xb(e, t, n, r) { | |
const i = Wv(r.schema, t); | |
let a = n; | |
a == null || | |
a !== a || | |
(Array.isArray(a) && (a = i.commaSeparated ? nb(a) : tb(a)), | |
i.property === 'style' && typeof a == 'string' && (a = wb(a)), | |
i.space && i.property | |
? (e[Zr.call(co, i.property) ? co[i.property] : i.property] = a) | |
: i.attribute && (e[i.attribute] = a)); | |
} | |
function wb(e) { | |
const t = {}; | |
try { | |
hb(e, n); | |
} catch {} | |
return t; | |
function n(r, i) { | |
const a = r.slice(0, 4) === '-ms-' ? `ms-${r.slice(4)}` : r; | |
t[a.replace(/-([a-z])/g, Sb)] = i; | |
} | |
} | |
function Sb(e, t) { | |
return t.toUpperCase(); | |
} | |
function Cb(e) { | |
return [e.start.line, ':', e.start.column, '-', e.end.line, ':', e.end.column] | |
.map(String) | |
.join(''); | |
} | |
const ho = {}.hasOwnProperty, | |
Db = 'https://github.com/remarkjs/react-markdown/blob/main/changelog.md', | |
xn = { | |
plugins: { to: 'remarkPlugins', id: 'change-plugins-to-remarkplugins' }, | |
renderers: { to: 'components', id: 'change-renderers-to-components' }, | |
astPlugins: { id: 'remove-buggy-html-in-markdown-parser' }, | |
allowDangerousHtml: { id: 'remove-buggy-html-in-markdown-parser' }, | |
escapeHtml: { id: 'remove-buggy-html-in-markdown-parser' }, | |
source: { to: 'children', id: 'change-source-to-children' }, | |
allowNode: { to: 'allowElement', id: 'replace-allownode-allowedtypes-and-disallowedtypes' }, | |
allowedTypes: { | |
to: 'allowedElements', | |
id: 'replace-allownode-allowedtypes-and-disallowedtypes', | |
}, | |
disallowedTypes: { | |
to: 'disallowedElements', | |
id: 'replace-allownode-allowedtypes-and-disallowedtypes', | |
}, | |
includeNodeIndex: { | |
to: 'includeElementIndex', | |
id: 'change-includenodeindex-to-includeelementindex', | |
}, | |
}; | |
function xs(e) { | |
for (const a in xn) | |
if (ho.call(xn, a) && ho.call(e, a)) { | |
const o = xn[a]; | |
console.warn( | |
`[react-markdown] Warning: please ${ | |
o.to ? `use \`${o.to}\` instead of` : 'remove' | |
} \`${a}\` (see <${Db}#${o.id}> for more info)` | |
), | |
delete xn[a]; | |
} | |
const t = Fg() | |
.use(Wh) | |
.use(e.remarkPlugins || []) | |
.use(Fv, { ...e.remarkRehypeOptions, allowDangerousHtml: !0 }) | |
.use(e.rehypePlugins || []) | |
.use(Qv, e), | |
n = new zl(); | |
typeof e.children == 'string' | |
? (n.value = e.children) | |
: e.children !== void 0 && | |
e.children !== null && | |
console.warn( | |
`[react-markdown] Warning: please pass a string as \`children\` (not: \`${e.children}\`)` | |
); | |
const r = t.runSync(t.parse(n), n); | |
if (r.type !== 'root') throw new TypeError('Expected a `root` node'); | |
let i = _.createElement(_.Fragment, {}, ys({ options: e, schema: Kv, listDepth: 0 }, r)); | |
return e.className && (i = _.createElement('div', { className: e.className }, i)), i; | |
} | |
xs.propTypes = { | |
children: W.string, | |
className: W.string, | |
allowElement: W.func, | |
allowedElements: W.arrayOf(W.string), | |
disallowedElements: W.arrayOf(W.string), | |
unwrapDisallowed: W.bool, | |
remarkPlugins: W.arrayOf( | |
W.oneOfType([ | |
W.object, | |
W.func, | |
W.arrayOf(W.oneOfType([W.bool, W.string, W.object, W.func, W.arrayOf(W.any)])), | |
]) | |
), | |
rehypePlugins: W.arrayOf( | |
W.oneOfType([ | |
W.object, | |
W.func, | |
W.arrayOf(W.oneOfType([W.bool, W.string, W.object, W.func, W.arrayOf(W.any)])), | |
]) | |
), | |
sourcePos: W.bool, | |
rawSourcePos: W.bool, | |
skipHtml: W.bool, | |
includeElementIndex: W.bool, | |
transformLinkUri: W.oneOfType([W.func, W.bool]), | |
linkTarget: W.oneOfType([W.func, W.string]), | |
transformImageUri: W.func, | |
components: W.object, | |
}; | |
const Ib = () => | |
new Promise((e) => { | |
chrome.storage.sync.get( | |
[ | |
'rolesList', | |
'tokenLength', | |
'role', | |
'length', | |
'openAIkey', | |
'keyStatus', | |
'liStatus', | |
'isSubscription', | |
'params', | |
'license', | |
], | |
(t) => e(t) | |
); | |
}); | |
let vo = '', | |
bo = 'Chat', | |
bt = 0; | |
const kb = () => Math.random().toString(36).slice(2, 6), | |
Eb = () => { | |
const [e, t] = N.useState(0), | |
[n, r] = N.useState(''), | |
[i, a] = N.useState(!1), | |
[o, l] = N.useState(''), | |
s = N.useRef(null), | |
[c, d] = N.useState([]), | |
[u, f] = N.useState(), | |
p = N.useRef(null), | |
[m, h] = N.useState({ bytes: 0, megaBytes: 0 }), | |
[x, b] = N.useState(!1), | |
[C, S] = N.useState(''), | |
D = (k) => { | |
const Q = JSON.stringify(k).length, | |
oe = Q / (1024 * 1024); | |
h({ bytes: Q, megaBytes: Number(oe.toFixed(2)) }); | |
}; | |
N.useEffect(() => { | |
chrome.storage.local.get(['qChats', 'token'], (k) => { | |
const v = k.qChats || [], | |
Q = k.token || ''; | |
d(v), S(Q), f(v[0]), D(v); | |
}); | |
}, []), | |
N.useEffect(() => { | |
var k; | |
f(c[e]), (k = s.current) == null || k.focus(); | |
}, [e]), | |
N.useEffect(() => { | |
var k; | |
(p.current.scrollTop = p.current.scrollHeight), (k = s.current) == null || k.focus(); | |
}, [u]); | |
const E = (k) => { | |
t(k), a(!1), r(''); | |
}, | |
w = (k) => { | |
k.stopPropagation(), a(() => !0), r(() => (u == null ? void 0 : u.title) || ''); | |
}, | |
O = (k) => { | |
k.stopPropagation(); | |
const v = [...c]; | |
(v[e].title = n), a(!1), r(''), d(v), chrome.storage.local.set({ qChats: v }); | |
}, | |
L = (k) => { | |
k.stopPropagation(), a(!1), r(''); | |
}, | |
F = (k) => { | |
k.stopPropagation(); | |
const v = [...c]; | |
v.splice(e, 1), t(() => 0), f(v[0]), d(() => v), chrome.storage.local.set({ qChats: v }); | |
}, | |
V = async (k) => { | |
var I, T, z; | |
if ((k.preventDefault(), !o)) return; | |
const v = { title: o.split(' ').slice(0, 6).join(' '), id: kb(), messages: [] }; | |
let Q = '', | |
oe = '', | |
ee = 's'; | |
const he = await Ib(), | |
{ | |
rolesList: fe, | |
tokenLength: Le, | |
role: Se, | |
length: Ve, | |
openAIkey: et, | |
keyStatus: ft, | |
liStatus: tt, | |
isSubscription: Je, | |
params: nt, | |
license: rt, | |
} = he; | |
if (!tt || (!Je && (!et || !ft))) return; | |
(oe = Se), (ee = bt || Ve); | |
const Ke = | |
/^([\w\s.,`+:^;@<>=!\\|?\\'"()\\[\]{}$%&*-]+)(?:\/([\w\s]+))?(?:#([\w\s]+))?$/gi.exec(o); | |
if (Ke) { | |
const [, U, H, de] = Ke; | |
H && (oe = H), U && (Q = U), de && (ee = de); | |
} | |
if (oe) { | |
const U = | |
(fe == null | |
? void 0 | |
: fe.filter((H) => H.name.toLowerCase() === oe.toLocaleLowerCase())) || []; | |
U.length > 0 && | |
((vo = U[0].prompt), (bo = U[0].name), chrome.storage.sync.set({ role: U[0].id })); | |
} | |
if (ee) { | |
const U = parseInt(ee); | |
if (U) bt = U; | |
else { | |
const H = ee.toLowerCase(), | |
De = | |
Le[ | |
H === 's' || H === 'small' | |
? 'small' | |
: H === 'm' || H === 'medium' | |
? 'medium' | |
: H === 'l' || H === 'long' | |
? 'long' | |
: H === 'll' || H === 'longer' | |
? 'longer' | |
: Ve | |
]; | |
De && (bt = De); | |
} | |
} | |
const it = { user: Q + `[${bo}]`, ai: '' }, | |
dn = `</s> Provide answer in no more than ${bt} tokens.`, | |
gt = []; | |
u == null || | |
u.messages.forEach((U) => { | |
gt.push({ role: 'system', content: U.ai }), gt.push({ role: 'user', content: U.user }); | |
}), | |
gt.push({ role: 'system', content: vo }), | |
gt.push({ role: 'user', content: Q + (bt ? dn : '') }); | |
const pn = { | |
model: nt.gptModel || 'gpt-3.5-turbo', | |
messages: gt, | |
stream: !0, | |
...(bt && { max_tokens: bt }), | |
...(Je ? { license: rt, token: C } : {}), | |
}, | |
_e = { ...(u || v) }; | |
_e.messages.push(it); | |
const mt = _e.messages.length - 1; | |
l(''), f(() => _e); | |
let Ct = ''; | |
try { | |
if (!Je) { | |
const H = await fetch('https://api.openai.com/v1/chat/completions', { | |
method: 'POST', | |
headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${et}` }, | |
body: JSON.stringify(pn), | |
}), | |
de = (I = H == null ? void 0 : H.body) == null ? void 0 : I.getReader(), | |
De = new TextDecoder('utf-8'); | |
for (;;) { | |
const { done: Pe, value: Ze } = (await (de == null ? void 0 : de.read())) || {}; | |
if (Pe) break; | |
const Ae = De.decode(Ze), | |
le = Ae.split(` | |
`); | |
if (Ae.includes('error') && Ae.includes('message')) { | |
const Lt = JSON.parse(Ae).error.message; | |
(Ct += Lt), | |
f((at) => { | |
const fn = { ...at }; | |
return (fn.messages[mt].ai += Lt), fn; | |
}); | |
break; | |
} | |
const ht = le | |
.map((ue) => ue.replace(/^data: /, '').trim()) | |
.filter((ue) => ue !== '' && ue !== '[DONE]') | |
.map((ue) => JSON.parse(ue)); | |
for (const ue of ht) { | |
const at = | |
(z = (T = (ue == null ? void 0 : ue.choices)[0]) == null ? void 0 : T.delta) == | |
null | |
? void 0 | |
: z.content; | |
at && | |
((Ct += at), | |
f((fn) => { | |
const zi = { ...fn }; | |
return (zi.messages[mt].ai += at), zi; | |
})); | |
} | |
} | |
} | |
if (Je) { | |
const H = await fetch('https://api.quickyai.com/generate', { | |
method: 'POST', | |
headers: { 'Content-Type': 'application/json' }, | |
body: JSON.stringify(pn), | |
}), | |
de = H.headers.get('x-token'); | |
de && chrome.storage.local.set({ token: de }); | |
const Pe = H.body.getReader(), | |
Ze = new TextDecoder(); | |
let Ae = !1; | |
for (; !Ae; ) { | |
const { value: le, done: ht } = await Pe.read(); | |
Ae = ht; | |
const ue = Ze.decode(le); | |
(Ct += ue), | |
f((Lt) => { | |
const at = { ...Lt }; | |
return (at.messages[mt].ai += ue), at; | |
}); | |
} | |
} | |
_e.messages[mt].ai = Ct; | |
const U = c.length > 0 ? [...c] : [v]; | |
(U[e] = u || { ..._e }), d(U), chrome.storage.local.set({ qChats: U }); | |
} catch { | |
(_e.messages[mt].ai = 'Something went wrong'), f(_e); | |
} | |
}, | |
A = (k) => { | |
k.key === 'Enter' && !k.shiftKey && (k.preventDefault(), V(k)); | |
}, | |
R = (k) => { | |
k.stopPropagation(), r(k.target.value); | |
}, | |
Y = (k) => { | |
l(k.currentTarget.value); | |
}, | |
q = (k) => { | |
const v = (k.match(/\n/g) || []).length; | |
return Math.min(v + 1, 5); | |
}; | |
function $(k, v) { | |
const Q = document.createElement('a'); | |
Q.setAttribute( | |
'href', | |
'data:text/plain;charset=utf-8,' + encodeURIComponent(JSON.stringify(v)) | |
), | |
Q.setAttribute('download', k), | |
(Q.style.display = 'none'), | |
document.body.appendChild(Q), | |
Q.click(), | |
document.body.removeChild(Q); | |
} | |
const J = () => { | |
const k = c || []; | |
if (k.length < 1) return; | |
const v = new Date().toISOString().slice(0, 10); | |
$(`QuickyAI_Chats_${v}.json`, k); | |
}, | |
ie = () => { | |
const k = document.createElement('input'); | |
(k.type = 'file'), | |
(k.accept = 'application/json'), | |
(k.style.display = 'none'), | |
document.body.appendChild(k), | |
k.click(), | |
(k.onchange = () => { | |
const v = k.files; | |
if (v.length <= 0 || v[0].type !== 'application/json') return; | |
const Q = new FileReader(); | |
Q.readAsText(v[0]), | |
(Q.onload = async (oe) => { | |
var fe; | |
if (!((fe = oe.target) != null && fe.result)) return; | |
const ee = JSON.parse(oe.target.result), | |
he = [...c, ...ee]; | |
d(he), f(he[0]), D(he), chrome.storage.local.set({ qChats: he }); | |
}), | |
document.body.removeChild(k); | |
}); | |
}, | |
ce = () => { | |
const k = [...c]; | |
(k.length = 0), | |
t(() => 0), | |
d(() => k), | |
f(k[0]), | |
D(k), | |
chrome.storage.local.set({ qChats: k }), | |
b(!1); | |
}, | |
me = () => { | |
b(!0); | |
}, | |
y = (k) => { | |
k.stopPropagation(), b(!1); | |
}, | |
pe = () => { | |
if ((t(() => 0), c.length < 1 || !c[0] || !u)) return; | |
const k = [...c]; | |
k.unshift(void 0), d(k), f(void 0); | |
}; | |
return g.jsxs(g.Fragment, { | |
children: [ | |
g.jsx(yg, { isOpen: x, onDelete: ce, onClose: y }), | |
g.jsxs('div', { | |
className: | |
'w-full flex gap-2 overflow-hidden relative text-base h-[85vh] p-4 mt-4 max-w-[86rem] mx-auto', | |
children: [ | |
g.jsxs('div', { | |
className: 'w-1/4 p-2 pb-12 bg-gray-700 rounded-lg text-white', | |
children: [ | |
g.jsxs('div', { | |
className: 'flex justify-between items-center mb-4', | |
children: [ | |
g.jsx('h1', { | |
className: 'text-2xl px-2 font-medium mb-0', | |
children: 'History', | |
}), | |
g.jsx('button', { | |
className: 'px-2 py-0.5 rounded bg-blue-500 hover:bg-blue-600 text-sm', | |
onClick: pe, | |
children: 'New chat', | |
}), | |
], | |
}), | |
g.jsx('ul', { | |
className: 'space-y-4 overflow-auto h-[92%] scrollbar list-none', | |
children: c.map((k, v) => | |
g.jsxs( | |
'li', | |
{ | |
className: `${ | |
v === e ? 'bg-blue-100 text-gray-900' : '' | |
} p-2 rounded cursor-pointer`, | |
onClick: () => E(v), | |
children: [ | |
g.jsxs('div', { | |
className: 'flex items-center justify-between', | |
children: [ | |
i && v === e | |
? g.jsx('input', { | |
type: 'text', | |
className: | |
'border border-blue-500 rounded-md px-1 focus:outline-none', | |
value: n, | |
onChange: R, | |
autoFocus: !0, | |
}) | |
: g.jsx('span', { | |
className: | |
'text-ellipsis overflow-hidden inline-block whitespace-nowrap w-[220px]', | |
children: k == null ? void 0 : k.title, | |
}), | |
v === e && | |
g.jsxs('div', { | |
children: [ | |
!i && | |
g.jsx('button', { | |
className: | |
'text-blue-500 hover:text-blue-600 focus:outline-none mr-3', | |
onClick: w, | |
title: 'Edit title', | |
children: g.jsxs('svg', { | |
stroke: 'currentColor', | |
fill: 'none', | |
strokeWidth: '2', | |
viewBox: '0 0 24 24', | |
strokeLinecap: 'round', | |
strokeLinejoin: 'round', | |
className: 'h-4 w-4', | |
height: '1em', | |
width: '1em', | |
xmlns: 'http://www.w3.org/2000/svg', | |
children: [ | |
g.jsx('path', { d: 'M12 20h9' }), | |
g.jsx('path', { | |
d: 'M16.5 3.5a2.121 2.121 0 0 1 3 3L7 19l-4 1 1-4L16.5 3.5z', | |
}), | |
], | |
}), | |
}), | |
!i && | |
g.jsx('button', { | |
className: | |
'text-red-400 hover:text-red-500 focus:outline-none', | |
onClick: F, | |
title: 'Delete chat', | |
children: g.jsx('svg', { | |
xmlns: 'http://www.w3.org/2000/svg', | |
className: 'w-4 h-4', | |
viewBox: '0 0 24 24', | |
children: g.jsxs('g', { | |
fill: 'currentColor', | |
children: [ | |
g.jsx('path', { | |
d: 'M3 6.386c0-.484.345-.877.771-.877h2.665c.529-.016.996-.399 1.176-.965l.03-.1l.115-.391c.07-.24.131-.45.217-.637c.338-.739.964-1.252 1.687-1.383c.184-.033.378-.033.6-.033h3.478c.223 0 .417 0 .6.033c.723.131 1.35.644 1.687 1.383c.086.187.147.396.218.637l.114.391l.03.1c.18.566.74.95 1.27.965h2.57c.427 0 .772.393.772.877s-.345.877-.771.877H3.77c-.425 0-.77-.393-.77-.877Z', | |
}), | |
g.jsx('path', { | |
fillRule: 'evenodd', | |
d: 'M11.596 22h.808c2.783 0 4.174 0 5.08-.886c.904-.886.996-2.339 1.181-5.245l.267-4.188c.1-1.577.15-2.366-.303-2.865c-.454-.5-1.22-.5-2.753-.5H8.124c-1.533 0-2.3 0-2.753.5c-.454.5-.404 1.288-.303 2.865l.267 4.188c.185 2.906.277 4.36 1.182 5.245c.905.886 2.296.886 5.079.886Zm-1.35-9.811c-.04-.434-.408-.75-.82-.707c-.413.043-.713.43-.672.864l.5 5.263c.04.434.408.75.82.707c.413-.043.713-.43.672-.864l-.5-5.263Zm4.329-.707c.412.043.713.43.671.864l-.5 5.263c-.04.434-.409.75-.82.707c-.413-.043-.713-.43-.672-.864l.5-5.263c.04-.434.409-.75.82-.707Z', | |
clipRule: 'evenodd', | |
}), | |
], | |
}), | |
}), | |
}), | |
i && | |
g.jsxs(g.Fragment, { | |
children: [ | |
g.jsx('button', { | |
className: | |
'text-blue-500 hover:text-blue-600 focus:outline-none mr-3', | |
onClick: O, | |
title: 'Save edit', | |
children: g.jsx('svg', { | |
xmlns: 'http://www.w3.org/2000/svg', | |
width: '1em', | |
height: '1em', | |
viewBox: '0 0 64 64', | |
children: g.jsx('path', { | |
fill: 'currentColor', | |
d: 'M56 2L18.8 42.9L8 34.7H2L18.8 62L62 2z', | |
}), | |
}), | |
}), | |
g.jsx('button', { | |
className: | |
'text-gray-600 hover:text-gray-700 focus:outline-none', | |
onClick: L, | |
title: 'Cancel edit', | |
children: g.jsx('svg', { | |
xmlns: 'http://www.w3.org/2000/svg', | |
width: '1em', | |
height: '1em', | |
viewBox: '0 0 15 15', | |
children: g.jsx('path', { | |
fill: 'currentColor', | |
d: 'M3.64 2.27L7.5 6.13l3.84-3.84A.92.92 0 0 1 12 2a1 1 0 0 1 1 1a.9.9 0 0 1-.27.66L8.84 7.5l3.89 3.89A.9.9 0 0 1 13 12a1 1 0 0 1-1 1a.92.92 0 0 1-.69-.27L7.5 8.87l-3.85 3.85A.92.92 0 0 1 3 13a1 1 0 0 1-1-1a.9.9 0 0 1 .27-.66L6.16 7.5L2.27 3.61A.9.9 0 0 1 2 3a1 1 0 0 1 1-1c.24.003.47.1.64.27Z', | |
}), | |
}), | |
}), | |
], | |
}), | |
], | |
}), | |
], | |
}), | |
g.jsxs('span', { | |
children: [ | |
(k == null ? void 0 : k.messages.length) || 0, | |
' ', | |
(k == null ? void 0 : k.messages.length) === 1 | |
? 'response' | |
: 'responses', | |
], | |
}), | |
], | |
}, | |
v | |
) | |
), | |
}), | |
g.jsxs('div', { | |
className: 'text-sm rounded h-[8%] flex gap-2 justify-start items-center px-2', | |
children: [ | |
g.jsxs('button', { | |
className: | |
'px-2 py-1 rounded bg-blue-500 hover:bg-blue-600 flex gap-1 items-center', | |
onClick: ie, | |
title: 'Import chats', | |
children: [ | |
g.jsx('svg', { | |
xmlns: 'http://www.w3.org/2000/svg', | |
className: 'w-4 h-4', | |
viewBox: '0 0 24 24', | |
children: g.jsx('path', { | |
fill: 'currentColor', | |
d: 'm14 12l-4-4v3H2v2h8v3m10 2V6a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v3h2V6h12v12H6v-3H4v3a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2Z', | |
}), | |
}), | |
g.jsx('span', { children: 'Import' }), | |
], | |
}), | |
g.jsxs('button', { | |
className: | |
'px-2 py-1 rounded bg-purple-500 hover:bg-purple-600 flex gap-1 items-center', | |
onClick: J, | |
title: 'Export chats', | |
children: [ | |
g.jsx('svg', { | |
xmlns: 'http://www.w3.org/2000/svg', | |
className: 'w-4 h-4', | |
viewBox: '0 0 24 24', | |
children: g.jsx('path', { | |
fill: 'currentColor', | |
d: 'm23 12l-4-4v3h-9v2h9v3M1 18V6a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v3h-2V6H3v12h12v-3h2v3a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2Z', | |
}), | |
}), | |
g.jsx('span', { children: 'Export' }), | |
], | |
}), | |
g.jsx('button', { | |
title: 'Delete all chats', | |
className: | |
'px-2 py-1.5 rounded bg-red-500 hover:bg-red-600 flex gap-1 items-center', | |
onClick: me, | |
children: g.jsx('svg', { | |
xmlns: 'http://www.w3.org/2000/svg', | |
className: 'w-4 h-4', | |
viewBox: '0 0 24 24', | |
children: g.jsxs('g', { | |
fill: 'currentColor', | |
children: [ | |
g.jsx('path', { | |
d: 'M3 6.386c0-.484.345-.877.771-.877h2.665c.529-.016.996-.399 1.176-.965l.03-.1l.115-.391c.07-.24.131-.45.217-.637c.338-.739.964-1.252 1.687-1.383c.184-.033.378-.033.6-.033h3.478c.223 0 .417 0 .6.033c.723.131 1.35.644 1.687 1.383c.086.187.147.396.218.637l.114.391l.03.1c.18.566.74.95 1.27.965h2.57c.427 0 .772.393.772.877s-.345.877-.771.877H3.77c-.425 0-.77-.393-.77-.877Z', | |
}), | |
g.jsx('path', { | |
fillRule: 'evenodd', | |
d: 'M11.596 22h.808c2.783 0 4.174 0 5.08-.886c.904-.886.996-2.339 1.181-5.245l.267-4.188c.1-1.577.15-2.366-.303-2.865c-.454-.5-1.22-.5-2.753-.5H8.124c-1.533 0-2.3 0-2.753.5c-.454.5-.404 1.288-.303 2.865l.267 4.188c.185 2.906.277 4.36 1.182 5.245c.905.886 2.296.886 5.079.886Zm-1.35-9.811c-.04-.434-.408-.75-.82-.707c-.413.043-.713.43-.672.864l.5 5.263c.04.434.408.75.82.707c.413-.043.713-.43.672-.864l-.5-5.263Zm4.329-.707c.412.043.713.43.671.864l-.5 5.263c-.04.434-.409.75-.82.707c-.413-.043-.713-.43-.672-.864l.5-5.263c.04-.434.409-.75.82-.707Z', | |
clipRule: 'evenodd', | |
}), | |
], | |
}), | |
}), | |
}), | |
g.jsxs('div', { | |
className: 'justify-self-end whitespace-nowrap', | |
title: 'Size of the chats', | |
children: [ | |
g.jsxs('span', { | |
className: 'text-gray-50', | |
children: [m.megaBytes, 'MB'], | |
}), | |
g.jsx('span', { className: 'px-0.5', children: '/' }), | |
g.jsx('span', { className: 'text-gray-400', children: '5MB' }), | |
], | |
}), | |
], | |
}), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'w-3/4 pl-4 h-full relative rounded-lg', | |
children: [ | |
g.jsx('h2', { | |
className: 'text-lg font-semibold mb-1', | |
children: u == null ? void 0 : u.title, | |
}), | |
g.jsxs('div', { | |
className: 'overflow-auto h-[85%] scrollbar pb-32', | |
ref: p, | |
children: [ | |
u == null | |
? void 0 | |
: u.messages.map((k, v) => | |
g.jsxs( | |
'div', | |
{ | |
className: 'flex flex-col gap-2', | |
children: [ | |
g.jsxs('div', { | |
className: 'flex items-start gap-2 rounded bg-gray-100 p-3', | |
children: [ | |
g.jsx('div', { | |
className: | |
'text-gray-700 rounded-full w-8 h-8 flex items-center justify-center border border-gray-300', | |
children: g.jsx('span', { | |
children: g.jsx('svg', { | |
xmlns: 'http://www.w3.org/2000/svg', | |
className: 'w-7 h-7', | |
viewBox: '0 0 24 24', | |
children: g.jsx('path', { | |
fill: 'currentColor', | |
d: 'M12 12q-1.65 0-2.825-1.175T8 8q0-1.65 1.175-2.825T12 4q1.65 0 2.825 1.175T16 8q0 1.65-1.175 2.825T12 12Zm-8 8v-2.8q0-.85.438-1.563T5.6 14.55q1.55-.775 3.15-1.163T12 13q1.65 0 3.25.388t3.15 1.162q.725.375 1.163 1.088T20 17.2V20H4Z', | |
}), | |
}), | |
}), | |
}), | |
g.jsx('div', { | |
className: 'ml-2', | |
children: g.jsx('p', { children: k.user }), | |
}), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'flex items-start gap-2 p-3', | |
children: [ | |
g.jsx('div', { | |
className: | |
'rounded-full w-8 h-8 flex-shrink-0 select-none flex items-center justify-center p-1 border', | |
children: g.jsx('img', { src: '/icon-32.png', alt: 'AI' }), | |
}), | |
g.jsx('div', { | |
className: 'ml-2 w-full rounded', | |
children: g.jsx(xs, { children: k.ai }), | |
}), | |
], | |
}), | |
], | |
}, | |
v | |
) | |
), | |
!u && | |
g.jsxs('div', { | |
className: 'flex flex-col items-center gap-4 mt-32', | |
children: [ | |
g.jsx('div', { | |
className: 'text-4xl text-gray-600 font-medium', | |
children: 'QuickyAI', | |
}), | |
g.jsx('div', { | |
className: 'text-center text-xl text-gray-500', | |
children: 'Start your new Chat now!', | |
}), | |
], | |
}), | |
], | |
}), | |
g.jsx('div', { | |
className: 'mt-4 h-[6%]', | |
children: g.jsxs('form', { | |
className: 'flex items-end gap-2 bottom-0 absolute w-full', | |
children: [ | |
g.jsx('textarea', { | |
className: | |
'border border-gray-300 rounded-lg px-3 py-2 focus:outline-blue-400 max-h-64 text-base resize-none no-scrollbar w-[80%]', | |
placeholder: 'Enter your text', | |
onChange: Y, | |
rows: q(o), | |
ref: s, | |
onKeyDown: A, | |
value: o, | |
autoFocus: !0, | |
}), | |
g.jsx('button', { | |
className: | |
'bg-blue-400 hover:bg-blue-500 text-white px-6 py-2 rounded-lg w-[17%] flex justify-center items-center outline-none', | |
onClick: V, | |
type: 'submit', | |
children: g.jsx('svg', { | |
xmlns: 'http://www.w3.org/2000/svg', | |
className: 'w-6 h-6', | |
viewBox: '0 0 24 24', | |
children: g.jsx('path', { | |
fill: 'currentColor', | |
d: 'm20.665 3.717l-17.73 6.837c-1.21.486-1.203 1.161-.222 1.462l4.552 1.42l10.532-6.645c.498-.303.953-.14.579.192l-8.533 7.701h-.002l.002.001l-.314 4.692c.46 0 .663-.211.921-.46l2.211-2.15l4.599 3.397c.848.467 1.457.227 1.668-.785l3.019-14.228c.309-1.239-.473-1.8-1.282-1.434z', | |
}), | |
}), | |
}), | |
], | |
}), | |
}), | |
], | |
}), | |
], | |
}), | |
], | |
}); | |
}, | |
Pb = [ | |
{ name: 'rose', hex: '#ffeff3' }, | |
{ name: 'blue', hex: '#e1efff' }, | |
{ name: 'purple', hex: '#e5e0fd' }, | |
{ name: 'lime', hex: '#c3ffc9' }, | |
{ name: 'yellow', hex: '#fdf8b8' }, | |
], | |
Ab = [ | |
{ name: 'GPT-4', value: 'gpt-4' }, | |
{ name: 'GPT-4 32K', value: 'gpt-4-32k' }, | |
{ name: 'GPT-3.5', value: 'gpt-3.5-turbo' }, | |
{ name: 'GPT-3.5 16K', value: 'gpt-3.5-turbo-16k' }, | |
], | |
yo = { | |
completionTextSize: 17, | |
titleBg: '#ffeff3', | |
gptModel: 'gpt-3.5-turbo', | |
titleTextSize: 15, | |
hideRole: !1, | |
}, | |
Nb = () => { | |
const [e, t] = N.useState(yo), | |
[n, r] = N.useState(!0); | |
N.useEffect(() => { | |
chrome.storage.sync.get(['params'], (u) => { | |
if (u.params) { | |
const { | |
completionTextSize: f, | |
titleBg: p, | |
gptModel: m, | |
titleTextSize: h, | |
hideRole: x, | |
} = u.params; | |
t(() => ({ | |
completionTextSize: f, | |
titleBg: p, | |
gptModel: m, | |
titleTextSize: h, | |
hideRole: x, | |
})), | |
setTimeout(() => { | |
r(!0); | |
}, 1); | |
} | |
}); | |
}, []), | |
N.useEffect(() => { | |
r(!1); | |
}, [e]); | |
const i = (u) => { | |
const f = +u.currentTarget.value; | |
t((p) => ({ ...p, completionTextSize: f })); | |
}, | |
a = (u) => { | |
const f = +u.currentTarget.value; | |
t((p) => ({ ...p, titleTextSize: f })); | |
}, | |
o = (u) => { | |
const f = u.target.value; | |
t((p) => ({ ...p, gptModel: f })); | |
}, | |
l = (u) => { | |
const f = u.target.checked; | |
t((p) => ({ ...p, hideRole: f })); | |
}, | |
s = (u) => { | |
t((f) => ({ ...f, titleBg: u })); | |
}, | |
c = () => { | |
const { completionTextSize: u, titleBg: f, gptModel: p, titleTextSize: m, hideRole: h } = e; | |
chrome.storage.sync.get(['params'], (x) => { | |
const b = x.params, | |
C = { completionTextSize: u, titleBg: f, gptModel: p, titleTextSize: m, hideRole: h }; | |
chrome.storage.sync.set({ params: { ...b, ...C } }), r(!0); | |
}); | |
}, | |
d = () => { | |
t(yo); | |
}; | |
return g.jsxs('div', { | |
className: 'px-20 mx-auto pb-20 max-w-6xl relative', | |
children: [ | |
g.jsx('h1', { | |
className: 'text-3xl font-semibold text-center font-sans mt-6', | |
children: 'Settings', | |
}), | |
g.jsxs('div', { | |
className: 'text-base mt-6 flex flex-col gap-6', | |
children: [ | |
g.jsxs('div', { | |
className: 'flex items-center gap-4', | |
children: [ | |
g.jsxs('div', { | |
className: 'font-medium', | |
children: [ | |
g.jsx('span', { className: 'w-32 inline-block', children: 'GPT Model' }), | |
g.jsx('span', { children: ':' }), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'relative', | |
children: [ | |
g.jsx('select', { | |
id: 'model', | |
className: | |
'block appearance-none bg-gray-50 border border-gray-300 hover:border-gray-300 px-2 py-1 pr-8 rounded-md leading-normal focus:outline-none focus:ring-blue-500 focus:border-blue-500 text-sm font-medium', | |
value: e.gptModel, | |
onChange: o, | |
children: Ab.map((u, f) => | |
g.jsx('option', { value: u.value, children: u.name }, f) | |
), | |
}), | |
g.jsx('div', { | |
className: | |
'pointer-events-none absolute inset-y-0 right-0 flex items-center px-2 text-gray-700', | |
children: g.jsx('svg', { | |
className: 'fill-current h-4 w-4', | |
xmlns: 'http://www.w3.org/2000/svg', | |
viewBox: '0 0 20 20', | |
children: g.jsx('path', { d: 'M10 12l-6-6h12z' }), | |
}), | |
}), | |
], | |
}), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'flex items-center gap-4', | |
children: [ | |
g.jsxs('div', { | |
className: 'font-medium', | |
children: [ | |
g.jsx('span', { className: 'w-32 inline-block', children: 'Result text size' }), | |
g.jsx('span', { children: ':' }), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'flex gap-2 items-center', | |
children: [ | |
g.jsx('input', { | |
type: 'number', | |
min: 5, | |
value: e.completionTextSize, | |
onChange: i, | |
className: | |
'block w-20 px-2 py-0.5 text-gray-900 border border-gray-300 rounded-md bg-gray-50 focus:ring-blue-500 focus:ring-2 outline-none ', | |
}), | |
' ', | |
g.jsx('span', { children: 'px' }), | |
], | |
}), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'flex items-center gap-4', | |
children: [ | |
g.jsxs('div', { | |
className: 'font-medium', | |
children: [ | |
g.jsx('span', { className: 'w-32 inline-block', children: 'Title text size' }), | |
g.jsx('span', { children: ':' }), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'flex gap-2 items-center', | |
children: [ | |
g.jsx('input', { | |
type: 'number', | |
min: 5, | |
value: e.titleTextSize, | |
onChange: a, | |
className: | |
'block w-20 px-2 py-0.5 text-gray-900 border border-gray-300 rounded-md bg-gray-50 focus:ring-blue-500 focus:ring-2 outline-none ', | |
}), | |
' ', | |
g.jsx('span', { children: 'px' }), | |
], | |
}), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'flex items-center gap-4', | |
children: [ | |
g.jsxs('div', { | |
className: 'font-medium', | |
children: [ | |
g.jsx('span', { className: 'w-32 inline-block', children: 'Hide prompt' }), | |
g.jsx('span', { children: ':' }), | |
], | |
}), | |
g.jsx('div', { | |
className: '-mb-2', | |
children: g.jsxs('label', { | |
className: 'relative inline-flex items-center cursor-pointer', | |
children: [ | |
g.jsx('input', { | |
type: 'checkbox', | |
checked: e.hideRole, | |
onChange: l, | |
className: 'sr-only peer', | |
}), | |
g.jsx('div', { | |
className: | |
"w-11 h-6 bg-gray-200 peer-focus:outline-none peer-focus:ring-4 peer-focus:ring-blue-300 dark:peer-focus:ring-blue-800 rounded-full peer dark:bg-gray-700 peer-checked:after:translate-x-full peer-checked:after:border-white after:content-[''] after:absolute after:top-[2px] after:left-[2px] after:bg-white after:border-gray-300 after:border after:rounded-full after:h-5 after:w-5 after:transition-all dark:border-gray-600 peer-checked:bg-blue-600", | |
}), | |
], | |
}), | |
}), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'flex items-center gap-4', | |
children: [ | |
g.jsxs('div', { | |
className: 'font-medium', | |
children: [ | |
g.jsx('span', { className: 'w-32 inline-block', children: 'Theme color' }), | |
g.jsx('span', { children: ':' }), | |
], | |
}), | |
g.jsx('div', { | |
className: 'flex gap-2 items-center', | |
children: Pb.map((u) => | |
g.jsx( | |
'button', | |
{ | |
className: `px-3 py-1 rounded text-gray-700 font-medium mr-2 mb-2 text-ellipsis overflow-hidden w-16 h-6 flex justify-center items-center hover:outline outline-blue-400 ${ | |
u.hex === e.titleBg ? 'outline outline-offset-2 outline-2' : '' | |
}`, | |
style: { backgroundColor: u.hex }, | |
onClick: () => s(u.hex), | |
}, | |
u.name | |
) | |
), | |
}), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'flex items-center gap-4 font-normal mt-10', | |
children: [ | |
g.jsx('button', { | |
className: | |
'bg-gray-400 hover:bg-gray-500 text-white py-2 px-4 rounded-md transition-colors duration-200', | |
onClick: d, | |
children: 'Restore default', | |
}), | |
g.jsx('button', { | |
className: `${ | |
n ? 'bg-green-600 hover:bg-green-700' : 'bg-blue-600 hover:bg-blue-700' | |
} text-white py-2 px-4 rounded-md transition-colors duration-200`, | |
onClick: c, | |
children: n ? 'Saved' : 'Save settings', | |
}), | |
], | |
}), | |
], | |
}), | |
g.jsx('div', { | |
className: 'absolute right-6 top-20', | |
children: g.jsxs('div', { | |
className: 'bs-container w-[360px] h-40', | |
children: [ | |
g.jsxs('div', { | |
className: 'bs-title-container', | |
style: { backgroundColor: e.titleBg }, | |
children: [ | |
g.jsxs('div', { | |
className: 'bs-controls', | |
children: [ | |
g.jsx('div', { className: 'bs-red bs-circle', children: '×' }), | |
g.jsx('div', { className: 'bs-yellow bs-circle', children: '–' }), | |
g.jsx('div', { className: 'bs-green bs-circle', children: '+' }), | |
], | |
}), | |
g.jsxs('div', { | |
className: 'bs-title', | |
style: { fontSize: e.titleTextSize }, | |
children: [ | |
'Quicky AI', | |
' ', | |
g.jsx('span', { | |
className: 'bs-title-role', | |
style: { display: e.hideRole ? 'none' : 'inline' }, | |
children: '(Explain)', | |
}), | |
], | |
}), | |
], | |
}), | |
g.jsx('div', { | |
className: 'bs-completion', | |
spellCheck: 'false', | |
'data-bs-text': 'Enter your text here', | |
style: { fontSize: e.completionTextSize }, | |
children: | |
'A sample response text to check the size of it. A sample response text to check the size of it.', | |
}), | |
g.jsx('div', { | |
className: 'bs-copy-container', | |
children: g.jsx('div', { | |
className: 'bs-copy', | |
children: g.jsxs('svg', { | |
xmlns: 'http://www.w3.org/2000/svg', | |
width: '20', | |
height: '20', | |
viewBox: '0 0 24 24', | |
fill: 'none', | |
stroke: 'currentColor', | |
strokeWidth: '2', | |
strokeLinecap: 'round', | |
strokeLinejoin: 'round', | |
className: 'feather feather-copy', | |
children: [ | |
g.jsx('rect', { | |
x: '9', | |
y: '9', | |
width: '13', | |
height: '13', | |
rx: '2', | |
ry: '2', | |
}), | |
g.jsx('path', { | |
d: 'M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1', | |
}), | |
], | |
}), | |
}), | |
}), | |
g.jsx('div', { className: 'bs-resizer' }), | |
], | |
}), | |
}), | |
], | |
}); | |
}; | |
function Ob() { | |
const [e, t] = N.useState('keys'), | |
r = new URLSearchParams(document.location.search).get('id'); | |
N.useEffect(() => { | |
r === 'keys' && t('keys'), | |
r === 'prompts' && t('prompts'), | |
r === 'shortcuts' && t('shortcuts'), | |
r === 'guide' && t('guide'), | |
r === 'history' && t('history'), | |
r === 'settings' && t('settings'); | |
}, []); | |
const i = (a) => { | |
t(a); | |
const o = new URL(window.location.href); | |
o.searchParams.set('id', a), window.history.pushState(null, '', o.toString()); | |
}; | |
return g.jsxs(g.Fragment, { | |
children: [ | |
g.jsx(Is, { onClick: i, selectedTab: e }), | |
e === 'keys' && g.jsx(Ps, {}), | |
e === 'prompts' && g.jsx(mg, {}), | |
e === 'shortcuts' && g.jsx(vg, {}), | |
e === 'guide' && g.jsx(bg, {}), | |
e === 'history' && g.jsx(Eb, {}), | |
e === 'settings' && g.jsx(Nb, {}), | |
], | |
}); | |
} | |
function Tb() { | |
const e = document.querySelector('#__root'); | |
if (!e) throw new Error("Can't find Options root element"); | |
Ds(e).render(g.jsx(Ob, {})); | |
} | |
Tb(); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment