@turnipxenon/pineapple 2.2.1 → 2.4.1

package/.svelte-kit/__package__/components/ElementVisbilityDetector.svelte

@@ -0,0 +1,18 @@
+<script>import { onMount } from "svelte";
+export let isVisible = true;
+let stickyElem;
+let observer;
+onMount(() => {
+  observer = new IntersectionObserver(
+    ([e]) => {
+      isVisible = e.intersectionRatio >= 1;
+    },
+    { threshold: [1] }
+  );
+  observer.observe(stickyElem);
+});
+</script>
+
+<span bind:this={stickyElem}>
+	<slot/>
+</span>

package/.svelte-kit/__package__/components/ElementVisbilityDetector.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        isVisible?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type ElementVisbilityDetectorProps = typeof __propDef.props;
+export type ElementVisbilityDetectorEvents = typeof __propDef.events;
+export type ElementVisbilityDetectorSlots = typeof __propDef.slots;
+export default class ElementVisbilityDetector extends SvelteComponent<ElementVisbilityDetectorProps, ElementVisbilityDetectorEvents, ElementVisbilityDetectorSlots> {
+}
+export {};

package/.svelte-kit/__package__/components/LazyAsset.svelte

@@ -0,0 +1,96 @@
+<script>import { LazyAssetStatus, LazyAssetType } from "./LazyAssetType";
+import BgTiledAres from "../assets/bg_tiled/bg_tiled_ares.png";
+import { onMount } from "svelte";
+export let src;
+export let alt;
+export let width;
+export let height;
+export let props = {};
+props = {
+  ...props,
+  alt,
+  width,
+  height
+};
+let extension = "";
+const getAssetType = () => {
+  const srcArray = src.split(".");
+  extension = srcArray[srcArray.length - 1];
+  switch (extension) {
+    case "png":
+    case "webp":
+    case "gif":
+    case "jpg":
+      return LazyAssetType.Image;
+    case "ogg":
+    case "webm":
+    case "mp4":
+      return LazyAssetType.Video;
+    default:
+      console.log(`Unknown asset type for: ${src}`);
+      return LazyAssetType.Unknown;
+  }
+};
+const assetType = getAssetType();
+let actualSrc = "";
+let status = LazyAssetStatus.Loading;
+onMount(async () => {
+  const path = src.includes("https://") ? src : `${window.location.origin}${src}`;
+  switch (assetType) {
+    case LazyAssetType.Image: {
+      const img = new Image();
+      img.onload = () => {
+        actualSrc = path;
+        status = LazyAssetStatus.Loaded;
+      };
+      img.src = path;
+      break;
+    }
+    case LazyAssetType.Video: {
+      fetch(path).then((resp) => resp.blob()).then((blob) => {
+        actualSrc = URL.createObjectURL(blob);
+        status = LazyAssetStatus.Loaded;
+      }).catch((error) => {
+        console.warn(error);
+        status = LazyAssetStatus.Error;
+      });
+      break;
+    }
+    case LazyAssetType.Unknown: {
+      console.warn("Unknown asset: ", path);
+      status = LazyAssetStatus.Error;
+      break;
+    }
+  }
+});
+</script>
+
+{#if status === LazyAssetStatus.Loaded}
+	{#if assetType === LazyAssetType.Image}
+		<img src={actualSrc} alt="Placeholder image" {...props} />
+	{:else if assetType === LazyAssetType.Video}
+		<video playsinline autoplay muted loop {...props} poster={BgTiledAres} style="object-fit: scale-down">
+			<source src={actualSrc} type={`video/${extension}`} />
+			Your browser does not support the video tag.
+		</video>
+	{:else}
+		<img src={actualSrc} alt="Placeholder image" />
+	{/if}
+{:else}
+	<img class="rotate" src={BgTiledAres} {...props} style="object-fit: scale-down" />
+{/if}
+
+<style>
+    .rotate {
+        animation: rotation 4s infinite linear;
+    }
+
+    @keyframes rotation {
+        from {
+            transform: rotate(0deg);
+        }
+        to {
+            transform: rotate(359deg);
+        }
+    }
+</style>

package/.svelte-kit/__package__/components/LazyAsset.svelte.d.ts

@@ -0,0 +1,20 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        src: string;
+        alt: string;
+        width: string;
+        height: string;
+        props?: {} | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type LazyAssetProps = typeof __propDef.props;
+export type LazyAssetEvents = typeof __propDef.events;
+export type LazyAssetSlots = typeof __propDef.slots;
+export default class LazyAsset extends SvelteComponent<LazyAssetProps, LazyAssetEvents, LazyAssetSlots> {
+}
+export {};

package/.svelte-kit/__package__/components/LazyAssetType.d.ts

@@ -0,0 +1,10 @@
+export declare enum LazyAssetType {
+    Image = 0,
+    Video = 1,
+    Unknown = 2
+}
+export declare enum LazyAssetStatus {
+    Loading = 0,
+    Loaded = 1,
+    Error = 2
+}

package/.svelte-kit/__package__/components/LazyAssetType.js

@@ -0,0 +1,12 @@
+export var LazyAssetType;
+(function (LazyAssetType) {
+    LazyAssetType[LazyAssetType["Image"] = 0] = "Image";
+    LazyAssetType[LazyAssetType["Video"] = 1] = "Video";
+    LazyAssetType[LazyAssetType["Unknown"] = 2] = "Unknown";
+})(LazyAssetType || (LazyAssetType = {}));
+export var LazyAssetStatus;
+(function (LazyAssetStatus) {
+    LazyAssetStatus[LazyAssetStatus["Loading"] = 0] = "Loading";
+    LazyAssetStatus[LazyAssetStatus["Loaded"] = 1] = "Loaded";
+    LazyAssetStatus[LazyAssetStatus["Error"] = 2] = "Error";
+})(LazyAssetStatus || (LazyAssetStatus = {}));

package/.svelte-kit/__package__/components/OnElementVisbilityChanged.d.ts

@@ -0,0 +1 @@
+export type OnElementVisibilityChanged = (isVisible: boolean) => void;

package/.svelte-kit/__package__/components/OnElementVisbilityChanged.js

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

package/.svelte-kit/__package__/components/RandomizedBackground.svelte

@@ -0,0 +1,64 @@
+<script>import { generatedDailySeed, mulberry32Generator } from "../util/stable_random";
+import BgTiledAres from "../assets/bg_tiled/bg_tiled_ares.png";
+import BgTiledCorn from "../assets/bg_tiled/bg_tiled_corn.png";
+import BgTiledPineapple from "../assets/bg_tiled/bg_tiled_pineapple.png";
+import BgTiledReinhard from "../assets/bg_tiled/bg_tiled_reinhard.png";
+import BgTiledTomato from "../assets/bg_tiled/bg_tiled_tomato.png";
+import BgTiledTurnip from "../assets/bg_tiled/bg_tiled_turnip.png";
+import RandomizedImage from "./RandomizedImage.svelte";
+export let enable;
+const imageList = [BgTiledAres, BgTiledCorn, BgTiledPineapple, BgTiledReinhard, BgTiledTomato, BgTiledTurnip];
+const seed = generatedDailySeed();
+const rng = mulberry32Generator(seed);
+const shuffle = (array) => {
+  let currentIndex = array.length, randomIndex;
+  while (currentIndex != 0) {
+    randomIndex = Math.floor(rng() * currentIndex);
+    currentIndex--;
+    [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
+  }
+  return array;
+};
+let generatedImageList = [];
+for (let i = 0; i < 20; i++) {
+  shuffle(imageList);
+  generatedImageList = generatedImageList.concat(imageList);
+}
+</script>
+
+<svelte:head>
+	<!-- from: https://dev.to/khromov/preloading-images-in-svelte-465h	-->
+	{#each imageList as image}
+		<link rel="preload" as="image" href={image} />
+	{/each}
+	<link
+		as="video"
+		href="https://video.twimg.com/ext_tw_video/1318728494256410624/pu/vid/640x360/TMklz6hiTkQu3xhn.mp4"
+		rel="preload"
+	/>
+</svelte:head>
+
+<!--todo: add a letterbox beyond 1960px + 16 rem-->
+{#if enable}
+	<div class="default-background" aria-hidden="true">
+		{#each generatedImageList as imageItem}
+			<svelte:component this={RandomizedImage} src={imageItem} {rng} />
+		{/each}
+	</div>
+{/if}
+
+<style>
+    .default-background {
+        position: fixed;
+        display: flex;
+        top: -8rem;
+        left: 50%;
+        transform: translate(-50%, 0);
+        width: calc(100vw + 16rem);
+        max-width: 1960px;
+        height: calc(100vh + 16rem);
+        flex-wrap: wrap;
+        overflow: hidden;
+        z-index: -10;
+    }
+</style>

package/.svelte-kit/__package__/components/RandomizedBackground.svelte.d.ts

@@ -0,0 +1,16 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        enable: any;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type RandomizedBackgroundProps = typeof __propDef.props;
+export type RandomizedBackgroundEvents = typeof __propDef.events;
+export type RandomizedBackgroundSlots = typeof __propDef.slots;
+export default class RandomizedBackground extends SvelteComponent<RandomizedBackgroundProps, RandomizedBackgroundEvents, RandomizedBackgroundSlots> {
+}
+export {};

package/.svelte-kit/__package__/components/RandomizedImage.svelte

@@ -0,0 +1,37 @@
+<script>import { modeCurrent } from "@skeletonlabs/skeleton";
+export let src;
+export let rng;
+let rotateRandom = rng() * 90 - 45;
+const paddingLeft = 1 + rng() * 5;
+const paddingRight = 1 + rng() * 5;
+const paddingTop = 1 + rng() * 7;
+</script>
+
+<div
+	style="--paddingTop: {paddingTop}rem;
+        --paddingLeft: {paddingLeft}rem;
+        --paddingRight: {paddingRight}rem;">
+	<img {src} class="randomized-image-style"
+	     aria-hidden="true"
+	     style="--rotateRandom:{rotateRandom}deg;"
+	     alt=""
+	     class:darkMode={modeCurrent} />
+</div>
+
+<style>
+    div {
+        padding-top: var(--paddingTop);
+        padding-left: var(--paddingLeft);
+        padding-right: var(--paddingRight);
+    }
+
+    img {
+        width: 8rem;
+        height: 8rem;
+        transform: rotate(var(--rotateRandom));
+    }
+
+    .darkMode {
+        filter: brightness(50%);
+    }
+</style>

package/.svelte-kit/__package__/components/RandomizedImage.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        src: string;
+        rng: () => number;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type RandomizedImageProps = typeof __propDef.props;
+export type RandomizedImageEvents = typeof __propDef.events;
+export type RandomizedImageSlots = typeof __propDef.slots;
+export default class RandomizedImage extends SvelteComponent<RandomizedImageProps, RandomizedImageEvents, RandomizedImageSlots> {
+}
+export {};

package/.svelte-kit/__package__/components/SocialSection.svelte

@@ -0,0 +1,160 @@
+<script>
+	import MailIcon from "../assets/icons/mail.svg";
+	import GithubIcon from "../assets/icons/github-mark.svg";
+	import { ItchLogoHotLink } from "../consts";
+	import LinkedinIcon from "../assets/icons/linkedin.svg";
+	import { onMount } from "svelte";
+
+	export let isSmallVersion = false;
+	export let email = "turnipxenon@gmail.com";
+	export let linkedinSlug = "turnip-xenon";
+	export let isSlot = false;
+
+	let shouldShowExtra = false;
+	const style = `
+		--preferred-justify-content: ${isSlot ? "flex-start" : "center"};
+		--preferred-overall-margin-bottom: ${isSlot ? "0" : "0.75lh"};
+	`;
+
+	onMount(() => {
+		shouldShowExtra = window.screen.availWidth >= 440;
+	});
+</script>
+
+<div class="socials" class:isSmall={isSmallVersion} style={style}>
+	<button type="button" class="social-button turnip-button"
+	        role="link"
+	        title="https://github.com/TurnipXenon"
+	        on:click={() => window.open("https://github.com/TurnipXenon")}>
+		<img src={GithubIcon} alt="github icon">
+		{#if (!isSmallVersion)}
+			<span>TurnipXenon</span>
+		{/if}
+	</button>
+	<button type="button" class="social-button turnip-button"
+	        role="link"
+	        title={`https://www.linkedin.com/in/${linkedinSlug}/`}
+	        on:click={() => window.open(`https://www.linkedin.com/in/${linkedinSlug}/`)}>
+		<img src={LinkedinIcon} alt="linkedikn icon">
+		{#if (!isSmallVersion)}
+			<span>{linkedinSlug}</span>
+		{/if}
+	</button>
+	<button type="button" class="social-button turnip-button"
+	        role="link"
+	        title={`mailto:${email}`}
+	        on:click={() => window.open(`mailto:${email}`)}>
+		<img src={MailIcon} alt="mail icon" />
+		{#if (!isSmallVersion)}
+			<span>{email}</span>
+		{/if}
+	</button>
+	{#if (shouldShowExtra)}
+		<button type="button" class="social-button turnip-button"
+		        role="link"
+		        title="https://turnipxenon.itch.io/"
+		        on:click={() => window.open("https://turnipxenon.itch.io/")}>
+			<img src={ItchLogoHotLink} alt="itch icon">
+			{#if (!isSmallVersion)}
+				<span>TurnipXenon</span>
+			{/if}
+		</button>
+	{/if}
+</div>
+
+<style>
+    :is(.dark .social-button) {
+        --tw-bg-opacity: 1;
+        background-color: rgb(var(--color-primary-500) / var(--tw-bg-opacity));
+        color: rgb(var(--on-primary));
+}
+
+.social-button:disabled {
+        cursor: not-allowed;
+        opacity: 0.5;
+}
+
+.social-button:disabled:hover {
+        --tw-brightness: brightness(1);
+        filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
+}
+
+.social-button:disabled:active {
+        --tw-scale-x: 1;
+        --tw-scale-y: 1;
+        transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));
+}
+
+.social-button {
+        font-size: 1rem;
+        line-height: 1.5rem;
+        padding-left: 1.25rem;
+        padding-right: 1.25rem;
+        padding-top: 9px;
+        padding-bottom: 9px;
+        white-space: nowrap;
+        text-align: center;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        transition-property: all;
+        transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+        transition-duration: 150ms;
+        border-radius: var(--theme-rounded-base);
+}
+
+.social-button > :not([hidden]) ~ :not([hidden]) {
+        --tw-space-x-reverse: 0;
+        margin-right: calc(0.5rem * var(--tw-space-x-reverse));
+        margin-left: calc(0.5rem * calc(1 - var(--tw-space-x-reverse)));
+}
+
+.social-button:hover {
+        --tw-brightness: brightness(1.15);
+        filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
+}
+
+.social-button:active {
+        --tw-scale-x: 95%;
+        --tw-scale-y: 95%;
+        transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));
+        --tw-brightness: brightness(.9);
+        filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
+}
+
+.social-button {
+        --tw-bg-opacity: 1;
+        background-color: rgb(var(--color-primary-500) / var(--tw-bg-opacity));
+        color: rgb(var(--on-primary));
+}
+
+:is(.dark .social-button) {
+        --tw-bg-opacity: 1;
+        background-color: rgb(var(--color-primary-500) / var(--tw-bg-opacity));
+        color: rgb(var(--on-primary));
+}
+
+    button > img {
+        max-height: 1lh;
+    }
+
+    button {
+        min-width: 0;
+        min-height: 0;
+    }
+
+    .socials {
+        display: flex;
+        flex-wrap: wrap;
+        justify-content: var(--preferred-justify-content);
+    }
+
+    .socials > button {
+        margin: 0 0.5em var(--preferred-overall-margin-bottom);
+    }
+
+    .socials.isSmall > button {
+        margin-left: 0.25em;
+        margin-right: 0.25em;
+    }
+</style>

package/.svelte-kit/__package__/components/SocialSection.svelte.d.ts

@@ -0,0 +1,29 @@
+/** @typedef {typeof __propDef.props}  SocialSectionProps */
+/** @typedef {typeof __propDef.events}  SocialSectionEvents */
+/** @typedef {typeof __propDef.slots}  SocialSectionSlots */
+export default class SocialSection extends SvelteComponent<{
+    isSmallVersion?: boolean | undefined;
+    email?: string | undefined;
+    linkedinSlug?: string | undefined;
+    isSlot?: boolean | undefined;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}> {
+}
+export type SocialSectionProps = typeof __propDef.props;
+export type SocialSectionEvents = typeof __propDef.events;
+export type SocialSectionSlots = typeof __propDef.slots;
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        isSmallVersion?: boolean | undefined;
+        email?: string | undefined;
+        linkedinSlug?: string | undefined;
+        isSlot?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export {};

package/.svelte-kit/__package__/components/StickyElement.svelte

@@ -0,0 +1,36 @@
+<script>import { onMount } from "svelte";
+import { fly } from "svelte/transition";
+export let isFirst = false;
+let stickyElem;
+let isSticky = false;
+let observer;
+onMount(() => {
+  observer = new IntersectionObserver(
+    ([e]) => {
+      isSticky = e.intersectionRatio < 1;
+    },
+    { threshold: [1] }
+  );
+  observer.observe(stickyElem);
+});
+</script>
+
+<span transition:fly={{y: -100}}>
+{#if (isFirst && !isSticky)}
+	<!-- intentionally empty -->
+{:else if (isSticky)}
+	{" | "}
+{:else }
+	<br>
+{/if}
+	<span class="sticky-div" bind:this={stickyElem}>
+		<slot/>
+	</span>
+</span>
+
+<style>
+    .sticky-div {
+        position: sticky;
+        top: -1px;
+    }
+</style>

package/.svelte-kit/__package__/components/StickyElement.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        isFirst?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type StickyElementProps = typeof __propDef.props;
+export type StickyElementEvents = typeof __propDef.events;
+export type StickyElementSlots = typeof __propDef.slots;
+export default class StickyElement extends SvelteComponent<StickyElementProps, StickyElementEvents, StickyElementSlots> {
+}
+export {};

package/.svelte-kit/__package__/components/ToggleableContent.svelte

@@ -0,0 +1,66 @@
+<script>import { ToggleableContentType } from "./ToggleableContentType";
+import { afterUpdate, onMount } from "svelte";
+export let toggle = ToggleableContentType.Default;
+var GibberishState = /* @__PURE__ */ ((GibberishState2) => {
+  GibberishState2[GibberishState2["NonExistent"] = 0] = "NonExistent";
+  GibberishState2[GibberishState2["CreatingParent"] = 1] = "CreatingParent";
+  GibberishState2[GibberishState2["Binded"] = 2] = "Binded";
+  return GibberishState2;
+})(GibberishState || {});
+let defaultSlot = void 0;
+let gibberishState = 0 /* NonExistent */;
+let gibberishParent;
+let gibberishSlot;
+const chaoticWordBank = ["niko", "toba", "seal", "aquarium", "ojisan", "baikal"];
+const turnToGibberish = (node) => {
+  for (const childNodes of node.childNodes) {
+    turnToGibberish(childNodes);
+  }
+  if (node.nodeType === Node.TEXT_NODE && node.textContent?.trim()) {
+    const max = node.textContent.length;
+    node.textContent = "";
+    while (node.textContent.length < max) {
+      node.textContent += chaoticWordBank[Math.floor(Math.random() * chaoticWordBank.length)] + " ";
+    }
+  }
+};
+const processDefaultSlot = (slot) => {
+  if (!slot || toggle == ToggleableContentType.Default) {
+    return;
+  }
+  turnToGibberish(slot);
+};
+const attachGibberish = (parent) => {
+  console.log("Help");
+  if (gibberishState !== 1 /* CreatingParent */ && parent !== void 0) {
+    return;
+  }
+  console.log("Help1");
+  if (gibberishSlot === void 0) {
+    console.warn("Gibberish slot was not created");
+    return;
+  }
+  console.log("Help2");
+  if (gibberishParent === void 0) {
+    console.warn("Gibberish parent was not created");
+    return;
+  }
+  console.log("Help3");
+  gibberishParent.appendChild(gibberishSlot);
+  console.log(gibberishParent);
+  gibberishState = 2 /* Binded */;
+};
+onMount(() => {
+  processDefaultSlot(defaultSlot);
+});
+$:
+  attachGibberish(gibberishParent);
+</script>
+
+{#if toggle === ToggleableContentType.Default}
+	<slot />
+{:else if (ToggleableContentType.Gibberish === toggle)}
+	<div bind:this={defaultSlot} style={`visibility: ${gibberishState === GibberishState.Binded}`}>
+		<slot />
+	</div>
+{/if}

package/.svelte-kit/__package__/components/ToggleableContent.svelte.d.ts

@@ -0,0 +1,19 @@
+import { SvelteComponent } from "svelte";
+import { ToggleableContentType } from "./ToggleableContentType";
+declare const __propDef: {
+    props: {
+        toggle?: ToggleableContentType | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type ToggleableContentProps = typeof __propDef.props;
+export type ToggleableContentEvents = typeof __propDef.events;
+export type ToggleableContentSlots = typeof __propDef.slots;
+export default class ToggleableContent extends SvelteComponent<ToggleableContentProps, ToggleableContentEvents, ToggleableContentSlots> {
+}
+export {};

package/.svelte-kit/__package__/components/ToggleableContentType.d.ts

@@ -0,0 +1,4 @@
+export declare enum ToggleableContentType {
+    Default = 0,
+    Gibberish = 1
+}

package/.svelte-kit/__package__/components/ToggleableContentType.js

@@ -0,0 +1,5 @@
+export var ToggleableContentType;
+(function (ToggleableContentType) {
+    ToggleableContentType[ToggleableContentType["Default"] = 0] = "Default";
+    ToggleableContentType[ToggleableContentType["Gibberish"] = 1] = "Gibberish";
+})(ToggleableContentType || (ToggleableContentType = {}));