typespeed 2.0.13 → 2.0.16

package/test/node_modules/@acuminous/bitsyntax/lib/pattern.js

@@ -0,0 +1,119 @@
+// -*- js-indent-level: 2 -*-
+// Constructing patterns
+
+'use strict';
+
+function set(values) {
+  var s = {};
+  for (var i in values) {
+    if (!Object.prototype.hasOwnProperty.call(values, i)) continue;
+    s[values[i]] = 1;
+  }
+  return s;
+}
+
+// Construct a segment bound to a variable, e.g., from a segment like
+// "Len:32/unsigned-big". `specifiers0` is an array.
+function variable(name, size, specifiers0) {
+  var specifiers = set(specifiers0);
+  var segment = {name: name};
+  segment.type = type_in(specifiers);
+  specs(segment, segment.type, specifiers);
+  segment.size = size_of(segment, segment.type, size, segment.unit);
+  return segment;
+}
+
+module.exports.variable = variable;
+module.exports.rest = function() {
+  return variable('_', true, ['binary']);
+}
+
+// Construct a segment with a literal value, e.g., from a segment like
+// "206". `specifiers0` is an array.
+
+function value(val, size, specifiers0) {
+  var specifiers = set(specifiers0);
+  var segment = {value: val};
+  segment.type = type_in(specifiers);
+  // TODO check type v. value ..
+  specs(segment, segment.type, specifiers);
+  segment.size = size_of(segment, segment.type, size, segment.unit);
+  return segment;
+}
+
+module.exports.value = value;
+
+// A string can appear as a literal, but it must appear without
+// specifiers.
+function string(val) {
+  return {value: val, type: 'string'};
+}
+module.exports.string = string;
+
+var TYPES = {'integer': 1, 'binary': 1, 'float': 1};
+function type_in(specifiers) {
+  for (var t in specifiers) {
+    if (!Object.prototype.hasOwnProperty.call(specifiers, t)) continue;
+    if (TYPES[t]) { return t; }
+  }
+  return 'integer';
+}
+
+function specs(segment, type, specifiers) {
+  switch (type) {
+  case 'integer':
+    segment.signed = signed_in(specifiers);
+    // fall through
+  case 'float':
+    segment.bigendian = endian_in(specifiers);
+    // fall through
+  default:
+    segment.unit = unit_in(specifiers, segment.type);
+  }
+  return segment;
+}
+
+function endian_in(specifiers) {
+  // default is big, but I have chosen true = bigendian
+  return !specifiers['little'];
+}
+
+function signed_in(specifiers) {
+  // this time I got it right; default is unsigned
+  return specifiers['signed'];
+}
+
+function unit_in(specifiers, type) {
+  for (var s in specifiers) {
+    if (!Object.prototype.hasOwnProperty.call(specifiers, s)) continue;
+    if (s.substr(0, 5) == 'unit:') {
+      var unit = parseInt(s.substr(5));
+      // TODO check sane for type
+      return unit;
+    }
+  }
+  // OK defaults then
+  switch (type) {
+  case 'binary':
+    return 8;
+  case 'integer':
+  case 'float':
+    return 1;
+  }
+}
+
+function size_of(segment, type, size, unit) {
+  if (size !== undefined && size !== '') {
+    return size;
+  }
+  else {
+    switch (type) {
+    case 'integer':
+      return 8;
+    case 'float':
+      return 64;
+    case 'binary':
+      return true;
+    }
+  }
+}

package/test/node_modules/@acuminous/bitsyntax/package.json

@@ -0,0 +1,36 @@
+{
+  "author": "Michael Bridgen <mikeb@squaremobius.net>",
+  "name": "@acuminous/bitsyntax",
+  "description": "Pattern-matching on byte buffers",
+  "license": "MIT",
+  "version": "0.1.2",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/acuminous/bitsyntax-js.git"
+  },
+  "main": "./index",
+  "scripts": {
+    "test": "make test",
+    "prepublish": "make all"
+  },
+  "engines": {
+    "node": ">=0.8"
+  },
+  "dependencies": {
+    "buffer-more-ints": "~1.0.0",
+    "debug": "^4.3.4",
+    "safe-buffer": "~5.1.2"
+  },
+  "devDependencies": {
+    "pegjs": "^0.7.0",
+    "zunit": "^3.2.1"
+  },
+  "bugs": {
+    "url": "https://github.com/acuminous/bitsyntax-js/issues"
+  },
+  "homepage": "https://github.com/acuminous/bitsyntax-js#readme",
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  }
+}

package/test/node_modules/@acuminous/bitsyntax/test/consing.test.js

@@ -0,0 +1,50 @@
+var syntax = require('zunit').syntax;
+var assert = require('assert');
+var parse = require('..').parse;
+var build = require('..').build;
+var builder = require('..').builder;
+var write = require('..').write;
+
+var Buffer = require('safe-buffer').Buffer;
+var suite = syntax.describe;
+var test = syntax.it;
+
+TEST_CASES = [
+  ['n:8', {n:255}, [255]],
+  ['n:16', {n: 0xf0f0}, [240, 240]],
+  ['n:32', {n: 0x12345678}, [18,52,86,120]],
+  ['n:64', {n: 0xffffffffffffffff}, [255,255,255,255,255,255,255,255]],
+
+  ['n:8, s/binary', {n: 255, s: Buffer.from("foobar")}, [255, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72]],
+  ['n:8, "foobar", m:8', {n: 255, m:0}, [255, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72, 0]],
+  ['n:8, s:n/binary', {n:6, s: Buffer.from('foobar')}, [6, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72]],
+  ['n:8, s:n/binary', {n:4, s: Buffer.from('foobar')}, [4, 0x66, 0x6f, 0x6f, 0x62]],
+  ['n:size', {n:4, size:8}, [4]],
+  ['206:n/unit:8', {n:1}, [206]]
+];
+
+function bufferToArray(buf) {
+  return Array.prototype.slice.call(buf);
+}
+
+suite("Construction", function() {
+  TEST_CASES.forEach(function(c) {
+    var p = parse(c[0]);
+    test(c[0], function() {
+      assert.deepEqual(c[2], bufferToArray(build(p, c[1])));
+    });
+    test(c[0], function() {
+      var buf = Buffer.alloc(1024);
+      var end = write(buf, 7, p, c[1]);
+      buf = buf.slice(7, end);
+      assert.deepEqual(c[2], bufferToArray(buf));
+    });
+    test(c[0], function() {
+      var cons = builder(c[0]);
+      var buf = cons(c[1]);
+      assert.deepEqual(c[2], bufferToArray(buf));
+    });
+
+  });
+
+});

package/test/node_modules/@acuminous/bitsyntax/test/matching.test.js

@@ -0,0 +1,193 @@
+var syntax = require('zunit').syntax;
+var match = require('..').match;
+var parse = require('..').parse;
+var compile = require('..').matcher;
+var assert = require('assert');
+
+var Buffer = require('safe-buffer').Buffer;
+var suite = syntax.describe;
+var test = syntax.it;
+
+Object.prototype.AMQPLIB_ISSUE_453 = 123123123
+
+var INT_TESTS = [
+    ['n:8',
+     [[[255], 255]]],
+    ['n:8/signed',
+     [[[255], -1]]],
+    ['n:1/unit:8',
+     [[[129], 129]]],
+    ['n:1/unit:8-signed',
+     [[[129], -127]]],
+
+    ['n:16',
+     [[[1, 255], 511]]],
+    ['n:16/signed',
+     [[[255, 65], -191]]],
+    ['n:16/little',
+     [[[255, 1], 511]]],
+    ['n:16/signed-little',
+     [[[65, 255], -191]]],
+
+    ['n:32',
+     [[[45, 23, 97, 102], 756506982]]],
+    ['n:32/signed',
+     [[[245, 23, 97, 102], -183017114]]],
+    ['n:32/little',
+     [[[245, 23, 97, 102], 1717639157]]],
+    ['n:32/signed-little',
+     [[[245, 23, 97, 129], -2124343307]]],
+
+    ['n:4/signed-little-unit:8',
+     [[[245, 23, 97, 129], -2124343307]]],
+
+    ['n:64',
+     [[[1,2,3,4,5,6,7,8], 72623859790382856]]],
+    ['n:64/signed',
+     [[[255,2,3,4,5,6,7,8], -71491328285473016]]],
+    ['n:64/little',
+     [[[1,2,3,4,5,6,7,8], 578437695752307201]]],
+    ['n:64/little-signed',
+     [[[1,2,3,4,5,6,7,255], -70080650589044223]]],
+    ['n:8/signed-unit:8-little',
+     [[[1,2,3,4,5,6,7,255], -70080650589044223]]],
+];
+
+suite("Integer",
+      function() {
+
+        INT_TESTS.forEach(function(p) {
+          var pattern = parse(p[0]);
+          var cpattern = compile(p[0]);
+          p[1].forEach(function(tc) {
+            test(p[0], function() {
+              assert.deepEqual({n: tc[1]}, match(pattern, Buffer.from(tc[0])));
+            });
+            test(p[0], function() {
+              assert.deepEqual({n: tc[1]}, cpattern(Buffer.from(tc[0])));
+            });
+          });
+        });
+      });
+
+
+// test cases largely constructed in Erlang using e.g.,
+// Pi = math:pi(), <<Pi:32/float>>.
+FLOAT_TESTS = [
+  ['n:32/float',
+   [[[64,73,15,219], Math.PI],
+    [[0, 0, 0, 0], 0.0 ]]],
+
+  ['n:64/float',
+   [[[64,9,33,251,84,68,45,24], Math.PI],
+    [[0, 0, 0, 0, 0, 0, 0, 0], 0.0]]],
+
+  ['n:32/float-little',
+   [[[219, 15, 73, 64], Math.PI],
+    [[0, 0, 0, 0], 0.0]]],
+
+  ['n:64/float-little',
+   [[[24, 45, 68, 84, 251, 33, 9, 64], Math.PI],
+    [[0, 0, 0, 0, 0, 0, 0, 0], 0.0]]],
+
+  ['n:4/float-unit:8',
+   [[[64,73,15,219], Math.PI],
+    [[0, 0, 0, 0], 0.0]]]
+];
+
+suite("Float",
+      function() {
+        var precision = 0.00001;
+        FLOAT_TESTS.forEach(function(p) {
+          var pattern = parse(p[0]);
+          var cpattern = compile(p[0]);
+          p[1].forEach(function(tc) {
+            test(p[0], function() {
+              var m = match(pattern, Buffer.from(tc[0]));
+              assert.ok(m.n !== undefined);
+              assert.ok(Math.abs(tc[1] - m.n) < precision);
+            });
+            test(p[0], function() {
+              var m = cpattern(Buffer.from(tc[0]));
+              assert.ok(m.n !== undefined);
+              assert.ok(Math.abs(tc[1] - m.n) < precision);
+            });
+          });
+        });
+      });
+
+BINARY_TESTS = [
+  ['n:0/unit:8-binary', []],
+  ['n:1/unit:8-binary', [93]],
+  ['n:5/unit:8-binary', [1, 2, 3, 4, 5]],
+  ['n:32/unit:1-binary', [255, 254, 253, 252]]
+];
+
+suite("Binary",
+      function() {
+        BINARY_TESTS.forEach(function(p) {
+          var pattern = parse(p[0]);
+          var cpattern = compile(p[0]);
+          var prest = p[0] + ', _/binary';
+          var patternrest = parse(prest);
+          var cpatternrest = compile(prest);
+          test(p[0], function() {
+            assert.deepEqual({n: Buffer.from(p[1])},
+                             match(pattern, Buffer.from(p[1])));
+            assert.deepEqual({n: Buffer.from(p[1])},
+                             cpattern(Buffer.from(p[1])));
+          });
+          test(prest, function() {
+            var plusgarbage = p[1].concat([5, 98, 23, 244]);
+            assert.deepEqual({n: Buffer.from(p[1])},
+                             match(patternrest, Buffer.from(plusgarbage)));
+            assert.deepEqual({n: Buffer.from(p[1])},
+                             cpatternrest(Buffer.from(plusgarbage)));
+          });
+        });
+      });
+
+var VAR_TESTS = [
+  ['size, n:size',
+   [[[8, 5], 5],
+    [[32, 0, 0, 0, 167], 167]]],
+
+  ['size, n:size/binary',
+   [[[2, 5, 6], Buffer.from([5, 6])]]],
+
+  ['a, b:a, n:b',
+   [[[8, 32, 0, 0, 2, 100], 612]]]
+];
+
+suite("Environment",
+      function() {
+        VAR_TESTS.forEach(function(p) {
+          var pattern = parse(p[0]);
+          var cpattern = compile(p[0]);
+          p[1].forEach(function(tc) {
+            test(p[0], function() {
+              assert.deepEqual(tc[1], match(pattern, Buffer.from(tc[0])).n);
+            });
+            test(p[0], function() {
+              assert.deepEqual(tc[1], cpattern(Buffer.from(tc[0])).n);
+            });
+          });
+        });
+      });
+
+STRING_TESTS = [
+  ['"foobar", n:8', "foobarA", 'A'.charCodeAt(0)],
+  ['n:8, "foobar", _/binary', "CfoobarGARBAGE", 'C'.charCodeAt(0)],
+  ['"foo, :-bar\\"", n:8, "another"', 'foo, :-bar"Zanother', 'Z'.charCodeAt(0)]
+];
+
+suite("String",
+      function() {
+        STRING_TESTS.forEach(function(p) {
+          var pattern = parse(p[0]);
+          test(p[0], function() {
+            var res = match(pattern, Buffer.from(p[1]));
+            assert.equal(res.n, p[2]);
+          });
+        });
+      });

package/test/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v18.
 
 ### Additional Details
- * Last updated: Thu, 11 May 2023 20:02:57 GMT
+ * Last updated: Sun, 21 May 2023 21:02:54 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`, `structuredClone`
 

package/test/node_modules/@types/node/buffer.d.ts

@@ -202,6 +202,9 @@ declare module 'buffer' {
     // the copy below in a Node environment.
     type __Blob = typeof globalThis extends { onmessage: any; Blob: infer T } ? T : NodeBlob;
     global {
+        namespace NodeJS {
+            export { BufferEncoding };
+        }
         // Buffer class
         type BufferEncoding =
             | 'ascii'
@@ -2280,7 +2283,7 @@ declare module 'buffer' {
          * **For code running using Node.js APIs, converting between base64-encoded strings**
          * **and binary data should be performed using `Buffer.from(str, 'base64')` and`buf.toString('base64')`.**
          * @since v15.13.0, v14.17.0
-         * @deprecated Use `Buffer.from(data, 'base64')` instead.
+         * @legacy Use `Buffer.from(data, 'base64')` instead.
          * @param data The Base64-encoded input string.
          */
         function atob(data: string): string;
@@ -2296,7 +2299,7 @@ declare module 'buffer' {
          * **For code running using Node.js APIs, converting between base64-encoded strings**
          * **and binary data should be performed using `Buffer.from(str, 'base64')` and`buf.toString('base64')`.**
          * @since v15.13.0, v14.17.0
-         * @deprecated Use `buf.toString('base64')` instead.
+         * @legacy Use `buf.toString('base64')` instead.
          * @param data An ASCII (Latin1) string.
          */
         function btoa(data: string): string;

package/test/node_modules/@types/node/child_process.d.ts

@@ -634,6 +634,15 @@ declare module 'child_process' {
     }
     interface CommonSpawnOptions extends CommonOptions, MessagingOptions, Abortable {
         argv0?: string | undefined;
+        /**
+         * Can be set to 'pipe', 'inherit', 'overlapped', or 'ignore', or an array of these strings.
+         * If passed as an array, the first element is used for `stdin`, the second for
+         * `stdout`, and the third for `stderr`. A fourth element can be used to
+         * specify the `stdio` behavior beyond the standard streams. See
+         * {@link ChildProcess.stdio} for more information.
+         *
+         * @default 'pipe'
+         */
         stdio?: StdioOptions | undefined;
         shell?: boolean | string | undefined;
         windowsVerbatimArguments?: boolean | undefined;
@@ -1195,6 +1204,15 @@ declare module 'child_process' {
         execPath?: string | undefined;
         execArgv?: string[] | undefined;
         silent?: boolean | undefined;
+        /**
+         * Can be set to 'pipe', 'inherit', 'overlapped', or 'ignore', or an array of these strings.
+         * If passed as an array, the first element is used for `stdin`, the second for
+         * `stdout`, and the third for `stderr`. A fourth element can be used to
+         * specify the `stdio` behavior beyond the standard streams. See
+         * {@link ChildProcess.stdio} for more information.
+         *
+         * @default 'pipe'
+         */
         stdio?: StdioOptions | undefined;
         detached?: boolean | undefined;
         windowsVerbatimArguments?: boolean | undefined;
@@ -1295,6 +1313,15 @@ declare module 'child_process' {
     function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
     interface CommonExecOptions extends CommonOptions {
         input?: string | NodeJS.ArrayBufferView | undefined;
+        /**
+         * Can be set to 'pipe', 'inherit', 'overlapped', or 'ignore', or an array of these strings.
+         * If passed as an array, the first element is used for `stdin`, the second for
+         * `stdout`, and the third for `stderr`. A fourth element can be used to
+         * specify the `stdio` behavior beyond the standard streams. See
+         * {@link ChildProcess.stdio} for more information.
+         *
+         * @default 'pipe'
+         */
         stdio?: StdioOptions | undefined;
         killSignal?: NodeJS.Signals | number | undefined;
         maxBuffer?: number | undefined;

package/test/node_modules/@types/node/globals.d.ts

@@ -64,6 +64,7 @@ interface AbortSignal extends EventTarget {
     readonly aborted: boolean;
     readonly reason: any;
     onabort: null | ((this: AbortSignal, event: Event) => any);
+    throwIfAborted(): void;
 }
 
 declare var AbortController: typeof globalThis extends {onmessage: any; AbortController: infer T}

package/test/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "18.16.8",
+    "version": "18.16.14",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -232,6 +232,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "eb9081f287c2ff8ab18f8f075951c063e8cf1ecc7d25b2af87fc9a9ef63b37af",
+    "typesPublisherContentHash": "1ddc18d0b32383ce71e84dee2d8cf940cfad390444fd7248f2435c57f7d2c2b4",
     "typeScriptVersion": "4.3"
 }

package/test/node_modules/@types/node/test.d.ts

@@ -10,7 +10,6 @@ declare module 'node:test' {
      * @returns A {@link TestsStream} that emits events about the test execution.
      */
     function run(options?: RunOptions): TestsStream;
-
     /**
      * The `test()` function is the value imported from the test module. Each invocation of this
      * function results in reporting the test to the {@link TestsStream}.
@@ -49,7 +48,19 @@ declare module 'node:test' {
     function test(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
     function test(options?: TestOptions, fn?: TestFn): Promise<void>;
     function test(fn?: TestFn): Promise<void>;
-
+    namespace test {
+        export {
+            after,
+            afterEach,
+            before,
+            beforeEach,
+            describe,
+            it,
+            run,
+            mock,
+            test
+        };
+    }
     /**
      * @since v18.6.0
      * @param name The name of the suite, which is displayed when reporting suite results.
@@ -73,6 +84,15 @@ declare module 'node:test' {
         function todo(name?: string, fn?: SuiteFn): void;
         function todo(options?: TestOptions, fn?: SuiteFn): void;
         function todo(fn?: SuiteFn): void;
+
+        /**
+         * Shorthand for marking a suite as `only`, same as `describe([name], { only: true }[, fn])`.
+         * @since v18.15.0
+         */
+        function only(name?: string, options?: TestOptions, fn?: SuiteFn): void;
+        function only(name?: string, fn?: SuiteFn): void;
+        function only(options?: TestOptions, fn?: SuiteFn): void;
+        function only(fn?: SuiteFn): void;
     }
 
     /**
@@ -83,22 +103,31 @@ declare module 'node:test' {
      * @param fn The function under test. If the test uses callbacks, the callback function is
      *    passed as the second argument. Default: A no-op function.
      */
-    function it(name?: string, options?: TestOptions, fn?: ItFn): void;
-    function it(name?: string, fn?: ItFn): void;
-    function it(options?: TestOptions, fn?: ItFn): void;
-    function it(fn?: ItFn): void;
+    function it(name?: string, options?: TestOptions, fn?: TestFn): void;
+    function it(name?: string, fn?: TestFn): void;
+    function it(options?: TestOptions, fn?: TestFn): void;
+    function it(fn?: TestFn): void;
     namespace it {
         // Shorthand for skipping a test, same as `it([name], { skip: true }[, fn])`.
-        function skip(name?: string, options?: TestOptions, fn?: ItFn): void;
-        function skip(name?: string, fn?: ItFn): void;
-        function skip(options?: TestOptions, fn?: ItFn): void;
-        function skip(fn?: ItFn): void;
+        function skip(name?: string, options?: TestOptions, fn?: TestFn): void;
+        function skip(name?: string, fn?: TestFn): void;
+        function skip(options?: TestOptions, fn?: TestFn): void;
+        function skip(fn?: TestFn): void;
 
         // Shorthand for marking a test as `TODO`, same as `it([name], { todo: true }[, fn])`.
-        function todo(name?: string, options?: TestOptions, fn?: ItFn): void;
-        function todo(name?: string, fn?: ItFn): void;
-        function todo(options?: TestOptions, fn?: ItFn): void;
-        function todo(fn?: ItFn): void;
+        function todo(name?: string, options?: TestOptions, fn?: TestFn): void;
+        function todo(name?: string, fn?: TestFn): void;
+        function todo(options?: TestOptions, fn?: TestFn): void;
+        function todo(fn?: TestFn): void;
+
+        /**
+         * Shorthand for marking a test as `only`, same as `it([name], { only: true }[, fn])`.
+         * @since v18.15.0
+         */
+        function only(name?: string, options?: TestOptions, fn?: TestFn): void;
+        function only(name?: string, fn?: TestFn): void;
+        function only(options?: TestOptions, fn?: TestFn): void;
+        function only(fn?: TestFn): void;
     }
 
     /**
@@ -114,12 +143,6 @@ declare module 'node:test' {
      */
     type SuiteFn = (done: (result?: any) => void) => void;
 
-    /**
-     * The type of a function under test.
-     * If the test uses callbacks, the callback function is passed as an argument
-     */
-    type ItFn = (done: (result?: any) => void) => any;
-
     interface RunOptions {
         /**
          * If a number is provided, then that many files would run in parallel.

package/test/node_modules/@types/node/ts4.8/buffer.d.ts

@@ -202,6 +202,9 @@ declare module 'buffer' {
     // the copy below in a Node environment.
     type __Blob = typeof globalThis extends { onmessage: any; Blob: infer T } ? T : NodeBlob;
     global {
+        namespace NodeJS {
+            export { BufferEncoding };
+        }
         // Buffer class
         type BufferEncoding =
             | 'ascii'
@@ -2280,7 +2283,7 @@ declare module 'buffer' {
          * **For code running using Node.js APIs, converting between base64-encoded strings**
          * **and binary data should be performed using `Buffer.from(str, 'base64')` and`buf.toString('base64')`.**
          * @since v15.13.0, v14.17.0
-         * @deprecated Use `Buffer.from(data, 'base64')` instead.
+         * @legacy Use `Buffer.from(data, 'base64')` instead.
          * @param data The Base64-encoded input string.
          */
         function atob(data: string): string;
@@ -2296,7 +2299,7 @@ declare module 'buffer' {
          * **For code running using Node.js APIs, converting between base64-encoded strings**
          * **and binary data should be performed using `Buffer.from(str, 'base64')` and`buf.toString('base64')`.**
          * @since v15.13.0, v14.17.0
-         * @deprecated Use `buf.toString('base64')` instead.
+         * @legacy Use `buf.toString('base64')` instead.
          * @param data An ASCII (Latin1) string.
          */
         function btoa(data: string): string;