byp4a55 professor6T9

Linux msk-1-vm-cn73 5.14.0-710.el9.x86_64 #1 SMP PREEMPT_DYNAMIC Wed May 27 09:04:56 UTC 2026 x86_64
Apache
127.0.0.1

File Name : node.js

import { Type } from 'main.core';
import type { BBCodeEncoder } from 'ui.bbcode.encoder';
import { getByIndex } from '../../../shared';
import { typeof BBCodeElementNode } from './element-node';
import { typeof BBCodeTextNode } from './text-node';
import { typeof BBCodeNewLineNode } from './new-line-node';
import { typeof BBCodeTabNode } from './tab-node';
import { typeof BBCodeRootNode } from './root-node';
import { typeof BBCodeFragmentNode } from './fragment-node';
import { typeof BBCodeScheme } from '../scheme/bbcode-scheme';
import { type BBCodeNodeScheme } from '../scheme/node-schemes/node-scheme';

export type BBCodeNodeOptions = {
	name?: string,
	parent?: BBCodeParentNode | null,
	children?: Array<BBCodeContentNode | BBCodeFragmentNode>,
	scheme: BBCodeScheme,
};

export type SerializedBBCodeNode = {
	name: string,
	children: Array<SerializedBBCodeNode>,
};

type PrivateMapKey = BBCodeNode | BBCodeContentNode | BBCodeRootNode | BBCodeFragmentNode;
type PrivateStorage = {[key: string]: any};

export const privateMap: WeakMap<PrivateMapKey, PrivateStorage> = new WeakMap();
export const nameSymbol: Symbol = Symbol('name');

export class BBCodeNode
{
	[nameSymbol]: string = '#unknown';
	children: Array<BBCodeContentNode | BBCodeFragmentNode> = [];

constructor(options: BBCodeNodeOptions = {})
	{
		privateMap.set(this, {
			delayedChildren: [],
		});

this.setName(options.name);
		privateMap.get(this).scheme = options.scheme;
		this.setParent(options.parent);
		this.setChildren(options.children);
	}

static get ELEMENT_NODE(): number
	{
		return 1;
	}

static get TEXT_NODE(): number
	{
		return 2;
	}

static get ROOT_NODE(): number
	{
		return 3;
	}

static get FRAGMENT_NODE(): number
	{
		return 4;
	}

static freezeProperty(node: BBCodeNode, property: string, value: any, enumerable: boolean = true)
	{
		Object.defineProperty(node, property, {
			value,
			writable: false,
			configurable: false,
			enumerable,
		});
	}

static makeNonEnumerableProperty(node: BBCodeNode, property: string)
	{
		Object.defineProperty(node, property, {
			writable: false,
			enumerable: false,
			configurable: false,
		});
	}

static flattenChildren(children: Array<BBCodeContentNode | BBCodeFragmentNode>): Array<BBCodeContentNode>
	{
		if (Type.isArrayFilled(children))
		{
			return children.flatMap((node: BBCodeContentNode | BBCodeFragmentNode) => {
				if (node.getType() === BBCodeNode.FRAGMENT_NODE)
				{
					return node.getChildren();
				}

return node;
			});
		}

return [];
	}

setScheme(scheme: BBCodeScheme, onUnknown: (node: BBCodeContentNode) => any)
	{
		privateMap.get(this).scheme = scheme;
	}

getScheme(): BBCodeScheme
	{
		return privateMap.get(this).scheme;
	}

getTagScheme(): BBCodeNodeScheme
	{
		return this.getScheme().getTagScheme(this.getName());
	}

getEncoder(): BBCodeEncoder
	{
		return this.getScheme().getEncoder();
	}

prepareCase(value: string): string
	{
		const scheme: BBCodeScheme = this.getScheme();
		const currentCase = scheme.getOutputTagCase();
		if (currentCase === 'upper')
		{
			return value.toUpperCase();
		}

return value.toLowerCase();
	}

setName(name: string)
	{
		if (Type.isString(name))
		{
			this[nameSymbol] = name.toLowerCase();
		}
	}

getName(): string
	{
		return this[nameSymbol];
	}

getDisplayedName(): string
	{
		return this.prepareCase(this.getName());
	}

setParent(parent: BBCodeParentNode | null = null)
	{
		const mounted = !this.hasParent() && parent;
		privateMap.get(this).parent = parent;

if (mounted)
		{
			this.onNodeDidMount();
		}
	}

getParent(): BBCodeParentNode | null
	{
		return privateMap.get(this).parent;
	}

getType(): number
	{
		return privateMap.get(this).type;
	}

hasParent(): boolean
	{
		return Boolean(privateMap.get(this).parent);
	}

remove()
	{
		if (this.hasParent())
		{
			this.getParent().removeChild(this);
		}
	}

setChildren(children: Array<BBCodeContentNode | BBCodeFragmentNode>)
	{
		if (Type.isArray(children))
		{
			this.children = [];
			this.appendChild(...children);
		}
	}

getChildren(): Array<BBCodeContentNode>
	{
		return [...this.children];
	}

getLastChild(): ?BBCodeContentNode
	{
		return getByIndex(this.getChildren(), -1);
	}

getLastChildOfType(type: number): ?BBCodeContentNode
	{
		return this.getChildren().reverse().find((node: BBCodeContentNode) => {
			return node.getType() === type;
		});
	}

getLastChildOfName(name: string): ?BBCodeContentNode
	{
		return this.getChildren().reverse().find((node: BBCodeContentNode) => {
			return node.getType() === BBCodeNode.ELEMENT_NODE && node.getName() === name;
		});
	}

getFirstChild(): ?BBCodeContentNode
	{
		return getByIndex(this.getChildren(), 0);
	}

getFirstChildOfType(type: number): ?BBCodeContentNode
	{
		return this.getChildren().find((node: BBCodeContentNode) => {
			return node.getType() === type;
		});
	}

getFirstChildOfName(name: string): ?BBCodeContentNode
	{
		return this.getChildren().find((node: BBCodeContentNode) => {
			return node.getType() === BBCodeNode.ELEMENT_NODE && node.getName() === name;
		});
	}

getPreviewsSibling(): ?BBCodeContentNode
	{
		if (this.hasParent())
		{
			const parentChildren: Array<BBCodeContentNode> = this.getParent().getChildren();
			const currentIndex: number = parentChildren.indexOf(this);
			if (currentIndex > 0)
			{
				return getByIndex(parentChildren, currentIndex - 1);
			}
		}

return null;
	}

getPreviewsSiblings(): ?Array<BBCodeContentNode>
	{
		if (this.hasParent())
		{
			const parentChildren: Array<BBCodeContentNode> = this.getParent().getChildren();
			const currentIndex: number = parentChildren.indexOf(this);

return parentChildren.filter((child: BBCodeContentNode, index) => {
				return index < currentIndex;
			});
		}

return null;
	}

getNextSibling(): ?BBCodeContentNode
	{
		if (this.hasParent())
		{
			const parentChildren: Array<BBCodeContentNode> = this.getParent().getChildren();
			const currentIndex: number = parentChildren.indexOf(this);
			if (currentIndex !== -1 && currentIndex !== parentChildren.length)
			{
				return getByIndex(parentChildren, currentIndex + 1);
			}
		}

return null;
	}

getNextSiblings(): ?Array<BBCodeContentNode>
	{
		if (this.hasParent())
		{
			const parentChildren: Array<BBCodeContentNode> = this.getParent().getChildren();
			const currentIndex: number = parentChildren.indexOf(this);

return parentChildren.filter((child: BBCodeContentNode, index) => {
				return index > currentIndex;
			});
		}

return null;
	}

getChildrenCount(): number
	{
		return this.children.length;
	}

hasChildren(): boolean
	{
		return this.getChildrenCount() > 0;
	}

isEmpty(): boolean
	{
		return this.getChildrenCount() === 0;
	}

adjustChildren()
	{
		this.setChildren(this.getChildren());
	}

setDelayedChildren(children: Array<BBCodeContentNode>)
	{
		if (Type.isArray(children))
		{
			privateMap.get(this).delayedChildren = children;
		}
	}

addDelayedChildren(children: Array<BBCodeContentNode>)
	{
		if (Type.isArrayFilled(children))
		{
			this.setDelayedChildren([
				...this.getDelayedChildren(),
				...children,
			]);
		}
	}

hasDelayedChildren(): boolean
	{
		return privateMap.get(this).delayedChildren.length > 0;
	}

getDelayedChildren(): Array<BBCodeContentNode>
	{
		return [...privateMap.get(this).delayedChildren];
	}

appendChild(...children: Array<BBCodeContentNode | BBCodeFragmentNode>)
	{
		const flattenedChildren: Array<BBCodeContentNode> = BBCodeNode.flattenChildren(children);

flattenedChildren.forEach((node: BBCodeContentNode) => {
			node.remove();
			node.setParent(this);
			this.children.push(node);
		});
	}

prependChild(...children: Array<BBCodeContentNode | BBCodeFragmentNode>)
	{
		const flattenedChildren: Array<BBCodeContentNode> = BBCodeNode.flattenChildren(children);

flattenedChildren.forEach((node: BBCodeContentNode) => {
			node.remove();
			node.setParent(this);
			this.children.unshift(node);
		});
	}

insertBefore(...nodes: Array<BBCodeContentNode>)
	{
		if (this.hasParent() && Type.isArrayFilled(nodes))
		{
			const parent: BBCodeContentNode = this.getParent();
			const parentChildren: Array<BBCodeContentNode> = parent.getChildren();
			const currentNodeIndex: number = parentChildren.indexOf(this);

const deleteCount: number = 0;
			parentChildren.splice(currentNodeIndex, deleteCount, ...nodes);

parent.setChildren(parentChildren);
		}
	}

insertAfter(...nodes: Array<BBCodeContentNode>)
	{
		if (this.hasParent() && Type.isArrayFilled(nodes))
		{
			const parent: BBCodeContentNode = this.getParent();
			const parentChildren: Array<BBCodeContentNode> = parent.getChildren();
			const currentNodeIndex: number = parentChildren.indexOf(this);

const startIndex: number = currentNodeIndex + 1;
			const deleteCount: number = 0;
			parentChildren.splice(startIndex, deleteCount, ...nodes);

parent.setChildren(parentChildren);
		}
	}

propagateChild(...children: Array<BBCodeContentNode>)
	{
		if (this.hasParent())
		{
			this.insertBefore(
				...children.filter((child: BBCodeContentNode) => {
					return !['#linebreak', '#tab'].includes(child.getName());
				}),
			);
		}
		else
		{
			this.addDelayedChildren(children);
		}
	}

onNodeDidMount()
	{
		const delayedChildren = this.getDelayedChildren();
		if (Type.isArrayFilled(delayedChildren))
		{
			this.propagateChild(...delayedChildren);
			this.setDelayedChildren([]);
		}
	}

removeChild(...children: Array<BBCodeContentNode>)
	{
		const filteredChildren = [];
		this.children.forEach((node: BBCodeContentNode) => {
			if (children.includes(node))
			{
				node.setParent(null);
			}
			else
			{
				filteredChildren.push(node);
			}
		});

this.children = filteredChildren;
	}

replaceChild(targetNode: BBCodeContentNode, ...children: Array<BBCodeContentNode | BBCodeFragmentNode>)
	{
		this.children = this.children.flatMap((node: BBCodeContentNode) => {
			if (node === targetNode)
			{
				node.setParent(null);

const flattenedChildren: Array<BBCodeContentNode> = BBCodeNode.flattenChildren(children);

return flattenedChildren.map((child: BBCodeContentNode) => {
					child.remove();
					child.setParent(this);

return child;
				});
			}

return node;
		});
	}

replace(...children: Array<BBCodeContentNode | BBCodeFragmentNode>)
	{
		if (this.hasParent())
		{
			const parent = this.getParent();
			parent.replaceChild(this, ...children);
		}
	}

clone(options: { deep: boolean } = {}): BBCodeNode
	{
		const children = (() => {
			if (options.deep)
			{
				return this.getChildren().map((child) => {
					return child.clone(options);
				});
			}

return [];
		})();

return this.getScheme().createNode({
			name: this.getName(),
			parent: this.getParent(),
			children,
		});
	}

toPlainText(): string
	{
		return this.getChildren().map((child) => {
			return child.toPlainText();
		}).join('');
	}

getTextContent(): string
	{
		return this.toPlainText();
	}

getPlainTextLength(): number
	{
		return this.toPlainText().length;
	}

removePreviewsSiblings()
	{
		const removePreviewsSiblings = (node: BBCodeContentNode) => {
			const previewsSiblings = node.getPreviewsSiblings();
			if (Type.isArray(previewsSiblings))
			{
				previewsSiblings.forEach((sibling: BBCodeContentNode) => {
					sibling.remove();
				});
			}

const parent = node.getParent();
			if (parent)
			{
				removePreviewsSiblings(parent);
			}
		};

removePreviewsSiblings(this);
	}

removeNextSiblings()
	{
		const removeNextSiblings = (node: BBCodeContentNode) => {
			const nextSiblings = node.getNextSiblings();
			if (Type.isArray(nextSiblings))
			{
				nextSiblings.forEach((sibling: BBCodeContentNode) => {
					sibling.remove();
				});
			}

const parent = node.getParent();
			if (parent)
			{
				removeNextSiblings(parent);
			}
		};

removeNextSiblings(this);
	}

findByTextIndex(index: number): ?{ node: BBCodeTextNode, startIndex: number, endIndex: number }
	{
		let currentIndex = 0;
		let startIndex = 0;
		let endIndex = 0;

const node = BBCodeNode.flattenAst(this).find((child: BBCodeContentNode) => {
			if (
				child.getName() === '#text'
				|| child.getName() === '#linebreak'
				|| child.getName() === '#tab'
			)
			{
				startIndex = currentIndex;
				endIndex = startIndex + child.getLength();
				currentIndex = endIndex;

return index >= startIndex && endIndex >= index;
			}

return false;
		});

if (node)
		{
			return { node, startIndex, endIndex };
		}

return null;
	}

split(options: { offset: number, byWord?: boolean}): Array<BBCodeContentNode>
	{
		const { offset, byWord = false } = options;
		const plainTextLength = this.getPlainTextLength();

const leftTree = (() => {
			if (plainTextLength === offset)
			{
				return this.clone({ deep: true });
			}

if (offset <= 0 || offset > plainTextLength)
			{
				return null;
			}

return tree;
		})();

const rightTree = (() => {
			if (plainTextLength === offset)
			{
				return null;
			}

if (offset === 0)
			{
				return this.clone({ deep: true });
			}

return tree;
		})();

return [leftTree, rightTree];
	}

static flattenAst(ast): Array<any>
	{
		const flat = [];

if (ast.hasChildren())
		{
			ast.getChildren().forEach((child: BBCodeContentNode) => {
				traverse(child);
			});
		}

return flat;
	}

toJSON(): SerializedBBCodeNode
	{
		return {
			name: this.getName(),
			children: this.getChildren().map((child: BBCodeContentNode) => {
				return child.toJSON();
			}),
		};
	}
}

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	600/600	0755	2026-06-09 10:05:51
..	dir	-	600/600	0755	2026-06-09 10:05:51
element-node.js	text/x-java	10.8 KB	600/600	0644	2026-06-09 10:05:51
fragment-node.js	text/x-java	895 B	600/600	0644	2026-06-09 10:05:51
new-line-node.js	text/x-java	493 B	600/600	0644	2026-06-09 10:05:51
node.js	text/x-java	14.54 KB	600/600	0644	2026-06-09 10:05:51
root-node.js	text/x-java	1.62 KB	600/600	0644	2026-06-09 10:05:51
tab-node.js	text/x-java	475 B	600/600	0644	2026-06-09 10:05:51
text-node.js	text/x-java	3.19 KB	600/600	0644	2026-06-09 10:05:51

Team Anon Force

https://t.me/Professor6T9x