working rss feed to nostr publish

node_modules/tstl/container/Deque.d.ts

@@ -0,0 +1,167 @@
+/**
+ * @packageDocumentation
+ * @module std
+ */
+import { IArrayContainer } from "../base/container/IArrayContainer";
+import { ArrayContainer } from "../internal/container/linear/ArrayContainer";
+import { ArrayIterator } from "../internal/iterator/ArrayIterator";
+import { ArrayReverseIterator } from "../internal/iterator/ArrayReverseIterator";
+import { IForwardIterator } from "../iterator/IForwardIterator";
+/**
+ * Double ended queue.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export declare class Deque<T> extends ArrayContainer<T, Deque<T>, Deque<T>, Deque.Iterator<T>, Deque.ReverseIterator<T>, T> implements IArrayContainer<T, Deque<T>, Deque.Iterator<T>, Deque.ReverseIterator<T>> {
+    private matrix_;
+    private size_;
+    private capacity_;
+    /**
+     * Default Constructor.
+     */
+    constructor();
+    /**
+     * Initializer Constructor.
+     *
+     * @param items Items to assign.
+     */
+    constructor(items: T[]);
+    /**
+     * Copy Constructor
+     *
+     * @param obj Object to copy.
+     */
+    constructor(obj: Deque<T>);
+    /**
+     * Fill Constructor.
+     *
+     * @param size Initial size.
+     * @param val Value to fill.
+     */
+    constructor(size: number, val: T);
+    /**
+     * Range Constructor.
+     *
+     * @param first Input iterator of the first position.
+     * @param last Input iterator of the last position.
+     */
+    constructor(first: Readonly<IForwardIterator<T>>, last: Readonly<IForwardIterator<T>>);
+    /**
+     * @inheritDoc
+     */
+    assign(n: number, val: T): void;
+    /**
+     * @inheritDoc
+     */
+    assign<InputIterator extends Readonly<IForwardIterator<T, InputIterator>>>(first: InputIterator, last: InputIterator): void;
+    /**
+     * @inheritDoc
+     */
+    clear(): void;
+    /**
+     * @inheritDoc
+     */
+    resize(n: number): void;
+    /**
+     * Reserve {@link capacity} enable to store *n* elements.
+     *
+     * @param n The capacity to reserve.
+     */
+    reserve(n: number): void;
+    private _Reserve;
+    /**
+     * Shrink {@link capacity} to actual {@link size}.
+     */
+    shrink_to_fit(): void;
+    /**
+     * @inheritDoc
+     */
+    swap(obj: Deque<T>): void;
+    private _Swap;
+    private static _Emend;
+    /**
+     * @inheritDoc
+     */
+    size(): number;
+    /**
+     * The capacity to store elements.
+     *
+     * @return The capacity.
+     */
+    capacity(): number;
+    /**
+     * @inheritDoc
+     */
+    nth(index: number): Deque.Iterator<T>;
+    /**
+     * @inheritDoc
+     */
+    [Symbol.iterator](): IterableIterator<T>;
+    protected source(): Deque<T>;
+    protected _At(index: number): T;
+    protected _Set(index: number, val: T): void;
+    private _Fetch_index;
+    private _Compute_col_size;
+    /**
+     * @inheritDoc
+     */
+    push(...items: T[]): number;
+    /**
+     * @inheritDoc
+     */
+    push_front(val: T): void;
+    /**
+     * @inheritDoc
+     */
+    push_back(val: T): void;
+    /**
+     * @inheritDoc
+     */
+    pop_front(): void;
+    protected _Pop_back(): void;
+    protected _Insert_by_range<InputIterator extends Readonly<IForwardIterator<T, InputIterator>>>(pos: Deque.Iterator<T>, first: InputIterator, last: InputIterator): Deque.Iterator<T>;
+    private _Insert_to_middle;
+    private _Insert_to_end;
+    private _Try_expand_capacity;
+    private _Try_add_row_at_front;
+    private _Try_add_row_at_back;
+    protected _Erase_by_range(first: Deque.Iterator<T>, last: Deque.Iterator<T>): Deque.Iterator<T>;
+}
+/**
+ *
+ */
+export declare namespace Deque {
+    /**
+     * Iterator of {@link Deque}
+     */
+    type Iterator<T> = ArrayIterator<T, Deque<T>>;
+    /**
+     * Reverse iterator of {@link Deque}
+     */
+    type ReverseIterator<T> = ArrayReverseIterator<T, Deque<T>>;
+    const Iterator: typeof ArrayIterator;
+    const ReverseIterator: typeof ArrayReverseIterator;
+    /**
+     * Row size of the {@link Deque.matrix_ matrix} which contains elements.
+     *
+     * Note that the {@link ROW_SIZE} affects on time complexity of accessing and inserting element.
+     * Accessing element is {@link ROW_SIZE} times slower than ordinary {@link Vector} and inserting element
+     * in middle position is {@link ROW_SIZE} times faster than ordinary {@link Vector}.
+     *
+     * When the {@link ROW_SIZE} returns 8, time complexity of accessing element is O(8) and inserting
+     * element in middle position is O(N/8). ({@link Vector}'s time complexity of accessement is O(1)
+     * and inserting element is O(N)).
+     */
+    const ROW_SIZE = 8;
+    /**
+     * Minimum {@link Deque.capacity}.
+     *
+     * Although a {@link Deque} has few elements, even no element is belonged to, the {@link Deque}
+     * keeps the minimum {@link Deque.capacity} at least.
+     */
+    const MIN_CAPACITY = 36;
+    /**
+     * Expansion ratio.
+     */
+    const MAGNIFIER = 1.5;
+}