roxxie-proxy-u-prod 0.1.0

package/source/external/dreamlandjs/src/core/consts.d.ts

@@ -0,0 +1,16 @@
+export const DREAMLAND: unique symbol;
+export const NO_CHANGE: unique symbol;
+
+export const COMMA_TOKEN: unique symbol;
+export const COMBINATOR_TOKEN: unique symbol;
+export const ID_TOKEN: unique symbol;
+export const CLASS_TOKEN: unique symbol;
+export const PSEUDO_ELEMENT_TOKEN: unique symbol;
+export const PSEUDO_CLASS_TOKEN: unique symbol;
+export const UNIVERSAL_TOKEN: unique symbol;
+export const ATTRIBUTE_TOKEN: unique symbol;
+export const TYPE_TOKEN: unique symbol;
+
+export const MAP: <K, V>(x?: [K, V][]) => Map<K, V>;
+export const WEAKMAP: <K extends object, V>() => WeakMap<K, V>;
+export const WEAKREF: <V extends object>(val: V) => WeakRef<V>;

package/source/external/dreamlandjs/src/core/consts.js

@@ -0,0 +1,18 @@
+export let [
+	// dl
+	DREAMLAND,
+	NO_CHANGE,
+	// selectorParser
+	COMMA_TOKEN,
+	COMBINATOR_TOKEN,
+	ID_TOKEN,
+	CLASS_TOKEN,
+	PSEUDO_ELEMENT_TOKEN,
+	PSEUDO_CLASS_TOKEN,
+	UNIVERSAL_TOKEN,
+	ATTRIBUTE_TOKEN,
+	TYPE_TOKEN,
+] = Array.from(Array(11), Symbol);
+export let MAP = (x) => new Map(x);
+export let WEAKMAP = () => new WeakMap();
+export let WEAKREF = (x) => new WeakRef(x);

package/source/external/dreamlandjs/src/core/css/index.ts

@@ -0,0 +1,111 @@
+import {
+	COMBINATOR_TOKEN,
+	COMMA_TOKEN,
+	PSEUDO_CLASS_TOKEN,
+	PSEUDO_ELEMENT_TOKEN,
+} from "../consts";
+import { ComponentFn, ComponentFnState } from "../jsx/definitions";
+import { stringify, Token, tokenize } from "./selectorParser";
+
+export type CssInit = {
+	_strings: TemplateStringsArray;
+	_funcs: (((state: any) => any) | string)[];
+	_rewrite: typeof _rewrite;
+};
+
+export let css = /*@__NO_SIDE_EFFECTS__*/ <T extends ComponentFn<any, any>>(
+	_strings: TemplateStringsArray,
+	..._funcs: (((state: ComponentFnState<T>) => any) | string)[]
+): CssInit => {
+	return {
+		_strings,
+		_funcs,
+		_rewrite,
+	};
+};
+
+// added to every component's root, determines start of scoped css scope
+export let CSS_COMPONENT = "dlc";
+
+export let genuid = () => {
+	// prettier-ignore
+	// dl 0.0.x:
+	//     `${Array(4).fill(0).map(()=>Math.floor(Math.random()*36).toString(36)}).join('')}`
+	return [...Array(16)].reduce(a => a + Math.random().toString(36)[2], '')
+	// the above will occasionally misfire with `undefined` or 0 in the string whenever Math.random returns exactly 0 or really small numbers
+	// we don't care, it would be very uncommon for that to actually happen 16 times
+};
+
+let GLOBAL = ":global(";
+let _rewrite = (style: HTMLStyleElement, css: string, tag: string) => {
+	let where = tokenize(`:where(.${tag})`);
+	let globalWhereTransformation = `:where(._${genuid()} `;
+
+	let rewriteSelector = (tokens: Token[], inGlobal?: boolean): Token[] => {
+		for (let i = 0; i < tokens.length; i++) {
+			let token = tokens[i];
+
+			let idx: number, cnt: number, arr: Token[] | undefined;
+			if (token._type == PSEUDO_CLASS_TOKEN && token.arg) {
+				let global = token.nm == "global";
+
+				let rewritten = rewriteSelector(
+					tokenize(token.arg),
+					global || inGlobal
+				);
+				if (global) {
+					idx = i;
+					cnt = 1;
+					arr = rewritten;
+				} else {
+					token.arg = stringify(rewritten);
+					token._content = `:${token.nm}(${token.arg})`;
+				}
+			} else if (
+				!inGlobal &&
+				(i === tokens.length - 1 ||
+					[COMBINATOR_TOKEN, COMMA_TOKEN].includes(tokens[i + 1]._type))
+			) {
+				idx = i;
+				while (idx > 0 && tokens[idx]._type == PSEUDO_ELEMENT_TOKEN) {
+					idx--;
+				}
+
+				idx++;
+				cnt = 0;
+				arr = where;
+			}
+
+			if (arr) {
+				tokens.splice(idx!, cnt!, ...arr);
+				i += arr.length;
+			}
+		}
+		return tokens;
+	};
+
+	let rewriteRules = (list: any) =>
+		[...list].map((rule: any) => {
+			if (rule.selectorText) {
+				rule.selectorText = stringify(
+					rewriteSelector(
+						tokenize(
+							rule.selectorText.replaceAll(globalWhereTransformation, GLOBAL)
+						)
+					)
+				).replace(/:scope/g, `.${tag}.${CSS_COMPONENT}`);
+			}
+			if (rule.cssRules) {
+				rewriteRules(rule.cssRules);
+			}
+			return rule;
+		});
+
+	style.innerText = css.replaceAll(GLOBAL, globalWhereTransformation);
+	rewriteRules(style.sheet!.cssRules);
+	dev: {
+		style.innerText = [...style.sheet!.cssRules]
+			.map((x) => x.cssText)
+			.join("\n");
+	}
+};

package/source/external/dreamlandjs/src/core/css/selectorParser.ts

@@ -0,0 +1,313 @@
+//
+/*
+https://github.com/LeaVerou/parsel modified for size
+
+MIT License
+
+Copyright (c) 2020 Lea Verou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+import {
+	COMMA_TOKEN,
+	COMBINATOR_TOKEN,
+	ID_TOKEN,
+	CLASS_TOKEN,
+	PSEUDO_ELEMENT_TOKEN,
+	PSEUDO_CLASS_TOKEN,
+	UNIVERSAL_TOKEN,
+	ATTRIBUTE_TOKEN,
+	TYPE_TOKEN,
+	MAP,
+} from "../consts";
+import { fatal } from "../utils";
+
+export interface BaseToken {
+	readonly _type: symbol;
+	_content: string;
+	_pos: [number, number];
+}
+
+export interface CommaToken extends BaseToken {
+	_type: typeof COMMA_TOKEN;
+}
+
+export interface CombinatorToken extends BaseToken {
+	_type: typeof COMBINATOR_TOKEN;
+}
+
+export interface NamedToken extends BaseToken {
+	nm: string;
+}
+
+export interface IdToken extends NamedToken {
+	_type: typeof ID_TOKEN;
+}
+
+export interface ClassToken extends NamedToken {
+	_type: typeof CLASS_TOKEN;
+}
+
+export interface PseudoElementToken extends NamedToken {
+	_type: typeof PSEUDO_ELEMENT_TOKEN;
+	arg?: string;
+}
+
+export interface PseudoClassToken extends NamedToken {
+	_type: typeof PSEUDO_CLASS_TOKEN;
+	arg?: string;
+}
+
+export interface NamespacedToken extends BaseToken {
+	ns?: string;
+}
+
+export interface UniversalToken extends NamespacedToken {
+	_type: typeof UNIVERSAL_TOKEN;
+}
+
+export interface AttributeToken extends NamespacedToken, NamedToken {
+	_type: typeof ATTRIBUTE_TOKEN;
+	op?: string;
+	val?: string;
+	case?: "i" | "I" | "s" | "S";
+}
+
+export interface TypeToken extends NamespacedToken, NamedToken {
+	_type: typeof TYPE_TOKEN;
+}
+
+export interface UnknownToken extends BaseToken {
+	_type: never;
+}
+
+export type Token =
+	| AttributeToken
+	| IdToken
+	| ClassToken
+	| CommaToken
+	| CombinatorToken
+	| PseudoElementToken
+	| PseudoClassToken
+	| UniversalToken
+	| TypeToken
+	| UnknownToken;
+
+let TOKENS: Map<symbol, RegExp> = MAP([
+	[
+		ATTRIBUTE_TOKEN,
+		/\[\s*(?:(?<ns>\*|[-\w\P{ASCII}]*)\|)?(?<nm>[-\w\P{ASCII}]+)\s*(?:(?<op>\W?=)\s*(?<val>.+?)\s*(\s(?<case>[iIsS]))?\s*)?\]/gu,
+	],
+	[ID_TOKEN, /#(?<nm>[-\w\P{ASCII}]+)/gu],
+	[CLASS_TOKEN, /\.(?<nm>[-\w\P{ASCII}]+)/gu],
+	[COMMA_TOKEN, /\s*,\s*/g], // must be before combinator
+	[COMBINATOR_TOKEN, /\s*[\s>+~]\s*/g], // this must be after attribute
+	[PSEUDO_ELEMENT_TOKEN, /::(?<nm>[-\w\P{ASCII}]+)(?:\((?<arg>¶*)\))?/gu], // this must be before pseudo-class
+	[PSEUDO_CLASS_TOKEN, /:(?<nm>[-\w\P{ASCII}]+)(?:\((?<arg>¶*)\))?/gu],
+	[UNIVERSAL_TOKEN, /(?:(?<ns>\*|[-\w\P{ASCII}]*)\|)?\*/gu],
+	[TYPE_TOKEN, /(?:(?<ns>\*|[-\w\P{ASCII}]*)\|)?(?<nm>[-\w\P{ASCII}]+)/gu], // this must be last
+]);
+
+let getArgumentPatternByType = (type: symbol) => {
+	if (type == PSEUDO_CLASS_TOKEN || type == PSEUDO_ELEMENT_TOKEN) {
+		return new RegExp(TOKENS.get(type)!.source.replace("¶", "."), "gu");
+	} else {
+		return TOKENS.get(type);
+	}
+};
+
+let gobbleParens = (text: string, offset: number, nesting = 0): string =>
+	text.slice(
+		offset,
+		text
+			.split("")
+			.findIndex(
+				(x, i) =>
+					i >= offset && (nesting += x == "(" ? 1 : x == ")" ? -1 : 0) == 0
+			) + 1 || text.length
+	);
+
+let tokenizeBy = (text: string): Token[] => {
+	if (!text) {
+		return [];
+	}
+
+	let tokens: (Token | string)[] = [text];
+	for (let [_type, pattern] of TOKENS.entries()) {
+		for (let i = 0; i < tokens.length; i++) {
+			let token = tokens[i];
+			if (typeof token !== "string") {
+				continue;
+			}
+
+			pattern.lastIndex = 0;
+			let match = pattern.exec(token);
+			if (!match) {
+				continue;
+			}
+
+			let from = match.index - 1;
+			let args: typeof tokens = [];
+			let _content = match[0];
+
+			let before = token.slice(0, from + 1);
+			if (before) {
+				args.push(before);
+			}
+
+			args.push({
+				...match.groups,
+				_type,
+				_content,
+			} as any);
+
+			let after = token.slice(from + _content.length + 1);
+			if (after) {
+				args.push(after);
+			}
+
+			tokens.splice(i, 1, ...args);
+		}
+	}
+
+	let offset = 0;
+	for (let token of tokens) {
+		if (typeof token === "string") {
+			dev: {
+				throw new Error(
+					`Unexpected sequence ${token} found at index ${offset}`
+				);
+			}
+			prod: {
+				fatal();
+			}
+		} else {
+			token._pos = [offset, (offset += token._content.length)];
+			if (token._type == COMBINATOR_TOKEN || token._type == COMMA_TOKEN) {
+				token._content = token._content.trim() || " ";
+			}
+		}
+	}
+
+	return tokens as Token[];
+};
+
+let STRING_PATTERN = /(['"])([^\\\n]*?)\1/g;
+let ESCAPE_PATTERN = /\\./g;
+export let tokenize = (selector: string): Token[] => {
+	// Prevent leading/trailing whitespaces from being interpreted as combinators
+	selector = selector.trim();
+	if (selector === "") {
+		return [];
+	}
+
+	type Replacement = { _value: string; _offset: number };
+	let replacements: Replacement[] = [];
+
+	// Replace escapes with placeholders.
+	selector = selector.replace(
+		ESCAPE_PATTERN,
+		(_value: string, _offset: number) => {
+			replacements.push({ _value, _offset });
+			return "\uE000".repeat(_value.length);
+		}
+	);
+
+	// Replace strings with placeholders.
+	selector = selector.replace(
+		STRING_PATTERN,
+		(_value: string, quote: string, content: string, _offset: number) => {
+			replacements.push({ _value, _offset });
+			return `${quote}${"\uE001".repeat(content.length)}${quote}`;
+		}
+	);
+
+	// Replace parentheses with placeholders.
+	{
+		let pos = 0;
+		let offset: number;
+		while ((offset = selector.indexOf("(", pos)) > -1) {
+			let value = gobbleParens(selector, offset);
+			replacements.push({ _value: value, _offset: offset });
+			selector = `${selector.slice(0, offset)}(${"¶".repeat(
+				value.length - 2
+			)})${selector.slice(offset + value.length)}`;
+			pos = offset + value.length;
+		}
+	}
+
+	// Now we have no nested structures and we can parse with regexes
+	let tokens = tokenizeBy(selector);
+
+	// Replace placeholders in reverse order.
+	let changedTokens: Token[] = [];
+	for (let replacement of replacements.reverse()) {
+		for (let token of tokens) {
+			let { _offset, _value } = replacement;
+			if (
+				!(token._pos[0] <= _offset && _offset + _value.length <= token._pos[1])
+			) {
+				continue;
+			}
+
+			let { _content } = token;
+			let tokenOffset = _offset - token._pos[0];
+			token._content =
+				_content.slice(0, tokenOffset) +
+				_value +
+				_content.slice(tokenOffset + _value.length);
+			if (token._content !== _content) {
+				changedTokens.push(token);
+			}
+		}
+	}
+
+	// Update changed tokens.
+	for (let token of changedTokens) {
+		let pattern = getArgumentPatternByType(token._type);
+		if (!pattern) {
+			dev: {
+				throw new Error(`Unknown token type: ${String(token._type)}`);
+			}
+			prod: {
+				fatal();
+			}
+		}
+		pattern.lastIndex = 0;
+		let match = pattern.exec(token._content);
+		if (!match) {
+			dev: {
+				throw new Error(
+					`Unable to parse content for ${String(token._type)}: ${token._content}`
+				);
+			}
+			prod: {
+				fatal();
+			}
+		}
+		Object.assign(token, match.groups);
+	}
+
+	return tokens;
+};
+
+export let stringify = (tokens: Token[]): string => {
+	return tokens.map((x) => x._content).join("");
+};

package/source/external/dreamlandjs/src/core/delegate.ts

@@ -0,0 +1,28 @@
+import { Component, ComponentContext } from "./jsx/definitions";
+import { callDelegateListeners, currentComponentCx } from "./jsx/index";
+
+export interface DelegateListener<T> {
+	_callback: (value: T) => void;
+	_cx?: ComponentContext<Component<any, any>>;
+}
+
+export type Delegate<T> = {
+	listen: (callback: (value: T) => void) => void;
+	(value: T): void;
+};
+
+export let createDelegate = <T>(): Delegate<T> => {
+	let listeners: DelegateListener<T>[] = [];
+
+	let delegate = ((value: T) =>
+		callDelegateListeners(value, listeners)) as Delegate<T>;
+
+	delegate.listen = (_callback: (value: T) => void) => {
+		listeners.push({
+			_callback,
+			_cx: currentComponentCx,
+		});
+	};
+
+	return delegate;
+};

package/source/external/dreamlandjs/src/core/index.ts

@@ -0,0 +1,31 @@
+import { defineUse } from "./state";
+import "./state";
+
+export { Pointer } from "./state/pointers";
+export {
+	Stateful,
+	createState,
+	stateListen,
+	stateProxy,
+	isStateful,
+} from "./state/state";
+
+export { createDelegate, Delegate } from "./delegate";
+
+export { css } from "./css";
+
+export {
+	ComponentChild,
+	Component,
+	FC,
+	ComponentState,
+	ComponentContext,
+	ComponentInstance,
+	JSX,
+} from "./jsx/definitions";
+export { h, jsx, Fragment } from "./jsx";
+export { setDomImpl, getDom as domImpl, DomImpl } from "./jsx/dom";
+
+export { DREAMLAND, NO_CHANGE } from "./consts";
+
+defineUse();

package/source/external/dreamlandjs/src/core/jsx/child.ts

@@ -0,0 +1,91 @@
+import { MAP } from "../consts";
+import { CSS_COMPONENT } from "../css";
+import { Pointer, maybeListen } from "../state/pointers";
+import { findLIS } from "../utils";
+import { ComponentChild } from "./definitions";
+import { CSS_IDENT, getDom } from "./dom";
+
+let isBlacklisted = (val: any): val is null | undefined | boolean =>
+	[null, undefined, false, true].includes(val);
+
+export let mapChild = (
+	child: ComponentChild,
+	parent: Node,
+	cssIdent?: string,
+	identOverride?: string
+): Node[] => {
+	let [, NODE, new_Text, new_Comment, , , hydrating] = getDom();
+
+	if (isBlacklisted(child)) {
+		return [new_Comment()];
+	} else if (child instanceof Pointer) {
+		let start = new_Comment("[");
+		let end = new_Comment("]");
+		let current: Node[];
+
+		maybeListen(child, start, (val: ComponentChild) => {
+			if (current && !start.parentNode) return;
+			let mapped: Node[] = mapChild(val, parent, cssIdent, child._cssIdent);
+			let hydrating = getDom()[6];
+
+			// pretty sure it's not possible to put a pointer child in not a htmlelement
+			if (!hydrating?.(parent as HTMLElement) && current) {
+				let actual: Node[] = [];
+				for (let n = start.nextSibling; n && n !== end; n = n.nextSibling) {
+					actual.push(n);
+				}
+				let old = MAP(actual.map((x, i) => [x, i]));
+				let staticNodes = mapped.map((x) => old.get(x)!).filter((x) => x);
+				let LIS = MAP(findLIS(staticNodes).map((x) => [actual[x], ,]));
+				let anchor: Node = start;
+
+				mapped.map((child) => {
+					if (!old.has(child) || !LIS.has(child)) {
+						parent.insertBefore(child, anchor.nextSibling);
+					}
+					anchor = child;
+				});
+
+				actual.map(
+					(x) =>
+						!mapped.includes(x) &&
+						x.parentNode === parent &&
+						parent.removeChild(x)
+				);
+			}
+			current = mapped;
+		});
+
+		return [
+			start,
+			...(hydrating?.(parent as HTMLElement) ? [] : current!),
+			end,
+		];
+	} else if (child instanceof (NODE as typeof globalThis.Node)) {
+		let list: DOMTokenList;
+		let apply = (child: any) => {
+			if ((list = child.classList)) {
+				let arr = [...list];
+				let other = arr.find((x) => x.startsWith(CSS_IDENT));
+
+				if (arr.find((x) => x == CSS_COMPONENT)) return;
+
+				if (!other) {
+					list.add(identOverride || cssIdent!);
+				} else if (identOverride && other !== identOverride) {
+					list.remove(other);
+					list.add(identOverride);
+				}
+
+				[...child.childNodes].map(apply);
+			}
+		};
+		if (identOverride || cssIdent) apply(child);
+
+		return [child];
+	} else if (child instanceof Array) {
+		return child.flatMap((x) => mapChild(x, parent, cssIdent, identOverride));
+	} else {
+		return [new_Text(child as string)];
+	}
+};