semantic-typescript 0.5.3 → 0.7.0

package/dist/set.d.ts

@@ -1,19 +0,0 @@
-import { HashMap } from "./map";
-import type { BiConsumer, Consumer, TriConsumer } from "./utility";
-export declare class HashSet<E> implements Set<E> {
-    protected map: HashMap<E, boolean>;
-    size: number;
-    constructor();
-    add(value: E): this;
-    clear(): void;
-    delete(value: E): boolean;
-    entries(): SetIterator<[E, E]>;
-    forEach(consumer: Consumer<E>): void;
-    forEach(consumer: BiConsumer<E, E>): void;
-    forEach(consumer: TriConsumer<E, E, Set<E>>): void;
-    has(value: E): boolean;
-    keys(): IterableIterator<E>;
-    values(): IterableIterator<E>;
-    [Symbol.iterator](): IterableIterator<E>;
-    [Symbol.toStringTag]: string;
-}

package/dist/set.js

@@ -1,65 +0,0 @@
-import { HashMap } from "./map";
-export class HashSet {
-    map = new HashMap();
-    size = 0;
-    constructor() {
-        Object.defineProperty(this, "size", {
-            get: () => this.map.size,
-            set: (value) => {
-                this.map.size = value;
-            },
-            enumerable: true,
-            configurable: true
-        });
-        Object.freeze(this);
-    }
-    add(value) {
-        this.map.set(value, true);
-        return this;
-    }
-    clear() {
-        this.map.clear();
-    }
-    delete(value) {
-        return this.map.delete(value);
-    }
-    *entries() {
-        for (let [key, value] of this.map.entries()) {
-            if (value) {
-                yield [key, key];
-            }
-        }
-    }
-    forEach(consumer) {
-        for (let [key, value] of this.map.entries()) {
-            if (value) {
-                consumer(key, key);
-            }
-        }
-    }
-    has(value) {
-        return this.map.has(value);
-    }
-    *keys() {
-        for (let [key, value] of this.map.entries()) {
-            if (value) {
-                yield key;
-            }
-        }
-    }
-    *values() {
-        for (let [key, value] of this.map.entries()) {
-            if (value) {
-                yield key;
-            }
-        }
-    }
-    [Symbol.iterator]() {
-        return this.values();
-    }
-    [Symbol.toStringTag] = "HashSet";
-}
-;
-Object.freeze(HashSet);
-Object.freeze(HashSet.prototype);
-Object.freeze(Object.getPrototypeOf(HashSet));

package/dist/tree.d.ts

@@ -1,82 +0,0 @@
-import { BinaryNode, RedBlackNode, type Node } from './node';
-import { Optional } from './optional';
-import { type Comparator } from './utility';
-export interface Tree<E, N extends Node<E, N>, T extends Tree<E, N, T>> extends Iterable<E> {
-    root(): Optional<N>;
-    isEmpty(): boolean;
-    size(): bigint;
-    height(): bigint;
-    depth(): bigint;
-    width(): bigint;
-    level(): bigint;
-    add(value: E): void;
-    remove(value: E): void;
-    contains(value: E): boolean;
-    find(value: E): Optional<N>;
-    preorder(): Generator<E>;
-    inorder(): Generator<E>;
-    postorder(): Generator<E>;
-    breadth(): Generator<E>;
-    toArray(): Array<E>;
-    toSet(): Set<E>;
-    sub(node: N): T;
-    prune(node: Node<E, N>): T;
-    merge(other: T): T;
-    [Symbol.iterator](): Iterator<E>;
-}
-export declare abstract class AbstractTree<E, N extends Node<E, N>, T extends Tree<E, N, T>> implements Tree<E, N, T> {
-    protected readonly Tree: symbol;
-    protected internal: bigint;
-    constructor();
-    abstract root(): Optional<N>;
-    isEmpty(): boolean;
-    size(): bigint;
-    abstract add(value: E): void;
-    abstract remove(value: E): void;
-    contains(value: E): boolean;
-    abstract find(value: E): Optional<N>;
-    abstract preorder(): Generator<E>;
-    abstract inorder(): Generator<E>;
-    abstract postorder(): Generator<E>;
-    abstract breadth(): Generator<E>;
-    toArray(): Array<E>;
-    toSet(): Set<E>;
-    abstract sub(node: N): T;
-    abstract prune(node: Node<E, N>): T;
-    abstract merge(other: T): T;
-    height(): bigint;
-    width(): bigint;
-    depth(): bigint;
-    level(): bigint;
-    abstract [Symbol.iterator](): Iterator<E>;
-}
-export declare abstract class BinaryTree<E, N extends BinaryNode<E, N>, T extends BinaryTree<E, N, T>> extends AbstractTree<E, N, T> {
-    protected readonly BinaryTree: symbol;
-    protected first: Optional<N>;
-    constructor();
-    constructor(root: Optional<N>);
-    root(): Optional<N>;
-    find(value: E): Optional<N>;
-    preorder(): Generator<E>;
-    inorder(): Generator<E>;
-    postorder(): Generator<E>;
-    isBalanced(): boolean;
-    isComplete(): boolean;
-    isFull(): boolean;
-    isPerfect(): boolean;
-    [Symbol.iterator](): Iterator<E>;
-}
-export declare class RedBlackTree<E> extends BinaryTree<E, RedBlackNode<E>, RedBlackTree<E>> {
-    protected readonly RedBlackTree: symbol;
-    protected comparator: Comparator<E>;
-    constructor();
-    constructor(root: Optional<RedBlackNode<E>>);
-    constructor(comparator: Comparator<E>);
-    constructor(root: Optional<RedBlackNode<E>>, comparator: Comparator<E>);
-    add(value: E): void;
-    remove(value: E): void;
-    breadth(): Generator<E>;
-    sub(node: RedBlackNode<E>): RedBlackTree<E>;
-    prune(node: Node<E, RedBlackNode<E>>): RedBlackTree<E>;
-    merge(other: RedBlackTree<E>): RedBlackTree<E>;
-}

package/dist/tree.js

@@ -1,257 +0,0 @@
-import { isFunction, isRedBlackNode } from './guard';
-import { useCompare } from './hook';
-import { BinaryNode, RedBlackNode } from './node';
-import { Optional } from './optional';
-import { BinaryTreeSymbol, TreeSymbol } from './symbol';
-import { validate } from './utility';
-export class AbstractTree {
-    Tree = TreeSymbol;
-    internal = 0n;
-    constructor() {
-    }
-    isEmpty() {
-        return this.root().isEmpty();
-    }
-    size() {
-        return this.internal;
-    }
-    contains(value) {
-        return this.find(value).isPresent();
-    }
-    toArray() {
-        return Array.from(this.preorder());
-    }
-    toSet() {
-        return new Set(this.preorder());
-    }
-    height() {
-        let root = this.root();
-        if (root.isPresent()) {
-            return root.get().height();
-        }
-        return 0n;
-    }
-    width() {
-        let root = this.root();
-        if (root.isPresent()) {
-            return root.get().width();
-        }
-        return 0n;
-    }
-    depth() {
-        let root = this.root();
-        if (root.isPresent()) {
-            return root.get().depth();
-        }
-        return 0n;
-    }
-    level() {
-        let root = this.root();
-        if (root.isPresent()) {
-            return root.get().level();
-        }
-        return 0n;
-    }
-}
-;
-export class BinaryTree extends AbstractTree {
-    BinaryTree = BinaryTreeSymbol;
-    first;
-    constructor(root = Optional.empty()) {
-        super();
-        this.first = root;
-    }
-    root() {
-        return this.first;
-    }
-    find(value) {
-        let root = this.root();
-        if (root.isPresent()) {
-            for (let node of root.get().preorder()) {
-                if (node.getElement() === value || Object.is(node.getElement(), value)) {
-                    return Optional.of(node);
-                }
-            }
-        }
-        return Optional.empty();
-    }
-    *preorder() {
-        let root = this.root();
-        if (root.isPresent()) {
-            for (let node of root.get().preorder()) {
-                let element = node.getElement();
-                if (validate(element) && element.isPresent()) {
-                    yield element.get();
-                }
-            }
-        }
-    }
-    *inorder() {
-        let root = this.root();
-        if (root.isPresent()) {
-            for (let node of root.get().inorder()) {
-                let element = node.getElement();
-                if (validate(element) && element.isPresent()) {
-                    yield element.get();
-                }
-            }
-        }
-    }
-    *postorder() {
-        let root = this.root();
-        if (root.isPresent()) {
-            for (let node of root.get().postorder()) {
-                let element = node.getElement();
-                if (validate(element) && element.isPresent()) {
-                    yield element.get();
-                }
-            }
-        }
-    }
-    isBalanced() {
-        let root = this.root();
-        if (root.isPresent()) {
-            return root.get().isBanlanced();
-        }
-        return false;
-    }
-    isComplete() {
-        let root = this.root();
-        if (root.isPresent()) {
-            return root.get().isComplete();
-        }
-        return false;
-    }
-    isFull() {
-        let root = this.root();
-        if (root.isPresent()) {
-            return root.get().isFull();
-        }
-        return false;
-    }
-    isPerfect() {
-        let root = this.root();
-        if (root.isPresent()) {
-            return root.get().isPerfect();
-        }
-        return false;
-    }
-    *[Symbol.iterator]() {
-        yield* this.preorder();
-    }
-}
-;
-export class RedBlackTree extends BinaryTree {
-    RedBlackTree = Symbol("RedBlackTree");
-    comparator;
-    constructor(argument1, argument2) {
-        if (isFunction(argument1)) {
-            super();
-            this.comparator = argument1;
-        }
-        else if (isRedBlackNode(argument1)) {
-            super(argument1);
-            if (isFunction(argument2)) {
-                this.comparator = argument2;
-            }
-            else {
-                this.comparator = useCompare;
-            }
-        }
-        else {
-            throw new TypeError("Invalid arguments.");
-        }
-    }
-    add(value) {
-        let node = new RedBlackNode(value);
-        if (this.first.isEmpty()) {
-            this.first = Optional.of(node);
-        }
-        else {
-            this.first.get().compareAndLink(node);
-        }
-        this.internal++;
-    }
-    remove(value) {
-        let node = this.find(value);
-        if (node.isPresent()) {
-            node.get().detach();
-            node.get().fix();
-            this.internal--;
-        }
-    }
-    *breadth() {
-        let root = this.root();
-        if (root.isPresent()) {
-            let queue = [root.get()];
-            while (queue.length > 0) {
-                let node = queue.shift();
-                let element = node.getElement();
-                if (validate(element) && element.isPresent()) {
-                    yield element.get();
-                }
-                if (validate(node.getLeft()) && node.getRight().isPresent()) {
-                    queue.push(node.getLeft().get());
-                }
-                if (validate(node.getLeft()) && node.getLeft().isPresent()) {
-                    queue.push(node.getLeft().get());
-                }
-            }
-        }
-    }
-    sub(node) {
-        return new RedBlackTree(Optional.of(node));
-    }
-    prune(node) {
-        let tree = new RedBlackTree();
-        let queue = [node];
-        while (queue.length > 0) {
-            let node = queue.shift();
-            let element = node.getElement();
-            if (validate(element) && element.isPresent()) {
-                tree.add(element.get());
-            }
-            if (validate(node.getLeft()) && node.getLeft().isPresent()) {
-                queue.push(node.getLeft().get());
-            }
-            if (validate(node.getRight()) && node.getRight().isPresent()) {
-                queue.push(node.getRight().get());
-            }
-            return tree;
-        }
-        return tree;
-    }
-    merge(other) {
-        let tree = new RedBlackTree();
-        let queue = [this.root().get()];
-        while (queue.length > 0) {
-            let node = queue.shift();
-            let element = node.getElement();
-            if (validate(element) && element.isPresent()) {
-                tree.add(element.get());
-            }
-            if (validate(node.getLeft()) && node.getLeft().isPresent()) {
-                queue.push(node.getLeft().get());
-            }
-            if (validate(node.getRight()) && node.getRight().isPresent()) {
-                queue.push(node.getRight().get());
-            }
-        }
-        queue = [other.root().get()];
-        while (queue.length > 0) {
-            let node = queue.shift();
-            let element = node.getElement();
-            if (validate(element) && element.isPresent()) {
-                tree.add(element.get());
-            }
-            if (validate(node.getLeft()) && node.getLeft().isPresent()) {
-                queue.push(node.getLeft().get());
-            }
-            if (validate(node.getRight()) && node.getRight().isPresent()) {
-                queue.push(node.getRight().get());
-            }
-        }
-        return tree;
-    }
-}
-;