IronMQ does not support an offset when peeking messages.

{@inheritdoc}
332939
public function peekQueue($queueName, $index = 0, $limit = 20)
    {
        if ($messages = $this->ironmq->peekMessages($queueName, $limit)) {
            return $this->pluck($messages, 'body');
        }

        return [];
    }
1313228
public void handleIncomingMessage(byte[] data, int offset, int len) {
		synchronized(messageQueue) {
			messageQueue.add(new IncomingMessage(data, offset, len));
		}
		synchronized(lock) {
			lock.notifyAll();
		}
	}
1307119
private boolean okayToSendMessage(IRTMPEvent message) {
        if (message instanceof IStreamData) {
            final long now = System.currentTimeMillis();
            // check client buffer size
            if (isClientBufferFull(now)) {
                return false;
            }
            // get pending message count
            long pending = pendingMessages();
            if (bufferCheckInterval > 0 && now >= nextCheckBufferUnderrun) {
                if (pending > underrunTrigger) {
                    // client is playing behind speed, notify him
                    sendInsufficientBandwidthStatus(currentItem.get());
                }
                nextCheckBufferUnderrun = now + bufferCheckInterval;
            }
            // check for under run
            if (pending > underrunTrigger) {
                // too many messages already queued on the connection
                return false;
            }
            return true;
        } else {
            String itemName = "Undefined";
            // if current item exists get the name to help debug this issue
            if (currentItem.get() != null) {
                itemName = currentItem.get().getName();
            }
            Object[] errorItems = new Object[] { message.getClass(), message.getDataType(), itemName };
            throw new RuntimeException(String.format("Expected IStreamData but got %s (type %s) for %s", errorItems));
        }
    }
312724
function requestJumpToDef(session, offset) {
                var response = ScopeManager.requestJumptoDef(session, session.editor.document, offset);

                if (response.hasOwnProperty("promise")) {
                    response.promise.done(handleJumpResponse).fail(function () {
                        result.reject();
                    });
                }
            }
1343049
NatsMessage accumulate(long maxSize, long maxMessages, Duration timeout)
            throws InterruptedException {

        if (!this.singleThreadedReader) {
            throw new IllegalStateException("Accumulate is only supported in single reader mode.");
        }

        if (!this.isRunning()) {
            return null;
        }

        NatsMessage msg = this.queue.poll();

        if (msg == null) {
            msg = waitForTimeout(timeout);
            
            if (!this.isRunning() || (msg == null)) {
                return null;
            }
        }

        long size = msg.getSizeInBytes();

        if (maxMessages <= 1 || size >= maxSize) {
            this.sizeInBytes.addAndGet(-size);
            this.length.decrementAndGet();
            signalIfNotEmpty();
            return msg;
        }

        long count = 1;
        NatsMessage cursor = msg;

        while (cursor != null) {
            NatsMessage next = this.queue.peek();
            if (next != null) {
                long s = next.getSizeInBytes();

                if (maxSize<0 || (size + s) < maxSize) { // keep going
                    size += s;
                    count++;
                    
                    cursor.next = this.queue.poll();
                    cursor = cursor.next;

                    if (count == maxMessages) {
                        break;
                    }
                } else { // One more is too far
                    break;
                }
            } else { // Didn't meet max condition
                break;
            }
        }

        this.sizeInBytes.addAndGet(-size);
        this.length.addAndGet(-count);

        signalIfNotEmpty();
        return msg;
    }
532516
private void onMTMessage(MTMessage mtMessage) {
        if (mtMessage.getSeqNo() % 2 == 1) {
            scheduller.confirmMessage(mtMessage.getMessageId());
        }
        if (!needProcessing(mtMessage.getMessageId())) {
            if (Logger.LOG_IGNORED) {
                Logger.d(TAG, "Ignoring messages #" + mtMessage.getMessageId());
            }
            return;
        }
        try {
            TLObject intMessage = protoContext.deserializeMessage(new ByteArrayInputStream(mtMessage.getContent()));
            onMTProtoMessage(mtMessage.getMessageId(), intMessage);
        } catch (DeserializeException e) {
            callback.onApiMessage(mtMessage.getContent(), this);
        } catch (IOException e) {
            Logger.e(TAG, e);
            // ???
        }
    }
1080896
public boolean containsInstructionWithOffset(int offset) {
        Iterator<InstructionHandle> i = instructionIterator();
        while (i.hasNext()) {
            if (i.next().getPosition() == offset) {
                return true;
            }
        }
        return false;
    }
722656
@SuppressWarnings("unchecked")
    @Override
    public E peek() {
        final AtomicReferenceArray<E> buffer = consumerBuffer;
        final long index = lpConsumerIndex();
        final long mask = consumerMask;
        final int offset = calcElementOffset(index, mask);
        // LoadLoad
        final Object e = lvElement(buffer, offset);
        if (e == JUMP) {
            return newBufferPeek(buffer, index);
        }
        return (E) e;
    }
1286921
ServerRequest peek() {
        ServerRequest req = null;
        synchronized (reqQueueLockObject) {
            try {
                req = queue.get(0);
            } catch (IndexOutOfBoundsException | NoSuchElementException ignored) {
            }
        }
        return req;
    }
596837
public function peek($offset = 0)
    {
        $c = $this->next($offset);
        $this->backup($offset);

        return $c;
    }
729160
@Nonnull
  public Query offset(int offset) {
    QueryOptions newOptions = new QueryOptions(options);
    newOptions.offset = offset;
    return new Query(firestore, path, newOptions);
  }
482499
def offset(self):
        
        try:
            return Offset(self._annotations[EventData.PROP_OFFSET].decode('UTF-8'))
        except (KeyError, AttributeError):
            return None
632402
public void calcOffset(Container compAnchor, Point offset)
    {
        offset.x = 0;
        offset.y = 0;
        Container parent = this;
        while (parent != null)
        {
            offset.x -= parent.getLocation().x;
            offset.y -= parent.getLocation().y;
            parent = parent.getParent();
            if (parent == compAnchor)
                return; // Success
        }
        // Failure - comp not found.
        offset.x = 0;
        offset.y = 0;
    }
997019
public SIBusMessage peek() 
  
  throws SISessionUnavailableException, SIResourceException, SIIncorrectCallException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "peek");
    
    checkValidState("peek");
    
    _localConsumerPoint.checkNotClosed();

    SIBusMessage nextMessage = null;
    
    if(!_seenSingleMessage)
    {
      // Because this message is not in the message store there is no need to copy it
      // before giving it to a caller unless this is pubsub, in which case there may be
      // other subscriptions referencing the same message, in which case we must copy the
      // message (unless the caller indicates that they won't be altering it)
      if(_isPubsub &&
         ((ConnectionImpl)(_localConsumerPoint.getConsumerSession().getConnection())).getMessageCopiedWhenReceived())
      {
        try
        {
          nextMessage = (_singleMessage.getMessage()).getReceived();
        }
        catch (MessageCopyFailedException e)
        {
          FFDCFilter.processException(
            e,
            "com.ibm.ws.sib.processor.impl.SingleLockedMessageEnumerationImpl.peek",
            "1:456:1.44",
            this);
              
          SibTr.exception(tc, e);
          SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
            new Object[] {
              "com.ibm.ws.sib.processor.impl.SingleLockedMessageEnumerationImpl",
              "1:463:1.44",
              e });
            
          _seenSingleMessage = false;
          _messageAvailable = false;
    
          if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
            SibTr.exit(CoreSPILockedMessageEnumeration.tc, "peek", e);
    
          throw new SIResourceException(
            nls.getFormattedMessage(
              "INTERNAL_MESSAGING_ERROR_CWSIP0002",
              new Object[] {
                "com.ibm.ws.sib.processor.impl.SingleLockedMessageEnumerationImpl",
                "1:477:1.44",
                e },
              null),
            e);
        }
      }
      else
        nextMessage = _singleMessage.getMessage();
    }
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "peek", nextMessage);
    return nextMessage;
  }
976186
def offset(self, value):
        

        self._query = self._query.skip(value)

        return self
924251
public function setChatOffset($offsetX, $offsetY)
    {
        $offset = array((float)$offsetX, (float)$offsetY);
        $this->setProperty($this->chatProperties, "offset", implode(" ", $offset));
        return $this;
    }
202390
@Override
    public T peek() {
        synchronized (this) {
            if (numberOfUsedExpeditedSlots.get() > 0) {
                return expeditedBuffer[expeditedTakeIndex];
            } else if (numberOfUsedSlots.get() > 0) {
                return buffer[takeIndex];
            } else {
                return null;
            }
        }
    }