@tstdl/base 0.85.13 → 0.86.0-beta1

package/data-structures/linked-list.js

@@ -1,393 +1,375 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var linked_list_exports = {};
-__export(linked_list_exports, {
-  LinkedList: () => LinkedList
-});
-module.exports = __toCommonJS(linked_list_exports);
-var import_serializable = require("../serializer/serializable.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_list = require("./list.js");
-var __decorate = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 var LinkedList_1;
-let LinkedList = LinkedList_1 = class LinkedList2 extends import_list.List {
-  head;
-  tail;
-  get firstNode() {
-    return this.head;
-  }
-  get lastNode() {
-    return this.tail;
-  }
-  constructor(items) {
-    super();
-    this.clear();
-    if ((0, import_type_guards.isDefined)(items)) {
-      this.addMany(items);
-    }
-  }
-  [import_serializable.Serializable.serialize](instance) {
-    return [...instance];
-  }
-  [import_serializable.Serializable.deserialize](data, tryDereference) {
-    const linkedList = new LinkedList_1();
-    for (const item of data) {
-      const node = linkedList.add(item);
-      tryDereference(item, (dereferenced) => node.item = dereferenced);
-    }
-    return linkedList;
-  }
-  _at(index) {
-    const node = this.nodeAt(index);
-    return node.item;
-  }
-  /** get node at index */
-  nodeAt(index) {
-    const normalizedIndex = this.normalizeIndex(index);
-    this.ensureBounds(normalizedIndex);
-    const indexFromEnd = this.size - 1 - normalizedIndex;
-    let node;
-    if (normalizedIndex <= indexFromEnd) {
-      node = this.head;
-      for (let i = 0; i < normalizedIndex; i++) {
-        node = node.next;
-      }
-    } else {
-      node = this.tail;
-      for (let i = 0; i < indexFromEnd; i++) {
-        node = node.previous;
-      }
-    }
-    return node;
-  }
-  _indexOf(item, fromIndex = 0) {
-    let index = 0;
-    for (const node of this.nodes()) {
-      if (index < fromIndex) {
-        continue;
-      }
-      if (node.item == item) {
-        return index;
-      }
-      index++;
-    }
-    return void 0;
-  }
-  nodeOf(item) {
-    for (const node of this.nodes()) {
-      if (node.item == item) {
+import { Serializable, serializable } from '../serializer/serializable.js';
+import { isDefined, isUndefined } from '../utils/type-guards.js';
+import { List } from './list.js';
+export let LinkedList = LinkedList_1 = class LinkedList extends List {
+    head;
+    tail;
+    get firstNode() {
+        return this.head;
+    }
+    get lastNode() {
+        return this.tail;
+    }
+    constructor(items) {
+        super();
+        this.clear();
+        if (isDefined(items)) {
+            this.addMany(items);
+        }
+    }
+    [Serializable.serialize](instance) {
+        return [...instance];
+    }
+    [Serializable.deserialize](data, tryDereference) {
+        const linkedList = new LinkedList_1();
+        for (const item of data) {
+            const node = linkedList.add(item);
+            tryDereference(item, (dereferenced) => (node.item = dereferenced));
+        }
+        return linkedList;
+    }
+    _at(index) {
+        const node = this.nodeAt(index);
+        return node.item;
+    }
+    /** get node at index */
+    nodeAt(index) {
+        const normalizedIndex = this.normalizeIndex(index);
+        this.ensureBounds(normalizedIndex);
+        const indexFromEnd = (this.size - 1) - normalizedIndex;
+        let node;
+        if (normalizedIndex <= indexFromEnd) {
+            node = this.head;
+            for (let i = 0; i < normalizedIndex; i++) {
+                node = node.next;
+            }
+        }
+        else {
+            node = this.tail;
+            for (let i = 0; i < indexFromEnd; i++) {
+                node = node.previous;
+            }
+        }
+        return node;
+    }
+    _indexOf(item, fromIndex = 0) {
+        let index = 0;
+        for (const node of this.nodes()) {
+            if (index < fromIndex) {
+                continue;
+            }
+            if (node.item == item) {
+                return index;
+            }
+            index++;
+        }
+        return undefined;
+    }
+    nodeOf(item) {
+        for (const node of this.nodes()) {
+            if (node.item == item) {
+                return node;
+            }
+        }
+        return undefined;
+    }
+    findIndex(predicate) {
+        let index = 0;
+        for (const node of this.nodes()) {
+            if (predicate(node.item, index)) {
+                return index;
+            }
+            index++;
+        }
+        return undefined;
+    }
+    _lastIndexOf(item, fromIndex = (this.size - 1)) {
+        let index = this.size - 1;
+        for (const node of this.nodesReverse()) {
+            if (index > fromIndex) {
+                continue;
+            }
+            if (node.item == item) {
+                return index;
+            }
+            index--;
+        }
+        return undefined;
+    }
+    findLastIndex(predicate) {
+        let index = this.size - 1;
+        for (const node of this.nodesReverse()) {
+            if (predicate(node.item, index)) {
+                return index;
+            }
+            index++;
+        }
+        return undefined;
+    }
+    lastNodeOf(item) {
+        for (const node of this.nodesReverse()) {
+            if (node.item == item) {
+                return node;
+            }
+        }
+        return undefined;
+    }
+    _set(index, item) {
+        const node = this.nodeAt(index);
+        node.item = item;
+        this.emitChange();
+    }
+    includes(item) {
+        for (const entry of this) {
+            if (entry === item) {
+                return true;
+            }
+        }
+        return false;
+    }
+    add(item) {
+        const node = {
+            item,
+            previous: undefined,
+            next: undefined
+        };
+        if (isDefined(this.tail)) {
+            this.tail.next = node;
+            node.previous = this.tail;
+            this.tail = node;
+        }
+        else {
+            this.head = node;
+            this.tail = node;
+        }
+        this.incrementSize();
         return node;
-      }
-    }
-    return void 0;
-  }
-  findIndex(predicate) {
-    let index = 0;
-    for (const node of this.nodes()) {
-      if (predicate(node.item, index)) {
-        return index;
-      }
-      index++;
-    }
-    return void 0;
-  }
-  _lastIndexOf(item, fromIndex = this.size - 1) {
-    let index = this.size - 1;
-    for (const node of this.nodesReverse()) {
-      if (index > fromIndex) {
-        continue;
-      }
-      if (node.item == item) {
-        return index;
-      }
-      index--;
-    }
-    return void 0;
-  }
-  findLastIndex(predicate) {
-    let index = this.size - 1;
-    for (const node of this.nodesReverse()) {
-      if (predicate(node.item, index)) {
-        return index;
-      }
-      index++;
-    }
-    return void 0;
-  }
-  lastNodeOf(item) {
-    for (const node of this.nodesReverse()) {
-      if (node.item == item) {
+    }
+    prepend(item) {
+        const node = {
+            item,
+            previous: undefined,
+            next: this.head
+        };
+        if (isDefined(this.head)) {
+            this.head.previous = node;
+            this.head = node;
+        }
+        else {
+            this.head = node;
+            this.tail = node;
+        }
+        this.incrementSize();
         return node;
-      }
-    }
-    return void 0;
-  }
-  _set(index, item) {
-    const node = this.nodeAt(index);
-    node.item = item;
-    this.emitChange();
-  }
-  includes(item) {
-    for (const entry of this) {
-      if (entry === item) {
-        return true;
-      }
-    }
-    return false;
-  }
-  add(item) {
-    const node = {
-      item,
-      previous: void 0,
-      next: void 0
-    };
-    if ((0, import_type_guards.isDefined)(this.tail)) {
-      this.tail.next = node;
-      node.previous = this.tail;
-      this.tail = node;
-    } else {
-      this.head = node;
-      this.tail = node;
-    }
-    this.incrementSize();
-    return node;
-  }
-  prepend(item) {
-    const node = {
-      item,
-      previous: void 0,
-      next: this.head
-    };
-    if ((0, import_type_guards.isDefined)(this.head)) {
-      this.head.previous = node;
-      this.head = node;
-    } else {
-      this.head = node;
-      this.tail = node;
-    }
-    this.incrementSize();
-    return node;
-  }
-  /** add item after node */
-  addAfterNode(node, item) {
-    const newNode = {
-      item,
-      previous: node,
-      next: node.next
-    };
-    node.next = newNode;
-    if ((0, import_type_guards.isDefined)(newNode.next)) {
-      newNode.next.previous = newNode;
-    } else {
-      this.tail = newNode;
-    }
-    this.incrementSize();
-    return newNode;
-  }
-  /** add item before node */
-  addBeforeNode(node, item) {
-    const newNode = {
-      item,
-      previous: node.previous,
-      next: node
-    };
-    node.previous = newNode;
-    if ((0, import_type_guards.isDefined)(newNode.previous)) {
-      newNode.previous.next = newNode;
-    } else {
-      this.head = newNode;
-    }
-    this.incrementSize();
-    return newNode;
-  }
-  addMany(items) {
-    let count = 0;
-    let node = this.tail;
-    for (const item of items) {
-      node = {
-        item,
-        previous: node,
-        next: void 0
-      };
-      if (count != 0) {
-        node.previous.next = node;
-      } else {
-        if ((0, import_type_guards.isDefined)(node.previous)) {
-          node.previous.next = node;
-        }
-        if ((0, import_type_guards.isUndefined)(this.head)) {
-          this.head = node;
-        }
-      }
-      count++;
-    }
-    if (count > 0) {
-      this.tail = node;
-      this.incrementSize(count);
-    }
-  }
-  /** add many items at the start */
-  prependMany(items) {
-    const oldHead = this.head;
-    let count = 0;
-    let node;
-    for (const item of items) {
-      node = {
-        item,
-        previous: node,
-        next: void 0
-      };
-      if (count != 0) {
-        node.previous.next = node;
-      } else {
-        this.head = node;
-      }
-      count++;
-    }
-    if (count > 0) {
-      if ((0, import_type_guards.isDefined)(oldHead)) {
-        node.next = oldHead;
-        oldHead.previous = node;
-      } else {
-        this.tail = node;
-      }
-      this.incrementSize(count);
-    }
-  }
-  remove(item) {
-    const node = this.nodeOf(item);
-    if ((0, import_type_guards.isDefined)(node)) {
-      this.removeNode(node);
-      return true;
-    }
-    return false;
-  }
-  _removeAt(index) {
-    const node = this.removeNodeAt(index);
-    return node.item;
-  }
-  _removeManyAt(index, count) {
-    const nodes = this.removeManyNodesAt(index, count);
-    return nodes.map((node) => node.item);
-  }
-  /** remove node at index */
-  removeNodeAt(index) {
-    const normalizedIndex = this.normalizeIndex(index);
-    this.ensureBounds(normalizedIndex);
-    const node = this.nodeAt(normalizedIndex);
-    this.removeNode(node);
-    return node;
-  }
-  /** remove node */
-  removeNode(node) {
-    if ((0, import_type_guards.isDefined)(node.previous)) {
-      node.previous.next = node.next;
-    }
-    if ((0, import_type_guards.isDefined)(node.next)) {
-      node.next.previous = node.previous;
-    }
-    if (node == this.head) {
-      this.head = node.next;
-    }
-    if (node == this.tail) {
-      this.tail = node.previous;
-    }
-    this.decrementSize();
-  }
-  removeManyNodesAt(index, count = this.size - index) {
-    const normalizedIndex = this.normalizeIndex(index);
-    this.ensureBounds(normalizedIndex, count);
-    if (count <= 0) {
-      return [];
-    }
-    const firstNode = this.nodeAt(normalizedIndex);
-    const nodes = [firstNode];
-    let lastNode = firstNode;
-    for (let i = 1; i < count; i++) {
-      lastNode = lastNode.next;
-      nodes.push(lastNode);
-    }
-    if ((0, import_type_guards.isDefined)(firstNode.previous)) {
-      firstNode.previous.next = lastNode.next;
-    } else {
-      this.head = lastNode.next;
-    }
-    if ((0, import_type_guards.isDefined)(lastNode.next)) {
-      lastNode.next.previous = firstNode.previous;
-    } else {
-      this.tail = firstNode.previous;
-    }
-    this.decrementSize(count);
-    return nodes;
-  }
-  clone() {
-    return new LinkedList_1(this);
-  }
-  *items() {
-    let node = this.head;
-    while ((0, import_type_guards.isDefined)(node)) {
-      yield node.item;
-      node = node.next;
-    }
-  }
-  *itemsReverse() {
-    let node = this.tail;
-    while ((0, import_type_guards.isDefined)(node)) {
-      yield node.item;
-      node = node.previous;
-    }
-  }
-  /** yields all nodes from the list */
-  *nodes() {
-    let node = this.head;
-    while ((0, import_type_guards.isDefined)(node)) {
-      yield node;
-      node = node.next;
-    }
-  }
-  /** yields all nodes from the list in reverse */
-  *nodesReverse() {
-    let node = this.tail;
-    while ((0, import_type_guards.isDefined)(node)) {
-      yield node;
-      node = node.previous;
-    }
-  }
-  _clear() {
-    this.head = void 0;
-    this.tail = void 0;
-  }
+    }
+    /** add item after node */
+    addAfterNode(node, item) {
+        const newNode = {
+            item,
+            previous: node,
+            next: node.next
+        };
+        node.next = newNode;
+        if (isDefined(newNode.next)) {
+            newNode.next.previous = newNode;
+        }
+        else {
+            this.tail = newNode;
+        }
+        this.incrementSize();
+        return newNode;
+    }
+    /** add item before node */
+    addBeforeNode(node, item) {
+        const newNode = {
+            item,
+            previous: node.previous,
+            next: node
+        };
+        node.previous = newNode;
+        if (isDefined(newNode.previous)) {
+            newNode.previous.next = newNode;
+        }
+        else {
+            this.head = newNode;
+        }
+        this.incrementSize();
+        return newNode;
+    }
+    addMany(items) {
+        let count = 0;
+        let node = this.tail;
+        for (const item of items) {
+            node = {
+                item,
+                previous: node,
+                next: undefined
+            };
+            if (count != 0) {
+                node.previous.next = node;
+            }
+            else {
+                if (isDefined(node.previous)) {
+                    node.previous.next = node;
+                }
+                if (isUndefined(this.head)) {
+                    this.head = node;
+                }
+            }
+            count++;
+        }
+        if (count > 0) {
+            this.tail = node;
+            this.incrementSize(count);
+        }
+    }
+    /** add many items at the start */
+    prependMany(items) {
+        const oldHead = this.head;
+        let count = 0;
+        let node;
+        for (const item of items) {
+            node = {
+                item,
+                previous: node,
+                next: undefined
+            };
+            if (count != 0) {
+                node.previous.next = node;
+            }
+            else {
+                this.head = node;
+            }
+            count++;
+        }
+        if (count > 0) {
+            if (isDefined(oldHead)) {
+                node.next = oldHead;
+                oldHead.previous = node;
+            }
+            else {
+                this.tail = node;
+            }
+            this.incrementSize(count);
+        }
+    }
+    remove(item) {
+        const node = this.nodeOf(item);
+        if (isDefined(node)) {
+            this.removeNode(node);
+            return true;
+        }
+        return false;
+    }
+    _removeAt(index) {
+        const node = this.removeNodeAt(index);
+        return node.item;
+    }
+    _removeManyAt(index, count) {
+        const nodes = this.removeManyNodesAt(index, count);
+        return nodes.map((node) => node.item);
+    }
+    /** remove node at index */
+    removeNodeAt(index) {
+        const normalizedIndex = this.normalizeIndex(index);
+        this.ensureBounds(normalizedIndex);
+        const node = this.nodeAt(normalizedIndex);
+        this.removeNode(node);
+        return node;
+    }
+    /** remove node */
+    removeNode(node) {
+        if (isDefined(node.previous)) {
+            node.previous.next = node.next;
+        }
+        if (isDefined(node.next)) {
+            node.next.previous = node.previous;
+        }
+        if (node == this.head) {
+            this.head = node.next;
+        }
+        if (node == this.tail) {
+            this.tail = node.previous;
+        }
+        this.decrementSize();
+    }
+    removeManyNodesAt(index, count = this.size - index) {
+        const normalizedIndex = this.normalizeIndex(index);
+        this.ensureBounds(normalizedIndex, count);
+        if (count <= 0) {
+            return [];
+        }
+        const firstNode = this.nodeAt(normalizedIndex);
+        const nodes = [firstNode];
+        let lastNode = firstNode;
+        for (let i = 1; i < count; i++) {
+            lastNode = lastNode.next;
+            nodes.push(lastNode);
+        }
+        if (isDefined(firstNode.previous)) {
+            firstNode.previous.next = lastNode.next;
+        }
+        else {
+            this.head = lastNode.next;
+        }
+        if (isDefined(lastNode.next)) {
+            lastNode.next.previous = firstNode.previous;
+        }
+        else {
+            this.tail = firstNode.previous;
+        }
+        this.decrementSize(count);
+        return nodes;
+    }
+    clone() {
+        return new LinkedList_1(this);
+    }
+    *items() {
+        let node = this.head;
+        while (isDefined(node)) {
+            yield node.item;
+            node = node.next;
+        }
+    }
+    *itemsReverse() {
+        let node = this.tail;
+        while (isDefined(node)) {
+            yield node.item;
+            node = node.previous;
+        }
+    }
+    /** yields all nodes from the list */
+    *nodes() {
+        let node = this.head;
+        while (isDefined(node)) {
+            yield node;
+            node = node.next;
+        }
+    }
+    /** yields all nodes from the list in reverse */
+    *nodesReverse() {
+        let node = this.tail;
+        while (isDefined(node)) {
+            yield node;
+            node = node.previous;
+        }
+    }
+    _clear() {
+        this.head = undefined;
+        this.tail = undefined;
+    }
 };
 LinkedList = LinkedList_1 = __decorate([
-  (0, import_serializable.serializable)("LinkedList"),
-  __metadata("design:paramtypes", [Object])
+    serializable('LinkedList'),
+    __metadata("design:paramtypes", [Object])
 ], LinkedList);