+
+or if you prefer paypal:
+
+
+
+## Testing
+
+This project is tested with BrowserStack.
+[BrowserStack](https://www.browserstack.com/open-source) offers free web testing to open source projects, but does not support this project in any other way.
diff --git a/.obsidian/plugins/obsidian-webpage-export-master/action.yml b/.obsidian/plugins/obsidian-webpage-export-master/action.yml
new file mode 100644
index 00000000..d534b378
--- /dev/null
+++ b/.obsidian/plugins/obsidian-webpage-export-master/action.yml
@@ -0,0 +1,46 @@
+name: "Export Obsidian vault to HTML"
+description: "Exports the Obsidian vault to HTML"
+
+inputs:
+ vault:
+ description: "Path to the Obsidian vault"
+ required: true
+ default: "."
+ config:
+ description: "Path to the configuration file"
+ required: false
+ version:
+ description: "Version of the plugin"
+ required: false
+ default: "latest"
+
+outputs:
+ output:
+ description: "Path to the output folder"
+ value: ${{ steps.run-docker.outputs.output }}
+
+runs:
+ using: "composite"
+
+ steps:
+ - name: Run docker container
+ id: run-docker
+ shell: bash
+
+ run: |
+ set +e
+
+ mkdir -p ./.output
+
+ if [ -z "${{ inputs.config }}" ]; then
+ docker run --rm -v ${{ inputs.vault }}:/vault -v ./.output:/output KosmosisDire/obsidian-webpage-export:${{ inputs.version }} >> ./.log.txt
+ else
+ docker run --rm -v ${{ inputs.vault }}:/vault -v ${{ inputs.config }}:/config.json -v ./.output:/output KosmosisDire/obsidian-webpage-export:${{ inputs.version }} >> ./.log.txt
+ fi
+
+ cat ./.log.txt
+
+ if [ $? -eq 137 ]; then
+ exit 0
+ echo "output=./.output" >> $GITHUB_OUTPUT
+ fi
diff --git a/.obsidian/plugins/obsidian-webpage-export-master/assets/assets.d.ts b/.obsidian/plugins/obsidian-webpage-export-master/assets/assets.d.ts
new file mode 100644
index 00000000..41de9535
--- /dev/null
+++ b/.obsidian/plugins/obsidian-webpage-export-master/assets/assets.d.ts
@@ -0,0 +1,26 @@
+declare module "*.txt.js" {
+ const value: string
+ export default value
+}
+
+declare module "*.txt.css" {
+ const value: string
+ export default value
+}
+
+declare module "*.txt" {
+ const value: string
+ export default value
+}
+
+// binary
+declare module "*.wasm" {
+ const value: Uint8Array
+ export default value
+}
+
+declare module "*.png" {
+ const value: Uint8Array
+ export default value
+}
+
diff --git a/.obsidian/plugins/obsidian-webpage-export-master/assets/deferred.txt.css b/.obsidian/plugins/obsidian-webpage-export-master/assets/deferred.txt.css
new file mode 100644
index 00000000..c9dd415e
--- /dev/null
+++ b/.obsidian/plugins/obsidian-webpage-export-master/assets/deferred.txt.css
@@ -0,0 +1,296 @@
+/* Define default values for variables */
+body
+{
+ --line-width: 40em;
+ --line-width-adaptive: 40em;
+ --file-line-width: 40em;
+ --sidebar-width: min(20em, 80vw);
+ --collapse-arrow-size: 11px;
+ --tree-horizontal-spacing: 0.6em;
+ --tree-vertical-spacing: 0.6em;
+ --sidebar-margin: 12px;
+}
+
+/*#region Sidebars */
+
+.sidebar {
+ height: 100%;
+ min-width: calc(var(--sidebar-width) + var(--divider-width-hover));
+ max-width: calc(var(--sidebar-width) + var(--divider-width-hover));
+ font-size: 14px;
+ z-index: 10;
+
+ position: relative;
+ overflow: hidden;
+ /* overflow: clip; */
+
+ transition: min-width ease-in-out, max-width ease-in-out;
+ transition-duration: .2s;
+ contain: size;
+}
+
+.sidebar-left {
+ left: 0;
+}
+
+.sidebar-right {
+ right: 0;
+}
+
+.sidebar.is-collapsed {
+ min-width: 0;
+ max-width: 0;
+}
+
+body.floating-sidebars .sidebar {
+ position: absolute;
+}
+
+.sidebar-content {
+ height: 100%;
+ min-width: calc(var(--sidebar-width) - var(--divider-width-hover));
+ top: 0;
+ padding: var(--sidebar-margin);
+ padding-top: 4em;
+ line-height: var(--line-height-tight);
+ background-color: var(--background-secondary);
+ transition: background-color,border-right,border-left,box-shadow;
+ transition-duration: var(--color-fade-speed);
+ transition-timing-function: ease-in-out;
+ position: absolute;
+ display: flex;
+ flex-direction: column;
+}
+
+/* If the sidebar isn't collapsed the content should have the same width as it */
+.sidebar:not(.is-collapsed) .sidebar-content {
+ min-width: calc(max(100%,var(--sidebar-width)) - 3px);
+ max-width: calc(max(100%,var(--sidebar-width)) - 3px);
+}
+
+.sidebar-left .sidebar-content
+{
+ left: 0;
+ border-top-right-radius: var(--radius-l);
+ border-bottom-right-radius: var(--radius-l);
+}
+
+.sidebar-right .sidebar-content
+{
+ right: 0;
+ border-top-left-radius: var(--radius-l);
+ border-bottom-left-radius: var(--radius-l);
+}
+
+/* Hide empty sidebars */
+.sidebar:has(.sidebar-content:empty):has(.topbar-content:empty)
+{
+ display: none;
+}
+
+.sidebar-topbar {
+ height: 2em;
+ width: var(--sidebar-width);
+ top: var(--sidebar-margin);
+ padding-inline: var(--sidebar-margin);
+ z-index: 1;
+
+ position: fixed;
+ display: flex;
+ align-items: center;
+
+ transition: width ease-in-out;
+ transition-duration: inherit;
+}
+
+.sidebar.is-collapsed .sidebar-topbar {
+ width: calc(2.3em + var(--sidebar-margin) * 2);
+}
+
+.sidebar .sidebar-topbar.is-collapsed
+{
+ width: 0;
+}
+
+.sidebar-left .sidebar-topbar {
+ left: 0;
+}
+
+.sidebar-right .sidebar-topbar {
+ right: 0;
+}
+
+.topbar-content {
+ overflow: hidden;
+ overflow: clip;
+ width: 100%;
+ height: 100%;
+ display: flex;
+ align-items: center;
+ transition: inherit;
+}
+
+.sidebar.is-collapsed .topbar-content {
+ width: 0;
+ transition: inherit;
+}
+
+.clickable-icon.sidebar-collapse-icon {
+ background-color: transparent;
+ color: var(--icon-color-focused);
+ padding: 0!important;
+ margin: 0!important;
+ height: 100%!important;
+ width: 2.3em !important;
+ margin-inline: 0.14em!important;
+ position: absolute;
+}
+
+.sidebar-left .clickable-icon.sidebar-collapse-icon {
+ transform: rotateY(180deg);
+ right: var(--sidebar-margin);
+}
+
+.sidebar-right .clickable-icon.sidebar-collapse-icon {
+ transform: rotateY(180deg);
+ left: var(--sidebar-margin);
+}
+
+.clickable-icon.sidebar-collapse-icon svg.svg-icon {
+ width: 100%;
+ height: 100%;
+}
+
+.sidebar-section-header
+{
+ margin: 0 0 1em 0;
+ text-transform: uppercase;
+ letter-spacing: 0.06em;
+ font-weight: 600;
+}
+
+/*#endregion */
+
+/*#region Content / Markdown Preview View */
+
+body
+{
+ transition: background-color var(--color-fade-speed) ease-in-out;
+}
+
+.webpage-container {
+ display: flex;
+ flex-direction: row;
+ height: 100%;
+ width: 100%;
+ align-items: stretch;
+ justify-content: center;
+}
+
+.document-container
+{
+ opacity: 1;
+ flex-basis: 100%;
+ max-width: 100%;
+ width: 100%;
+ height: 100%;
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ transition: opacity 0.2s ease-in-out;
+ contain: inline-size;
+}
+
+.hide
+{
+ opacity: 0;
+ transition: opacity 0.2s ease-in-out;
+}
+
+.document-container > .markdown-preview-view
+{
+ margin: var(--sidebar-margin);
+ margin-bottom: 0;
+ width: 100%;
+ width: -webkit-fill-available;
+ width: -moz-available;
+ width: fill-available;
+ background-color: var(--background-primary);
+ transition: background-color var(--color-fade-speed) ease-in-out;
+ border-top-right-radius: var(--window-radius, var(--radius-m));
+ border-top-left-radius: var(--window-radius, var(--radius-m));
+ overflow-x: hidden !important;
+ overflow-y: auto !important;
+ display: flex !important;
+ flex-direction: column !important;
+ align-items: center !important;
+ contain: inline-size;
+}
+
+.document-container>.markdown-preview-view>.markdown-preview-sizer
+{
+ padding-bottom: 80vh !important;
+ width: 100% !important;
+ max-width: var(--line-width) !important;
+ flex-basis: var(--line-width) !important;
+ transition: background-color var(--color-fade-speed) ease-in-out;
+ contain: inline-size;
+}
+
+.view-content img:not([width]), .markdown-rendered img:not([width])
+{
+ max-width: 100%;
+ outline: none;
+}
+
+/* If the markdown view is displaying a raw file or embed then increase it's size to make everything as large as possible */
+.document-container > .view-content.embed {
+ display: flex;
+ padding: 1em;
+ height: 100%;
+ width: 100%;
+ align-items: center;
+ justify-content: center;
+}
+
+.document-container > .view-content.embed > *
+{
+ max-width: 100%;
+ max-height: 100%;
+ object-fit: contain;
+}
+
+*:has(> :is(.math, table)) {
+ overflow-x: auto !important;
+}
+
+/* For custom view exports */
+.document-container > .view-content
+{
+ overflow-x: auto;
+ contain: content;
+ padding: 0;
+ margin: 0;
+ height: 100%;
+}
+
+/*#endregion */
+
+/*#region Loading */
+
+.scroll-highlight
+{
+ position: absolute;
+ width: 100%;
+ height: 100%;
+ pointer-events: none;
+ z-index: 1000;
+ background-color: hsla(var(--color-accent-hsl),.25);
+ opacity: 0;
+ padding: 1em;
+ inset: 50%;
+ translate: -50% -50%;
+ border-radius: var(--radius-s);
+}
+
+/*#endregion */
diff --git a/.obsidian/plugins/obsidian-webpage-export-master/assets/deferred.txt.js b/.obsidian/plugins/obsidian-webpage-export-master/assets/deferred.txt.js
new file mode 100644
index 00000000..8e8b0927
--- /dev/null
+++ b/.obsidian/plugins/obsidian-webpage-export-master/assets/deferred.txt.js
@@ -0,0 +1,98 @@
+async function loadIncludes()
+{
+ if (location.protocol != "file:")
+ {
+ // replace include tags with the contents of the file
+ let includeTags = document.querySelectorAll("include");
+ for (let i = 0; i < includeTags.length; i++)
+ {
+ let includeTag = includeTags[i];
+ let includePath = includeTag.getAttribute("src");
+
+ try
+ {
+ const request = await fetch(includePath);
+ if (!request.ok)
+ {
+ console.log("Could not include file: " + includePath);
+ includeTag?.remove();
+ continue;
+ }
+
+ let includeText = await request.text();
+ let docFrag = document.createRange().createContextualFragment(includeText);
+ let includeChildren = Array.from(docFrag.children);
+ for (let child of includeChildren)
+ {
+ child.classList.add("hide");
+ child.style.transition = "opacity 0.5s ease-in-out";
+
+ setTimeout(() =>
+ {
+ child.classList.remove("hide");
+ }, 10);
+ };
+
+ includeTag.before(docFrag);
+ includeTag.remove();
+
+ console.log("Included file: " + includePath);
+ }
+ catch (e)
+ {
+ includeTag?.remove();
+ console.log("Could not include file: " + includePath, e);
+ continue;
+ }
+ }
+ }
+ else
+ {
+ let e = document.querySelectorAll("include");
+ if (e.length > 0)
+ {
+ var error = document.createElement("div");
+ error.id = "error";
+ error.textContent = "Web server exports must be hosted on an http / web server to be viewed correctly.";
+ error.style.position = "fixed";
+ error.style.top = "50%";
+ error.style.left = "50%";
+ error.style.transform = "translate(-50%, -50%)";
+ error.style.fontSize = "1.5em";
+ error.style.fontWeight = "bold";
+ error.style.textAlign = "center";
+ document.body.appendChild(error);
+ document.querySelector(".document-container")?.classList.remove("hide");
+ }
+ }
+}
+
+document.addEventListener("DOMContentLoaded", () =>
+{
+ loadIncludes();
+});
+
+let isFileProtocol = location.protocol == "file:";
+
+function waitLoadScripts(scriptNames, callback)
+{
+ let scripts = scriptNames.map(name => document.getElementById(name + "-script"));
+ let index = 0;
+
+ function loadNext()
+ {
+ let script = scripts[index];
+ index++;
+
+ if (!script || script.getAttribute('loaded') == "true") // if already loaded
+ {
+ if (index < scripts.length)
+ loadNext();
+ }
+
+ if (index < scripts.length) script.addEventListener("load", loadNext);
+ else callback();
+ }
+
+ loadNext();
+}
diff --git a/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-render-worker.txt.js b/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-render-worker.txt.js
new file mode 100644
index 00000000..5134b274
--- /dev/null
+++ b/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-render-worker.txt.js
@@ -0,0 +1,417 @@
+// Import Pixi.js library
+if( 'function' === typeof importScripts)
+{
+ importScripts('https://d157l7jdn8e5sf.cloudfront.net/v7.2.0/webworker.js', './tinycolor.js');
+
+ addEventListener('message', onMessage);
+
+ let app;
+ let container;
+ let graphics;
+
+ isDrawing = false;
+
+ let linkCount = 0;
+ let linkSources = [];
+ let linkTargets = [];
+ let nodeCount = 0;
+ let radii = [];
+ let labels = [];
+ let labelFade = [];
+ let labelWidths = [];
+ let pixiLabels = [];
+ let cameraOffset = {x: 0, y: 0};
+ let positions = new Float32Array(0);
+ let linkLength = 0;
+ let edgePruning = 0;
+ let colors =
+ {
+ background: 0x232323,
+ link: 0xAAAAAA,
+ node: 0xCCCCCC,
+ outline: 0xAAAAAA,
+ text: 0xFFFFFF,
+ accent: 0x4023AA
+ }
+
+ let hoveredNode = -1;
+ let lastHoveredNode = -1;
+ let grabbedNode = -1;
+ let updateAttached = false;
+ let attachedToGrabbed = [];
+ let activeNode = -1;
+ let attachedToActive = [];
+
+ let cameraScale = 1;
+ let cameraScaleRoot = 1;
+
+ function toScreenSpace(x, y, floor = true)
+ {
+ if (floor)
+ {
+ return {x: Math.floor((x * cameraScale) + cameraOffset.x), y: Math.floor((y * cameraScale) + cameraOffset.y)};
+ }
+ else
+ {
+ return {x: (x * cameraScale) + cameraOffset.x, y: (y * cameraScale) + cameraOffset.y};
+ }
+ }
+
+ function vecToScreenSpace({x, y}, floor = true)
+ {
+ return toScreenSpace(x, y, floor);
+ }
+
+ function toWorldspace(x, y)
+ {
+ return {x: (x - cameraOffset.x) / cameraScale, y: (y - cameraOffset.y) / cameraScale};
+ }
+
+ function vecToWorldspace({x, y})
+ {
+ return toWorldspace(x, y);
+ }
+
+ function setCameraCenterWorldspace({x, y})
+ {
+ cameraOffset.x = (canvas.width / 2) - (x * cameraScale);
+ cameraOffset.y = (canvas.height / 2) - (y * cameraScale);
+ }
+
+ function getCameraCenterWorldspace()
+ {
+ return toWorldspace(canvas.width / 2, canvas.height / 2);
+ }
+
+ function getNodeScreenRadius(radius)
+ {
+ return radius * cameraScaleRoot;
+ }
+
+ function getNodeWorldspaceRadius(radius)
+ {
+ return radius / cameraScaleRoot;
+ }
+
+ function getPosition(index)
+ {
+ return {x: positions[index * 2], y: positions[index * 2 + 1]};
+ }
+
+ function mixColors(hexStart, hexEnd, factor)
+ {
+ return tinycolor.mix(tinycolor(hexStart.toString(16)), tinycolor(hexEnd.toString(16)), factor).toHexNumber()
+ }
+
+ function darkenColor(hexColor, factor)
+ {
+ return tinycolor(hexColor.toString(16)).darken(factor).toHexNumber();
+ }
+
+ function lightenColor(hexColor, factor)
+ {
+ return tinycolor(hexColor.toString(16)).lighten(factor).toHexNumber();
+ }
+
+ function invertColor(hex, bw)
+ {
+ hex = hex.toString(16); // force conversion
+ // fill extra space up to 6 characters with 0
+ while (hex.length < 6) hex = "0" + hex;
+
+ if (hex.indexOf('#') === 0) {
+ hex = hex.slice(1);
+ }
+ // convert 3-digit hex to 6-digits.
+ if (hex.length === 3) {
+ hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+ }
+ if (hex.length !== 6) {
+ throw new Error('Invalid HEX color:' + hex);
+ }
+ var r = parseInt(hex.slice(0, 2), 16),
+ g = parseInt(hex.slice(2, 4), 16),
+ b = parseInt(hex.slice(4, 6), 16);
+ if (bw) {
+ // https://stackoverflow.com/a/3943023/112731
+ return (r * 0.299 + g * 0.587 + b * 0.114) > 186
+ ? '#000000'
+ : '#FFFFFF';
+ }
+ // invert color components
+ r = (255 - r).toString(16);
+ g = (255 - g).toString(16);
+ b = (255 - b).toString(16);
+ // pad each with zeros and return
+ return "#" + padZero(r) + padZero(g) + padZero(b);
+ }
+
+ function clamp(value, min, max)
+ {
+ return Math.min(Math.max(value, min), max);
+ }
+
+ function lerp(a, b, t)
+ {
+ return a + (b - a) * t;
+ }
+
+ let hoverFade = 0;
+ let hoverFadeSpeed = 0.2;
+ let hoverFontSize = 15;
+ let normalFontSize = 12;
+ let fontRatio = hoverFontSize / normalFontSize;
+
+ function showLabel(index, fade, hovered = false)
+ {
+ let label = pixiLabels[index];
+ if (!label) return;
+ labelFade[index] = fade;
+
+ if(fade > 0.01) label.visible = true;
+ else
+ {
+ hideLabel(index);
+ return;
+ }
+
+ if (hovered) label.style.fontSize = hoverFontSize;
+ else label.style.fontSize = normalFontSize;
+
+
+ let nodePos = vecToScreenSpace(getPosition(index));
+ let width = (labelWidths[index] * (hovered ? fontRatio : 1)) / 2;
+ label.x = nodePos.x - width;
+ label.y = nodePos.y + getNodeScreenRadius(radii[index]) + 9;
+ label.alpha = fade;
+ }
+
+ function hideLabel(index)
+ {
+ let label = pixiLabels[index];
+ label.visible = false;
+ }
+
+ function draw()
+ {
+ graphics.clear();
+
+ let topLines = [];
+ if (updateAttached)
+ {
+ attachedToGrabbed = [];
+ // hoverFade = 0;
+ }
+
+ if (hoveredNode != -1 || grabbedNode != -1)
+ {
+ hoverFade = Math.min(1, hoverFade + hoverFadeSpeed);
+ }
+ else
+ {
+ hoverFade = Math.max(0, hoverFade - hoverFadeSpeed);
+ }
+
+ graphics.lineStyle(1, mixColors(colors.link, colors.background, hoverFade * 50), 0.7);
+
+ for (let i = 0; i < linkCount; i++)
+ {
+ let target = linkTargets[i];
+ let source = linkSources[i];
+
+ if (hoveredNode == source || hoveredNode == target || ((lastHoveredNode == source || lastHoveredNode == target) && hoverFade != 0))
+ {
+ if (updateAttached && hoveredNode == source)
+ attachedToGrabbed.push(target);
+
+ else if (updateAttached && hoveredNode == target)
+ attachedToGrabbed.push(source);
+
+ topLines.push(i);
+ }
+
+ let startWorld = getPosition(source);
+ let endWorld = getPosition(target);
+
+ let start = vecToScreenSpace(startWorld);
+ let end = vecToScreenSpace(endWorld);
+
+ let dist = Math.sqrt(Math.pow(startWorld.x - endWorld.x, 2) + Math.pow(startWorld.y - endWorld.y, 2));
+
+ if (dist < (radii[source] + radii[target]) * edgePruning)
+ {
+ graphics.moveTo(start.x, start.y);
+ graphics.lineTo(end.x, end.y);
+ }
+ }
+
+ let opacity = 1 - (hoverFade * 0.5);
+ graphics.beginFill(mixColors(colors.node, colors.background, hoverFade * 50), opacity);
+ graphics.lineStyle(0, 0xffffff);
+ for (let i = 0; i < nodeCount; i++)
+ {
+ let screenRadius = getNodeScreenRadius(radii[i]);
+
+ if (hoveredNode != i)
+ {
+ if (screenRadius > 2)
+ {
+
+ let labelFade = lerp(0, (screenRadius - 4) / 8 - (1/cameraScaleRoot)/6 * 0.9, Math.max(1 - hoverFade, 0.2));
+ showLabel(i, labelFade);
+ }
+ else
+ {
+ hideLabel(i);
+ }
+ }
+
+ if (hoveredNode == i || (lastHoveredNode == i && hoverFade != 0) || (hoveredNode != -1 && attachedToGrabbed.includes(i))) continue;
+
+ let pos = vecToScreenSpace(getPosition(i));
+ graphics.drawCircle(pos.x, pos.y, screenRadius);
+ }
+
+ graphics.endFill();
+
+
+ opacity = hoverFade * 0.7;
+ graphics.lineStyle(1, mixColors(mixColors(colors.link, colors.accent, hoverFade * 100), colors.background, 20), opacity);
+
+ for (let i = 0; i < topLines.length; i++)
+ {
+ let target = linkTargets[topLines[i]];
+ let source = linkSources[topLines[i]];
+
+ // draw lines on top when hovered
+ let start = vecToScreenSpace(getPosition(source));
+ let end = vecToScreenSpace(getPosition(target));
+
+
+ graphics.moveTo(start.x, start.y);
+ graphics.lineTo(end.x, end.y);
+ }
+
+ if(hoveredNode != -1 || (lastHoveredNode != -1 && hoverFade != 0))
+ {
+ graphics.beginFill(mixColors(colors.node, colors.accent, hoverFade * 20), 0.9);
+ graphics.lineStyle(0, 0xffffff);
+ for (let i = 0; i < attachedToGrabbed.length; i++)
+ {
+ let point = attachedToGrabbed[i];
+
+ let pos = vecToScreenSpace(getPosition(point));
+
+ graphics.drawCircle(pos.x, pos.y, getNodeScreenRadius(radii[point]));
+ showLabel(point, Math.max(hoverFade * 0.6, labelFade[point]));
+ }
+ graphics.endFill();
+
+ let index = hoveredNode != -1 ? hoveredNode : lastHoveredNode;
+
+ let pos = vecToScreenSpace(getPosition(index));
+ graphics.beginFill(mixColors(colors.node, colors.accent, hoverFade * 100), 1);
+ graphics.lineStyle(hoverFade, mixColors(invertColor(colors.background, true), colors.accent, 50));
+ graphics.drawCircle(pos.x, pos.y, getNodeScreenRadius(radii[index]));
+ graphics.endFill();
+
+ showLabel(index, Math.max(hoverFade, labelFade[index]), true);
+ }
+
+
+
+ updateAttached = false;
+
+ graphics.lineStyle(2, colors.accent);
+ // draw the active node
+ if (activeNode != -1)
+ {
+ let pos = vecToScreenSpace(getPosition(activeNode));
+ graphics.drawCircle(pos.x, pos.y, getNodeScreenRadius(radii[activeNode]) + 4);
+
+ }
+ }
+
+ function onMessage(event)
+ {
+ if(event.data.type == "draw")
+ {
+ positions = new Float32Array(event.data.positions);
+ draw();
+ }
+ else if(event.data.type == "update_camera")
+ {
+ cameraOffset = event.data.cameraOffset;
+ cameraScale = event.data.cameraScale;
+ cameraScaleRoot = Math.sqrt(cameraScale);
+ }
+ else if(event.data.type == "update_interaction")
+ {
+ if(hoveredNode != event.data.hoveredNode && event.data.hoveredNode != -1) updateAttached = true;
+ if(grabbedNode != event.data.grabbedNode && event.data.hoveredNode != -1) updateAttached = true;
+
+ if(event.data.hoveredNode == -1) lastHoveredNode = hoveredNode;
+ else lastHoveredNode = -1;
+
+ hoveredNode = event.data.hoveredNode;
+ grabbedNode = event.data.grabbedNode;
+ }
+ else if(event.data.type == "resize")
+ {
+ app.renderer.resize(event.data.width, event.data.height);
+ }
+ else if(event.data.type == "set_active")
+ {
+ activeNode = event.data.active;
+ }
+ else if(event.data.type == "update_colors")
+ {
+ colors = event.data.colors;
+
+ for (let label of pixiLabels)
+ {
+ label.style.fill = invertColor(colors.background, true);
+ }
+ }
+ else if(event.data.type == "init")
+ {
+ // Extract data from message
+ linkCount = event.data.linkCount;
+ linkSources = event.data.linkSources;
+ linkTargets = event.data.linkTargets;
+ nodeCount = event.data.nodeCount;
+ radii = event.data.radii;
+ labels = event.data.labels;
+ linkLength = event.data.linkLength;
+ edgePruning = event.data.edgePruning;
+
+ app = new PIXI.Application({... event.data.options, antialias: true, resolution: 2, backgroundAlpha: 0, transparent: true});
+ container = new PIXI.Container();
+ graphics = new PIXI.Graphics();
+ app.stage.addChild(container);
+ container.addChild(graphics);
+
+ pixiLabels = [];
+ for (let i = 0; i < nodeCount; i++)
+ {
+ let label = new PIXI.Text(labels[i], {fontFamily : 'Arial', fontSize: 12, fontWeight: "normal", fill : invertColor(colors.background, true), align : 'center', anchor: 0.5});
+ pixiLabels.push(label);
+ labelWidths.push(label.width);
+ labelFade.push(0);
+ app.stage.addChild(label);
+ }
+
+ }
+ else
+ {
+ console.log("Unknown message type sent to graph worker: " + event.data.type);
+ }
+ }
+}
+
+
+
+
+
+
+
diff --git a/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-view.txt.js b/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-view.txt.js
new file mode 100644
index 00000000..13eb4ee4
--- /dev/null
+++ b/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-view.txt.js
@@ -0,0 +1,1036 @@
+// -------------------------- GRAPH VIEW --------------------------
+var running = false;
+let batchFraction = 1; // how much of the graph to update per frame
+let minBatchFraction = 0.3; // batch fraction is updated dynamically, but never goes below this value
+let dt = 1;
+let targetFPS = 40;
+let startingCameraRect = {minX: -1, minY: -1, maxX: 1, maxY: 1};
+
+let mouseWorldPos = { x: undefined, y: undefined };
+let scrollVelocity = 0;
+let averageFPS = targetFPS * 2;
+
+let pixiApp = undefined;
+let graphRenderer = undefined;
+
+class GraphAssembly
+{
+ static nodeCount = 0;
+ static linkCount = 0;
+ static hoveredNode = -1;
+
+ static #positionsPtr = 0;
+ static #positionsByteLength = 0;
+ static #radiiPtr = 0;
+ static #linkSourcesPtr = 0;
+ static #linkTargetsPtr = 0;
+
+ static linkSources = new Int32Array(0);
+ static linkTargets = new Int32Array(0);
+ static radii = new Float32Array(0);
+ static maxRadius = 0;
+ static averageRadius = 0;
+ static minRadius = 0;
+
+ /**
+ * @param {{graphOptions: {attractionForce: number, linkLength: number, repulsionForce: number, centralForce: number, edgePruning: number, minNodeRadius: number, maxNodeRadius: number}, nodeCount: number, linkCount:number, radii: number[], labels: string[], paths: string[], linkSources: number[], linkTargets: number[], linkCounts: number[]}} graphData
+ */
+ static init(graphData)
+ {
+ GraphAssembly.nodeCount = graphData.nodeCount;
+ GraphAssembly.linkCount = graphData.linkCount;
+
+ // create arrays for the data
+ let positions = new Float32Array(GraphAssembly.nodeCount * 2);
+ GraphAssembly.radii = new Float32Array(graphData.radii);
+ GraphAssembly.linkSources = new Int32Array(graphData.linkSources);
+ GraphAssembly.linkTargets = new Int32Array(graphData.linkTargets);
+
+ // allocate memory on the heap
+ GraphAssembly.#positionsPtr = Module._malloc(positions.byteLength);
+ GraphAssembly.#positionsByteLength = positions.byteLength;
+ GraphAssembly.#radiiPtr = Module._malloc(GraphAssembly.radii.byteLength);
+ GraphAssembly.#linkSourcesPtr = Module._malloc(GraphAssembly.linkSources.byteLength);
+ GraphAssembly.#linkTargetsPtr = Module._malloc(GraphAssembly.linkTargets.byteLength);
+
+ GraphAssembly.maxRadius = GraphAssembly.radii.reduce((a, b) => Math.max(a, b));
+ GraphAssembly.averageRadius = GraphAssembly.radii.reduce((a, b) => a + b) / GraphAssembly.radii.length;
+ GraphAssembly.minRadius = GraphAssembly.radii.reduce((a, b) => Math.min(a, b));
+
+ positions = this.loadState();
+
+ // copy the data to the heap
+ Module.HEAP32.set(new Int32Array(positions.buffer), GraphAssembly.#positionsPtr / positions.BYTES_PER_ELEMENT);
+ Module.HEAP32.set(new Int32Array(GraphAssembly.radii.buffer), GraphAssembly.#radiiPtr / GraphAssembly.radii.BYTES_PER_ELEMENT);
+ Module.HEAP32.set(new Int32Array(GraphAssembly.linkSources.buffer), GraphAssembly.#linkSourcesPtr / GraphAssembly.linkSources.BYTES_PER_ELEMENT);
+ Module.HEAP32.set(new Int32Array(GraphAssembly.linkTargets.buffer), GraphAssembly.#linkTargetsPtr / GraphAssembly.linkTargets.BYTES_PER_ELEMENT);
+
+ Module._Init(
+ GraphAssembly.#positionsPtr,
+ GraphAssembly.#radiiPtr,
+ GraphAssembly.#linkSourcesPtr,
+ GraphAssembly.#linkTargetsPtr,
+ GraphAssembly.nodeCount,
+ GraphAssembly.linkCount,
+ batchFraction,
+ dt,
+ graphData.graphOptions.attractionForce,
+ graphData.graphOptions.linkLength,
+ graphData.graphOptions.repulsionForce,
+ graphData.graphOptions.centralForce,
+ );
+ }
+
+ /**
+ * @returns {Float32Array}
+ */
+ static get positions()
+ {
+ return Module.HEAP32.buffer.slice(GraphAssembly.#positionsPtr, GraphAssembly.#positionsPtr + GraphAssembly.#positionsByteLength);
+ }
+
+ /**
+ * @param {GraphRenderWorker} renderWorker
+ * */
+ static saveState(renderWorker)
+ {
+ // save all rounded to int
+ localStorage.setItem("positions", JSON.stringify(new Float32Array(GraphAssembly.positions).map(x => Math.round(x))));
+ }
+
+ /**
+ * @returns {Float32Array}
+ * */
+ static loadState()
+ {
+ let positionsLoad = localStorage.getItem("positions");
+ let positions = null;
+ if(positionsLoad) positions = new Float32Array(Object.values(JSON.parse(positionsLoad)));
+ if (!positions || !positionsLoad || positions.length != GraphAssembly.nodeCount * 2)
+ {
+ positions = new Float32Array(GraphAssembly.nodeCount * 2);
+ let spawnRadius = (GraphAssembly.averageRadius * Math.sqrt(GraphAssembly.nodeCount)) * 2;
+ for (let i = 0; i < GraphAssembly.nodeCount; i++)
+ {
+ let distance = (1 - GraphAssembly.radii[i] / GraphAssembly.maxRadius) * spawnRadius;
+ positions[i * 2] = Math.cos(i/GraphAssembly.nodeCount * 7.41 * 2 * Math.PI) * distance;
+ positions[i * 2 + 1] = Math.sin(i/GraphAssembly.nodeCount * 7.41 * 2 * Math.PI) * distance;
+ }
+ }
+
+ // fit view to positions
+ let minX = Infinity;
+ let maxX = -Infinity;
+ let minY = Infinity;
+ let maxY = -Infinity;
+ for (let i = 0; i < GraphAssembly.nodeCount-1; i+=2)
+ {
+ let pos = { x: positions[i], y: positions[i + 1] };
+ minX = Math.min(minX, pos.x);
+ maxX = Math.max(maxX, pos.x);
+ minY = Math.min(minY, pos.y);
+ maxY = Math.max(maxY, pos.y);
+ }
+
+ let margin = 50;
+
+ startingCameraRect = { minX: minX - margin, minY: minY - margin, maxX: maxX + margin, maxY: maxY + margin };
+
+ return positions;
+ }
+
+ /**
+ * @param {{x: number, y: number}} mousePosition
+ * @param {number} grabbedNode
+ */
+ static update(mousePosition, grabbedNode, cameraScale)
+ {
+ GraphAssembly.hoveredNode = Module._Update(mousePosition.x, mousePosition.y, grabbedNode, cameraScale);
+ }
+
+ static free()
+ {
+ Module._free(GraphAssembly.#positionsPtr);
+ Module._free(GraphAssembly.#radiiPtr);
+ Module._free(GraphAssembly.#linkSourcesPtr);
+ Module._free(GraphAssembly.#linkTargetsPtr);
+ Module._FreeMemory();
+ }
+
+ /**
+ * @param {number} value
+ */
+ static set batchFraction(value)
+ {
+ Module._SetBatchFractionSize(value);
+ }
+
+ /**
+ * @param {number} value
+ */
+ static set attractionForce(value)
+ {
+ Module._SetAttractionForce(value);
+ }
+
+ /**
+ * @param {number} value
+ */
+ static set repulsionForce(value)
+ {
+ Module._SetRepulsionForce(value);
+ }
+
+ /**
+ * @param {number} value
+ */
+ static set centralForce(value)
+ {
+ Module._SetCentralForce(value);
+ }
+
+ /**
+ * @param {number} value
+ */
+ static set linkLength(value)
+ {
+ Module._SetLinkLength(value);
+ }
+
+ /**
+ * @param {number} value
+ */
+ static set dt(value)
+ {
+ Module._SetDt(value);
+ }
+}
+
+class GraphRenderWorker
+{
+ #cameraOffset;
+ #cameraScale;
+ #hoveredNode;
+ #grabbedNode;
+ #colors;
+ #width;
+ #height;
+
+
+ constructor()
+ {
+ this.canvas = document.querySelector("#graph-canvas");
+ this.canvasSidebar = undefined;
+
+ try
+ {
+ this.canvasSidebar = document.querySelector(".sidebar:has(#graph-canvas)");
+ }
+ catch(e)
+ {
+ console.log("Error: " + e + "\n\n Using fallback.");
+
+ let rightSidebar = document.querySelector(".sidebar-right");
+ let leftSidebar = document.querySelector(".sidebar-left");
+
+ this.canvasSidebar = rightSidebar.querySelector("#graph-canvas") ? rightSidebar : leftSidebar;
+ }
+
+ this.view = this.canvas.transferControlToOffscreen();
+
+ this.worker = new Worker(new URL("./graph-render-worker.js", import.meta.url));
+
+ this.#cameraOffset = {x: 0, y: 0};
+ this.#cameraScale = 1;
+ this.#hoveredNode = -1;
+ this.#grabbedNode = -1;
+ this.#colors =
+ {
+ background: 0x000000,
+ link: 0x000000,
+ node: 0x000000,
+ outline: 0x000000,
+ text: 0x000000,
+ accent: 0x000000,
+ }
+ this.#width = 0;
+ this.#height = 0;
+
+ this.cameraOffset = {x: this.canvas.width / 2, y: this.canvas.height / 2};
+ this.cameraScale = 1;
+ this.hoveredNode = -1;
+ this.grabbedNode = -1;
+ this.resampleColors();
+
+ this.#pixiInit();
+
+ this.width = this.canvas.width;
+ this.height = this.canvas.height;
+
+ this.autoResizeCanvas();
+
+ this.fitToRect(startingCameraRect);
+ }
+
+ #pixiInit()
+ {
+ let { width, height } = this.view;
+
+ this.worker.postMessage(
+ {
+ type: 'init',
+ linkCount: GraphAssembly.linkCount,
+ linkSources: GraphAssembly.linkSources,
+ linkTargets: GraphAssembly.linkTargets,
+ nodeCount: GraphAssembly.nodeCount,
+ radii: GraphAssembly.radii,
+ labels: graphData.labels,
+ linkLength: graphData.graphOptions.linkLength,
+ edgePruning: graphData.graphOptions.edgePruning,
+ options: { width: width, height: height, view: this.view },
+ }, [this.view]);
+ }
+
+ fitToRect(rect) // {minX, minY, maxX, maxY}
+ {
+ let min = {x: rect.minX, y: rect.minY};
+ let max = {x: rect.maxX, y: rect.maxY};
+
+ let width = max.x - min.x;
+ let height = max.y - min.y;
+
+ let scale = 1/Math.min(width/this.width, height / this.height);
+
+ this.cameraScale = scale;
+ this.cameraOffset = { x: (this.width / 2) - ((rect.minX + width / 2) * scale), y: (this.height / 2) - ((rect.minY + height / 2) * scale) };
+ }
+
+ fitToNodes()
+ {
+ this.fitToRect(startingCameraRect);
+ }
+
+ sampleColor(variable)
+ {
+ let testEl = document.createElement('div');
+ document.body.appendChild(testEl);
+ testEl.style.setProperty('display', 'none');
+ testEl.style.setProperty('color', 'var(' + variable + ')');
+
+ let col = getComputedStyle(testEl).color;
+ let opacity = getComputedStyle(testEl).opacity;
+
+ testEl.remove();
+
+ function toColorObject(str)
+ {
+ var match = str.match(/rgb?\((\d+),\s*(\d+),\s*(\d+)\)/);
+ return match ? {
+ red: parseInt(match[1]),
+ green: parseInt(match[2]),
+ blue: parseInt(match[3]),
+ alpha: 1
+ } : null
+ }
+
+ let color = toColorObject(col);
+ let alpha = parseFloat(opacity);
+ let result =
+ {
+ a: (alpha * color?.alpha ?? 1) ?? 1,
+ rgb: (color?.red << 16 | color?.green << 8 | color?.blue) ?? 0x888888
+ };
+
+ return result;
+ };
+
+ resampleColors()
+ {
+ this.colors =
+ {
+ background: this.sampleColor('--background-secondary').rgb,
+ link: this.sampleColor('--graph-line').rgb,
+ node: this.sampleColor('--graph-node').rgb,
+ outline: this.sampleColor('--graph-line').rgb,
+ text: this.sampleColor('--graph-text').rgb,
+ accent: this.sampleColor('--interactive-accent').rgb,
+ };
+ }
+
+ draw(_positions)
+ {
+ this.worker.postMessage(
+ {
+ type: 'draw',
+ positions: _positions,
+ }, [_positions]);
+ }
+
+ resizeCanvas(width, height)
+ {
+ this.worker.postMessage(
+ {
+ type: "resize",
+ width: width,
+ height: height,
+ });
+
+ this.#width = width;
+ this.#height = height;
+ }
+
+ autoResizeCanvas()
+ {
+ if (this.width != this.canvas.offsetWidth || this.height != this.canvas.offsetHeight)
+ {
+ this.centerCamera();
+ this.resizeCanvas(this.canvas.offsetWidth, this.canvas.offsetHeight);
+ }
+ }
+
+ centerCamera()
+ {
+ this.cameraOffset = { x: this.width / 2, y: this.height / 2 };
+ }
+
+ #pixiSetInteraction(hoveredNodeIndex, grabbedNodeIndex)
+ {
+ let obj =
+ {
+ type: "update_interaction",
+ hoveredNode: hoveredNodeIndex,
+ grabbedNode: grabbedNodeIndex,
+ }
+
+ this.worker.postMessage(obj);
+ }
+
+ #pixiSetCamera(cameraOffset, cameraScale)
+ {
+ this.worker.postMessage(
+ {
+ type: "update_camera",
+ cameraOffset: cameraOffset,
+ cameraScale: cameraScale,
+ });
+ }
+
+ #pixiSetColors(colors)
+ {
+ this.worker.postMessage(
+ {
+ type: "update_colors",
+ colors: colors,
+ });
+
+ }
+
+ set cameraOffset(offset)
+ {
+ this.#cameraOffset = offset;
+ this.#pixiSetCamera(offset, this.cameraScale);
+ }
+
+ set cameraScale(scale)
+ {
+ this.#cameraScale = scale;
+ this.#pixiSetCamera(this.cameraOffset, scale);
+ }
+
+ get cameraOffset()
+ {
+ return this.#cameraOffset;
+ }
+
+ get cameraScale()
+ {
+ return this.#cameraScale;
+ }
+
+ /**
+ * @param {number} node
+ */
+ set hoveredNode(node)
+ {
+ this.#hoveredNode = node;
+ this.#pixiSetInteraction(node, this.#grabbedNode);
+ }
+
+ /**
+ * @param {number} node
+ */
+ set grabbedNode(node)
+ {
+ this.#grabbedNode = node;
+ this.#pixiSetInteraction(this.#hoveredNode, node);
+ }
+
+ /**
+ * @param {number} node
+ */
+ set activeNode(node)
+ {
+ this.worker.postMessage(
+ {
+ type: 'set_active',
+ active: node,
+ });
+ }
+
+ get hoveredNode()
+ {
+ return this.#hoveredNode;
+ }
+
+ get grabbedNode()
+ {
+ return this.#grabbedNode;
+ }
+
+ /**
+ * @param {{ background: number; link: number; node: number; outline: number; text: number; accent: number; }} colors
+ */
+ set colors(colors)
+ {
+ this.#colors = colors;
+ this.#pixiSetColors(colors);
+ }
+
+ get colors()
+ {
+ return this.#colors;
+ }
+
+ set width(width)
+ {
+ this.#width = width;
+ this.resizeCanvas(width, this.#height);
+ }
+
+ set height(height)
+ {
+ this.#height = height;
+ this.resizeCanvas(this.#width, height);
+ }
+
+ get height()
+ {
+ return this.#height;
+ }
+
+ get width()
+ {
+ return this.#width;
+ }
+
+ /**
+ * @param {number} x
+ * @param {number} y
+ * @param {boolean} floor
+ * @returns {{x: number; y: number;}}
+ */
+ toScreenSpace(x, y, floor = true)
+ {
+ if (floor)
+ {
+ return {x: Math.floor((x * this.cameraScale) + this.cameraOffset.x), y: Math.floor((y * this.cameraScale) + this.cameraOffset.y)};
+ }
+ else
+ {
+ return {x: (x * this.cameraScale) + this.cameraOffset.x, y: (y * this.cameraScale) + this.cameraOffset.y};
+ }
+ }
+
+ /**
+ * @param {{x: number; y: number;}} vector
+ * @param {boolean} floor
+ * @returns {{x: number; y: number;}}
+ */
+ vecToScreenSpace(vector, floor = true)
+ {
+ return this.toScreenSpace(vector.x, vector.y, floor);
+ }
+
+ /**
+ * @param {number} x
+ * @param {number} y
+ * @returns {{x: number; y: number;}}
+ */
+ toWorldspace(x, y)
+ {
+ return {x: (x - this.cameraOffset.x) / this.cameraScale, y: (y - this.cameraOffset.y) / this.cameraScale};
+ }
+
+ /**
+ * @param {{x: number; y: number;}} vector
+ * @returns {{x: number; y: number;}}
+ */
+ vecToWorldspace(vector)
+ {
+ return this.toWorldspace(vector.x, vector.y);
+ }
+
+ setCameraCenterWorldspace({x, y})
+ {
+ this.cameraOffset = {x: (this.width / 2) - (x * this.cameraScale), y: (this.height / 2) - (y * this.cameraScale)};
+ }
+
+ getCameraCenterWorldspace()
+ {
+ return this.toWorldspace(this.width / 2, this.height / 2);
+ }
+}
+
+async function initializeGraphView()
+{
+ if(running) return;
+ running = true;
+
+ graphData.graphOptions.repulsionForce /= batchFraction; // compensate for batch fraction
+ pixiApp = new PIXI.Application();
+
+ console.log("Module Ready");
+ GraphAssembly.init(graphData); // graphData is a global variable set in another script
+
+ graphRenderer = new GraphRenderWorker();
+ window.graphRenderer = graphRenderer;
+
+ initializeGraphEvents();
+
+ pixiApp.ticker.maxFPS = targetFPS;
+ pixiApp.ticker.add(updateGraph);
+
+ setActiveDocument(new URL(window.location.href), false, false);
+
+ setInterval(() =>
+ {
+ function isHidden(el) {
+ var style = window.getComputedStyle(el);
+ return (style.display === 'none')
+ }
+
+ try
+ {
+ var hidden = (graphRenderer.canvasSidebar.classList.contains("is-collapsed"));
+ }
+ catch(e)
+ {
+ return;
+ }
+
+ if(running && hidden)
+ {
+ running = false;
+ }
+ else if (!running && !hidden)
+ {
+ running = true;
+ graphRenderer.autoResizeCanvas();
+ graphRenderer.centerCamera();
+ }
+
+ }, 1000);
+}
+
+let firstUpdate = true;
+function updateGraph()
+{
+ if(!running) return;
+
+ if (graphRenderer.canvasSidebar.classList.contains("is-collapsed")) return;
+
+ if (firstUpdate)
+ {
+ setTimeout(() => graphRenderer?.canvas?.classList.remove("hide"), 500);
+ firstUpdate = false;
+ }
+
+ GraphAssembly.update(mouseWorldPos, graphRenderer.grabbedNode, graphRenderer.cameraScale);
+
+ if (GraphAssembly.hoveredNode != graphRenderer.hoveredNode)
+ {
+ graphRenderer.hoveredNode = GraphAssembly.hoveredNode;
+ graphRenderer.canvas.style.cursor = GraphAssembly.hoveredNode == -1 ? "default" : "pointer";
+ }
+
+ graphRenderer.autoResizeCanvas();
+ graphRenderer.draw(GraphAssembly.positions);
+
+ averageFPS = averageFPS * 0.95 + pixiApp.ticker.FPS * 0.05;
+
+ if (averageFPS < targetFPS * 0.8 && batchFraction > minBatchFraction)
+ {
+ batchFraction = Math.max(batchFraction - 0.5 * 1/targetFPS, minBatchFraction);
+ GraphAssembly.batchFraction = batchFraction;
+ GraphAssembly.repulsionForce = graphData.graphOptions.repulsionForce / batchFraction;
+ }
+
+ if (averageFPS > targetFPS * 1.2 && batchFraction < 1)
+ {
+ batchFraction = Math.min(batchFraction + 0.5 * 1/targetFPS, 1);
+ GraphAssembly.batchFraction = batchFraction;
+ GraphAssembly.repulsionForce = graphData.graphOptions.repulsionForce / batchFraction;
+ }
+
+ if (scrollVelocity != 0)
+ {
+ let cameraCenter = graphRenderer.getCameraCenterWorldspace();
+
+ if (Math.abs(scrollVelocity) < 0.001)
+ {
+ scrollVelocity = 0;
+ }
+
+ zoomGraphViewAroundPoint(mouseWorldPos, scrollVelocity);
+
+ scrollVelocity *= 0.65;
+ }
+}
+
+function zoomGraphViewAroundPoint(point, zoom, minScale = 0.15, maxScale = 15.0)
+{
+ let cameraCenter = graphRenderer.getCameraCenterWorldspace();
+
+ graphRenderer.cameraScale = Math.max(Math.min(graphRenderer.cameraScale + zoom * graphRenderer.cameraScale, maxScale), minScale);
+ if(graphRenderer.cameraScale != minScale && graphRenderer.cameraScale != maxScale && scrollVelocity > 0 && mouseWorldPos.x != undefined && mouseWorldPos.y != undefined)
+ {
+ let aroundDiff = {x: point.x - cameraCenter.x, y: point.y - cameraCenter.y};
+ let movePos = {x: cameraCenter.x + aroundDiff.x * zoom, y: cameraCenter.y + aroundDiff.y * zoom};
+ graphRenderer.setCameraCenterWorldspace(movePos);
+ }
+ else graphRenderer.setCameraCenterWorldspace(cameraCenter);
+}
+
+function scaleGraphViewAroundPoint(point, scale, minScale = 0.15, maxScale = 15.0)
+{
+ let cameraCenter = graphRenderer.getCameraCenterWorldspace();
+
+ let scaleBefore = graphRenderer.cameraScale;
+ graphRenderer.cameraScale = Math.max(Math.min(scale * graphRenderer.cameraScale, maxScale), minScale);
+ let diff = (scaleBefore - graphRenderer.cameraScale) / scaleBefore;
+ if(graphRenderer.cameraScale != minScale && graphRenderer.cameraScale != maxScale && scale != 0)
+ {
+ let aroundDiff = {x: point.x - cameraCenter.x, y: point.y - cameraCenter.y};
+ let movePos = {x: cameraCenter.x - aroundDiff.x * diff, y: cameraCenter.y - aroundDiff.y * diff};
+ graphRenderer.setCameraCenterWorldspace(movePos);
+ }
+ else graphRenderer.setCameraCenterWorldspace(cameraCenter);
+}
+
+function initializeGraphEvents()
+{
+ window.addEventListener('beforeunload', () =>
+ {
+ running = false;
+ GraphAssembly.free();
+ });
+
+ let graphExpanded = false;
+ let lastCanvasWidth = graphRenderer.canvas.width;
+ window.addEventListener('resize', () =>
+ {
+ if(graphExpanded)
+ {
+ graphRenderer.autoResizeCanvas();
+ graphRenderer.centerCamera();
+ }
+ else
+ {
+ if (graphRenderer.canvas.width != lastCanvasWidth)
+ {
+ graphRenderer.autoResizeCanvas();
+ graphRenderer.centerCamera();
+ }
+ }
+ });
+
+ let container = document.querySelector(".graph-view-container");
+
+ function handleOutsideClick(event)
+ {
+ if (event.composedPath().includes(container))
+ {
+ return;
+ }
+ toggleExpandedGraph();
+ }
+
+ function toggleExpandedGraph()
+ {
+ let initialWidth = container.clientWidth;
+ let initialHeight = container.clientHeight;
+
+ // scale and fade out animation:
+ container.classList.add("scale-down");
+ let fadeOutAnimation = container.animate({ opacity: 0 }, {duration: 100, easing: "ease-in", fill: "forwards"});
+ fadeOutAnimation.addEventListener("finish", function()
+ {
+ container.classList.toggle("expanded");
+
+ graphRenderer.autoResizeCanvas();
+ graphRenderer.centerCamera();
+
+ let finalWidth = container.clientWidth;
+ let finalHeight = container.clientHeight;
+ graphRenderer.cameraScale *= ((finalWidth / initialWidth) + (finalHeight / initialHeight)) / 2;
+
+ container.classList.remove("scale-down");
+ container.classList.add("scale-up");
+
+ updateGraph();
+
+ let fadeInAnimation = container.animate({ opacity: 1 }, {duration: 200, easing: "ease-out", fill: "forwards"});
+ fadeInAnimation.addEventListener("finish", function()
+ {
+ container.classList.remove("scale-up");
+ });
+ });
+
+ graphExpanded = !graphExpanded;
+
+ if (graphExpanded) document.addEventListener("pointerdown", handleOutsideClick);
+ else document.removeEventListener("pointerdown", handleOutsideClick);
+ }
+
+ async function navigateToNode(nodeIndex)
+ {
+ if (!graphExpanded) GraphAssembly.saveState(graphRenderer);
+ else toggleExpandedGraph();
+ let url = graphData.paths[nodeIndex];
+ if(window.location.pathname.endsWith(graphData.paths[nodeIndex])) return;
+ await loadDocument(url, true, true);
+ }
+
+ // Get the mouse position relative to the canvas.
+ function getPointerPosOnCanvas(event)
+ {
+ var rect = graphRenderer.canvas.getBoundingClientRect();
+ let pos = getPointerPosition(event);
+
+ return {
+ x: pos.x - rect.left,
+ y: pos.y - rect.top
+ };
+ }
+
+ let startPointerPos = { x: 0, y: 0 };
+ let pointerPos = { x: 0, y: 0 };
+ let lastPointerPos = { x: 0, y: 0 };
+ let pointerDelta = { x: 0, y: 0 };
+ let dragDisplacement = { x: 0, y: 0 };
+ let startDragTime = 0;
+ let pointerDown = false;
+ let middleDown = false;
+ let pointerInside = false;
+ let graphContainer = document.querySelector(".graph-view-container");
+ let firstPointerDownId = -1;
+
+ function handlePointerEnter(enter)
+ {
+ let lastDistance = 0;
+ let startZoom = false;
+
+ function handleMouseMove(move)
+ {
+ pointerPos = getPointerPosOnCanvas(move);
+ mouseWorldPos = graphRenderer.vecToWorldspace(pointerPos);
+ pointerDelta = { x: pointerPos.x - lastPointerPos.x, y: pointerPos.y - lastPointerPos.y };
+ lastPointerPos = pointerPos;
+
+ if (graphRenderer.grabbedNode != -1) dragDisplacement = { x: pointerPos.x - startPointerPos.x, y: pointerPos.y - startPointerPos.y };
+
+ if (pointerDown && graphRenderer.hoveredNode != -1 && graphRenderer.grabbedNode == -1 && graphRenderer.hoveredNode != graphRenderer.grabbedNode)
+ {
+ graphRenderer.grabbedNode = graphRenderer.hoveredNode;
+ }
+
+ if ((pointerDown && graphRenderer.hoveredNode == -1 && graphRenderer.grabbedNode == -1) || middleDown)
+ {
+ graphRenderer.cameraOffset = { x: graphRenderer.cameraOffset.x + pointerDelta.x, y: graphRenderer.cameraOffset.y + pointerDelta.y };
+ }
+ else
+ {
+ if (graphRenderer.hoveredNode != -1) graphRenderer.canvas.style.cursor = "pointer";
+ else graphRenderer.canvas.style.cursor = "default";
+ }
+ }
+
+ function handleTouchMove(move)
+ {
+ if (move.touches?.length == 1)
+ {
+ if(startZoom)
+ {
+ lastPointerPos = getPointerPosOnCanvas(move);
+ startZoom = false;
+ }
+
+ handleMouseMove(move);
+ return;
+ }
+
+ // pinch zoom
+ if (move.touches?.length == 2)
+ {
+ let touch1 = getTouchPosition(move.touches[0]);
+ let touch2 = getTouchPosition(move.touches[1]);
+
+ pointerPos = getPointerPosOnCanvas(move);
+ pointerDelta = { x: pointerPos.x - lastPointerPos.x, y: pointerPos.y - lastPointerPos.y };
+ lastPointerPos = pointerPos;
+
+ let distance = Math.sqrt(Math.pow(touch1.x - touch2.x, 2) + Math.pow(touch1.y - touch2.y, 2));
+
+ if (!startZoom)
+ {
+ startZoom = true;
+ lastDistance = distance;
+ pointerDelta = { x: 0, y: 0 };
+ mouseWorldPos = { x: undefined, y: undefined};
+ graphRenderer.grabbedNode = -1;
+ graphRenderer.hoveredNode = -1;
+ }
+
+ let distanceDelta = distance - lastDistance;
+ let scaleDelta = distanceDelta / lastDistance;
+
+ scaleGraphViewAroundPoint(graphRenderer.vecToWorldspace(pointerPos), 1 + scaleDelta, 0.15, 15.0);
+ graphRenderer.cameraOffset = { x: graphRenderer.cameraOffset.x + pointerDelta.x, y: graphRenderer.cameraOffset.y + pointerDelta.y };
+
+ lastDistance = distance;
+ }
+ }
+
+ function handlePointerUp(up)
+ {
+ document.removeEventListener("pointerup", handlePointerUp);
+
+ let pointerUpTime = Date.now();
+
+ setTimeout(() =>
+ {
+ if (pointerDown && graphRenderer.hoveredNode != -1 && Math.abs(dragDisplacement.x) <= 4 && Math.abs(dragDisplacement.y) <= 4 && pointerUpTime - startDragTime < 300)
+ {
+ navigateToNode(graphRenderer.hoveredNode);
+ }
+
+ if (pointerDown && graphRenderer.grabbedNode != -1)
+ {
+ graphRenderer.grabbedNode = -1;
+ }
+
+ if (up.button == 0) pointerDown = false;
+ if (up.pointerType == "touch" && firstPointerDownId == up.pointerId)
+ {
+ firstPointerDownId = -1;
+ pointerDown = false;
+ }
+ if (up.button == 1) middleDown = false;
+ if (!pointerInside)
+ {
+ document.removeEventListener("mousemove", handleMouseMove);
+ document.removeEventListener("touchmove", handleTouchMove);
+ }
+ }, 0);
+ }
+
+ function handlePointerDown(down)
+ {
+ document.addEventListener("pointerup", handlePointerUp);
+ mouseWorldPos = graphRenderer.vecToWorldspace(pointerPos);
+ dragDisplacement = { x: 0, y: 0 };
+ if (down.button == 0) pointerDown = true;
+ if (down.pointerType == "touch" && firstPointerDownId == -1)
+ {
+ firstPointerDownId = down.pointerId;
+ pointerDown = true;
+ }
+ if (down.button == 1) middleDown = true;
+
+ startPointerPos = pointerPos;
+ startDragTime = Date.now();
+
+ if (pointerDown && graphRenderer.hoveredNode != -1)
+ {
+ graphRenderer.grabbedNode = graphRenderer.hoveredNode;
+ }
+ }
+
+ function handlePointerLeave(leave)
+ {
+ setTimeout(() =>
+ {
+ pointerInside = false;
+ if (!pointerDown)
+ {
+ document.removeEventListener("mousemove", handleMouseMove);
+ document.removeEventListener("touchmove", handleTouchMove);
+ mouseWorldPos = { x: undefined, y: undefined };
+ }
+ graphContainer.removeEventListener("pointerdown", handlePointerDown);
+ graphContainer.removeEventListener("pointerleave", handlePointerLeave);
+ }, 1);
+ }
+
+ pointerPos = getPointerPosOnCanvas(enter);
+ mouseWorldPos = graphRenderer.vecToWorldspace(pointerPos);
+ lastPointerPos = getPointerPosOnCanvas(enter);
+ pointerInside = true;
+
+ document.addEventListener("mousemove", handleMouseMove);
+ document.addEventListener("touchmove", handleTouchMove);
+ graphContainer.addEventListener("pointerdown", handlePointerDown);
+ graphContainer.addEventListener("pointerleave", handlePointerLeave);
+ }
+
+ graphContainer.addEventListener("pointerenter", handlePointerEnter);
+
+ document.querySelector(".graph-expand.graph-icon")?.addEventListener("click", event =>
+ {
+ event.stopPropagation();
+
+ toggleExpandedGraph();
+ });
+
+ graphContainer.addEventListener("wheel", function(e)
+ {
+ let startingScrollVelocity = 0.09;
+ let delta = e.deltaY;
+ if (delta > 0)
+ {
+ if(scrollVelocity >= -startingScrollVelocity)
+ {
+ scrollVelocity = -startingScrollVelocity;
+ }
+ scrollVelocity *= 1.4;
+ }
+ else
+ {
+ if(scrollVelocity <= startingScrollVelocity)
+ {
+ scrollVelocity = startingScrollVelocity;
+ }
+ scrollVelocity *= 1.4;
+ }
+ });
+
+ // recenter the graph on double click
+ graphContainer.addEventListener("dblclick", function(e)
+ {
+ graphRenderer.fitToNodes();
+ });
+
+ document.querySelector(".theme-toggle-input")?.addEventListener("change", event =>
+ {
+ setTimeout(() => graphRenderer.resampleColors(), 0);
+ });
+}
+
+window.addEventListener("load", () =>
+{
+ waitLoadScripts(["pixi", "graph-data", "graph-render-worker", "graph-wasm"], () =>
+ {
+ Module['onRuntimeInitialized'] = initializeGraphView;
+ setTimeout(() => Module['onRuntimeInitialized'](), 300);
+ });
+});
diff --git a/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-wasm.txt.js b/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-wasm.txt.js
new file mode 100644
index 00000000..72379806
--- /dev/null
+++ b/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-wasm.txt.js
@@ -0,0 +1,777 @@
+
+// Wasm glue
+var Module = typeof Module != "undefined" ? Module : {};
+var moduleOverrides = Object.assign({}, Module);
+var arguments_ = [];
+var thisProgram = "./this.program";
+var quit_ = (status,toThrow)=>{
+ throw toThrow
+}
+;
+var ENVIRONMENT_IS_WEB = typeof window == "object";
+var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
+var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
+var scriptDirectory = "";
+function locateFile(path) {
+ if (Module["locateFile"]) {
+ return Module["locateFile"](path, scriptDirectory)
+ }
+ return scriptDirectory + path
+}
+var read_, readAsync, readBinary, setWindowTitle;
+if (ENVIRONMENT_IS_NODE) {
+ var fs = require("fs");
+ var nodePath = require("path");
+ if (ENVIRONMENT_IS_WORKER) {
+ scriptDirectory = nodePath.dirname(scriptDirectory) + "/"
+ } else {
+ scriptDirectory = __dirname + "/"
+ }
+ read_ = (filename,binary)=>{
+ filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+ return fs.readFileSync(filename, binary ? undefined : "utf8")
+ }
+ ;
+ readBinary = filename=>{
+ var ret = read_(filename, true);
+ if (!ret.buffer) {
+ ret = new Uint8Array(ret)
+ }
+ return ret
+ }
+ ;
+ readAsync = (filename,onload,onerror)=>{
+ filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+ fs.readFile(filename, function(err, data) {
+ if (err)
+ onerror(err);
+ else
+ onload(data.buffer)
+ })
+ }
+ ;
+ if (!Module["thisProgram"] && process.argv.length > 1) {
+ thisProgram = process.argv[1].replace(/\\/g, "/")
+ }
+ arguments_ = process.argv.slice(2);
+ if (typeof module != "undefined") {
+ module["exports"] = Module
+ }
+ process.on("uncaughtException", function(ex) {
+ if (ex !== "unwind" && !(ex instanceof ExitStatus) && !(ex.context instanceof ExitStatus)) {
+ throw ex
+ }
+ });
+ var nodeMajor = process.versions.node.split(".")[0];
+ if (nodeMajor < 15) {
+ process.on("unhandledRejection", function(reason) {
+ throw reason
+ })
+ }
+ quit_ = (status,toThrow)=>{
+ process.exitCode = status;
+ throw toThrow
+ }
+ ;
+ Module["inspect"] = function() {
+ return "[Emscripten Module object]"
+ }
+} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ if (ENVIRONMENT_IS_WORKER) {
+ scriptDirectory = self.location.href
+ } else if (typeof document != "undefined" && document.currentScript) {
+ scriptDirectory = document.currentScript.src
+ }
+ if (scriptDirectory.indexOf("blob:") !== 0) {
+ scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1)
+ } else {
+ scriptDirectory = ""
+ }
+ {
+ read_ = url=>{
+ var xhr = new XMLHttpRequest;
+ xhr.open("GET", url, false);
+ xhr.send(null);
+ return xhr.responseText
+ }
+ ;
+ if (ENVIRONMENT_IS_WORKER) {
+ readBinary = url=>{
+ var xhr = new XMLHttpRequest;
+ xhr.open("GET", url, false);
+ xhr.responseType = "arraybuffer";
+ xhr.send(null);
+ return new Uint8Array(xhr.response)
+ }
+ }
+ readAsync = (url,onload,onerror)=>{
+ var xhr = new XMLHttpRequest;
+ xhr.open("GET", url, true);
+ xhr.responseType = "arraybuffer";
+ xhr.onload = ()=>{
+ if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+ onload(xhr.response);
+ return
+ }
+ onerror()
+ }
+ ;
+ xhr.onerror = onerror;
+ xhr.send(null)
+ }
+ }
+ setWindowTitle = title=>document.title = title
+} else {}
+var out = Module["print"] || console.log.bind(console);
+var err = Module["printErr"] || console.warn.bind(console);
+Object.assign(Module, moduleOverrides);
+moduleOverrides = null;
+if (Module["arguments"])
+ arguments_ = Module["arguments"];
+if (Module["thisProgram"])
+ thisProgram = Module["thisProgram"];
+if (Module["quit"])
+ quit_ = Module["quit"];
+var wasmBinary;
+if (Module["wasmBinary"])
+ wasmBinary = Module["wasmBinary"];
+var noExitRuntime = Module["noExitRuntime"] || true;
+if (typeof WebAssembly != "object") {
+ abort("no native wasm support detected")
+}
+var wasmMemory;
+var ABORT = false;
+var EXITSTATUS;
+var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+function updateMemoryViews() {
+ var b = wasmMemory.buffer;
+ Module["HEAP8"] = HEAP8 = new Int8Array(b);
+ Module["HEAP16"] = HEAP16 = new Int16Array(b);
+ Module["HEAP32"] = HEAP32 = new Int32Array(b);
+ Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
+ Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
+ Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
+ Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
+ Module["HEAPF64"] = HEAPF64 = new Float64Array(b)
+}
+var wasmTable;
+var __ATPRERUN__ = [];
+var __ATINIT__ = [];
+var __ATPOSTRUN__ = [];
+var runtimeInitialized = false;
+function preRun() {
+ if (Module["preRun"]) {
+ if (typeof Module["preRun"] == "function")
+ Module["preRun"] = [Module["preRun"]];
+ while (Module["preRun"].length) {
+ addOnPreRun(Module["preRun"].shift())
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__)
+}
+function initRuntime() {
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__)
+}
+function postRun() {
+ if (Module["postRun"]) {
+ if (typeof Module["postRun"] == "function")
+ Module["postRun"] = [Module["postRun"]];
+ while (Module["postRun"].length) {
+ addOnPostRun(Module["postRun"].shift())
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__)
+}
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb)
+}
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb)
+}
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb)
+}
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null;
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module["monitorRunDependencies"]) {
+ Module["monitorRunDependencies"](runDependencies)
+ }
+}
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module["monitorRunDependencies"]) {
+ Module["monitorRunDependencies"](runDependencies)
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback()
+ }
+ }
+}
+function abort(what) {
+ if (Module["onAbort"]) {
+ Module["onAbort"](what)
+ }
+ what = "Aborted(" + what + ")";
+ err(what);
+ ABORT = true;
+ EXITSTATUS = 1;
+ what += ". Build with -sASSERTIONS for more info.";
+ var e = new WebAssembly.RuntimeError(what);
+ throw e
+}
+var dataURIPrefix = "data:application/octet-stream;base64,";
+function isDataURI(filename) {
+ return filename.startsWith(dataURIPrefix)
+}
+function isFileURI(filename) {
+ return filename.startsWith("file://")
+}
+var wasmBinaryFile;
+wasmBinaryFile = "graph-wasm.wasm";
+if (!isDataURI(wasmBinaryFile)) {
+ wasmBinaryFile = locateFile(wasmBinaryFile)
+}
+function getBinary(file) {
+ try {
+ if (file == wasmBinaryFile && wasmBinary) {
+ return new Uint8Array(wasmBinary)
+ }
+ if (readBinary) {
+ return readBinary(file)
+ }
+ throw "both async and sync fetching of the wasm failed"
+ } catch (err) {
+ abort(err)
+ }
+}
+function getBinaryPromise(binaryFile) {
+ if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+ if (typeof fetch == "function" && !isFileURI(binaryFile)) {
+ return fetch(binaryFile, {
+ credentials: "same-origin"
+ }).then(function(response) {
+ if (!response["ok"]) {
+ throw "failed to load wasm binary file at '" + binaryFile + "'"
+ }
+ return response["arrayBuffer"]()
+ }).catch(function() {
+ return getBinary(binaryFile)
+ })
+ } else {
+ if (readAsync) {
+ return new Promise(function(resolve, reject) {
+ readAsync(binaryFile, function(response) {
+ resolve(new Uint8Array(response))
+ }, reject)
+ }
+ )
+ }
+ }
+ }
+ return Promise.resolve().then(function() {
+ return getBinary(binaryFile)
+ })
+}
+function instantiateArrayBuffer(binaryFile, imports, receiver) {
+ return getBinaryPromise(binaryFile).then(function(binary) {
+ return WebAssembly.instantiate(binary, imports)
+ }).then(function(instance) {
+ return instance
+ }).then(receiver, function(reason) {
+ err("failed to asynchronously prepare wasm: " + reason);
+ abort(reason)
+ })
+}
+function instantiateAsync(binary, binaryFile, imports, callback) {
+ if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
+ return fetch(binaryFile, {
+ credentials: "same-origin"
+ }).then(function(response)
+ {
+ let responseClone = new Response(response.body, { headers: new Headers({"Content-Type": "application/wasm"}) });
+ var result = WebAssembly.instantiateStreaming(responseClone, imports);
+ return result.then(callback, function(reason) {
+ err("wasm streaming compile failed: " + reason);
+ err("falling back to ArrayBuffer instantiation");
+ return instantiateArrayBuffer(binaryFile, imports, callback)
+ })
+ })
+ } else {
+ return instantiateArrayBuffer(binaryFile, imports, callback)
+ }
+}
+function createWasm() {
+ var info = {
+ "a": wasmImports
+ };
+ function receiveInstance(instance, module) {
+ var exports = instance.exports;
+ Module["asm"] = exports;
+ wasmMemory = Module["asm"]["f"];
+ updateMemoryViews();
+ wasmTable = Module["asm"]["r"];
+ addOnInit(Module["asm"]["g"]);
+ removeRunDependency("wasm-instantiate");
+ return exports
+ }
+ addRunDependency("wasm-instantiate");
+ function receiveInstantiationResult(result) {
+ receiveInstance(result["instance"])
+ }
+ if (Module["instantiateWasm"]) {
+ try {
+ return Module["instantiateWasm"](info, receiveInstance)
+ } catch (e) {
+ err("Module.instantiateWasm callback failed with error: " + e);
+ return false
+ }
+ }
+ instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult);
+ return {}
+}
+var tempDouble;
+var tempI64;
+var ASM_CONSTS = {
+ 2304: $0=>{
+ console.log(UTF8ToString($0))
+ }
+};
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status
+}
+function callRuntimeCallbacks(callbacks) {
+ while (callbacks.length > 0) {
+ callbacks.shift()(Module)
+ }
+}
+function getValue(ptr, type="i8") {
+ if (type.endsWith("*"))
+ type = "*";
+ switch (type) {
+ case "i1":
+ return HEAP8[ptr >> 0];
+ case "i8":
+ return HEAP8[ptr >> 0];
+ case "i16":
+ return HEAP16[ptr >> 1];
+ case "i32":
+ return HEAP32[ptr >> 2];
+ case "i64":
+ return HEAP32[ptr >> 2];
+ case "float":
+ return HEAPF32[ptr >> 2];
+ case "double":
+ return HEAPF64[ptr >> 3];
+ case "*":
+ return HEAPU32[ptr >> 2];
+ default:
+ abort("invalid type for getValue: " + type)
+ }
+}
+function setValue(ptr, value, type="i8") {
+ if (type.endsWith("*"))
+ type = "*";
+ switch (type) {
+ case "i1":
+ HEAP8[ptr >> 0] = value;
+ break;
+ case "i8":
+ HEAP8[ptr >> 0] = value;
+ break;
+ case "i16":
+ HEAP16[ptr >> 1] = value;
+ break;
+ case "i32":
+ HEAP32[ptr >> 2] = value;
+ break;
+ case "i64":
+ tempI64 = [value >>> 0, (tempDouble = value,
+ +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)],
+ HEAP32[ptr >> 2] = tempI64[0],
+ HEAP32[ptr + 4 >> 2] = tempI64[1];
+ break;
+ case "float":
+ HEAPF32[ptr >> 2] = value;
+ break;
+ case "double":
+ HEAPF64[ptr >> 3] = value;
+ break;
+ case "*":
+ HEAPU32[ptr >> 2] = value;
+ break;
+ default:
+ abort("invalid type for setValue: " + type)
+ }
+}
+function _abort() {
+ abort("")
+}
+var readEmAsmArgsArray = [];
+function readEmAsmArgs(sigPtr, buf) {
+ readEmAsmArgsArray.length = 0;
+ var ch;
+ buf >>= 2;
+ while (ch = HEAPU8[sigPtr++]) {
+ buf += ch != 105 & buf;
+ readEmAsmArgsArray.push(ch == 105 ? HEAP32[buf] : HEAPF64[buf++ >> 1]);
+ ++buf
+ }
+ return readEmAsmArgsArray
+}
+function runEmAsmFunction(code, sigPtr, argbuf) {
+ var args = readEmAsmArgs(sigPtr, argbuf);
+ return ASM_CONSTS[code].apply(null, args)
+}
+function _emscripten_asm_const_int(code, sigPtr, argbuf) {
+ return runEmAsmFunction(code, sigPtr, argbuf)
+}
+function _emscripten_date_now() {
+ return Date.now()
+}
+function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.copyWithin(dest, src, src + num)
+}
+function getHeapMax() {
+ return 2147483648
+}
+function emscripten_realloc_buffer(size) {
+ var b = wasmMemory.buffer;
+ try {
+ wasmMemory.grow(size - b.byteLength + 65535 >>> 16);
+ updateMemoryViews();
+ return 1
+ } catch (e) {}
+}
+function _emscripten_resize_heap(requestedSize) {
+ var oldSize = HEAPU8.length;
+ requestedSize = requestedSize >>> 0;
+ var maxHeapSize = getHeapMax();
+ if (requestedSize > maxHeapSize) {
+ return false
+ }
+ let alignUp = (x,multiple)=>x + (multiple - x % multiple) % multiple;
+ for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+ var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+ overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+ var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
+ var replacement = emscripten_realloc_buffer(newSize);
+ if (replacement) {
+ return true
+ }
+ }
+ return false
+}
+function getCFunc(ident) {
+ var func = Module["_" + ident];
+ return func
+}
+function writeArrayToMemory(array, buffer) {
+ HEAP8.set(array, buffer)
+}
+function lengthBytesUTF8(str) {
+ var len = 0;
+ for (var i = 0; i < str.length; ++i) {
+ var c = str.charCodeAt(i);
+ if (c <= 127) {
+ len++
+ } else if (c <= 2047) {
+ len += 2
+ } else if (c >= 55296 && c <= 57343) {
+ len += 4;
+ ++i
+ } else {
+ len += 3
+ }
+ }
+ return len
+}
+function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
+ if (!(maxBytesToWrite > 0))
+ return 0;
+ var startIdx = outIdx;
+ var endIdx = outIdx + maxBytesToWrite - 1;
+ for (var i = 0; i < str.length; ++i) {
+ var u = str.charCodeAt(i);
+ if (u >= 55296 && u <= 57343) {
+ var u1 = str.charCodeAt(++i);
+ u = 65536 + ((u & 1023) << 10) | u1 & 1023
+ }
+ if (u <= 127) {
+ if (outIdx >= endIdx)
+ break;
+ heap[outIdx++] = u
+ } else if (u <= 2047) {
+ if (outIdx + 1 >= endIdx)
+ break;
+ heap[outIdx++] = 192 | u >> 6;
+ heap[outIdx++] = 128 | u & 63
+ } else if (u <= 65535) {
+ if (outIdx + 2 >= endIdx)
+ break;
+ heap[outIdx++] = 224 | u >> 12;
+ heap[outIdx++] = 128 | u >> 6 & 63;
+ heap[outIdx++] = 128 | u & 63
+ } else {
+ if (outIdx + 3 >= endIdx)
+ break;
+ heap[outIdx++] = 240 | u >> 18;
+ heap[outIdx++] = 128 | u >> 12 & 63;
+ heap[outIdx++] = 128 | u >> 6 & 63;
+ heap[outIdx++] = 128 | u & 63
+ }
+ }
+ heap[outIdx] = 0;
+ return outIdx - startIdx
+}
+function stringToUTF8(str, outPtr, maxBytesToWrite) {
+ return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
+}
+function stringToUTF8OnStack(str) {
+ var size = lengthBytesUTF8(str) + 1;
+ var ret = stackAlloc(size);
+ stringToUTF8(str, ret, size);
+ return ret
+}
+var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
+function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
+ var endIdx = idx + maxBytesToRead;
+ var endPtr = idx;
+ while (heapOrArray[endPtr] && !(endPtr >= endIdx))
+ ++endPtr;
+ if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+ return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr))
+ }
+ var str = "";
+ while (idx < endPtr) {
+ var u0 = heapOrArray[idx++];
+ if (!(u0 & 128)) {
+ str += String.fromCharCode(u0);
+ continue
+ }
+ var u1 = heapOrArray[idx++] & 63;
+ if ((u0 & 224) == 192) {
+ str += String.fromCharCode((u0 & 31) << 6 | u1);
+ continue
+ }
+ var u2 = heapOrArray[idx++] & 63;
+ if ((u0 & 240) == 224) {
+ u0 = (u0 & 15) << 12 | u1 << 6 | u2
+ } else {
+ u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63
+ }
+ if (u0 < 65536) {
+ str += String.fromCharCode(u0)
+ } else {
+ var ch = u0 - 65536;
+ str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
+ }
+ }
+ return str
+}
+function UTF8ToString(ptr, maxBytesToRead) {
+ return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""
+}
+function ccall(ident, returnType, argTypes, args, opts) {
+ var toC = {
+ "string": str=>{
+ var ret = 0;
+ if (str !== null && str !== undefined && str !== 0) {
+ ret = stringToUTF8OnStack(str)
+ }
+ return ret
+ }
+ ,
+ "array": arr=>{
+ var ret = stackAlloc(arr.length);
+ writeArrayToMemory(arr, ret);
+ return ret
+ }
+ };
+ function convertReturnValue(ret) {
+ if (returnType === "string") {
+ return UTF8ToString(ret)
+ }
+ if (returnType === "boolean")
+ return Boolean(ret);
+ return ret
+ }
+ var func = getCFunc(ident);
+ var cArgs = [];
+ var stack = 0;
+ if (args) {
+ for (var i = 0; i < args.length; i++) {
+ var converter = toC[argTypes[i]];
+ if (converter) {
+ if (stack === 0)
+ stack = stackSave();
+ cArgs[i] = converter(args[i])
+ } else {
+ cArgs[i] = args[i]
+ }
+ }
+ }
+ var ret = func.apply(null, cArgs);
+ function onDone(ret) {
+ if (stack !== 0)
+ stackRestore(stack);
+ return convertReturnValue(ret)
+ }
+ ret = onDone(ret);
+ return ret
+}
+function cwrap(ident, returnType, argTypes, opts) {
+ var numericArgs = !argTypes || argTypes.every(type=>type === "number" || type === "boolean");
+ var numericRet = returnType !== "string";
+ if (numericRet && numericArgs && !opts) {
+ return getCFunc(ident)
+ }
+ return function() {
+ return ccall(ident, returnType, argTypes, arguments, opts)
+ }
+}
+var wasmImports = {
+ "b": _abort,
+ "e": _emscripten_asm_const_int,
+ "d": _emscripten_date_now,
+ "c": _emscripten_memcpy_big,
+ "a": _emscripten_resize_heap
+};
+var asm = createWasm();
+var ___wasm_call_ctors = function() {
+ return (___wasm_call_ctors = Module["asm"]["g"]).apply(null, arguments)
+};
+var _SetBatchFractionSize = Module["_SetBatchFractionSize"] = function() {
+ return (_SetBatchFractionSize = Module["_SetBatchFractionSize"] = Module["asm"]["h"]).apply(null, arguments)
+}
+;
+var _SetAttractionForce = Module["_SetAttractionForce"] = function() {
+ return (_SetAttractionForce = Module["_SetAttractionForce"] = Module["asm"]["i"]).apply(null, arguments)
+}
+;
+var _SetLinkLength = Module["_SetLinkLength"] = function() {
+ return (_SetLinkLength = Module["_SetLinkLength"] = Module["asm"]["j"]).apply(null, arguments)
+}
+;
+var _SetRepulsionForce = Module["_SetRepulsionForce"] = function() {
+ return (_SetRepulsionForce = Module["_SetRepulsionForce"] = Module["asm"]["k"]).apply(null, arguments)
+}
+;
+var _SetCentralForce = Module["_SetCentralForce"] = function() {
+ return (_SetCentralForce = Module["_SetCentralForce"] = Module["asm"]["l"]).apply(null, arguments)
+}
+;
+var _SetDt = Module["_SetDt"] = function() {
+ return (_SetDt = Module["_SetDt"] = Module["asm"]["m"]).apply(null, arguments)
+}
+;
+var _Init = Module["_Init"] = function() {
+ return (_Init = Module["_Init"] = Module["asm"]["n"]).apply(null, arguments)
+}
+;
+var _Update = Module["_Update"] = function() {
+ return (_Update = Module["_Update"] = Module["asm"]["o"]).apply(null, arguments)
+}
+;
+var _SetPosition = Module["_SetPosition"] = function() {
+ return (_SetPosition = Module["_SetPosition"] = Module["asm"]["p"]).apply(null, arguments)
+}
+;
+var _FreeMemory = Module["_FreeMemory"] = function() {
+ return (_FreeMemory = Module["_FreeMemory"] = Module["asm"]["q"]).apply(null, arguments)
+}
+;
+var ___errno_location = function() {
+ return (___errno_location = Module["asm"]["__errno_location"]).apply(null, arguments)
+};
+var _malloc = Module["_malloc"] = function() {
+ return (_malloc = Module["_malloc"] = Module["asm"]["s"]).apply(null, arguments)
+}
+;
+var _free = Module["_free"] = function() {
+ return (_free = Module["_free"] = Module["asm"]["t"]).apply(null, arguments)
+}
+;
+var stackSave = function() {
+ return (stackSave = Module["asm"]["u"]).apply(null, arguments)
+};
+var stackRestore = function() {
+ return (stackRestore = Module["asm"]["v"]).apply(null, arguments)
+};
+var stackAlloc = function() {
+ return (stackAlloc = Module["asm"]["w"]).apply(null, arguments)
+};
+var ___cxa_is_pointer_type = function() {
+ return (___cxa_is_pointer_type = Module["asm"]["__cxa_is_pointer_type"]).apply(null, arguments)
+};
+Module["cwrap"] = cwrap;
+Module["setValue"] = setValue;
+Module["getValue"] = getValue;
+var calledRun;
+dependenciesFulfilled = function runCaller() {
+ if (!calledRun)
+ run();
+ if (!calledRun)
+ dependenciesFulfilled = runCaller
+}
+;
+function run() {
+ if (runDependencies > 0) {
+ return
+ }
+ preRun();
+ if (runDependencies > 0) {
+ return
+ }
+ function doRun() {
+ if (calledRun)
+ return;
+ calledRun = true;
+ Module["calledRun"] = true;
+ if (ABORT)
+ return;
+ initRuntime();
+ if (Module["onRuntimeInitialized"])
+ Module["onRuntimeInitialized"]();
+ postRun()
+ }
+ if (Module["setStatus"]) {
+ Module["setStatus"]("Running...");
+ setTimeout(function() {
+ setTimeout(function() {
+ Module["setStatus"]("")
+ }, 1);
+ doRun()
+ }, 1)
+ } else {
+ doRun()
+ }
+}
+if (Module["preInit"]) {
+ if (typeof Module["preInit"] == "function")
+ Module["preInit"] = [Module["preInit"]];
+ while (Module["preInit"].length > 0) {
+ Module["preInit"].pop()()
+ }
+}
+
+try
+{
+ run();
+}
+catch(e)
+{
+ console.error(e);
+}
diff --git a/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-wasm.wasm b/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-wasm.wasm
new file mode 100644
index 00000000..e94bee22
Binary files /dev/null and b/.obsidian/plugins/obsidian-webpage-export-master/assets/graph-wasm.wasm differ
diff --git a/.obsidian/plugins/obsidian-webpage-export-master/assets/icon.png b/.obsidian/plugins/obsidian-webpage-export-master/assets/icon.png
new file mode 100644
index 00000000..6f994895
Binary files /dev/null and b/.obsidian/plugins/obsidian-webpage-export-master/assets/icon.png differ
diff --git a/.obsidian/plugins/obsidian-webpage-export-master/assets/minisearch.txt.js b/.obsidian/plugins/obsidian-webpage-export-master/assets/minisearch.txt.js
new file mode 100644
index 00000000..df2e78e6
--- /dev/null
+++ b/.obsidian/plugins/obsidian-webpage-export-master/assets/minisearch.txt.js
@@ -0,0 +1,5 @@
+/**
+ * Minified by jsDelivr using Terser v5.19.2.
+ * Original file: /npm/minisearch@6.3.0/dist/umd/index.js
+ */
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).MiniSearch=e()}(this,(function(){"use strict";var t=function(){return t=Object.assign||function(t){for(var e,r=1,n=arguments.length;r