deno_node 0.192.0

Node compatibility for Deno
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

// Copyright 2018-2026 the Deno authors. MIT license.
// Copyright Joyent and Node contributors. All rights reserved. MIT license.
//
// Shared TLS helpers used by both tls.ts and _tls_wrap.js.
// Extracted to avoid circular dependency between those modules.

(function () {
const { core, primordials } = __bootstrap;
const { Buffer } = core.loadExtScript("ext:deno_node/internal/buffer.mjs");
const { codes } = core.loadExtScript("ext:deno_node/internal/errors.ts");
const {
  isArrayBufferView,
  isTypedArray,
  isUint8Array,
} = core.loadExtScript("ext:deno_node/internal/util/types.ts");

const {
  Array,
  ArrayBufferPrototypeSlice,
  ArrayIsArray,
  ArrayPrototypeReduce,
  DataViewPrototypeGetBuffer,
  DataViewPrototypeGetByteLength,
  DataViewPrototypeGetByteOffset,
  TypedArrayPrototypeGetBuffer,
  TypedArrayPrototypeGetByteLength,
  TypedArrayPrototypeGetByteOffset,
} = primordials;

function convertProtocols(protocols) {
  const lengths = new Array(protocols.length);
  const buffer = Buffer.allocUnsafe(
    ArrayPrototypeReduce(protocols, (total, protocol, index) => {
      const length = Buffer.byteLength(protocol);
      if (length > 255) {
        throw new codes.ERR_OUT_OF_RANGE(
          `The byte length of the protocol at index ${index} exceeds the maximum length.`,
          "<= 255",
          length,
          true,
        );
      }
      lengths[index] = length;
      return total + 1 + length;
    }, 0),
  );

  let offset = 0;
  for (let i = 0; i < protocols.length; i++) {
    buffer[offset++] = lengths[i];
    buffer.write(protocols[i], offset);
    offset += lengths[i];
  }

  return buffer;
}

function convertALPNProtocols(protocols, out) {
  if (ArrayIsArray(protocols)) {
    out.ALPNProtocols = convertProtocols(protocols);
  } else if (isUint8Array(protocols)) {
    out.ALPNProtocols = Buffer.from(protocols);
  } else if (isArrayBufferView(protocols)) {
    const buffer = isTypedArray(protocols)
      ? TypedArrayPrototypeGetBuffer(protocols)
      : DataViewPrototypeGetBuffer(protocols);
    const byteOffset = isTypedArray(protocols)
      ? TypedArrayPrototypeGetByteOffset(protocols)
      : DataViewPrototypeGetByteOffset(protocols);
    const byteLength = isTypedArray(protocols)
      ? TypedArrayPrototypeGetByteLength(protocols)
      : DataViewPrototypeGetByteLength(protocols);
    out.ALPNProtocols = Buffer.from(
      ArrayBufferPrototypeSlice(buffer, byteOffset, byteOffset + byteLength),
    );
  }
}

return { convertALPNProtocols, default: { convertALPNProtocols } };
})();