ULTRA [ www.resource.optimyar.com ]

Linux uranus.pws-dns.net 5.14.0-427.42.1.el9_4.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Nov 1 14:58:02 EDT 2024 x86_64

LiteSpeed

31.214.174.197 | Your IP: 216.73.216.208

Cant read [ /etc/named.conf ]

[ drwxrwxr-x ]

/ home / freeclou / app.optimyar.com / backend / node_modules / hpack.js / lib / hpack /

Home Upload Mass Deface Mass Delete Back Connect Notify

decoder.js

var hpack = require('../hpack');
var utils = hpack.utils;
var huffman = hpack.huffman.decode;
var assert = utils.assert;

var OffsetBuffer = require('obuf');

function Decoder() {
  this.buffer = new OffsetBuffer();
  this.bitOffset = 0;

// Used internally in decodeStr
  this._huffmanNode = null;
}
module.exports = Decoder;

Decoder.create = function create() {
  return new Decoder();
};

Decoder.prototype.isEmpty = function isEmpty() {
  return this.buffer.isEmpty();
};

Decoder.prototype.push = function push(chunk) {
  this.buffer.push(chunk);
};

Decoder.prototype.decodeBit = function decodeBit() {
  // Need at least one octet
  assert(this.buffer.has(1), 'Buffer too small for an int');

var octet;
  var offset = this.bitOffset;

if (++this.bitOffset === 8) {
    octet = this.buffer.readUInt8();
    this.bitOffset = 0;
  } else {
    octet = this.buffer.peekUInt8();
  }
  return (octet >>> (7 - offset)) & 1;
};

// Just for testing
Decoder.prototype.skipBits = function skipBits(n) {
  this.bitOffset += n;
  this.buffer.skip(this.bitOffset >> 3);
  this.bitOffset &= 0x7;
};

Decoder.prototype.decodeInt = function decodeInt() {
  // Need at least one octet
  assert(this.buffer.has(1), 'Buffer too small for an int');

var prefix = 8 - this.bitOffset;

// We are going to end up octet-aligned
  this.bitOffset = 0;

var max = (1 << prefix) - 1;
  var octet = this.buffer.readUInt8() & max;

// Fast case - int fits into the prefix
  if (octet !== max)
    return octet;

// TODO(indutny): what about > 32bit numbers?
  var res = 0;
  var isLast = false;
  var len = 0;
  do {
    octet = this.buffer.readUInt8();
    isLast = (octet & 0x80) === 0;

res <<= 7;
    res |= octet & 0x7f;
    len++;
  } while (!isLast);
  assert(isLast, 'Incomplete data for multi-octet integer');
  assert(len <= 4, 'Integer does not fit into 32 bits');

// Reverse bits
  res = (res >>> 21) |
        (((res >> 14) & 0x7f) << 7) |
        (((res >> 7) & 0x7f) << 14) |
        ((res & 0x7f) << 21);
  res >>= (4 - len) * 7;

// Append prefix max
  res += max;

return res;
};

Decoder.prototype.decodeHuffmanWord = function decodeHuffmanWord(input,
                                                                 inputBits,
                                                                 out) {
  var root = huffman;
  var node = this._huffmanNode;
  var word = input;
  var bits = inputBits;

for (; bits > 0; word &= (1 << bits) - 1) {
    // Nudge the word bit length to match it
    for (var i = Math.max(0, bits - 8); i < bits; i++) {
      var subnode = node[word >>> i];
      if (typeof subnode !== 'number') {
        node = subnode;
        bits = i;
        break;
      }

if (subnode === 0)
        continue;

// Word bit length should match
      if ((subnode >>> 9) !== bits - i) {
        subnode = 0;
        continue;
      }

var octet = subnode & 0x1ff;
      assert(octet !== 256, 'EOS in encoding');
      out.push(octet);
      node = root;

bits = i;
      break;
    }
    if (subnode === 0)
      break;
  }
  this._huffmanNode = node;

return bits;
};

Decoder.prototype.decodeStr = function decodeStr() {
  var isHuffman = this.decodeBit();
  var len = this.decodeInt();
  assert(this.buffer.has(len), 'Not enough octets for string');

if (!isHuffman)
    return this.buffer.take(len);

this._huffmanNode = huffman;

var out = [];

var word = 0;
  var bits = 0;
  var lastKey = 0;
  for (var i = 0; i < len; i++) {
    word <<= 8;
    word |= this.buffer.readUInt8();
    bits += 8;

bits = this.decodeHuffmanWord(word, bits, out);
    lastKey = word >> bits;
    word &= (1 << bits) - 1;
  }
  assert(this._huffmanNode === huffman, '8-bit EOS');
  assert(word + 1 === (1 << bits), 'Final sequence is not EOS');

this._huffmanNode = null;

return out;
};

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	freeclou/freeclou	drwxrwxr-x	2025-01-27 08:09:43
..	dir	-	freeclou/freeclou	drwxrwxr-x	2025-01-27 08:09:43
compressor.js	text/plain	2.93 KB	freeclou/freeclou	-rw-rw-r--	2016-09-18 05:59:55
decoder.js	text/x-Algol68	3.77 KB	freeclou/freeclou	-rw-rw-r--	2016-03-24 04:14:30
decompressor.js	text/plain	2.64 KB	freeclou/freeclou	-rw-rw-r--	2016-09-18 05:41:03
encoder.js	text/plain	2.71 KB	freeclou/freeclou	-rw-rw-r--	2016-03-24 04:14:30
huffman.js	text/plain	11.98 KB	freeclou/freeclou	-rw-rw-r--	2016-03-24 04:14:30
static-table.js	text/plain	9.58 KB	freeclou/freeclou	-rw-rw-r--	2016-03-24 04:14:30
table.js	text/plain	2.16 KB	freeclou/freeclou	-rw-rw-r--	2016-09-18 05:43:10
utils.js	text/plain	511 B	freeclou/freeclou	-rw-rw-r--	2016-03-24 04:14:30