You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
892 lines
28 KiB
JavaScript
892 lines
28 KiB
JavaScript
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
|
|
// node_modules/incremental-dom/dist/incremental-dom-cjs.js
|
|
var require_incremental_dom_cjs = __commonJS({
|
|
"node_modules/incremental-dom/dist/incremental-dom-cjs.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var keyAttributeName = "key";
|
|
function getKeyAttributeName() {
|
|
return keyAttributeName;
|
|
}
|
|
function setKeyAttributeName(name) {
|
|
keyAttributeName = name;
|
|
}
|
|
var inAttributes = false;
|
|
var inSkip = false;
|
|
var inPatch = false;
|
|
function assert(val) {
|
|
if (!val) {
|
|
throw new Error("Expected value to be defined");
|
|
}
|
|
return val;
|
|
}
|
|
function assertInPatch(functionName) {
|
|
if (!inPatch) {
|
|
throw new Error("Cannot call " + functionName + "() unless in patch.");
|
|
}
|
|
}
|
|
function assertNoUnclosedTags(openElement, root2) {
|
|
if (openElement === root2) {
|
|
return;
|
|
}
|
|
let currentElement2 = openElement;
|
|
const openTags = [];
|
|
while (currentElement2 && currentElement2 !== root2) {
|
|
openTags.push(currentElement2.nodeName.toLowerCase());
|
|
currentElement2 = currentElement2.parentNode;
|
|
}
|
|
throw new Error("One or more tags were not closed:\n" + openTags.join("\n"));
|
|
}
|
|
function assertPatchOuterHasParentNode(parent) {
|
|
if (!parent) {
|
|
console.warn("patchOuter requires the node have a parent if there is a key.");
|
|
}
|
|
}
|
|
function assertNotInAttributes(functionName) {
|
|
if (inAttributes) {
|
|
throw new Error(functionName + "() can not be called between elementOpenStart() and elementOpenEnd().");
|
|
}
|
|
}
|
|
function assertNotInSkip(functionName) {
|
|
if (inSkip) {
|
|
throw new Error(functionName + "() may not be called inside an element that has called skip().");
|
|
}
|
|
}
|
|
function assertInAttributes(functionName) {
|
|
if (!inAttributes) {
|
|
throw new Error(functionName + "() can only be called after calling elementOpenStart().");
|
|
}
|
|
}
|
|
function assertVirtualAttributesClosed() {
|
|
if (inAttributes) {
|
|
throw new Error("elementOpenEnd() must be called after calling elementOpenStart().");
|
|
}
|
|
}
|
|
function assertCloseMatchesOpenTag(currentNameOrCtor, nameOrCtor) {
|
|
if (currentNameOrCtor !== nameOrCtor) {
|
|
throw new Error('Received a call to close "' + nameOrCtor + '" but "' + currentNameOrCtor + '" was open.');
|
|
}
|
|
}
|
|
function assertNoChildrenDeclaredYet(functionName, previousNode) {
|
|
if (previousNode !== null) {
|
|
throw new Error(functionName + "() must come before any child declarations inside the current element.");
|
|
}
|
|
}
|
|
function assertPatchElementNoExtras(maybeStartNode, maybeCurrentNode, expectedNextNode, expectedPrevNode) {
|
|
const startNode = assert(maybeStartNode);
|
|
const currentNode2 = assert(maybeCurrentNode);
|
|
const wasUpdated = currentNode2.nextSibling === expectedNextNode && currentNode2.previousSibling === expectedPrevNode;
|
|
const wasChanged = currentNode2.nextSibling === startNode.nextSibling && currentNode2.previousSibling === expectedPrevNode;
|
|
const wasRemoved = currentNode2 === startNode;
|
|
if (!wasUpdated && !wasChanged && !wasRemoved) {
|
|
throw new Error("There must be exactly one top level call corresponding to the patched element.");
|
|
}
|
|
}
|
|
function updatePatchContext(newContext) {
|
|
inPatch = newContext != null;
|
|
}
|
|
function setInAttributes(value) {
|
|
const previous = inAttributes;
|
|
inAttributes = value;
|
|
return previous;
|
|
}
|
|
function setInSkip(value) {
|
|
const previous = inSkip;
|
|
inSkip = value;
|
|
return previous;
|
|
}
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
function Blank() {
|
|
}
|
|
Blank.prototype = /* @__PURE__ */ Object.create(null);
|
|
function has(map, property) {
|
|
return hasOwnProperty.call(map, property);
|
|
}
|
|
function createMap() {
|
|
return new Blank();
|
|
}
|
|
function truncateArray(arr, length) {
|
|
while (arr.length > length) {
|
|
arr.pop();
|
|
}
|
|
}
|
|
function createArray(initialAllocationSize) {
|
|
const arr = new Array(initialAllocationSize);
|
|
truncateArray(arr, 0);
|
|
return arr;
|
|
}
|
|
var symbols = {
|
|
default: "__default"
|
|
};
|
|
function getNamespace(name) {
|
|
if (name.lastIndexOf("xml:", 0) === 0) {
|
|
return "http://www.w3.org/XML/1998/namespace";
|
|
}
|
|
if (name.lastIndexOf("xlink:", 0) === 0) {
|
|
return "http://www.w3.org/1999/xlink";
|
|
}
|
|
return null;
|
|
}
|
|
function applyAttr(el, name, value) {
|
|
if (value == null) {
|
|
el.removeAttribute(name);
|
|
} else {
|
|
const attrNS = getNamespace(name);
|
|
if (attrNS) {
|
|
el.setAttributeNS(attrNS, name, String(value));
|
|
} else {
|
|
el.setAttribute(name, String(value));
|
|
}
|
|
}
|
|
}
|
|
function applyProp(el, name, value) {
|
|
el[name] = value;
|
|
}
|
|
function setStyleValue(style, prop, value) {
|
|
if (prop.indexOf("-") >= 0) {
|
|
style.setProperty(prop, value);
|
|
} else {
|
|
style[prop] = value;
|
|
}
|
|
}
|
|
function applyStyle(el, name, style) {
|
|
assert("style" in el);
|
|
const elStyle = el.style;
|
|
if (typeof style === "string") {
|
|
elStyle.cssText = style;
|
|
} else {
|
|
elStyle.cssText = "";
|
|
for (const prop in style) {
|
|
if (has(style, prop)) {
|
|
setStyleValue(elStyle, prop, style[prop]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function applyAttributeTyped(el, name, value) {
|
|
const type = typeof value;
|
|
if (type === "object" || type === "function") {
|
|
applyProp(el, name, value);
|
|
} else {
|
|
applyAttr(el, name, value);
|
|
}
|
|
}
|
|
var attributes = createMap();
|
|
attributes[symbols.default] = applyAttributeTyped;
|
|
attributes["style"] = applyStyle;
|
|
function updateAttribute(el, name, value) {
|
|
const mutator = attributes[name] || attributes[symbols.default];
|
|
mutator(el, name, value);
|
|
}
|
|
var notifications = {
|
|
nodesCreated: null,
|
|
nodesDeleted: null
|
|
};
|
|
var Context = class {
|
|
constructor() {
|
|
this.created = [];
|
|
this.deleted = [];
|
|
}
|
|
markCreated(node) {
|
|
this.created.push(node);
|
|
}
|
|
markDeleted(node) {
|
|
this.deleted.push(node);
|
|
}
|
|
/**
|
|
* Notifies about nodes that were created during the patch operation.
|
|
*/
|
|
notifyChanges() {
|
|
if (notifications.nodesCreated && this.created.length > 0) {
|
|
notifications.nodesCreated(this.created);
|
|
}
|
|
if (notifications.nodesDeleted && this.deleted.length > 0) {
|
|
notifications.nodesDeleted(this.deleted);
|
|
}
|
|
}
|
|
};
|
|
function isDocumentRoot(node) {
|
|
return node.nodeType === 11 || node.nodeType === 9;
|
|
}
|
|
function isElement(node) {
|
|
return node.nodeType === 1;
|
|
}
|
|
function getAncestry(node, root2) {
|
|
const ancestry = [];
|
|
let cur = node;
|
|
while (cur !== root2) {
|
|
const n = assert(cur);
|
|
ancestry.push(n);
|
|
cur = n.parentNode;
|
|
}
|
|
return ancestry;
|
|
}
|
|
var getRootNode = typeof Node !== "undefined" && Node.prototype.getRootNode || function() {
|
|
let cur = this;
|
|
let prev = cur;
|
|
while (cur) {
|
|
prev = cur;
|
|
cur = cur.parentNode;
|
|
}
|
|
return prev;
|
|
};
|
|
function getActiveElement(node) {
|
|
const root2 = getRootNode.call(node);
|
|
return isDocumentRoot(root2) ? root2.activeElement : null;
|
|
}
|
|
function getFocusedPath(node, root2) {
|
|
const activeElement = getActiveElement(node);
|
|
if (!activeElement || !node.contains(activeElement)) {
|
|
return [];
|
|
}
|
|
return getAncestry(activeElement, root2);
|
|
}
|
|
function moveBefore(parentNode, node, referenceNode) {
|
|
const insertReferenceNode = node.nextSibling;
|
|
let cur = referenceNode;
|
|
while (cur !== null && cur !== node) {
|
|
const next = cur.nextSibling;
|
|
parentNode.insertBefore(cur, insertReferenceNode);
|
|
cur = next;
|
|
}
|
|
}
|
|
var NodeData = class {
|
|
constructor(nameOrCtor, key2, text4) {
|
|
this._attrsArr = null;
|
|
this.staticsApplied = false;
|
|
this.nameOrCtor = nameOrCtor;
|
|
this.key = key2;
|
|
this.text = text4;
|
|
}
|
|
hasEmptyAttrsArr() {
|
|
const attrs = this._attrsArr;
|
|
return !attrs || !attrs.length;
|
|
}
|
|
getAttrsArr(length) {
|
|
return this._attrsArr || (this._attrsArr = createArray(length));
|
|
}
|
|
};
|
|
function initData(node, nameOrCtor, key2, text4) {
|
|
const data = new NodeData(nameOrCtor, key2, text4);
|
|
node["__incrementalDOMData"] = data;
|
|
return data;
|
|
}
|
|
function isDataInitialized(node) {
|
|
return Boolean(node["__incrementalDOMData"]);
|
|
}
|
|
function recordAttributes(node, data) {
|
|
const attributes2 = node.attributes;
|
|
const length = attributes2.length;
|
|
if (!length) {
|
|
return;
|
|
}
|
|
const attrsArr = data.getAttrsArr(length);
|
|
for (let i = 0, j = 0; i < length; i += 1, j += 2) {
|
|
const attr2 = attributes2[i];
|
|
const name = attr2.name;
|
|
const value = attr2.value;
|
|
attrsArr[j] = name;
|
|
attrsArr[j + 1] = value;
|
|
}
|
|
}
|
|
function importSingleNode(node, fallbackKey) {
|
|
if (node["__incrementalDOMData"]) {
|
|
return node["__incrementalDOMData"];
|
|
}
|
|
const nodeName = isElement(node) ? node.localName : node.nodeName;
|
|
const keyAttrName = getKeyAttributeName();
|
|
const keyAttr = isElement(node) && keyAttrName != null ? node.getAttribute(keyAttrName) : null;
|
|
const key2 = isElement(node) ? keyAttr || fallbackKey : null;
|
|
const data = initData(node, nodeName, key2);
|
|
if (isElement(node)) {
|
|
recordAttributes(node, data);
|
|
}
|
|
return data;
|
|
}
|
|
function importNode(node) {
|
|
importSingleNode(node);
|
|
for (let child = node.firstChild; child; child = child.nextSibling) {
|
|
importNode(child);
|
|
}
|
|
}
|
|
function getData(node, fallbackKey) {
|
|
return importSingleNode(node, fallbackKey);
|
|
}
|
|
function getKey(node) {
|
|
assert(node["__incrementalDOMData"]);
|
|
return getData(node).key;
|
|
}
|
|
function clearCache(node) {
|
|
node["__incrementalDOMData"] = null;
|
|
for (let child = node.firstChild; child; child = child.nextSibling) {
|
|
clearCache(child);
|
|
}
|
|
}
|
|
function getNamespaceForTag(tag, parent) {
|
|
if (tag === "svg") {
|
|
return "http://www.w3.org/2000/svg";
|
|
}
|
|
if (tag === "math") {
|
|
return "http://www.w3.org/1998/Math/MathML";
|
|
}
|
|
if (parent == null) {
|
|
return null;
|
|
}
|
|
if (getData(parent).nameOrCtor === "foreignObject") {
|
|
return null;
|
|
}
|
|
return parent.namespaceURI;
|
|
}
|
|
function createElement(doc2, parent, nameOrCtor, key2) {
|
|
let el;
|
|
if (typeof nameOrCtor === "function") {
|
|
el = new nameOrCtor();
|
|
} else {
|
|
const namespace = getNamespaceForTag(nameOrCtor, parent);
|
|
if (namespace) {
|
|
el = doc2.createElementNS(namespace, nameOrCtor);
|
|
} else {
|
|
el = doc2.createElement(nameOrCtor);
|
|
}
|
|
}
|
|
initData(el, nameOrCtor, key2);
|
|
return el;
|
|
}
|
|
function createText(doc2) {
|
|
const node = doc2.createTextNode("");
|
|
initData(node, "#text", null);
|
|
return node;
|
|
}
|
|
function defaultMatchFn(matchNode, nameOrCtor, expectedNameOrCtor, key2, expectedKey) {
|
|
return nameOrCtor == expectedNameOrCtor && key2 == expectedKey;
|
|
}
|
|
var context = null;
|
|
var currentNode = null;
|
|
var currentParent = null;
|
|
var doc = null;
|
|
var focusPath = [];
|
|
var matchFn = defaultMatchFn;
|
|
var argsBuilder = [];
|
|
var attrsBuilder = [];
|
|
function getArgsBuilder() {
|
|
return argsBuilder;
|
|
}
|
|
function getAttrsBuilder() {
|
|
return attrsBuilder;
|
|
}
|
|
function matches(matchNode, nameOrCtor, key2) {
|
|
const data = getData(matchNode, key2);
|
|
return matchFn(matchNode, nameOrCtor, data.nameOrCtor, key2, data.key);
|
|
}
|
|
function getMatchingNode(matchNode, nameOrCtor, key2) {
|
|
if (!matchNode) {
|
|
return null;
|
|
}
|
|
let cur = matchNode;
|
|
do {
|
|
if (matches(cur, nameOrCtor, key2)) {
|
|
return cur;
|
|
}
|
|
} while (key2 && (cur = cur.nextSibling));
|
|
return null;
|
|
}
|
|
function clearUnvisitedDOM(maybeParentNode, startNode, endNode) {
|
|
const parentNode = maybeParentNode;
|
|
let child = startNode;
|
|
while (child !== endNode) {
|
|
const next = child.nextSibling;
|
|
parentNode.removeChild(child);
|
|
context.markDeleted(child);
|
|
child = next;
|
|
}
|
|
}
|
|
function getNextNode() {
|
|
if (currentNode) {
|
|
return currentNode.nextSibling;
|
|
} else {
|
|
return currentParent.firstChild;
|
|
}
|
|
}
|
|
function enterNode() {
|
|
currentParent = currentNode;
|
|
currentNode = null;
|
|
}
|
|
function exitNode() {
|
|
clearUnvisitedDOM(currentParent, getNextNode(), null);
|
|
currentNode = currentParent;
|
|
currentParent = currentParent.parentNode;
|
|
}
|
|
function nextNode() {
|
|
currentNode = getNextNode();
|
|
}
|
|
function createNode(nameOrCtor, key2) {
|
|
let node;
|
|
if (nameOrCtor === "#text") {
|
|
node = createText(doc);
|
|
} else {
|
|
node = createElement(doc, currentParent, nameOrCtor, key2);
|
|
}
|
|
context.markCreated(node);
|
|
return node;
|
|
}
|
|
function alignWithDOM(nameOrCtor, key2) {
|
|
nextNode();
|
|
const existingNode = getMatchingNode(currentNode, nameOrCtor, key2);
|
|
const node = existingNode || createNode(nameOrCtor, key2);
|
|
if (node === currentNode) {
|
|
return;
|
|
}
|
|
if (focusPath.indexOf(node) >= 0) {
|
|
moveBefore(currentParent, node, currentNode);
|
|
} else {
|
|
currentParent.insertBefore(node, currentNode);
|
|
}
|
|
currentNode = node;
|
|
}
|
|
function open(nameOrCtor, key2) {
|
|
alignWithDOM(nameOrCtor, key2);
|
|
enterNode();
|
|
return currentParent;
|
|
}
|
|
function close() {
|
|
{
|
|
setInSkip(false);
|
|
}
|
|
exitNode();
|
|
return currentNode;
|
|
}
|
|
function text3() {
|
|
alignWithDOM("#text", null);
|
|
return currentNode;
|
|
}
|
|
function currentElement() {
|
|
{
|
|
assertInPatch("currentElement");
|
|
assertNotInAttributes("currentElement");
|
|
}
|
|
return currentParent;
|
|
}
|
|
function currentPointer() {
|
|
{
|
|
assertInPatch("currentPointer");
|
|
assertNotInAttributes("currentPointer");
|
|
}
|
|
return getNextNode();
|
|
}
|
|
function skip() {
|
|
{
|
|
assertNoChildrenDeclaredYet("skip", currentNode);
|
|
setInSkip(true);
|
|
}
|
|
currentNode = currentParent.lastChild;
|
|
}
|
|
function createPatcher(run, patchConfig = {}) {
|
|
const { matches: matches2 = defaultMatchFn } = patchConfig;
|
|
const f = (node, fn, data) => {
|
|
const prevContext = context;
|
|
const prevDoc = doc;
|
|
const prevFocusPath = focusPath;
|
|
const prevArgsBuilder = argsBuilder;
|
|
const prevAttrsBuilder = attrsBuilder;
|
|
const prevCurrentNode = currentNode;
|
|
const prevCurrentParent = currentParent;
|
|
const prevMatchFn = matchFn;
|
|
let previousInAttributes = false;
|
|
let previousInSkip = false;
|
|
doc = node.ownerDocument;
|
|
context = new Context();
|
|
matchFn = matches2;
|
|
argsBuilder = [];
|
|
attrsBuilder = [];
|
|
currentNode = null;
|
|
currentParent = node.parentNode;
|
|
focusPath = getFocusedPath(node, currentParent);
|
|
{
|
|
previousInAttributes = setInAttributes(false);
|
|
previousInSkip = setInSkip(false);
|
|
updatePatchContext(context);
|
|
}
|
|
try {
|
|
const retVal = run(node, fn, data);
|
|
{
|
|
assertVirtualAttributesClosed();
|
|
}
|
|
return retVal;
|
|
} finally {
|
|
context.notifyChanges();
|
|
doc = prevDoc;
|
|
context = prevContext;
|
|
matchFn = prevMatchFn;
|
|
argsBuilder = prevArgsBuilder;
|
|
attrsBuilder = prevAttrsBuilder;
|
|
currentNode = prevCurrentNode;
|
|
currentParent = prevCurrentParent;
|
|
focusPath = prevFocusPath;
|
|
{
|
|
setInAttributes(previousInAttributes);
|
|
setInSkip(previousInSkip);
|
|
updatePatchContext(context);
|
|
}
|
|
}
|
|
};
|
|
return f;
|
|
}
|
|
function createPatchInner(patchConfig) {
|
|
return createPatcher((node, fn, data) => {
|
|
currentNode = node;
|
|
enterNode();
|
|
fn(data);
|
|
exitNode();
|
|
{
|
|
assertNoUnclosedTags(currentNode, node);
|
|
}
|
|
return node;
|
|
}, patchConfig);
|
|
}
|
|
function createPatchOuter(patchConfig) {
|
|
return createPatcher((node, fn, data) => {
|
|
const startNode = { nextSibling: node };
|
|
let expectedNextNode = null;
|
|
let expectedPrevNode = null;
|
|
{
|
|
expectedNextNode = node.nextSibling;
|
|
expectedPrevNode = node.previousSibling;
|
|
}
|
|
currentNode = startNode;
|
|
fn(data);
|
|
{
|
|
assertPatchOuterHasParentNode(currentParent);
|
|
assertPatchElementNoExtras(startNode, currentNode, expectedNextNode, expectedPrevNode);
|
|
}
|
|
if (currentParent) {
|
|
clearUnvisitedDOM(currentParent, getNextNode(), node.nextSibling);
|
|
}
|
|
return startNode === currentNode ? null : currentNode;
|
|
}, patchConfig);
|
|
}
|
|
var patchInner = createPatchInner();
|
|
var patchOuter = createPatchOuter();
|
|
var buffer = [];
|
|
var bufferStart = 0;
|
|
function queueChange(fn, a, b, c2) {
|
|
buffer.push(fn);
|
|
buffer.push(a);
|
|
buffer.push(b);
|
|
buffer.push(c2);
|
|
}
|
|
function flush() {
|
|
const start = bufferStart;
|
|
const end = buffer.length;
|
|
bufferStart = end;
|
|
for (let i = start; i < end; i += 4) {
|
|
const fn = buffer[i];
|
|
fn(buffer[i + 1], buffer[i + 2], buffer[i + 3]);
|
|
}
|
|
bufferStart = start;
|
|
truncateArray(buffer, start);
|
|
}
|
|
var prevValuesMap = createMap();
|
|
function calculateDiff(prev, next, updateCtx, updateFn) {
|
|
const isNew = !prev.length;
|
|
let i = 0;
|
|
for (; i < next.length; i += 2) {
|
|
const name = next[i];
|
|
if (isNew) {
|
|
prev[i] = name;
|
|
} else if (prev[i] !== name) {
|
|
break;
|
|
}
|
|
const value = next[i + 1];
|
|
if (isNew || prev[i + 1] !== value) {
|
|
prev[i + 1] = value;
|
|
queueChange(updateFn, updateCtx, name, value);
|
|
}
|
|
}
|
|
if (i < next.length || i < prev.length) {
|
|
const startIndex = i;
|
|
for (i = startIndex; i < prev.length; i += 2) {
|
|
prevValuesMap[prev[i]] = prev[i + 1];
|
|
}
|
|
for (i = startIndex; i < next.length; i += 2) {
|
|
const name = next[i];
|
|
const value = next[i + 1];
|
|
if (prevValuesMap[name] !== value) {
|
|
queueChange(updateFn, updateCtx, name, value);
|
|
}
|
|
prev[i] = name;
|
|
prev[i + 1] = value;
|
|
delete prevValuesMap[name];
|
|
}
|
|
truncateArray(prev, next.length);
|
|
for (const name in prevValuesMap) {
|
|
queueChange(updateFn, updateCtx, name, void 0);
|
|
delete prevValuesMap[name];
|
|
}
|
|
}
|
|
flush();
|
|
}
|
|
var ATTRIBUTES_OFFSET = 3;
|
|
var prevAttrsMap = createMap();
|
|
function diffAttrs(element, data) {
|
|
const attrsBuilder2 = getAttrsBuilder();
|
|
const prevAttrsArr = data.getAttrsArr(attrsBuilder2.length);
|
|
calculateDiff(prevAttrsArr, attrsBuilder2, element, updateAttribute);
|
|
truncateArray(attrsBuilder2, 0);
|
|
}
|
|
function diffStatics(node, data, statics) {
|
|
if (data.staticsApplied) {
|
|
return;
|
|
}
|
|
data.staticsApplied = true;
|
|
if (!statics || !statics.length) {
|
|
return;
|
|
}
|
|
if (data.hasEmptyAttrsArr()) {
|
|
for (let i = 0; i < statics.length; i += 2) {
|
|
updateAttribute(node, statics[i], statics[i + 1]);
|
|
}
|
|
return;
|
|
}
|
|
for (let i = 0; i < statics.length; i += 2) {
|
|
prevAttrsMap[statics[i]] = i + 1;
|
|
}
|
|
const attrsArr = data.getAttrsArr(0);
|
|
let j = 0;
|
|
for (let i = 0; i < attrsArr.length; i += 2) {
|
|
const name = attrsArr[i];
|
|
const value = attrsArr[i + 1];
|
|
const staticsIndex = prevAttrsMap[name];
|
|
if (staticsIndex) {
|
|
if (statics[staticsIndex] === value) {
|
|
delete prevAttrsMap[name];
|
|
}
|
|
continue;
|
|
}
|
|
attrsArr[j] = name;
|
|
attrsArr[j + 1] = value;
|
|
j += 2;
|
|
}
|
|
truncateArray(attrsArr, j);
|
|
for (const name in prevAttrsMap) {
|
|
updateAttribute(node, name, statics[prevAttrsMap[name]]);
|
|
delete prevAttrsMap[name];
|
|
}
|
|
}
|
|
function elementOpenStart(nameOrCtor, key2, statics) {
|
|
const argsBuilder2 = getArgsBuilder();
|
|
{
|
|
assertNotInAttributes("elementOpenStart");
|
|
setInAttributes(true);
|
|
}
|
|
argsBuilder2[0] = nameOrCtor;
|
|
argsBuilder2[1] = key2;
|
|
argsBuilder2[2] = statics;
|
|
}
|
|
function key(key2) {
|
|
const argsBuilder2 = getArgsBuilder();
|
|
{
|
|
assertInAttributes("key");
|
|
assert(argsBuilder2);
|
|
}
|
|
argsBuilder2[1] = key2;
|
|
}
|
|
function attr(name, value) {
|
|
const attrsBuilder2 = getAttrsBuilder();
|
|
{
|
|
assertInPatch("attr");
|
|
}
|
|
attrsBuilder2.push(name);
|
|
attrsBuilder2.push(value);
|
|
}
|
|
function elementOpenEnd() {
|
|
const argsBuilder2 = getArgsBuilder();
|
|
{
|
|
assertInAttributes("elementOpenEnd");
|
|
setInAttributes(false);
|
|
}
|
|
const node = open(argsBuilder2[0], argsBuilder2[1]);
|
|
const data = getData(node);
|
|
diffStatics(node, data, argsBuilder2[2]);
|
|
diffAttrs(node, data);
|
|
truncateArray(argsBuilder2, 0);
|
|
return node;
|
|
}
|
|
function elementOpen2(nameOrCtor, key2, statics, ...varArgs) {
|
|
{
|
|
assertNotInAttributes("elementOpen");
|
|
assertNotInSkip("elementOpen");
|
|
}
|
|
elementOpenStart(nameOrCtor, key2, statics);
|
|
for (let i = ATTRIBUTES_OFFSET; i < arguments.length; i += 2) {
|
|
attr(arguments[i], arguments[i + 1]);
|
|
}
|
|
return elementOpenEnd();
|
|
}
|
|
function applyAttrs() {
|
|
const node = currentElement();
|
|
const data = getData(node);
|
|
diffAttrs(node, data);
|
|
}
|
|
function applyStatics(statics) {
|
|
const node = currentElement();
|
|
const data = getData(node);
|
|
diffStatics(node, data, statics);
|
|
}
|
|
function elementClose2(nameOrCtor) {
|
|
{
|
|
assertNotInAttributes("elementClose");
|
|
}
|
|
const node = close();
|
|
{
|
|
assertCloseMatchesOpenTag(getData(node).nameOrCtor, nameOrCtor);
|
|
}
|
|
return node;
|
|
}
|
|
function elementVoid2(nameOrCtor, key2, statics, ...varArgs) {
|
|
elementOpen2.apply(null, arguments);
|
|
return elementClose2(nameOrCtor);
|
|
}
|
|
function text$1(value, ...varArgs) {
|
|
{
|
|
assertNotInAttributes("text");
|
|
assertNotInSkip("text");
|
|
}
|
|
const node = text3();
|
|
const data = getData(node);
|
|
if (data.text !== value) {
|
|
data.text = value;
|
|
let formatted = value;
|
|
for (let i = 1; i < arguments.length; i += 1) {
|
|
const fn = arguments[i];
|
|
formatted = fn(formatted);
|
|
}
|
|
if (node.data !== formatted) {
|
|
node.data = formatted;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
exports.applyAttr = applyAttr;
|
|
exports.applyProp = applyProp;
|
|
exports.attributes = attributes;
|
|
exports.alignWithDOM = alignWithDOM;
|
|
exports.close = close;
|
|
exports.createPatchInner = createPatchInner;
|
|
exports.createPatchOuter = createPatchOuter;
|
|
exports.currentElement = currentElement;
|
|
exports.currentPointer = currentPointer;
|
|
exports.open = open;
|
|
exports.patch = patchInner;
|
|
exports.patchInner = patchInner;
|
|
exports.patchOuter = patchOuter;
|
|
exports.skip = skip;
|
|
exports.skipNode = nextNode;
|
|
exports.setKeyAttributeName = setKeyAttributeName;
|
|
exports.clearCache = clearCache;
|
|
exports.getKey = getKey;
|
|
exports.importNode = importNode;
|
|
exports.isDataInitialized = isDataInitialized;
|
|
exports.notifications = notifications;
|
|
exports.symbols = symbols;
|
|
exports.applyAttrs = applyAttrs;
|
|
exports.applyStatics = applyStatics;
|
|
exports.attr = attr;
|
|
exports.elementClose = elementClose2;
|
|
exports.elementOpen = elementOpen2;
|
|
exports.elementOpenEnd = elementOpenEnd;
|
|
exports.elementOpenStart = elementOpenStart;
|
|
exports.elementVoid = elementVoid2;
|
|
exports.key = key;
|
|
exports.text = text$1;
|
|
}
|
|
});
|
|
|
|
// src/index.ts
|
|
var import_incremental_dom3 = __toESM(require_incremental_dom_cjs(), 1);
|
|
|
|
// src/App.ts
|
|
var import_incremental_dom2 = __toESM(require_incremental_dom_cjs(), 1);
|
|
|
|
// src/Header.ts
|
|
var import_incremental_dom = __toESM(require_incremental_dom_cjs(), 1);
|
|
function Header() {
|
|
(0, import_incremental_dom.elementOpen)("div", "", ["class", "header"]);
|
|
(0, import_incremental_dom.elementOpen)("h1");
|
|
(0, import_incremental_dom.text)("Choose Probabilities");
|
|
(0, import_incremental_dom.elementClose)("h1");
|
|
(0, import_incremental_dom.elementOpen)("h5");
|
|
(0, import_incremental_dom.text)("X-Axis = Ticks, Y-Axis = Underlying Price");
|
|
(0, import_incremental_dom.elementClose)("h5");
|
|
(0, import_incremental_dom.elementOpen)("h5");
|
|
(0, import_incremental_dom.text)("Begin with 2 Ticks, T_0 and T_1. Can add more in-between or at ends. Do not have to be equidistant.");
|
|
(0, import_incremental_dom.elementClose)("h5");
|
|
(0, import_incremental_dom.elementOpen)("h5");
|
|
(0, import_incremental_dom.text)('Begin with 2 Nodes to the "right" of each Node representing what can happen in the next tick. Can add more. No not need to be equidistant.');
|
|
(0, import_incremental_dom.elementClose)("h5");
|
|
(0, import_incremental_dom.elementClose)("div");
|
|
}
|
|
var Header_default = Header;
|
|
|
|
// src/App.ts
|
|
function Dates(datesP) {
|
|
const el = (0, import_incremental_dom2.elementOpen)("div");
|
|
(0, import_incremental_dom2.text)("Loading");
|
|
(0, import_incremental_dom2.elementClose)("div");
|
|
datesP.then((dates) => {
|
|
(0, import_incremental_dom2.patch)(el, () => {
|
|
(0, import_incremental_dom2.elementOpen)("select");
|
|
for (const date of dates) {
|
|
(0, import_incremental_dom2.elementOpen)("option", date);
|
|
(0, import_incremental_dom2.text)(date);
|
|
(0, import_incremental_dom2.elementClose)("option");
|
|
}
|
|
(0, import_incremental_dom2.elementClose)("select");
|
|
});
|
|
});
|
|
}
|
|
function App({ ticks = [0, 1, 2, 3, 4, 5] }) {
|
|
Header_default();
|
|
Dates(fetch("http://127.0.0.1:8234/option_quotes/AAPL/quote_dates").then((x) => x.json()));
|
|
}
|
|
var App_default = App;
|
|
|
|
// src/index.ts
|
|
var root = document.getElementById("app");
|
|
(0, import_incremental_dom3.patch)(root, function() {
|
|
App_default({});
|
|
});
|
|
/*! Bundled license information:
|
|
|
|
incremental-dom/dist/incremental-dom-cjs.js:
|
|
(**
|
|
* @preserve
|
|
* Copyright 2015 The Incremental DOM Authors. All Rights Reserved.
|
|
* Licensed under the Apache License, Version 2.0.
|
|
*)
|
|
*/
|