Class FastShiftArray<T>

Readonly[unscopables]

length

• get length(): number

  The number of logical elements in the queue.

  Does not include the "ghost" slots before headIndex.

  Returns number

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  q.shift();
  console.log(q.length); // 2
  Copy

• set length(value: number): void

  Sets the logical length of the queue, truncating or extending it.

  Setting length translates to items.length = value + headIndex so internal accounting stays consistent.

  Parameters

  • value: number

    The new logical length.

  Returns void

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4]);
  q.length = 2;
  console.log([...q]); // [1, 2]
  Copy

[iterator]

• "[iterator]"(): ArrayIterator<T>

  Iterates over the logical elements of the queue in order, skipping the internal "ghost" slots before headIndex.

  Returns ArrayIterator<T>

  Example

  const q = FastQueue.fromArray([10, 20, 30]);
  q.shift();
  for (const v of q) console.log(v); // 20, 30
  Copy

at

• at(index: number): T | undefined

  Returns the element at the given index, supporting negative indices.

  Negative indices count from the end (-1 is the last element) and bypass the headIndex offset so they always refer to the tail of the logical sequence.

  Parameters

  • index: number

    Zero-based (or negative) index.

  Returns T | undefined

  The element, or undefined if out of range.

  Example

  const q = FastQueue.fromArray([10, 20, 30]);
  console.log(q.at(0)); // 10
  console.log(q.at(-1)); // 30
  Copy

compact

• compact(): void

  Compacts the internal storage by discarding the ghost slots that accumulate after repeated shift() calls.

  This is done automatically when headIndex exceeds 100 000, but you can call it explicitly if memory pressure is a concern.

  Returns void

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  q.shift(); q.shift();
  q.compact(); // internal storage is now [3], headIndex = 0
  Copy

concat

• concat(...items: (T | ConcatArray<T>)[]): FastShiftArray<T>

  Returns a new FastQueue that is the concatenation of this queue and items.

  Each item in items may be a single element T or a ConcatArray<T> (e.g. another array or FastQueue).

  Parameters

  • ...items: (T | ConcatArray<T>)[]

    Elements or arrays to concatenate.

  Returns FastShiftArray<T>

  A new FastQueue<T>.

  Example

  const q = FastQueue.fromArray([1, 2]);
  const r = q.concat([3, 4], 5);
  console.log([...r]); // [1, 2, 3, 4, 5]
  Copy

concatArray

• concatArray(array: FastShiftArray<T>): FastShiftArray<T>

  Concatenates another FastQueue onto this one and returns a new FastQueue.

  Convenience wrapper around concat for FastQueue-to-FastQueue merges.

  Parameters

  • array: FastShiftArray<T>

    The queue to append.

  Returns FastShiftArray<T>

  A new FastQueue<T>.

  Example

  const a = FastQueue.fromArray([1, 2]);
  const b = FastQueue.fromArray([3, 4]);
  console.log([...a.concatArray(b)]); // [1, 2, 3, 4]
  Copy

copyWithin

• copyWithin(target: number, start: number, end?: number): this

  Copies a segment of the queue to a different position within the same queue.

  All indices are logical (zero-based).

  Parameters

  • target: number

    Zero-based index where the copied section will be pasted.

  • start: number

    Zero-based index of the section start to copy from.

  • Optionalend: number

    Zero-based index of the section end (exclusive).

  Returns this

  this for chaining.

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4, 5]);
  q.copyWithin(0, 3);
  console.log([...q]); // [4, 5, 3, 4, 5]
  Copy

entries

• entries(): ArrayIterator<[number, T]>

  Returns an ArrayIterator of [index, value] pairs for the logical elements.

  Returns ArrayIterator<[number, T]>

  Example

  const q = FastQueue.fromArray(['a', 'b', 'c']);
  for (const [i, v] of q.entries()) {
    console.log(i, v); // 0 'a', 1 'b', 2 'c'
  }
  Copy

every

• every<S>(
      predicate: (value: T, index: number, array: T[]) => value is S,
      thisArg?: any,
  ): this is S[]

  Returns true if every element satisfies predicate.

  Short-circuits on the first failing element. The type-guard overload narrows this to S[] when it returns true.

  Type Parameters

  • S

  Parameters

  • predicate: (value: T, index: number, array: T[]) => value is S

    Test function.

  • OptionalthisArg: any

    Value to use as this inside predicate.

  Returns this is S[]

  Example

  const q = FastQueue.fromArray([2, 4, 6]);
  console.log(q.every(x => x % 2 === 0)); // true
  Copy

• every(
      predicate: (value: T, index: number, array: T[]) => unknown,
      thisArg?: any,
  ): boolean

  Determines whether all the members of an array satisfy the specified test.

  Parameters

  • predicate: (value: T, index: number, array: T[]) => unknown

    A function that accepts up to three arguments. The every method calls the predicate function for each element in the array until the predicate returns a value which is coercible to the Boolean value false, or until the end of the array.

  • OptionalthisArg: any

    An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.

  Returns boolean

fill

• fill(value: T, start?: number, end?: number): this

  Fills elements from start (inclusive) to end (exclusive) with value.

  Indices are logical (zero-based); negative values are not supported.

  Parameters

  • value: T

    Value to fill with.

  • Optionalstart: number

    Start index (default 0).

  • Optionalend: number

    End index (default this.length).

  Returns this

  this for chaining.

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4]);
  q.fill(0, 1, 3);
  console.log([...q]); // [1, 0, 0, 4]
  Copy

filter

• filter<S>(
      predicate: (value: T, index: number, array: T[]) => value is S,
      thisArg?: any,
  ): FastShiftArray<S>

  Returns a new FastQueue containing only elements for which predicate returns truthy.

  The type-guard overload narrows the element type to S.

  Type Parameters

  • S

  Parameters

  • predicate: (value: T, index: number, array: T[]) => value is S

    Test function.

  • OptionalthisArg: any

    Value to use as this inside predicate.

  Returns FastShiftArray<S>

  A new FastQueue<S> or FastQueue<T>.

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4, 5]);
  const evens = q.filter(x => x % 2 === 0);
  console.log([...evens]); // [2, 4]
  Copy

• filter(
      predicate: (value: T, index: number, array: T[]) => unknown,
      thisArg?: any,
  ): FastShiftArray<T>

  Returns the elements of an array that meet the condition specified in a callback function.

  Parameters

  • predicate: (value: T, index: number, array: T[]) => unknown

    A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.

  • OptionalthisArg: any

    An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.

  Returns FastShiftArray<T>

find

• find<S>(
      predicate: (value: T, index: number, obj: T[]) => value is S,
      thisArg?: any,
  ): S | undefined

  Returns the first element for which predicate returns truthy, or undefined.

  The type-guard overload narrows the return type to S.

  Type Parameters

  • S

  Parameters

  • predicate: (value: T, index: number, obj: T[]) => value is S

    Test function.

  • OptionalthisArg: any

    Value to use as this inside predicate.

  Returns S | undefined

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4]);
  console.log(q.find(x => x > 2)); // 3
  Copy

• find(
      predicate: (value: T, index: number, obj: T[]) => unknown,
      thisArg?: any,
  ): T | undefined

  Returns the first element for which predicate returns truthy, or undefined.

  The type-guard overload narrows the return type to S.

  Parameters

  • predicate: (value: T, index: number, obj: T[]) => unknown

    Test function.

  • OptionalthisArg: any

    Value to use as this inside predicate.

  Returns T | undefined

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4]);
  console.log(q.find(x => x > 2)); // 3
  Copy

findIndex

• findIndex(
      predicate: (value: T, index: number, obj: T[]) => unknown,
      _thisArg?: any,
  ): number

  Returns the zero-based logical index of the first element for which predicate returns truthy, or -1 if none match.

  Parameters

  • predicate: (value: T, index: number, obj: T[]) => unknown

    Test function.

  • Optional_thisArg: any

    Unused.

  Returns number

  Example

  const q = FastQueue.fromArray([10, 20, 30]);
  console.log(q.findIndex(x => x > 15)); // 1
  Copy

findLast

• findLast<S>(
      predicate: (value: T, index: number, array: T[]) => value is S,
      thisArg?: any,
  ): S | undefined

  Returns the last element for which predicate returns truthy, or undefined.

  The type-guard overload narrows the return type to S.

  Type Parameters

  • S

  Parameters

  • predicate: (value: T, index: number, array: T[]) => value is S

    Test function.

  • OptionalthisArg: any

    Value to use as this inside predicate.

  Returns S | undefined

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4]);
  console.log(q.findLast(x => x % 2 === 0)); // 4
  Copy

• findLast(
      predicate: (value: T, index: number, array: T[]) => unknown,
      thisArg?: any,
  ): T | undefined

  Returns the last element for which predicate returns truthy, or undefined.

  The type-guard overload narrows the return type to S.

  Parameters

  • predicate: (value: T, index: number, array: T[]) => unknown

    Test function.

  • OptionalthisArg: any

    Value to use as this inside predicate.

  Returns T | undefined

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4]);
  console.log(q.findLast(x => x % 2 === 0)); // 4
  Copy

findLastIndex

• findLastIndex(
      predicate: (value: T, index: number, array: T[]) => unknown,
      _thisArg?: any,
  ): number

  Returns the zero-based logical index of the last element for which predicate returns truthy, or -1.

  Parameters

  • predicate: (value: T, index: number, array: T[]) => unknown

    Test function.

  • Optional_thisArg: any

    Unused.

  Returns number

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4]);
  console.log(q.findLastIndex(x => x % 2 === 0)); // 3
  Copy

flat

• flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[]

  Flattens the queue up to depth levels and returns a plain Array.

  Type Parameters

  • A
  • D extends number = 1

  Parameters

  • this: A
  • Optionaldepth: D

    Maximum depth to flatten (default 1).

  Returns FlatArray<A, D>[]

  A plain FlatArray<A, D>[].

  Example

  const q = FastQueue.fromArray([[1, 2], [3, [4, 5]]]);
  console.log(q.flat()); // [1, 2, 3, [4, 5]]
  console.log(q.flat(2)); // [1, 2, 3, 4, 5]
  Copy

flatMap

• flatMap<U>(
      callback: (value: T, index: number, array: T[]) => U | readonly U[],
      _thisArg?: any,
  ): FastShiftArray<U>

  Maps each element through callback and flattens the result one level deep.

  Type Parameters

  • U

  Parameters

  • callback: (value: T, index: number, array: T[]) => U | readonly U[]

    Function that returns a value or a readonly array.

  • Optional_thisArg: any

    Unused.

  Returns FastShiftArray<U>

  A new flattened FastQueue<U>.

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  const r = q.flatMap(x => [x, x * 10]);
  console.log([...r]); // [1, 10, 2, 20, 3, 30]
  Copy

forEach

• forEach(
      callback: (value: T, index: number, array: T[]) => void,
      _thisArg?: any,
  ): void

  Executes callback once for each logical element, in order.

  Parameters

  • callback: (value: T, index: number, array: T[]) => void

    Function to execute for each element.

  • Optional_thisArg: any

    Unused.

  Returns void

  Example

  FastQueue.fromArray([1, 2, 3]).forEach(x => console.log(x)); // 1 2 3
  Copy

get

• get(index: number): T | undefined

  Returns the element at index without going through the Proxy.

  Equivalent to queue[index] but useful when the proxy is disabled or when you want an explicit method call for clarity.

  Parameters

  • index: number

    Zero-based logical index.

  Returns T | undefined

  The element, or undefined if index is out of range.

  Example

  const q = FastQueue.fromArray(['a', 'b', 'c']);
  console.log(q.get(1)); // 'b'
  console.log(q.get(9)); // undefined
  Copy

includes

• includes(searchElement: T, fromIndex?: number): boolean

  Returns true if searchElement is present in the queue.

  Parameters

  • searchElement: T

    Value to search for.

  • OptionalfromIndex: number

    Optional starting index (default 0).

  Returns boolean

  Example

  const q = FastQueue.fromArray([1, 2, NaN]);
  console.log(q.includes(2)); // true
  console.log(q.includes(NaN)); // true  (uses SameValueZero)
  Copy

indexOf

• indexOf(value: T, index?: number): number

  Returns the index of the first occurrence of value, or -1 if not found.

  Parameters

  • value: T

    The value to search for.

  • Optionalindex: number

    Optional starting position (default 0).

  Returns number

  Zero-based logical index, or -1.

  Example

  const q = FastQueue.fromArray(['a', 'b', 'c', 'b']);
  console.log(q.indexOf('b')); // 1
  console.log(q.indexOf('b', 2)); // 3
  console.log(q.indexOf('z')); // -1
  Copy

isEmpty

• isEmpty(): boolean

  Returns true when the queue contains no elements.

  Returns boolean

  Example

  const q = FastQueue.empty<number>();
  console.log(q.isEmpty()); // true
  q.push(1);
  console.log(q.isEmpty()); // false
  Copy

isNotEmpty

• isNotEmpty(): boolean

  Returns true when the queue contains at least one element.

  Returns boolean

  Example

  const q = FastQueue.fromArray([42]);
  console.log(q.isNotEmpty()); // true
  Copy

join

• join(separator?: string): string

  Joins all logical elements into a string with separator between each pair.

  Parameters

  • separator: string = ','

    String placed between elements (default ',').

  Returns string

  The joined string.

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  console.log(q.join('-')); // '1-2-3'
  console.log(q.join()); // '1,2,3'
  Copy

keys

• keys(): ArrayIterator<number>

  Returns an ArrayIterator of the zero-based logical indices.

  Returns ArrayIterator<number>

  Example

  const q = FastQueue.fromArray(['x', 'y', 'z']);
  console.log([...q.keys()]); // [0, 1, 2]
  Copy

lastIndexOf

• lastIndexOf(value: T, index?: number): number

  Returns the index of the last occurrence of value, or -1 if not found.

  Parameters

  • value: T

    The value to search for.

  • Optionalindex: number

    Optional starting position for the backward search.

  Returns number

  Zero-based logical index, or -1.

  Example

  const q = FastQueue.fromArray([1, 2, 3, 2, 1]);
  console.log(q.lastIndexOf(2)); // 3
  console.log(q.lastIndexOf(9)); // -1
  Copy

map

• map<U>(
      callback: (value: T, index: number, array: T[]) => U,
      _thisArg?: T,
  ): FastShiftArray<U>

  Creates a new FastQueue with the results of calling callback on every element.

  Indices passed to callback are zero-based logical indices.

  Type Parameters

  • U

  Parameters

  • callback: (value: T, index: number, array: T[]) => U

    Function called for each element.

  • Optional_thisArg: T

    Unused (bound via arrow function in the caller).

  Returns FastShiftArray<U>

  A new FastQueue<U>.

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  const doubled = q.map(x => x * 2);
  console.log([...doubled]); // [2, 4, 6]
  Copy

pop

• pop(): T | undefined

  Removes and returns the last element of the queue.

  Returns T | undefined

  The last element, or undefined if the queue is empty.

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  console.log(q.pop()); // 3
  console.log([...q]); // [1, 2]
  Copy

push

• push(...item: T[]): number

  Appends one or more elements to the end of the queue.

  Parameters

  • ...item: T[]

    Elements to append.

  Returns number

  The new logical length of the queue.

  Example

  const q = FastQueue.fromArray([1, 2]);
  q.push(3, 4);
  console.log([...q]); // [1, 2, 3, 4]
  Copy

reduce

• reduce(
      callback: (
          previousValue: T,
          currentValue: T,
          currentIndex: number,
          array: T[],
      ) => T,
  ): T

  Reduces the queue to a single value, processing elements left-to-right.

  When called without initialValue the first element is used as the seed and processing starts at index 1.

  Parameters

  • callback: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T

    Reducer function.

  Returns T

  The accumulated result.

  Throws

  TypeError if the queue is empty and no initialValue is given.

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4]);
  console.log(q.reduce((acc, x) => acc + x, 0)); // 10
  console.log(q.reduce((acc, x) => acc + x)); // 10
  Copy

• reduce(
      callback: (
          previousValue: T,
          currentValue: T,
          currentIndex: number,
          array: T[],
      ) => T,
      initial: T,
  ): T

  Reduces the queue to a single value, processing elements left-to-right.

  When called without initialValue the first element is used as the seed and processing starts at index 1.

  Parameters

  • callback: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T

    Reducer function.

  • initial: T

    Optional initial accumulator value.

  Returns T

  The accumulated result.

  Throws

  TypeError if the queue is empty and no initialValue is given.

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4]);
  console.log(q.reduce((acc, x) => acc + x, 0)); // 10
  console.log(q.reduce((acc, x) => acc + x)); // 10
  Copy

• reduce<U>(
      callback: (
          previousValue: U,
          currentValue: T,
          currentIndex: number,
          array: T[],
      ) => U,
      initial: U,
  ): U

  Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

  Type Parameters

  • U

  Parameters

  • callback: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U
  • initial: U

  Returns U

reduceRight

• reduceRight(
      callback: (
          previousValue: T,
          currentValue: T,
          currentIndex: number,
          array: T[],
      ) => T,
  ): T

  Reduces the queue to a single value, processing elements right-to-left.

  Parameters

  • callback: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T

    Reducer function.

  Returns T

  The accumulated result.

  Throws

  TypeError if the queue is empty and no initialValue is given.

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  console.log(q.reduceRight((acc, x) => acc + x, '')); // '321'
  Copy

• reduceRight(
      callback: (
          previousValue: T,
          currentValue: T,
          currentIndex: number,
          array: T[],
      ) => T,
      initial: T,
  ): T

  Reduces the queue to a single value, processing elements right-to-left.

  Parameters

  • callback: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T

    Reducer function.

  • initial: T

    Optional initial accumulator value.

  Returns T

  The accumulated result.

  Throws

  TypeError if the queue is empty and no initialValue is given.

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  console.log(q.reduceRight((acc, x) => acc + x, '')); // '321'
  Copy

• reduceRight<U>(
      callback: (
          previousValue: U,
          currentValue: T,
          currentIndex: number,
          array: T[],
      ) => U,
      initial: U,
  ): U

  Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.

  Type Parameters

  • U

  Parameters

  • callback: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U
  • initial: U

  Returns U

reverse

• reverse(): FastShiftArray<T>

  Reverses the queue in place and returns this.

  Only the logical elements (from headIndex onward) are reversed; ghost slots are not touched.

  Returns FastShiftArray<T>

  this.

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  q.reverse();
  console.log([...q]); // [3, 2, 1]
  Copy

shift

• shift(): T | undefined

  Removes and returns the first element of the queue in O(1) time.

  After removal, headIndex is incremented rather than copying elements. Ghost slots are cleaned up automatically when headIndex exceeds 100 000.

  Returns T | undefined

  The first element, or undefined if the queue is empty.

  Example

  const q = FastQueue.fromArray([10, 20, 30]);
  console.log(q.shift()); // 10  (O(1))
  console.log(q[0]); // 20
  Copy

slice

• slice(start?: number, end?: number): FastShiftArray<T>

  Returns a section of the queue as a new FastQueue.

  Negative indices are supported: -1 refers to the last element.

  Parameters

  • Optionalstart: number

    Zero-based start index (inclusive, default 0).

  • Optionalend: number

    Zero-based end index (exclusive, default this.length).

  Returns FastShiftArray<T>

  A new FastQueue<T> with fresh backing storage.

  Example

  const q = FastQueue.fromArray([0, 1, 2, 3, 4]);
  console.log([...q.slice(1, 3)]); // [1, 2]
  console.log([...q.slice(-2)]); // [3, 4]
  Copy

some

• some(
      predicate: (value: T, index: number, array: T[]) => unknown,
      _thisArg?: any,
  ): boolean

  Returns true if at least one element satisfies predicate.

  Short-circuits on the first matching element.

  Parameters

  • predicate: (value: T, index: number, array: T[]) => unknown

    Test function.

  • Optional_thisArg: any

    Unused.

  Returns boolean

  Example

  const q = FastQueue.fromArray([1, 3, 5]);
  console.log(q.some(x => x % 2 === 0)); // false
  q.push(4);
  console.log(q.some(x => x % 2 === 0)); // true
  Copy

sort

• sort(compareFn?: (a: T, b: T) => number): this

  Sorts the queue in place using compareFn and returns this.

  Ghost slots are discarded during the sort, so headIndex is reset to 0 afterward.

  Parameters

  • OptionalcompareFn: (a: T, b: T) => number

    Optional comparison function (same semantics as Array.sort).

  Returns this

  this.

  Example

  const q = FastQueue.fromArray([3, 1, 2]);
  q.sort();
  console.log([...q]); // [1, 2, 3]
  
  q.sort((a, b) => b - a);
  console.log([...q]); // [3, 2, 1]
  Copy

splice

• splice(start: number, deleteCount?: number, ...insertItems: T[]): T[]

  Removes and/or inserts elements at start.

  Parameters

  • start: number

    Zero-based logical index at which to start changing the queue.

  • OptionaldeleteCount: number

    Number of elements to remove.

  • ...insertItems: T[]

    Elements to insert in place of the removed elements.

  Returns T[]

  An array of the removed elements.

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4]);
  const removed = q.splice(1, 2, 9, 8);
  console.log(removed); // [2, 3]
  console.log([...q]); // [1, 9, 8, 4]
  Copy

toArray

• toArray(start?: number, end?: number): T[]

  Returns a plain Array<T> containing the logical elements from start (inclusive) to end (exclusive).

  Parameters

  • start: number = 0

    Zero-based start index (default 0).

  • end: number = ...

    Zero-based end index (default this.length).

  Returns T[]

  A plain Array<T> — never a FastQueue.

  Example

  const q = FastQueue.fromArray([10, 20, 30, 40]);
  console.log(q.toArray(1, 3)); // [20, 30]
  Copy

toLocaleString

• toLocaleString(): string

  Returns a locale-sensitive string representation of the logical elements.

  Returns string

  Example

  const q = FastQueue.fromArray([1000, 2000]);
  console.log(q.toLocaleString()); // '1,000,2,000' (locale-dependent)
  Copy

toReversed

• toReversed(): FastShiftArray<T>

  Returns a new FastQueue with the elements in reverse order.

  The original queue is not modified.

  Returns FastShiftArray<T>

  A new reversed FastQueue<T>.

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  const r = q.toReversed();
  console.log([...r]); // [3, 2, 1]
  console.log([...q]); // [1, 2, 3]
  Copy

toSorted

• toSorted(compareFn?: (a: T, b: T) => number): FastShiftArray<T>

  Returns a new sorted FastQueue without modifying the original.

  Parameters

  • OptionalcompareFn: (a: T, b: T) => number

    Optional comparison function.

  Returns FastShiftArray<T>

  A new FastQueue<T> in sorted order.

  Example

  const q = FastQueue.fromArray([3, 1, 2]);
  const s = q.toSorted();
  console.log([...s]); // [1, 2, 3]
  console.log([...q]); // [3, 1, 2]
  Copy

toSpliced

• toSpliced(start: number, deleteCount: number, ...items: T[]): FastShiftArray<T>

  Returns a new FastQueue with a splice applied, without modifying the original.

  Parameters

  • start: number

    Zero-based logical start index.

  • deleteCount: number

    Number of elements to remove.

  • ...items: T[]

    Elements to insert.

  Returns FastShiftArray<T>

  A new FastQueue<T>.

  Example

  const q = FastQueue.fromArray([1, 2, 3, 4]);
  const r = q.toSpliced(1, 2, 9);
  console.log([...r]); // [1, 9, 4]
  console.log([...q]); // [1, 2, 3, 4]
  Copy

• toSpliced(start: number, deleteCount?: number): FastShiftArray<T>

  Copies an array and removes elements while returning the remaining elements.

  Parameters

  • start: number

    The zero-based location in the array from which to start removing elements.

  • OptionaldeleteCount: number

    The number of elements to remove.

  Returns FastShiftArray<T>

  A copy of the original array with the remaining elements.

toString

• toString(): string

  Returns a string representation of the logical elements, equivalent to join() with the default comma separator.

  Returns string

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  console.log(q.toString()); // '1,2,3'
  Copy

unshift

• unshift(...elements: T[]): number

  Inserts one or more elements at the beginning of the queue.

  If headIndex >= elements.length, elements are written into the ghost slots in-place without allocation. Otherwise, a new array is created.

  Parameters

  • ...elements: T[]

    Elements to prepend, in order.

  Returns number

  The new logical length.

  Example

  const q = FastQueue.fromArray([3, 4]);
  q.unshift(1, 2);
  console.log([...q]); // [1, 2, 3, 4]
  Copy

values

• values(): ArrayIterator<T>

  Returns an ArrayIterator over the logical element values.

  Returns ArrayIterator<T>

  Example

  const q = FastQueue.fromArray([10, 20, 30]);
  console.log([...q.values()]); // [10, 20, 30]
  Copy

with

• with(index: number, value: T): FastShiftArray<T>

  Returns a new FastQueue with the element at index replaced by value.

  The original queue is not modified.

  Parameters

  • index: number

    Zero-based logical index.

  • value: T

    Replacement value.

  Returns FastShiftArray<T>

  A new FastQueue<T>.

  Example

  const q = FastQueue.fromArray([1, 2, 3]);
  const r = q.with(1, 99);
  console.log([...r]); // [1, 99, 3]
  console.log([...q]); // [1, 2, 3]
  Copy

StaticcopyFromArray

• copyFromArray<T>(
      array: T[],
      useProxy?: boolean,
      compactingSize?: number,
  ): FastShiftArray<T>

  Creates a FastQueue from a copy of array.

  The queue owns its own storage; mutations do not affect the original.

  Type Parameters

  • T

  Parameters

  • array: T[]

    The array to copy.

  • OptionaluseProxy: boolean = true

    Optional parameter that determines whether to apply the index-offset proxy.

  • OptionalcompactingSize: number = COMPACTING_SIZE

    Optional parameter that determines the number of shifts before compacting the array.

  Returns FastShiftArray<T>

  A new FastQueue<T> with independent storage.

  Example

  const src = [1, 2, 3];
  const q = FastQueue.copyFromArray(src);
  q.push(4);
  console.log(src); // [1, 2, 3] — unchanged
  console.log([...q]); // [1, 2, 3, 4]
  Copy

Staticempty

• empty<T>(useProxy?: boolean, compactingSize?: number): FastShiftArray<T>

  Creates an empty FastQueue<T>.

  Type Parameters

  • T

  Parameters

  • OptionaluseProxy: boolean = true

    Optional parameter that determines whether to apply the index-offset proxy.

  • OptionalcompactingSize: number = COMPACTING_SIZE

    Optional parameter that determines the number of shifts before compacting the array.

  Returns FastShiftArray<T>

  A new empty FastQueue<T>.

  Example

  const q = FastQueue.empty<number>();
  q.push(1, 2);
  console.log(q.length); // 2
  Copy

StaticfromArray

• fromArray<T>(
      array: T[],
      useProxy?: boolean,
      compactingSize?: number,
  ): FastShiftArray<T>

  Creates a FastQueue that wraps array directly — no copy is made.

  Pass useProxy = false only when you know you will never use bracket notation to read or write elements.

  Type Parameters

  • T

  Parameters

  • array: T[]

    The array to wrap.

  • OptionaluseProxy: boolean = true

    Optional parameter that determines whether to apply the index-offset proxy.

  • OptionalcompactingSize: number = COMPACTING_SIZE

    Optional parameter that determines the number of shifts before compacting the array.

  Returns FastShiftArray<T>

  A new FastQueue<T> backed by array.

  Example

  const src = [1, 2, 3];
  const q = FastQueue.fromArray(src);
  q.push(4);
  console.log(src); // [1, 2, 3, 4] — same backing array
  Copy