Skips empty lines before frame headers (they are allowed after \00)
1793
private function skipEmptyLines()
    {
        $foundHeartbeat = false;
        while ($this->offset < $this->bufferSize) {
            $char = substr($this->buffer, $this->offset, 1);
            if ($char === "\x00" || $char === "\n" || $char === "\r") {
                $this->offset++;
                $foundHeartbeat = true;
            } else {
                break;
            }
        }
        if ($foundHeartbeat && $this->observer) {
            $this->observer->emptyLineReceived();
        }
    }
1371151
def without_indent(str)
      indent = str.split($/).each {|line| !line.strip.empty? }.map {|line| line.index(/[^\s]/) }.compact.min
      str.gsub(/^[[:blank:]]{#{indent}}/, '')
    end
133279
public void skipWhitespaces() {
    for (int i = mark; i < chars.length; i++) {
      if (Character.isWhitespace(chars[i])) {
        mark++;
      } else {
        break;
      }
    }
  }
875364
private int skipWhiteSpace(byte[] data, int start) {
        int index = start;
        while (index < data.length && (' ' == data[index] || '\t' == data[index])) {
            index++;
        }
        return index;
    }
725978
private State skipCommaSpaces2(State state) throws IOException {
        wsp1: for (;;) {
            switch (state.current) {
                default:
                    break wsp1;
                case 0x20:
                case 0x9:
                case 0xD:
                case 0xA:
                    break;
            }
            state.current = state.reader.read();
            state = appendToContext(state);
        }

        if (state.current != ',') {
            state.skipped = false; // no comma.
            return state;
        }

        wsp2: for (;;) {
            switch (state.current = state.reader.read()) {
                default:
                    state = appendToContext(state);
                    break wsp2;
                case 0x20:
                case 0x9:
                case 0xD:
                case 0xA:
                    state = appendToContext(state);
                    break;
            }
        }
        state.skipped = true; // had comma
        return state;
    }
451589
private static String stripIndentFromLine(String line, int numChars) {
        int length = line.length();
        return numChars <= length ? line.substring(numChars) : "";
    }
627952
private boolean skipOneLine() {
        if (!undecodedChunk.isReadable()) {
            return false;
        }
        byte nextByte = undecodedChunk.readByte();
        if (nextByte == HttpConstants.CR) {
            if (!undecodedChunk.isReadable()) {
                undecodedChunk.readerIndex(undecodedChunk.readerIndex() - 1);
                return false;
            }
            nextByte = undecodedChunk.readByte();
            if (nextByte == HttpConstants.LF) {
                return true;
            }
            undecodedChunk.readerIndex(undecodedChunk.readerIndex() - 2);
            return false;
        }
        if (nextByte == HttpConstants.LF) {
            return true;
        }
        undecodedChunk.readerIndex(undecodedChunk.readerIndex() - 1);
        return false;
    }
946028
public function skipWhitespace(): void
    {
        if (preg_match('/\h+/A', $this->data, $match, 0, $this->cursor)) {
            $this->char += mb_strlen($match[0]);
            $this->cursor += \strlen($match[0]);
        }
    }
771214
def trailing_blank_lines(physical_line, lines, line_number, total_lines):
    
    """
    if line_number == total_lines:
        stripped_last_line = physical_line.rstrip()
        if not stripped_last_line:
            return 0, "W391 blank line at end of file"
        if stripped_last_line == physical_line:
            return len(physical_line), "W292 no newline at end of file"
1121124
void skipMember() {
        bp = bp + 6;
        char ac = nextChar();
        for (int i = 0; i < ac; i++) {
            bp = bp + 2;
            int attrLen = nextInt();
            bp = bp + attrLen;
        }
    }
549936
public void skipLengthEncodedBytes() {
    int type = this.buf[this.position++] & 0xff;
    switch (type) {
      case 251:
        break;

      case 252:
        position += 2 + (0xffff & (((buf[position] & 0xff) + ((buf[position + 1] & 0xff) << 8))));
        break;

      case 253:
        position += 3 + (0xffffff & ((buf[position] & 0xff)
            + ((buf[position + 1] & 0xff) << 8)
            + ((buf[position + 2] & 0xff) << 16)));
        break;

      case 254:
        position += 8 + ((buf[position] & 0xff)
            + ((long) (buf[position + 1] & 0xff) << 8)
            + ((long) (buf[position + 2] & 0xff) << 16)
            + ((long) (buf[position + 3] & 0xff) << 24)
            + ((long) (buf[position + 4] & 0xff) << 32)
            + ((long) (buf[position + 5] & 0xff) << 40)
            + ((long) (buf[position + 6] & 0xff) << 48)
            + ((long) (buf[position + 7] & 0xff) << 56));
        break;

      default:
        position += type;
        break;
    }
  }
255718
def remove_blank_lines(source):
    
    io_obj = io.StringIO(source)
    source = [a for a in io_obj.readlines() if a.strip()]
    return "".join(source)
264797
function skipWhitespace() {
    while (i < input.length) {
      if (isWhitespace(input[i])) {
        i++;
        parser.pos_++;
        continue;
      }
      break;
    }
  }
1112823
def whitespace(lines: float = 1.0):
    
    r = _get_report()
    r.append_body(render.whitespace(lines))
    r.stdout_interceptor.write_source('\n')
159783
def _join_data_lines(lines, skip):
    
    lines = list(map(str.strip, lines))
    blank_lines = count_header_blanks(lines, skip)
    body = lines[skip + blank_lines + 2:]
    return '\n'.join(body)
1358471
def skipNullPadding(self, buff):
        '''
        
        '''
        def readNext(buff, first_run=True):
            datas = unpack('<i', buff.read(4))
            header = datas[0]

            if header == CHUNK_NULL_TYPE and first_run:
                print("Skipping null padding in StringPoolChunk header")
                header = readNext(buff, first_run=False)
            elif header != CHUNK_STRINGPOOL_TYPE:
                print("Invalid StringPoolChunk header")

            return header

        header = readNext(buff)
        return header >> 8, header & 0xFF
114471
function sanitizeLines(frame) {
	// Sanitize newlines & replace tabs.
	lines = stripAnsi(frame)
		.replace(/\r/g, '')
		.split('\n')
		.map(l => l.replace(/\t/g, '  '))
	// Remove left caret.
	var leftCaretLine = lines.find(l => l.startsWith('>'))
	if (leftCaretLine) {
		lines[lines.indexOf(leftCaretLine)] = leftCaretLine.replace('>', ' ')
	}
	// Remove left padding.
	// Loop while all lines start with space and strip the space from all lines.
	while (lines.find(l => !l.startsWith(' ')) == undefined) {
		lines = lines.map(l => l.slice(1))
	}
	return lines
}