lib: refactor internal webidl converters

Rework lib/internal/webidl.js into a documented shared converter
module that follows the Web IDL conversion algorithms more closely.

Improvements:
- Add documented converters and helper factories for dictionaries,
  enums, sequences, interfaces, required arguments, and integers.
- Move WebCrypto to the shared converters, keeping compatibility
  wrappers for existing BufferSource and BigInteger behavior.
- Use shared converters from Blob, Performance, Web Locks, and
  structured clone option handling.
- Add focused tests for core converters, WebCrypto converters,
  integer conversion, and buffer source behavior.

Fixes:
- Make core BufferSource and Uint8Array reject resizable ArrayBuffer
  and growable SharedArrayBuffer backing stores unless allowed.
  This is non-breaking because the core behavior has no runtime
  consumers other than WebCrypto. WebCrypto keeps its legacy behavior
  until a semver-major follow-up opts in to the correct behavior.
- Use Web IDL ToNumber and ToString behavior for BigInt, Symbol, and
  object primitive conversion.
- Use exact BigInt modulo for 64-bit ConvertToInt wrapping and
  document the Number approximation behavior.
- Normalize mathematical modulo results to +0 where Web IDL requires it.
- Cover detached buffers, resizable-backed views, growable-backed
  views, cross-realm buffer sources, and mutation-after-call behavior.

Signed-off-by: Filip Skokan <[email protected]>

Author: panva

benchmark/misc/webidl-convert-to-int.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  converter: [
+    'octet',
+    'unsigned short',
+    'unsigned long',
+    'long long',
+  ],
+  input: [
+    'integer',
+    'fractional',
+    'wrap',
+    'clamp',
+    'enforce-range',
+    'object',
+  ],
+  n: [1e6],
+}, { flags: ['--expose-internals'] });
+
+function getInput(input) {
+  switch (input) {
+    case 'integer':
+      return { value: 7 };
+    case 'fractional':
+      return { value: 7.9 };
+    case 'wrap':
+      return { value: 2 ** 63 + 2 ** 11 };
+    case 'clamp':
+      return { value: 300.8, options: { clamp: true } };
+    case 'enforce-range':
+      return { value: 7.9, options: { enforceRange: true } };
+    case 'object':
+      return {
+        value: {
+          valueOf() { return 7; },
+        },
+      };
+    default:
+      throw new Error(`Unsupported input: ${input}`);
+  }
+}
+
+function main({ n, converter, input }) {
+  const { converters } = require('internal/webidl');
+  const convert = converters[converter];
+  const { value, options } = getInput(input);
+
+  let noDead;
+  bench.start();
+  if (options === undefined) {
+    for (let i = 0; i < n; i++)
+      noDead = convert(value);
+  } else {
+    for (let i = 0; i < n; i++)
+      noDead = convert(value, options);
+  }
+  bench.end(n);
+
+  assert.strictEqual(typeof noDead, 'number');
+}

lib/internal/blob.js

@@ -54,7 +54,6 @@ const {
 const { inspect } = require('internal/util/inspect');
 const {
   converters,
-  convertToInt,
   createSequenceConverter,
 } = require('internal/webidl');
 
@@ -245,10 +244,14 @@ class Blob {
     if (!isBlob(this))
       throw new ERR_INVALID_THIS('Blob');
 
-    // Coerce values to int
-    const opts = { __proto__: null, signed: true };
-    start = convertToInt('start', start, 64, opts);
-    end = convertToInt('end', end, 64, opts);
+    start = converters['long long'](
+      start,
+      { __proto__: null, context: 'start' },
+    );
+    end = converters['long long'](
+      end,
+      { __proto__: null, context: 'end' },
+    );
 
     if (start < 0) {
       start = MathMax(this[kLength] + start, 0);