Meet JSON's functional half-brother.

// @JSOL v0.2.94

/**
 @description
 Sorts an array of numbers into ascending order using heapsort (CLRS
 chapter 6): treats the array as a binary heap using standard implicit
 indexing (a node at index i has children at 2i+1 and 2i+2), builds a
 max-heap out of the whole array, then repeatedly swaps the root (the
 current largest value) with the last unsorted element and re-heapifies
 the shrinking heap.
  No pointers or node objects needed: the parent/child relationship is
 entirely arithmetic on array indices, which is why heapsort is one of
 the few classic tree-based algorithms that translates directly into
 JSOL's array-only data model.
  O(n log n) in every case, and unlike merge-sort.jsol.js, sorts in place
 with no extra array needed.

@param {array<number>} $aValues - Numbers to sort.
@returns {array<number>} - A new array with the same numbers in ascending order.
*/

/**
 @contract
 {
   "cases": [
     { "$aValues": [5, 2, 9, 1, 5, 6] },
     { "$aValues": [] }
   ]
 }
*/

const $aSiftDown = function($aValues, $qHeapSize, $qRoot) {
    // JSOL.use: Explicitly binds self-reference for recursive closure execution across target runtimes.
    JSOL.use($aSiftDown);

    let $qLargest = $qRoot;
    const $qLeftChild = (2 * $qRoot) + 1;
    const $qRightChild = (2 * $qRoot) + 2;

    if ($qLeftChild < $qHeapSize && $aValues[$qLeftChild] > $aValues[$qLargest]) {
        $qLargest = $qLeftChild;
    }
    if ($qRightChild < $qHeapSize && $aValues[$qRightChild] > $aValues[$qLargest]) {
        $qLargest = $qRightChild;
    }

    if ($qLargest !== $qRoot) {
        const $nTemp = $aValues[$qRoot];
        $aValues[$qRoot] = $aValues[$qLargest];
        $aValues[$qLargest] = $nTemp;
        
        // Cross-Engine Parity Note: Array reassignment guarantees that in-place mutations persist
        // on target runtimes where arrays are passed by value (e.g., PHP) vs by reference (e.g., JS/TS).
        $aValues = $aSiftDown($aValues, $qHeapSize, $qLargest);
    }

    return $aValues;
};

const $aHeapSort = function($aValues) {
    // JSOL.use: Injects helper functions into closure scope for isolated target runtimes.
    JSOL.use($aSiftDown);

    let $aSorted = Arr.slice($aValues, 0, Arr.count($aValues));
    const $qLen = Arr.count($aSorted);

    // Build the max-heap: sift down every non-leaf node, from the last one back to the root.
    for (let $qI = Math.floor($qLen / 2) - 1; $qI >= 0; $qI = $qI - 1) {
        // Capture returned array to ensure mutation persistence across value-type array engines.
        $aSorted = $aSiftDown($aSorted, $qLen, $qI);
    }

    // Repeatedly move current max (root) to the end of unsorted region, then re-heapify.
    for (let $qEnd = $qLen - 1; $qEnd > 0; $qEnd = $qEnd - 1) {
        const $nTemp = $aSorted[0];
        $aSorted[0] = $aSorted[$qEnd];
        $aSorted[$qEnd] = $nTemp;
        
        // Capture returned array to ensure mutation persistence across value-type array engines.
        $aSorted = $aSiftDown($aSorted, $qEnd, 0);
    }

    return $aSorted;
};

// @JSOL v0.2.94

/**
 @description
 Sorts an array of numbers into ascending order using heapsort (CLRS
 chapter 6): treats the array as a binary heap using standard implicit
 indexing (a node at index i has children at 2i+1 and 2i+2), builds a
 max-heap out of the whole array, then repeatedly swaps the root (the
 current largest value) with the last unsorted element and re-heapifies
 the shrinking heap.
  No pointers or node objects needed: the parent/child relationship is
 entirely arithmetic on array indices, which is why heapsort is one of
 the few classic tree-based algorithms that translates directly into
 JSOL's array-only data model.
  O(n log n) in every case, and unlike merge-sort.jsol.js, sorts in place
 with no extra array needed.

@param {array<number>} $aValues - Numbers to sort.
@returns {array<number>} - A new array with the same numbers in ascending order.
*/

/**
 @contract
 {
   "cases": [
     { "$aValues": [5, 2, 9, 1, 5, 6] },
     { "$aValues": [] }
   ]
 }
*/

const $aSiftDown = function($aValues, $qHeapSize, $qRoot) {
  // JSOL.use: Explicitly binds self-reference for recursive closure execution across target runtimes.
    

    let $qLargest = $qRoot;
    const $qLeftChild = (2 * $qRoot) + 1;
    const $qRightChild = (2 * $qRoot) + 2;

    if ($qLeftChild < $qHeapSize && $aValues[$qLeftChild] > $aValues[$qLargest]) {
    $qLargest = $qLeftChild;
  }
  if ($qRightChild < $qHeapSize && $aValues[$qRightChild] > $aValues[$qLargest]) {
    $qLargest = $qRightChild;
  }
  if ($qLargest !== $qRoot) {
    const $nTemp = $aValues[$qRoot];
        $aValues[$qRoot] = $aValues[$qLargest];
        $aValues[$qLargest] = $nTemp;
        
        // Cross-Engine Parity Note: Array reassignment guarantees that in-place mutations persist
        // on target runtimes where arrays are passed by value (e.g., PHP) vs by reference (e.g., JS/TS).
        $aValues = $aSiftDown($aValues, $qHeapSize, $qLargest);
  }
  return $aValues;
};
const $aHeapSort = function($aValues) {
  // JSOL.use: Injects helper functions into closure scope for isolated target runtimes.
    

    let $aSorted = $aValues.slice( 0,  $aValues.length);
    const $qLen = $aSorted.length;

    // Build the max-heap: sift down every non-leaf node, from the last one back to the root.
    for (let $qI = Math.floor($qLen / 2) - 1; $qI >= 0; $qI = $qI - 1) {
    // Capture returned array to ensure mutation persistence across value-type array engines.
        $aSorted = $aSiftDown($aSorted, $qLen, $qI);
  }
  // Repeatedly move current max (root) to the end of unsorted region, then re-heapify.
    for (let $qEnd = $qLen - 1; $qEnd > 0; $qEnd = $qEnd - 1) {
    const $nTemp = $aSorted[0];
        $aSorted[0] = $aSorted[$qEnd];
        $aSorted[$qEnd] = $nTemp;
        
        // Capture returned array to ensure mutation persistence across value-type array engines.
        $aSorted = $aSiftDown($aSorted, $qEnd, 0);
  }
  return $aSorted;
};
window['$aSiftDown'] = $aSiftDown;

<?php
// @JSOL v0.2.94

/**
 @description
 Sorts an array of numbers into ascending order using heapsort (CLRS
 chapter 6): treats the array as a binary heap using standard implicit
 indexing (a node at index i has children at 2i+1 and 2i+2), builds a
 max-heap out of the whole array, then repeatedly swaps the root (the
 current largest value) with the last unsorted element and re-heapifies
 the shrinking heap.
  No pointers or node objects needed: the parent/child relationship is
 entirely arithmetic on array indices, which is why heapsort is one of
 the few classic tree-based algorithms that translates directly into
 JSOL's array-only data model.
  O(n log n) in every case, and unlike merge-sort.jsol.js, sorts in place
 with no extra array needed.

@param {array<number>} $aValues - Numbers to sort.
@returns {array<number>} - A new array with the same numbers in ascending order.
*/

/**
 @contract
 {
   "cases": [
     { "$aValues": [5, 2, 9, 1, 5, 6] },
     { "$aValues": [] }
   ]
 }
*/

$aSiftDown = function($aValues, $qHeapSize, $qRoot) use (&$aSiftDown) {
  $qLargest = $qRoot;
    $qLeftChild = (2 * $qRoot) + 1;
    $qRightChild = (2 * $qRoot) + 2;

    if ($qLeftChild < $qHeapSize && $aValues[$qLeftChild] > $aValues[$qLargest]) {
    $qLargest = $qLeftChild;
  }
  if ($qRightChild < $qHeapSize && $aValues[$qRightChild] > $aValues[$qLargest]) {
    $qLargest = $qRightChild;
  }
  if ($qLargest !== $qRoot) {
    $nTemp = $aValues[$qRoot];
        $aValues[$qRoot] = $aValues[$qLargest];
        $aValues[$qLargest] = $nTemp;
        
        // Cross-Engine Parity Note: Array reassignment guarantees that in-place mutations persist
        // on target runtimes where arrays are passed by value (e.g., PHP) vs by reference (e.g., JS/TS).
        $aValues = $aSiftDown($aValues, $qHeapSize, $qLargest);
  }
  return $aValues;
};
$aHeapSort = function($aValues) use (&$aSiftDown) {
  $aSorted = array_slice($aValues,  0,  count($aValues));
    $qLen = count($aSorted);

    // Build the max-heap: sift down every non-leaf node, from the last one back to the root.
    for ($qI = floor($qLen / 2) - 1; $qI >= 0; $qI = $qI - 1) {
    // Capture returned array to ensure mutation persistence across value-type array engines.
        $aSorted = $aSiftDown($aSorted, $qLen, $qI);
  }
  // Repeatedly move current max (root) to the end of unsorted region, then re-heapify.
    for ($qEnd = $qLen - 1; $qEnd > 0; $qEnd = $qEnd - 1) {
    $nTemp = $aSorted[0];
        $aSorted[0] = $aSorted[$qEnd];
        $aSorted[$qEnd] = $nTemp;
        
        // Capture returned array to ensure mutation persistence across value-type array engines.
        $aSorted = $aSiftDown($aSorted, $qEnd, 0);
  }
  return $aSorted;
};

declare var JSOL: any;
declare var Rgx: any;

// @JSOL v0.2.94

/**
 @description
 Sorts an array of numbers into ascending order using heapsort (CLRS
 chapter 6): treats the array as a binary heap using standard implicit
 indexing (a node at index i has children at 2i+1 and 2i+2), builds a
 max-heap out of the whole array, then repeatedly swaps the root (the
 current largest value) with the last unsorted element and re-heapifies
 the shrinking heap.
  No pointers or node objects needed: the parent/child relationship is
 entirely arithmetic on array indices, which is why heapsort is one of
 the few classic tree-based algorithms that translates directly into
 JSOL's array-only data model.
  O(n log n) in every case, and unlike merge-sort.jsol.js, sorts in place
 with no extra array needed.

@param {array<number>} $aValues - Numbers to sort.
@returns {array<number>} - A new array with the same numbers in ascending order.
*/

/**
 @contract
 {
   "cases": [
     { "$aValues": [5, 2, 9, 1, 5, 6] },
     { "$aValues": [] }
   ]
 }
*/

const $aSiftDown = function($aValues: any, $qHeapSize: any, $qRoot: any): any[] {
  // JSOL.use: Explicitly binds self-reference for recursive closure execution across target runtimes.
    

    let $qLargest: number = $qRoot;
    const $qLeftChild: number = (2 * $qRoot) + 1;
    const $qRightChild: number = (2 * $qRoot) + 2;

    if ($qLeftChild < $qHeapSize && $aValues[$qLeftChild] > $aValues[$qLargest]) {
    $qLargest = $qLeftChild;
  }
  if ($qRightChild < $qHeapSize && $aValues[$qRightChild] > $aValues[$qLargest]) {
    $qLargest = $qRightChild;
  }
  if ($qLargest !== $qRoot) {
    const $nTemp: number = $aValues[$qRoot];
        $aValues[$qRoot] = $aValues[$qLargest];
        $aValues[$qLargest] = $nTemp;
        
        // Cross-Engine Parity Note: Array reassignment guarantees that in-place mutations persist
        // on target runtimes where arrays are passed by value (e.g., PHP) vs by reference (e.g., JS/TS).
        $aValues = $aSiftDown($aValues, $qHeapSize, $qLargest);
  }
  return $aValues;
};
const $aHeapSort = function($aValues: any): any[] {
  // JSOL.use: Injects helper functions into closure scope for isolated target runtimes.
    

    let $aSorted: any[] = $aValues.slice( 0,  $aValues.length);
    const $qLen: number = $aSorted.length;

    // Build the max-heap: sift down every non-leaf node, from the last one back to the root.
    for (let $qI = Math.floor($qLen / 2) - 1; $qI >= 0; $qI = $qI - 1) {
    // Capture returned array to ensure mutation persistence across value-type array engines.
        $aSorted = $aSiftDown($aSorted, $qLen, $qI);
  }
  // Repeatedly move current max (root) to the end of unsorted region, then re-heapify.
    for (let $qEnd = $qLen - 1; $qEnd > 0; $qEnd = $qEnd - 1) {
    const $nTemp: number = $aSorted[0];
        $aSorted[0] = $aSorted[$qEnd];
        $aSorted[$qEnd] = $nTemp;
        
        // Capture returned array to ensure mutation persistence across value-type array engines.
        $aSorted = $aSiftDown($aSorted, $qEnd, 0);
  }
  return $aSorted;
};

import math
from jsol_core import JSOL

# @JSOL v0.2.94

#*
# @description
# Sorts an array of numbers into ascending order using heapsort (CLRS
# chapter 6): treats the array as a binary heap using standard implicit
# indexing (a node at index i has children at 2i+1 and 2i+2), builds a
# max-heap out of the whole array, then repeatedly swaps the root (the
# current largest value) with the last unsorted element and re-heapifies
# the shrinking heap.
#  No pointers or node objects needed: the parent/child relationship is
# entirely arithmetic on array indices, which is why heapsort is one of
# the few classic tree-based algorithms that translates directly into
# JSOL's array-only data model.
#  O(n log n) in every case, and unlike merge-sort.jsol.js, sorts in place
# with no extra array needed.
#
#@param {array<number>} $aValues - Numbers to sort.
#@returns {array<number>} - A new array with the same numbers in ascending order.
#

#*
# @contract
# {
#   "cases": [
#     { "$aValues": [5, 2, 9, 1, 5, 6] },
#     { "$aValues": [] }
#   ]
# }
#

def aSiftDown(aValues, qHeapSize, qRoot): 

  # JSOL.use: Explicitly binds self-reference for recursive closure execution across target runtimes.


  qLargest = qRoot;
  qLeftChild = (2 * qRoot) + 1;
  qRightChild = (2 * qRoot) + 2;

  if qLeftChild < qHeapSize and aValues[qLeftChild] > aValues[qLargest]: 

    qLargest = qLeftChild;


  if qRightChild < qHeapSize and aValues[qRightChild] > aValues[qLargest]: 

    qLargest = qRightChild;


  if qLargest != qRoot: 

    nTemp = aValues[qRoot];
    aValues[qRoot] = aValues[qLargest];
    aValues[qLargest] = nTemp;

    # Cross-Engine Parity Note: Array reassignment guarantees that in-place mutations persist
    # on target runtimes where arrays are passed by value (e.g., PHP) vs by reference (e.g., JS/TS).
    aValues = aSiftDown(aValues, qHeapSize, qLargest);


  return aValues;


def aHeapSort(aValues): 

  # JSOL.use: Injects helper functions into closure scope for isolated target runtimes.


  aSorted = aValues[ 0: len(aValues)];
  qLen = len(aSorted);

  # Build the max-heap: sift down every non-leaf node, from the last one back to the root.
  qI = math.floor(qLen / 2) - 1;
  while qI >= 0: 

    # Capture returned array to ensure mutation persistence across value-type array engines.
    aSorted = aSiftDown(aSorted, qLen, qI);

    qI = qI - 1;


  # Repeatedly move current max (root) to the end of unsorted region, then re-heapify.
  qEnd = qLen - 1;
  while qEnd > 0: 

    nTemp = aSorted[0];
    aSorted[0] = aSorted[qEnd];
    aSorted[qEnd] = nTemp;

    # Capture returned array to ensure mutation persistence across value-type array engines.
    aSorted = aSiftDown(aSorted, qEnd, 0);

    qEnd = qEnd - 1;


  return aSorted;