diff --git a/_posts/2022-01-11-substantial-presence-test/index.mdx b/_posts/2022-01-11-substantial-presence-test/index.mdx
index e61cd8b..9eb31c9 100644
--- a/_posts/2022-01-11-substantial-presence-test/index.mdx
+++ b/_posts/2022-01-11-substantial-presence-test/index.mdx
@@ -4,8 +4,23 @@ date: 2022-01-11
 status: draft
 ---
 
-The substantial presence test can be a bit confusing. Here's a simple calculator to help you determine whether you pass.
+The IRS uses the [Substantial Presence
+Test](https://www.irs.gov/individuals/international-taxpayers/substantial-presence-test) to determine whether
+a person is a resident for tax purposes. As of the time this calculator was built, the requirements for the
+test are that the person must be physically present in the United States on at lesat:
+
+1. 31 days during the current year, and
+2. 183 days during the 3-year period that includes the current year and the 2 years immediately before that,
+   counting:
+   - All the days you were present in the current year, and
+   - 1/3 of the days you were present in the first year before the current year, and
+   - 1/6 of the days you were present in the second year before the current year.
+
+This can be a bit confusing to calculate, so I've created a tool to help. Your changes will be automatically
+saved to your browser so you can come back later on the same device and get an updated answer if necessary.
 
 <br />
 
 <SubstantialPresenceTest />
+
+<br />
diff --git a/components/MdxRenderer.tsx b/components/MdxRenderer.tsx
index 12b61e2..42ea3d9 100644
--- a/components/MdxRenderer.tsx
+++ b/components/MdxRenderer.tsx
@@ -21,7 +21,9 @@ const shortcodes = {
   h4: createHeadingComponent('h4'),
   h5: createHeadingComponent('h5'),
   h6: createHeadingComponent('h6'),
-  SubstantialPresenceTest, // TODO: Should be able to import from just the article that uses this
+
+  // TODO: Should be able to import these from just the articles that uses them
+  SubstantialPresenceTest,
   RocketLeague,
 };
 
diff --git a/components/SubstantialPresenceTest.tsx b/components/SubstantialPresenceTest.tsx
index 1df65dd..71f6238 100644
--- a/components/SubstantialPresenceTest.tsx
+++ b/components/SubstantialPresenceTest.tsx
@@ -1,313 +1,394 @@
-import { Fragment, useEffect, useReducer, useState } from 'react';
+import { useAtom, useAtomValue } from 'jotai';
+import { atomWithStorage } from 'jotai/utils';
+import { FC } from 'react';
+import { addDays, differenceInDays } from 'date-fns';
 
-const NUM_YEARS_TO_INCLUDE = 10;
 const CURRENT_YEAR = new Date().getFullYear();
 const TOTAL_REQUIREMENT = 183;
-const YEAR_REQUIREMENTS = [
-  {
-    yearOffset: 0,
-    minimum: 31,
-    multiplier: 1,
-  },
-  {
-    yearOffset: -1,
-    multiplier: 1 / 3,
-  },
-  {
-    yearOffset: -2,
-    multiplier: 1 / 6,
-  },
-];
-
-function dateToValue(date: Date) {
-  return date.toISOString().split('T')[0];
+const CURRENT_YEAR_REQUIREMENT = 31;
+const YEAR_MULTIPLIERS = [1, 1 / 3, 1 / 6];
+const NUM_YEARS_TO_INCLUDE = YEAR_MULTIPLIERS.length * 4;
+
+interface Range {
+  start: number;
+  end: number;
 }
 
-function addDays(date: Date, days: number) {
-  const newDate = new Date(date);
-  newDate.setDate(newDate.getDate() + days);
-  return newDate;
+interface YearDetails {
+  present: boolean;
+  ranges: Range[];
 }
 
-type DayCounterRangeProps = {
-  year: number;
-  onChange?: (range: DayCounterRange) => void;
-};
+const yearAtom = atomWithStorage(
+  'substantialPresenceTest:selectedYear',
+  CURRENT_YEAR
+);
+const yearsDetailsAtom = atomWithStorage<Record<number, YearDetails>>(
+  'substantialPresenceTest:yearsDetails',
+  {}
+);
 
-const DayCounterRange = function ({ year, onChange }: DayCounterRangeProps) {
-  const min = `${year}-01-01`;
-  const max = year !== CURRENT_YEAR ? `${year}-12-31` : dateToValue(new Date());
+function getAllValidDays(
+  year: number,
+  yearsDetails: Record<number, YearDetails>
+) {
+  return YEAR_MULTIPLIERS.map((multiplier, i) => {
+    const offsetYear = year - i;
+    return getValidDays(multiplier, yearsDetails[offsetYear]);
+  }).reduce(
+    (acc, curr) => ({
+      totalDays: acc.totalDays + curr.validDays,
+      validDays: acc.validDays + curr.validDays,
+      lastDay: Math.max(curr.lastDay ?? 0, acc.lastDay ?? 0),
+    }),
+    { totalDays: 0, validDays: 0, lastDay: 0 }
+  );
+}
 
-  const [start, setStart] = useState(new Date(min));
-  const [end, setEnd] = useState(new Date(max));
+function getValidDays(multiplier: number, details?: YearDetails) {
+  const totalDays = details?.present
+    ? details.ranges.reduce(
+        (total, range) => total + differenceInDays(range.end, range.start) + 1,
+        0
+      )
+    : 0;
+  const validDays = Math.floor(totalDays * multiplier);
+  return { totalDays, validDays, lastDay: details?.ranges.at(-1)?.end };
+}
 
-  function computeChange() {
-    if (onChange) {
-      const timeDiff = end.getTime() - start.getTime();
-      const daysDiff = timeDiff / (1000 * 3600 * 24);
-      onChange({ count: daysDiff, start, end }); // TODO: Should we include the last day?
-    }
-  }
+const SubstantialPresenceTest = () => {
+  const year = useAtomValue(yearAtom);
+  const yearsDetails = useAtomValue(yearsDetailsAtom);
 
-  useEffect(() => {
-    computeChange();
-  }, [start, end]);
+  const { validDays, lastDay } = getAllValidDays(year, yearsDetails);
+  const { validDays: currentYearValidDays } = getValidDays(
+    YEAR_MULTIPLIERS[0],
+    yearsDetails[year]
+  );
 
-  function handleChange(setter: (date: Date) => void, value: Date) {
-    setter(value);
-  }
+  const dayOfPassing =
+    validDays >= TOTAL_REQUIREMENT
+      ? currentYearValidDays > CURRENT_YEAR_REQUIREMENT
+        ? new Date(lastDay!)
+        : addDays(lastDay!, CURRENT_YEAR_REQUIREMENT - currentYearValidDays)
+      : addDays(lastDay!, TOTAL_REQUIREMENT - validDays);
 
   return (
-    <span>
-      <label>
-        from{' '}
-        <input
-          type="date"
-          min={min}
-          max={dateToValue(addDays(end, -1))}
-          value={dateToValue(start)}
-          onChange={(e) =>
-            handleChange(setStart, new Date(e.target.valueAsDate!))
-          }
-        />
-      </label>{' '}
-      <label>
-        till{' '}
-        <input
-          type="date"
-          min={dateToValue(addDays(start, 1))}
-          max={max}
-          value={dateToValue(end)}
-          onChange={(e) =>
-            handleChange(setEnd, new Date(e.target.valueAsDate!))
-          }
-        />
-      </label>
-    </span>
+    <section
+      style={{
+        padding: 'var(--theme-spacing-2)',
+        backgroundColor: 'rgba(255, 255, 255, 0.05)',
+        borderRadius: 'var(--theme-roundness)',
+      }}
+    >
+      <h3 style={{ marginTop: '0' }}>Substantial Presence Test Calculator</h3>
+      <YearPicker />
+
+      <table
+        style={{
+          width: '100%',
+          borderSpacing: '5px',
+          margin: '20px 0',
+          padding: '5px',
+        }}
+      >
+        <tbody>
+          <YearCounterRows />
+
+          <tr>
+            <td></td>
+            <td>Total eligible days for the current year</td>
+            <td style={{ textAlign: 'right', whiteSpace: 'nowrap' }}>
+              {currentYearValidDays} / {CURRENT_YEAR_REQUIREMENT}
+            </td>
+          </tr>
+
+          <tr>
+            <td></td>
+            <td>Total eligible days</td>
+            <td style={{ textAlign: 'right', whiteSpace: 'nowrap' }}>
+              {validDays} / {TOTAL_REQUIREMENT}
+            </td>
+          </tr>
+        </tbody>
+      </table>
+
+      <div>
+        {validDays >= TOTAL_REQUIREMENT &&
+        currentYearValidDays >= CURRENT_YEAR_REQUIREMENT ? (
+          <>
+            You have passed the Substantial Presence Test for{' '}
+            <span style={{ fontWeight: 'bold' }}>{year}</span>!
+          </>
+        ) : dayOfPassing.getFullYear() === year ? (
+          <>
+            If you remain in the country, you will pass the Substantial Presence
+            Test on{' '}
+            <time
+              style={{ fontWeight: 'bold' }}
+              dateTime={dayOfPassing.toISOString()}
+            >
+              {dayOfPassing.toLocaleDateString()}
+            </time>
+            .
+          </>
+        ) : (
+          <>
+            You cannot pass the Substantial Presence Test in{' '}
+            <span style={{ fontWeight: 'bold' }}>{year}</span>.
+          </>
+        )}
+      </div>
+    </section>
   );
 };
 
-type DayCounterRange = {
-  count: number;
-  start: Date | null;
-  end: Date | null;
+const YearPicker = () => {
+  const [year, setYear] = useAtom(yearAtom);
+
+  return (
+    <label>
+      Which year would you like to test for?{' '}
+      <select value={year} onChange={(e) => setYear(+e.currentTarget.value)}>
+        {new Array(NUM_YEARS_TO_INCLUDE).fill(0).map((_, i) => {
+          const year = CURRENT_YEAR - i;
+          return (
+            <option key={year} value={year}>
+              {year}
+            </option>
+          );
+        })}
+      </select>
+    </label>
+  );
 };
 
-type DayCounterState = {
-  present: boolean;
-  ranges: DayCounterRange[];
-  count: number;
+const YearCounterRows = () => {
+  return (
+    <>
+      {YEAR_MULTIPLIERS.map((multiplier, i) => {
+        return <YearCounter key={i} yearOffset={i} multiplier={multiplier} />;
+      })}
+    </>
+  );
 };
 
-type DayCounterAction =
-  | { type: 'togglePresent' }
-  | { type: 'addRange' }
-  | { type: 'removeRange'; range: DayCounterRange }
-  | { type: 'updateRange'; range: DayCounterRange; updates: DayCounterRange };
-
-function dayCounterReducer(
-  state: DayCounterState,
-  action: DayCounterAction
-): DayCounterState {
-  function primaryReducer() {
-    if (action.type === 'togglePresent') {
-      return { ...state, present: !state.present };
-    } else if (action.type === 'addRange') {
-      return {
-        ...state,
-        ranges: [...state.ranges, { count: 0, start: null, end: null }],
-      };
-    } else if (action.type === 'removeRange') {
-      return {
-        ...state,
-        ranges: state.ranges.filter((x) => x !== action.range),
-      };
-    } else if (action.type === 'updateRange') {
-      return {
-        ...state,
-        ranges: state.ranges.map((x) =>
-          x !== action.range ? x : { ...x, ...action.updates }
-        ),
-      };
-    }
-    throw new Error();
-  }
-
-  const nextState = primaryReducer();
-  return {
-    ...nextState,
-    count: !nextState.present
-      ? 0
-      : nextState.ranges.reduce((count, range) => count + range.count, 0),
-  };
+function startOfYear(year: number) {
+  return new Date(`${year}-01-01`).getTime();
 }
 
-type DayCounterProps = {
-  year: number;
-  onChange?: (count: number) => void;
-};
+function endOfYear(year: number) {
+  return new Date(`${year}-12-31`).getTime();
+}
+
+function functionalEndOfYear(year: number) {
+  return Math.min(Date.now(), endOfYear(year));
+}
+
+interface YearCounterProps {
+  yearOffset: number;
+  multiplier: number;
+}
+
+const YearCounter: FC<YearCounterProps> = ({ yearOffset, multiplier }) => {
+  const year = useAtomValue(yearAtom) - yearOffset;
 
-const DayCounter = function ({ year, onChange }: DayCounterProps) {
-  const [state, dispatch] = useReducer(dayCounterReducer, {
+  const [yearsDetails, setYearsDetails] = useAtom(yearsDetailsAtom);
+  const details = yearsDetails[year] ?? {
     present: false,
-    ranges: [{ count: 0, start: null, end: null }],
-    count: 0,
-  });
+    ranges: [
+      {
+        start: startOfYear(year),
+        end: functionalEndOfYear(year),
+      },
+    ],
+  };
 
-  useEffect(() => {
-    if (onChange) {
-      onChange(state.count);
-    }
-  }, [state.count]);
+  const { totalDays, validDays } = getValidDays(multiplier, details);
 
   return (
-    <div
-      style={{
-        display: 'flex',
-        flexDirection: 'column',
-        alignItems: 'flex-start',
-        gap: 'var(--theme-spacing-1)',
-      }}
-    >
-      <label>
-        I was present{' '}
-        <input
-          type="checkbox"
-          checked={state.present}
-          onChange={() => dispatch({ type: 'togglePresent' })}
+    <>
+      <tr>
+        <td style={{ width: '75px' }}>{year}</td>
+        <td>
+          <label>
+            I was present{' '}
+            <input
+              type="checkbox"
+              checked={details.present}
+              onChange={(e) =>
+                setYearsDetails({
+                  ...yearsDetails,
+                  [year]: { ...details, present: e.currentTarget.checked },
+                })
+              }
+            />
+          </label>
+        </td>
+        <td style={{ textAlign: 'right', whiteSpace: 'nowrap' }}>
+          {totalDays} × 1/{1 / multiplier} = {validDays}
+        </td>
+      </tr>
+
+      {details.present && (
+        <YearCounterRanges
+          year={year}
+          yearDetails={details}
+          addRange={() => {
+            const previousRange = details.ranges.at(-1)!;
+            setYearsDetails({
+              ...yearsDetails,
+              [year]: {
+                ...details,
+                ranges: [
+                  ...details.ranges,
+                  {
+                    start: addDays(previousRange.end, 1).getTime(),
+                    end: functionalEndOfYear(year),
+                  },
+                ],
+              },
+            });
+          }}
+          removeRange={(i) => {
+            setYearsDetails({
+              ...yearsDetails,
+              [year]: {
+                ...details,
+                ranges: details.ranges.filter((_, j) => i !== j),
+              },
+            });
+          }}
+          setRange={(i, range) => {
+            setYearsDetails({
+              ...yearsDetails,
+              [year]: {
+                ...details,
+                ranges: details.ranges.map((r, j) => (i === j ? range : r)),
+              },
+            });
+          }}
         />
-      </label>
-
-      {state.present ? (
-        <>
-          {state.ranges.map((range, i) => (
-            <div key={i}>
-              <span>
-                {i !== 0 ? <span>and </span> : null}
-                <DayCounterRange
-                  year={year}
-                  onChange={(updates) =>
-                    dispatch({ type: 'updateRange', range, updates })
-                  }
-                />
-              </span>{' '}
-              <button
-                disabled={state.ranges.length === 1}
-                onClick={() => dispatch({ type: 'removeRange', range })}
-                style={{
-                  borderRadius: '28px',
-                  width: '28px',
-                  height: '28px',
-                  transition: 'ease-in-out 0.2s',
-                }}
-              >
-                x
-              </button>
-            </div>
-          ))}
+      )}
+
+      <tr style={{ height: '10px' }}></tr>
+    </>
+  );
+};
+
+interface YearCounterRangesProps {
+  year: number;
+  yearDetails: YearDetails;
+  addRange: () => void;
+  removeRange: (i: number) => void;
+  setRange: (i: number, range: Range) => void;
+}
+
+const YearCounterRanges: FC<YearCounterRangesProps> = ({
+  year,
+  yearDetails,
+  addRange,
+  removeRange,
+  setRange,
+}) => {
+  return (
+    <>
+      {yearDetails.ranges.map((range, i) => {
+        return (
+          <YearCounterRange
+            key={i}
+            year={year}
+            first={i === 0}
+            lastRemaining={yearDetails.ranges.length === 1}
+            previousRange={yearDetails.ranges[i - 1]}
+            range={range}
+            removeRange={() => removeRange(i)}
+            setStart={(start) => setRange(i, { ...range, start })}
+            setEnd={(end) => setRange(i, { ...range, end })}
+          />
+        );
+      })}
+      <tr>
+        <td></td>
+        <td>
           <button
-            onClick={() => dispatch({ type: 'addRange' })}
-            style={{ borderRadius: '28px' }}
+            onClick={addRange}
+            disabled={
+              dateString(yearDetails.ranges.at(-1)!.end) ===
+              dateString(functionalEndOfYear(year))
+            }
+            style={{ borderRadius: '100px' }}
           >
             + add range
           </button>
-        </>
-      ) : null}
-    </div>
+        </td>
+      </tr>
+    </>
   );
 };
 
-const SubstantialPresenceTest = function () {
-  function getDefaultDayCounts(year: number) {
-    const dayCounts: Record<number, number> = {};
-    YEAR_REQUIREMENTS.forEach((req) => (dayCounts[year + req.yearOffset] = 0));
-    return dayCounts;
-  }
-
-  const [year, setYear] = useState(CURRENT_YEAR);
-  const [dayCounts, setDayCounts] = useState<Record<number, number>>(
-    getDefaultDayCounts(CURRENT_YEAR)
-  );
-
-  const total = YEAR_REQUIREMENTS.reduce(
-    (sum, req) =>
-      sum + Math.floor(dayCounts[year + req.yearOffset] * req.multiplier),
-    0
-  );
+function dateString(datetime: number | Date) {
+  return new Date(datetime).toISOString().split('T')[0];
+}
 
-  const currentDate = new Date();
-  const passingDate = new Date(
-    currentDate.setDate(currentDate.getDate() + (TOTAL_REQUIREMENT - total))
-  );
+interface YearCounterRangeProps {
+  year: number;
+  first?: boolean;
+  lastRemaining: boolean;
+  previousRange?: YearDetails['ranges'][number];
+  range: YearDetails['ranges'][number];
+  removeRange: () => void;
+  setStart: (start: number) => void;
+  setEnd: (end: number) => void;
+}
 
+const YearCounterRange: FC<YearCounterRangeProps> = ({
+  year,
+  first = false,
+  lastRemaining,
+  previousRange,
+  range,
+  removeRange,
+  setStart,
+  setEnd,
+}) => {
   return (
-    <section
-      style={{
-        padding: 'var(--theme-spacing-2)',
-        backgroundColor: 'rgba(255, 255, 255, 0.05)',
-        borderRadius: 'var(--theme-roundness)',
-      }}
-    >
-      <h3 style={{ marginTop: '0' }}>Substantial Presence Test Calculator</h3>
-
-      <label>
-        Which year would you like to test for?{' '}
-        <select
-          value={year}
-          onChange={(e) => {
-            setYear(+e.target.value);
-            setDayCounts(getDefaultDayCounts(+e.target.value));
+    <tr>
+      <td></td>
+      <td>
+        {!first && 'and '}from{' '}
+        <input
+          type="date"
+          value={dateString(range.start)}
+          onChange={(e) => setStart(new Date(e.currentTarget.value).getTime())}
+          min={dateString(
+            previousRange
+              ? addDays(previousRange.end, 1).getTime()
+              : startOfYear(year)
+          )}
+          max={dateString(range.end)}
+        />{' '}
+        till{' '}
+        <input
+          type="date"
+          value={dateString(range.end)}
+          onChange={(e) => setEnd(new Date(e.currentTarget.value).getTime())}
+          min={dateString(range.start)}
+          max={dateString(functionalEndOfYear(year))}
+        />{' '}
+        <button
+          disabled={lastRemaining}
+          onClick={removeRange}
+          style={{
+            borderRadius: '100px',
+            height: '28px',
+            width: '28px',
           }}
         >
-          {new Array(NUM_YEARS_TO_INCLUDE).fill(0).map((_, i) => (
-            <option key={i} value={CURRENT_YEAR - i}>
-              {CURRENT_YEAR - i}
-            </option>
-          ))}
-        </select>
-      </label>
-
-      <div
-        style={{
-          display: 'grid',
-          gridTemplateColumns: 'min-content auto auto',
-          gap: 'var(--theme-spacing-3)',
-          marginTop: 'var(--theme-spacing-2)',
-        }}
-      >
-        {YEAR_REQUIREMENTS.map((req) => (
-          <Fragment key={year + req.yearOffset}>
-            <span style={{ opacity: 0.8 }}>{year + req.yearOffset}</span>
-            <DayCounter
-              year={year + req.yearOffset}
-              onChange={(count) => {
-                setDayCounts({
-                  ...dayCounts,
-                  [year + req.yearOffset]: Math.floor(count),
-                });
-              }}
-            />
-            <span>
-              {dayCounts[year + req.yearOffset]} x 1/{1 / req.multiplier} ={' '}
-              {Math.floor(dayCounts[year + req.yearOffset] * req.multiplier)}
-            </span>
-          </Fragment>
-        ))}
-
-        <span style={{ gridColumnStart: '2' }}>Total eligible days:</span>
-        <span>
-          {total} / {TOTAL_REQUIREMENT}
-        </span>
-
-        <span style={{ gridColumnStart: '2' }}>
-          {total < TOTAL_REQUIREMENT
-            ? `If you remain in the country, you will pass the Substantial Presence Test on ${dateToValue(
-                passingDate
-              )}`
-            : `You have passed the Substantial Presence Test for ${year}! 🎉`}
-        </span>
-      </div>
-    </section>
+          x
+        </button>
+      </td>
+    </tr>
   );
 };
 
diff --git a/package.json b/package.json
index a5a451f..fccb84a 100644
--- a/package.json
+++ b/package.json
@@ -10,7 +10,9 @@
   "dependencies": {
     "@types/remark-prism": "^1.3.0",
     "clsx": "^1.1.1",
+    "date-fns": "^2.28.0",
     "gray-matter": "^4.0.3",
+    "jotai": "^1.6.7",
     "next": "12.0.9",
     "next-mdx-remote": "^3.0.8",
     "prism-theme-night-owl": "^1.4.0",
diff --git a/styles/Layout.module.css b/styles/Layout.module.css
index 1a1545c..2dd2ce3 100644
--- a/styles/Layout.module.css
+++ b/styles/Layout.module.css
@@ -26,7 +26,7 @@
   padding-top: 0;
 }
 
-.main time {
+.main > time {
   opacity: 0.7;
 }
 
diff --git a/tsconfig.json b/tsconfig.json
index 99710e8..0f293bd 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -5,6 +5,8 @@
     "allowJs": true,
     "skipLibCheck": true,
     "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
     "forceConsistentCasingInFileNames": true,
     "noEmit": true,
     "esModuleInterop": true,
diff --git a/yarn.lock b/yarn.lock
index b5a9d24..979e11a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -880,6 +880,11 @@ data-urls@^2.0.0:
     whatwg-mimetype "^2.3.0"
     whatwg-url "^8.0.0"
 
+date-fns@^2.28.0:
+  version "2.28.0"
+  resolved "https://registry.yarnpkg.com/date-fns/-/date-fns-2.28.0.tgz#9570d656f5fc13143e50c975a3b6bbeb46cd08b2"
+  integrity sha512-8d35hViGYx/QH0icHYCeLmsLmMUheMmTyV9Fcm6gvNwdw31yXXH+O85sOBJ+OLnLQMKZowvpKb6FgMIQjcpvQw==
+
 debug@4, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1, debug@^4.3.2:
   version "4.3.3"
   resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.3.tgz#04266e0b70a98d4462e6e288e38259213332b664"
@@ -1809,6 +1814,11 @@ isexe@^2.0.0:
   resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
   integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=
 
+jotai@^1.6.7:
+  version "1.6.7"
+  resolved "https://registry.yarnpkg.com/jotai/-/jotai-1.6.7.tgz#d5bdc747b66e369f1d1e859dad8bcda85acb946f"
+  integrity sha512-MxAm86FYHm6asU3O1hbTKOWpPMP5oI8zNlgFRpZBB85cX79psF2eRb7ZqdGewOgYUUUKAlzZ+sH0IM7Pea6MkA==
+
 "js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"