Queue with O(1) enqueue and dequeue with JS arrays
Review
I find your indentations and line breaks rather difficult to read.

Object.defineProperty(this,&quot;head&quot;,{ value   : 0
                                  , writable: true
                                  });


I would suggest you use the idiomatic style.
After { move to the next line and indent once. Place the comma at the end of lines and spaces after commas if not at end of line
Object.defineProperty(this, &quot;head&quot;, { 
    value: 0,
    writable: true
});

or if the line is short
Object.defineProperty(this, &quot;head&quot;, {value: 0, writable: true});

or
Object.defineProperty(
    this, 
    &quot;head&quot;, { 
        value: 0,
        writable: true
    }
);

Same again with the ternary.

return this.head &lt; this.length ? ( first = this[this.head]
                                 , delete this[this.head++]
                                 , first
                                 )
                               : void 0;


Why use the operator void that requires the additional expression 0 when you can just express undefined.
I understand the reasoning for breaking up the group, but the indent is way to great. The idiomatic style is far more readable.
return this.head &lt; this.length ? ( 
        first = this[this.head],
        delete this[this.head++],
        first
    ) :                       
    undefined;                           

or
return this.head &lt; this.length ?
    (first = this[this.head], delete this[this.head++], first) :                       
    undefined; 

Unsafe encapsulation
Extending the Array with the behaviors enqueue and dequeue is just asking for bugs as any of the existing functions can damage state.
Rules of code: &quot;If it is there it will be used.&quot;
Good code enforces the rules by not exposing properties and behaviors that can damage state.
Even just the basic use of Queue is un-trusted because you expose head.
JS Queue
Complexity and performance are two side of the same coin. Though linked they are vastly difference. With shift at \$O(1)\$ its performance is still 10 times slower than pop
However you use delete to remove items. Again it is \$O(1)\$ but it is even slower than shift.
Linked list
I have found that a simple linked list is the most effective and performant solution for a queue in JS
Implementing it as a factory function allows closure to hold its state safely isolated from the code using the queue.
function Queue() {
    var head, tail;
    return Object.freeze({     
        enqueue(value) { 
            const link = {value, next: undefined};
            tail = head ? tail.next = link : head = link;
        },
        dequeue() {
            if (head) {
                const value = head.value;
                head = head.next;
                return value;
            }
        },
        peek() { return head?.value }
    });
}

This style offers robust encapsulation, maintains the ideal \$O(1)\$ for enqueue and dequeue without sacrificing performance.
Test
The test compares the execution time of your Queue against a linked list version of a queue.
There are two test cycles, First for 1000 items, then when done click the button for 500,000 items.
I Have made minor changes to your code to favor performance. Not using define property and not returning the array in enqueue.


var size = 1000;
const COOL = 200;

class Queue extends Array {
  constructor(){
    super();
    this.head = 0;
  }
  enqueue(x) { this.push(x) }
  dequeue() {
    var first;
    return this.head &lt; this.length ? 
        (first = this[this.head] , delete this[this.head++] , first) : 
        void 0;
  }
  peek() { return this[this.head] }
}

function QueueLinked() {
    var head, tail;
    return Object.freeze({     
        enqueue(value) { 
            const link = {value, next: undefined};
            tail = head ? tail.next = link : head = link;
        },
        dequeue() {
            if (head) {
                const value = head.value;
                head = head.next;
                return value;
            }
        },
        peek() { return head?.value }
    });
}


function fillQueue(queue, count = size) {
    while (count--) { queue.enqueue(count) }
    return queue;
}
function testOPQueue() {
    const q = fillQueue(new Queue());
    var ii = 0, val = 0;
    do {
        ii += val;
        val = q.dequeue();
    } while (val !== undefined);
    return ii;
}
function testLinkedQueue() {
    const q = fillQueue(QueueLinked());
    var ii = 0, val = 0;
    do {
        ii += val;
        val = q.dequeue();
    } while (val !== undefined);
    return ii;
}

if (testOPQueue() !== testLinkedQueue()) { throw new Error("Test results differ") }

const funcTest = (name, call, bias = 1) =&gt; ({name, call, time: 0, cycles: 0, bias});

timeFunctions(50, 500, "1000 items:",
    funcTest("Array Queue", testOPQueue),
    funcTest("Linked Queue", testLinkedQueue),
).then(() =&gt; {
    test2.classList.remove("hide");
    test2.addEventListener("click", () =&gt; {
        test2.classList.add("hide");
        size = 500000;
        timeFunctions(50, 3, "500,000 items:",
            funcTest("Array Queue", testOPQueue),
            funcTest("Linked Queue", testLinkedQueue),
        );
    });
});


function timeFunctions(testCount, cycles, name, ...functions) {
    return new Promise(done =&gt; {
        const testGroup = () =&gt; {
            var i;
            for (const func of functions) {
                i = cycles;
                const now = performance.now();
                while (i--) { func.call() }
                func.time += performance.now() - now;
                func.cycles += cycles;
            }
        }
        const test = () =&gt; {
            testGroup();
            console.clear();
            console.log(name + " " + (testCount - count + 1) + " of " + testCount);
            for (const func of functions) {
                console.log(
                    func.name.padEnd(maxNameLen + 2,".") + ": " + 
                    (((func.time / func.cycles) / func.bias).toFixed(3) + "ms").padStart(9," ") +
                    (" Total: " + func.time.toFixed(3) + "ms") 
                );
            }
            if (--count) { setTimeout(test, COOL) }
            else { done() }
        }
        var count = testCount;
        var maxNameLen = 0
        for (const func of functions) {
            func.time = 0;
            func.cycles = 0;
            maxNameLen = Math.max(maxNameLen, func.name.length);
        }
        setTimeout(test, COOL);
    });
}
.hide { display: none }
&lt;button id="test2" class="hide"&gt;Test 500000 items&lt;/button&gt;