a4-sophia-silkaitis

.firebase/hosting.YnVpbGQ.cache

@@ -0,0 +1,18 @@
+favicon.ico,1591988602000,12c77055696278694a8feb77a9421dd85f8af25a81d812822be112e4be628fcf
+github-icon.svg,1591988602000,c0af81355c00e551a44497c9a02d232ece8fcf0c6e7850809b6d0ab94769d50c
+ig-icon.svg,1591988602000,135d9239b7e214b58c5dc1e66153d62a7020d145ef0305bba198294a1cb54ae6
+index.html,1591988602000,bc56b924fd91469b71bd4240f43c2f9d64118c284c12aee19b4938ce85f84115
+linkedin-icon.svg,1591988602000,648a9ac3627cf9018dc3aa0b8ef74edcea2f9a5df1957d2196c8c7a7bbf77754
+personal-icon.svg,1591988602000,cf3af5f917bedcbe07dc0c8cb37a9e69c3f954d56bf980057a31e6ad54126449
+robots.txt,1591988602000,2544ca049f223a42bff01f72ad930a5edba75bbb7199d0f8430a02ff5aca16ec
+twitter-icon.svg,1591988602000,347e6560fbda375ad29a563ec0ed8a37f77c2cb1894b06f91c30a8e6ed5409e9
+up-icon.svg,1591988602000,a9d3df26b9f5bc7dc081f1cd17bc2e8ce8b7c1150e53ba71e0401be76a458999
+__snowpack__/env.js,1591988602000,1d1dbb381f9b947445d25149d947ba44e5caea73c4c266e433204b076e56cd8c
+js/bundle-0d765c9988f643d1b0bb.js.LICENSE.txt,1591988602000,709256af082b4849ab1027d627978fd0eaa3a3713bf0f6d7ca428e06b62caa9f
+iso-bold.woff,1591988602000,89ca7fa2e8df3df17d38bccabd0ea289c166f241e1685761fda906ed70289bdf
+iso-black.woff,1591988602000,74d87b403fe97d10edc3419da0cc9cd3353357bf7a271a2560dca5cc42519def
+iso-regular.woff,1591988602000,d0e3eff9ffcbbd00c9e54f225c0bcf36edfedfdb9f9a05633616a7d4b25d081c
+sample-photo.png,1591988602000,7b5f5cf23cf6d11d9d2be32a48d0f586abfada94a04829692581fd18cea8a50b
+css/style-0d765c9988f643d1b0bb.css,1591988602000,2720d86c22eaa5830ac2f7bc6bd0222da1aba7b2b073c6d16070bd071e9278de
+js/bundle-0d765c9988f643d1b0bb.js,1591988602000,4b82a042696d9df73a5eaa980171c445d6d2888219d51eb0eb6cc7e3e36a5126
+fish.svg,1591988602000,1cef12be60db4901818a0d9626d34248a13d7449d348d51dbcf71cf246f539fd

.gitignore

@@ -0,0 +1 @@
+build

.pm2/module_conf.json

@@ -0,0 +1 @@
+{}

.pm2/touch

@@ -0,0 +1 @@
+1603065323401

.snowpack/.snowpack/types/canvas-confetti/index.d.ts

@@ -0,0 +1,141 @@
+// Type definitions for canvas-confetti 1.3
+// Project: https://github.com/catdad/canvas-confetti#readme
+// Definitions by: Martin Tracey <https://github.com/matracey>
+//                 Josh Batley <https://github.com/joshbatley>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/**
+ * `confetti` takes a single optional object. When `window.Promise` is available, it will return a Promise to let you know when it is done. When promises are not available (like in IE), it will return
+ * `null`. You can polyfill promises using any of the popular polyfills. You can also provide a custom promise implementation to `confetti` through:
+ *
+ * `const MyPromise = require('some-promise-lib');
+ *  const confetti = require('canvas-confetti');
+ *  confetti.Promise = MyPromise;`
+ *
+ * If you call `confetti` multiple times before it is done, it
+ * will return the same promise every time. Internally, the same canvas element will be reused, continuing the existing animation with the new confetti added. The promise returned by each call to
+ * `confetti` will resolve once all animations are done.
+ *
+ */
+declare function confetti(options?: confetti.Options): Promise<null> | null;
+
+declare namespace confetti {
+    /**
+     * You can polyfill promises using any of the popular polyfills. You can also provide a promise implementation to `confetti` through this property.
+     */
+    let Promise: any;
+
+    type shape = 'square' | 'circle';
+
+    interface Options {
+        /**
+         * The number of confetti to launch. More is always fun... but be cool, there's a lot of math involved.
+         * @default 50
+         */
+        particleCount?: number;
+        /**
+         * The angle in which to launch the confetti, in degrees. 90 is straight up.
+         * @default 90
+         */
+        angle?: number;
+        /**
+         * How far off center the confetti can go, in degrees. 45 means the confetti will launch at the defined angle plus or minus 22.5 degrees.
+         * @default 45
+         */
+        spread?: number;
+        /**
+         * How fast the confetti will start going, in pixels.
+         * @default 45
+         */
+        startVelocity?: number;
+        /**
+         * How quickly the confetti will lose speed. Keep this number between 0 and 1, otherwise the confetti will gain speed. Better yet, just never change it.
+         * @default 0.9
+         */
+        decay?: number;
+        /**
+         * How many times the confetti will move. This is abstract... but play with it if the confetti disappear too quickly for you.
+         * @default 200
+         */
+        ticks?: number;
+        /**
+         * Where to start firing confetti from. Feel free to launch off-screen if you'd like.
+         */
+        origin?: Origin;
+        /**
+         * An array of color strings, in the HEX format... you know, like #bada55.
+         */
+        colors?: string[];
+        /**
+         * The possible values are square and circle. The default is to use both shapes in an even mix.
+         * @default ['square','circle']
+         */
+        shapes?: shape[];
+        /**
+         * The confetti should be on top, after all. But if you have a crazy high page, you can set it even higher.
+         * @default 100
+         */
+        zIndex?: number;
+        /**
+         * Scale factor for each confetti particle. Use decimals to make the confetti smaller.
+         * @default 1
+         */
+        scalar?: number;
+        /**
+         * How quickly the particles are pulled down. 1 is full gravity, 0.5 is half gravity, etc., but there are no limits.
+         * @default 1
+         */
+        gravity?: number;
+        /**
+         * Disables confetti entirely for users that prefer reduced motion. The confetti() promise will resolve immediately in this case.
+         * @default false
+         */
+        disableForReducedMotion?: boolean;
+    }
+
+    interface Origin {
+        /**
+         * The x position on the page, with 0 being the left edge and 1 being the right edge.
+         * @default 0.5
+         */
+        x?: number;
+        /**
+         * The y position on the page, with 0 being the left edge and 1 being the right edge.
+         * @default 0.5
+         */
+        y?: number;
+    }
+
+    interface GlobalOptions {
+        /**
+         * Whether to allow setting the canvas image size, as well as keep it correctly sized if the window changes size
+         * @default false
+         */
+        resize?: boolean;
+        /**
+         * Whether to use an asynchronous web worker to render the confetti animation, whenever possible
+         * @default false
+         */
+        useWorker?: boolean;
+    }
+
+    /**
+     * Stops the animation and clears all confetti, as well as immediately resolves any outstanding promises.
+     */
+    type Reset = () => void;
+    function reset(): Reset;
+
+    interface CreateTypes {
+        (options?: Options): () => Promise<null> | null;
+        reset: Reset;
+    }
+    /**
+     * This method creates an instance of the confetti function that uses a custom canvas.
+     */
+    function create(
+        canvas: HTMLCanvasElement,
+        options?: GlobalOptions
+    ): CreateTypes;
+}
+
+export = confetti;

.snowpack/.snowpack/types/canvas-confetti/package.json

@@ -0,0 +1 @@
+{"types": "index.d.ts"}

.snowpack/.snowpack/types/react-dom/experimental.d.ts

@@ -0,0 +1,87 @@
+/**
+ * These are types for things that are present in the `experimental` builds of React but not yet
+ * on a stable build.
+ *
+ * Once they are promoted to stable they can just be moved to the main index file.
+ *
+ * To load the types declared here in an actual project, there are three ways. The easiest one,
+ * if your `tsconfig.json` already has a `"types"` array in the `"compilerOptions"` section,
+ * is to add `"react-dom/experimental"` to the `"types"` array.
+ *
+ * Alternatively, a specific import syntax can to be used from a typescript file.
+ * This module does not exist in reality, which is why the {} is important:
+ *
+ * ```ts
+ * import {} from 'react-dom/experimental'
+ * ```
+ *
+ * It is also possible to include it through a triple-slash reference:
+ *
+ * ```ts
+ * /// <reference types="react-dom/experimental" />
+ * ```
+ *
+ * Either the import or the reference only needs to appear once, anywhere in the project.
+ */
+
+// See https://github.com/facebook/react/blob/master/packages/react-dom/src/client/ReactDOM.js to see how the exports are declared,
+// and https://github.com/facebook/react/blob/master/packages/shared/ReactFeatureFlags.js to verify which APIs are
+// flagged experimental or not. Experimental APIs will be tagged with `__EXPERIMENTAL__`.
+
+import React = require('react');
+import ReactDOM = require('.');
+
+export {};
+
+declare module '.' {
+    // enableSuspenseServerRenderer feature
+    interface HydrationOptions {
+        onHydrated?(suspenseInstance: Comment): void;
+        onDeleted?(suspenseInstance: Comment): void;
+    }
+
+    // exposeConcurrentModeAPIs features
+
+    interface RootOptions {
+        hydrate?: boolean;
+        hydrationOptions?: HydrationOptions;
+    }
+
+    interface Root {
+        render(children: React.ReactChild | React.ReactNodeArray, callback?: () => void): void;
+        unmount(callback?: () => void): void;
+    }
+
+    /**
+     * Replaces `ReactDOM.render` when the `.render` method is called and enables Blocking Mode.
+     *
+     * Opting into Concurrent Mode introduces semantic changes to how React works.
+     * This means that you can’t use Concurrent Mode in just a few components.
+     * Because of this, some apps may not be able to migrate directly to Concurrent Mode.
+     * Blocking Mode only contains a small subset of Concurrent Mode features and is intended
+     * as an intermediary migration step for apps that are unable to migrate directly.
+     *
+     * @see https://reactjs.org/docs/concurrent-mode-adoption.html#migration-step-blocking-mode
+     * @see https://reactjs.org/docs/concurrent-mode-reference.html#createblockingroot
+     */
+    function unstable_createBlockingRoot(
+        container: Element | Document | DocumentFragment | Comment,
+        options?: RootOptions,
+    ): Root;
+
+    /**
+     * Replaces `ReactDOM.render` when the `.render` method is called and enables Concurrent Mode.
+     *
+     * @see https://reactjs.org/docs/concurrent-mode-reference.html#createroot
+     */
+    function unstable_createRoot(container: Element | Document | DocumentFragment | Comment, options?: RootOptions): Root;
+
+    function unstable_flushControlled(callback: () => void): void;
+
+    // enableSelectiveHydration feature
+
+    /**
+     * @see https://github.com/facebook/react/commit/3a2b5f148d450c69aab67f055fc441d294c23518
+     */
+    function unstable_scheduleHydration(target: Element | Document | DocumentFragment | Comment): void;
+}

.snowpack/.snowpack/types/react-dom/index.d.ts

@@ -0,0 +1,98 @@
+// Type definitions for React (react-dom) 17.0
+// Project: https://reactjs.org
+// Definitions by: Asana <https://asana.com>
+//                 AssureSign <http://www.assuresign.com>
+//                 Microsoft <https://microsoft.com>
+//                 MartynasZilinskas <https://github.com/MartynasZilinskas>
+//                 Josh Rutherford <https://github.com/theruther4d>
+//                 Jessica Franco <https://github.com/Jessidhia>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+// NOTE: Users of the `experimental` builds of React should add a reference
+// to 'react-dom/experimental' in their project. See experimental.d.ts's top comment
+// for reference and documentation on how exactly to do it.
+
+export as namespace ReactDOM;
+
+import {
+    ReactInstance, Component, ComponentState,
+    ReactElement, SFCElement, CElement,
+    DOMAttributes, DOMElement, ReactNode, ReactPortal
+} from 'react';
+
+export function findDOMNode(instance: ReactInstance | null | undefined): Element | null | Text;
+export function unmountComponentAtNode(container: Element | DocumentFragment): boolean;
+
+export function createPortal(children: ReactNode, container: Element, key?: null | string): ReactPortal;
+
+export const version: string;
+export const render: Renderer;
+export const hydrate: Renderer;
+
+export function unstable_batchedUpdates<A, B>(callback: (a: A, b: B) => any, a: A, b: B): void;
+export function unstable_batchedUpdates<A>(callback: (a: A) => any, a: A): void;
+export function unstable_batchedUpdates(callback: () => any): void;
+
+export function unstable_renderSubtreeIntoContainer<T extends Element>(
+    parentComponent: Component<any>,
+    element: DOMElement<DOMAttributes<T>, T>,
+    container: Element,
+    callback?: (element: T) => any): T;
+export function unstable_renderSubtreeIntoContainer<P, T extends Component<P, ComponentState>>(
+    parentComponent: Component<any>,
+    element: CElement<P, T>,
+    container: Element,
+    callback?: (component: T) => any): T;
+export function unstable_renderSubtreeIntoContainer<P>(
+    parentComponent: Component<any>,
+    element: ReactElement<P>,
+    container: Element,
+    callback?: (component?: Component<P, ComponentState> | Element) => any): Component<P, ComponentState> | Element | void;
+
+export interface Renderer {
+    // Deprecated(render): The return value is deprecated.
+    // In future releases the render function's return type will be void.
+
+    <T extends Element>(
+        element: DOMElement<DOMAttributes<T>, T>,
+        container: Element | DocumentFragment | null,
+        callback?: () => void
+    ): T;
+
+    (
+        element: Array<DOMElement<DOMAttributes<any>, any>>,
+        container: Element | DocumentFragment | null,
+        callback?: () => void
+    ): Element;
+
+    (
+        element: SFCElement<any> | Array<SFCElement<any>>,
+        container: Element | DocumentFragment | null,
+        callback?: () => void
+    ): void;
+
+    <P, T extends Component<P, ComponentState>>(
+        element: CElement<P, T>,
+        container: Element | DocumentFragment | null,
+        callback?: () => void
+    ): T;
+
+    (
+        element: Array<CElement<any, Component<any, ComponentState>>>,
+        container: Element | DocumentFragment | null,
+        callback?: () => void
+    ): Component<any, ComponentState>;
+
+    <P>(
+        element: ReactElement<P>,
+        container: Element | DocumentFragment | null,
+        callback?: () => void
+    ): Component<P, ComponentState> | Element | void;
+
+    (
+        element: ReactElement[],
+        container: Element | DocumentFragment | null,
+        callback?: () => void
+    ): Component<any, ComponentState> | Element | void;
+}

.snowpack/.snowpack/types/react-dom/node-stream/index.d.ts

@@ -0,0 +1,18 @@
+import { ReactElement } from 'react';
+
+/**
+ * Render a ReactElement to its initial HTML. This should only be used on the
+ * server.
+ * See https://facebook.github.io/react/docs/react-dom-stream.html#rendertostream
+ */
+export function renderToStream(element: ReactElement): any;
+
+/**
+ * Similar to renderToStream, except this doesn't create extra DOM attributes
+ * such as data-react-id that React uses internally.
+ * See https://facebook.github.io/react/docs/react-dom-stream.html#rendertostaticstream
+ */
+export function renderToStaticStream(element: ReactElement): any;
+export const version: string;
+
+export as namespace ReactDOMNodeStream;

.snowpack/.snowpack/types/react-dom/package.json

@@ -0,0 +1 @@
+{"types": "index.d.ts"}