@zowe/db2-for-zowe-cli 6.1.18 → 6.1.19

package/node_modules/string_decoder/node_modules/safe-buffer/index.d.ts

@@ -0,0 +1,187 @@
+declare module "safe-buffer" {
+  export class Buffer {
+    length: number
+    write(string: string, offset?: number, length?: number, encoding?: string): number;
+    toString(encoding?: string, start?: number, end?: number): string;
+    toJSON(): { type: 'Buffer', data: any[] };
+    equals(otherBuffer: Buffer): boolean;
+    compare(otherBuffer: Buffer, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
+    copy(targetBuffer: Buffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
+    slice(start?: number, end?: number): Buffer;
+    writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
+    readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
+    readUInt8(offset: number, noAssert?: boolean): number;
+    readUInt16LE(offset: number, noAssert?: boolean): number;
+    readUInt16BE(offset: number, noAssert?: boolean): number;
+    readUInt32LE(offset: number, noAssert?: boolean): number;
+    readUInt32BE(offset: number, noAssert?: boolean): number;
+    readInt8(offset: number, noAssert?: boolean): number;
+    readInt16LE(offset: number, noAssert?: boolean): number;
+    readInt16BE(offset: number, noAssert?: boolean): number;
+    readInt32LE(offset: number, noAssert?: boolean): number;
+    readInt32BE(offset: number, noAssert?: boolean): number;
+    readFloatLE(offset: number, noAssert?: boolean): number;
+    readFloatBE(offset: number, noAssert?: boolean): number;
+    readDoubleLE(offset: number, noAssert?: boolean): number;
+    readDoubleBE(offset: number, noAssert?: boolean): number;
+    swap16(): Buffer;
+    swap32(): Buffer;
+    swap64(): Buffer;
+    writeUInt8(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt16LE(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt16BE(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt32LE(value: number, offset: number, noAssert?: boolean): number;
+    writeUInt32BE(value: number, offset: number, noAssert?: boolean): number;
+    writeInt8(value: number, offset: number, noAssert?: boolean): number;
+    writeInt16LE(value: number, offset: number, noAssert?: boolean): number;
+    writeInt16BE(value: number, offset: number, noAssert?: boolean): number;
+    writeInt32LE(value: number, offset: number, noAssert?: boolean): number;
+    writeInt32BE(value: number, offset: number, noAssert?: boolean): number;
+    writeFloatLE(value: number, offset: number, noAssert?: boolean): number;
+    writeFloatBE(value: number, offset: number, noAssert?: boolean): number;
+    writeDoubleLE(value: number, offset: number, noAssert?: boolean): number;
+    writeDoubleBE(value: number, offset: number, noAssert?: boolean): number;
+    fill(value: any, offset?: number, end?: number): this;
+    indexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;
+    lastIndexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;
+    includes(value: string | number | Buffer, byteOffset?: number, encoding?: string): boolean;
+
+    /**
+     * Allocates a new buffer containing the given {str}.
+     *
+     * @param str String to store in buffer.
+     * @param encoding encoding to use, optional.  Default is 'utf8'
+     */
+     constructor (str: string, encoding?: string);
+    /**
+     * Allocates a new buffer of {size} octets.
+     *
+     * @param size count of octets to allocate.
+     */
+    constructor (size: number);
+    /**
+     * Allocates a new buffer containing the given {array} of octets.
+     *
+     * @param array The octets to store.
+     */
+    constructor (array: Uint8Array);
+    /**
+     * Produces a Buffer backed by the same allocated memory as
+     * the given {ArrayBuffer}.
+     *
+     *
+     * @param arrayBuffer The ArrayBuffer with which to share memory.
+     */
+    constructor (arrayBuffer: ArrayBuffer);
+    /**
+     * Allocates a new buffer containing the given {array} of octets.
+     *
+     * @param array The octets to store.
+     */
+    constructor (array: any[]);
+    /**
+     * Copies the passed {buffer} data onto a new {Buffer} instance.
+     *
+     * @param buffer The buffer to copy.
+     */
+    constructor (buffer: Buffer);
+    prototype: Buffer;
+    /**
+     * Allocates a new Buffer using an {array} of octets.
+     *
+     * @param array
+     */
+    static from(array: any[]): Buffer;
+    /**
+     * When passed a reference to the .buffer property of a TypedArray instance,
+     * the newly created Buffer will share the same allocated memory as the TypedArray.
+     * The optional {byteOffset} and {length} arguments specify a memory range
+     * within the {arrayBuffer} that will be shared by the Buffer.
+     *
+     * @param arrayBuffer The .buffer property of a TypedArray or a new ArrayBuffer()
+     * @param byteOffset
+     * @param length
+     */
+    static from(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number): Buffer;
+    /**
+     * Copies the passed {buffer} data onto a new Buffer instance.
+     *
+     * @param buffer
+     */
+    static from(buffer: Buffer): Buffer;
+    /**
+     * Creates a new Buffer containing the given JavaScript string {str}.
+     * If provided, the {encoding} parameter identifies the character encoding.
+     * If not provided, {encoding} defaults to 'utf8'.
+     *
+     * @param str
+     */
+    static from(str: string, encoding?: string): Buffer;
+    /**
+     * Returns true if {obj} is a Buffer
+     *
+     * @param obj object to test.
+     */
+    static isBuffer(obj: any): obj is Buffer;
+    /**
+     * Returns true if {encoding} is a valid encoding argument.
+     * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
+     *
+     * @param encoding string to test.
+     */
+    static isEncoding(encoding: string): boolean;
+    /**
+     * Gives the actual byte length of a string. encoding defaults to 'utf8'.
+     * This is not the same as String.prototype.length since that returns the number of characters in a string.
+     *
+     * @param string string to test.
+     * @param encoding encoding used to evaluate (defaults to 'utf8')
+     */
+    static byteLength(string: string, encoding?: string): number;
+    /**
+     * Returns a buffer which is the result of concatenating all the buffers in the list together.
+     *
+     * If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer.
+     * If the list has exactly one item, then the first item of the list is returned.
+     * If the list has more than one item, then a new Buffer is created.
+     *
+     * @param list An array of Buffer objects to concatenate
+     * @param totalLength Total length of the buffers when concatenated.
+     *   If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly.
+     */
+    static concat(list: Buffer[], totalLength?: number): Buffer;
+    /**
+     * The same as buf1.compare(buf2).
+     */
+    static compare(buf1: Buffer, buf2: Buffer): number;
+    /**
+     * Allocates a new buffer of {size} octets.
+     *
+     * @param size count of octets to allocate.
+     * @param fill if specified, buffer will be initialized by calling buf.fill(fill).
+     *    If parameter is omitted, buffer will be filled with zeros.
+     * @param encoding encoding used for call to buf.fill while initalizing
+     */
+    static alloc(size: number, fill?: string | Buffer | number, encoding?: string): Buffer;
+    /**
+     * Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
+     * of the newly created Buffer are unknown and may contain sensitive data.
+     *
+     * @param size count of octets to allocate
+     */
+    static allocUnsafe(size: number): Buffer;
+    /**
+     * Allocates a new non-pooled buffer of {size} octets, leaving memory not initialized, so the contents
+     * of the newly created Buffer are unknown and may contain sensitive data.
+     *
+     * @param size count of octets to allocate
+     */
+    static allocUnsafeSlow(size: number): Buffer;
+  }
+}

package/node_modules/string_decoder/node_modules/safe-buffer/index.js

@@ -0,0 +1,62 @@
+/* eslint-disable node/no-deprecated-api */
+var buffer = require('buffer')
+var Buffer = buffer.Buffer
+
+// alternative to using Object.keys for old browsers
+function copyProps (src, dst) {
+  for (var key in src) {
+    dst[key] = src[key]
+  }
+}
+if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+  module.exports = buffer
+} else {
+  // Copy properties from require('buffer')
+  copyProps(buffer, exports)
+  exports.Buffer = SafeBuffer
+}
+
+function SafeBuffer (arg, encodingOrOffset, length) {
+  return Buffer(arg, encodingOrOffset, length)
+}
+
+// Copy static methods from Buffer
+copyProps(Buffer, SafeBuffer)
+
+SafeBuffer.from = function (arg, encodingOrOffset, length) {
+  if (typeof arg === 'number') {
+    throw new TypeError('Argument must not be a number')
+  }
+  return Buffer(arg, encodingOrOffset, length)
+}
+
+SafeBuffer.alloc = function (size, fill, encoding) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  var buf = Buffer(size)
+  if (fill !== undefined) {
+    if (typeof encoding === 'string') {
+      buf.fill(fill, encoding)
+    } else {
+      buf.fill(fill)
+    }
+  } else {
+    buf.fill(0)
+  }
+  return buf
+}
+
+SafeBuffer.allocUnsafe = function (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  return Buffer(size)
+}
+
+SafeBuffer.allocUnsafeSlow = function (size) {
+  if (typeof size !== 'number') {
+    throw new TypeError('Argument must be a number')
+  }
+  return buffer.SlowBuffer(size)
+}

package/node_modules/string_decoder/node_modules/safe-buffer/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "safe-buffer",
+  "description": "Safer Node.js Buffer API",
+  "version": "5.1.2",
+  "author": {
+    "name": "Feross Aboukhadijeh",
+    "email": "feross@feross.org",
+    "url": "http://feross.org"
+  },
+  "bugs": {
+    "url": "https://github.com/feross/safe-buffer/issues"
+  },
+  "devDependencies": {
+    "standard": "*",
+    "tape": "^4.0.0"
+  },
+  "homepage": "https://github.com/feross/safe-buffer",
+  "keywords": [
+    "buffer",
+    "buffer allocate",
+    "node security",
+    "safe",
+    "safe-buffer",
+    "security",
+    "uninitialized"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/feross/safe-buffer.git"
+  },
+  "scripts": {
+    "test": "standard && tape test/*.js"
+  }
+}

package/node_modules/which-typed-array/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v1.1.24](https://github.com/inspect-js/which-typed-array/compare/v1.1.23...v1.1.24) - 2026-09-18
+
+### Commits
+
+- [types] fix the types for good, hopefully [`d746946`](https://github.com/inspect-js/which-typed-array/commit/d746946a8a76dc6e58302de53856aff304dbdb98)
+
+## [v1.1.23](https://github.com/inspect-js/which-typed-array/compare/v1.1.22...v1.1.23) - 2026-09-16
+
+### Commits
+
+- [types] handle a consumer `lib` that lacks `Float16Array` [`7fd78fb`](https://github.com/inspect-js/which-typed-array/commit/7fd78fb1f90d00d1e340457c7e6a00492c1c5e79)
+- [Dev Deps] update `@arethetypeswrong/cli`, `@ljharb/eslint-config`, `auto-changelog`, `eslint`, `tape` [`885ae7d`](https://github.com/inspect-js/which-typed-array/commit/885ae7d6888b21bcacaae883f86861258196888d)
+- [readme] remove dead badges [`67844dd`](https://github.com/inspect-js/which-typed-array/commit/67844dd30a89dddfc98172672af6372ae2e74d13)
+
 ## [v1.1.22](https://github.com/inspect-js/which-typed-array/compare/v1.1.21...v1.1.22) - 2026-06-05
 
 ### Commits

package/node_modules/which-typed-array/README.md

@@ -2,8 +2,6 @@
 
 [![github actions][actions-image]][actions-url]
 [![coverage][codecov-image]][codecov-url]
-[![dependency status][deps-svg]][deps-url]
-[![dev dependency status][dev-deps-svg]][dev-deps-url]
 [![License][license-image]][license-url]
 [![Downloads][downloads-image]][downloads-url]
 

package/node_modules/which-typed-array/index.d.ts

@@ -4,32 +4,309 @@
  * @param {unknown} value The potential collection
  * @returns {TypedArrayName | false | null} 'Int8Array' | 'Uint8Array' | 'Uint8ClampedArray' | 'Int16Array' | 'Uint16Array' | 'Int32Array' | 'Uint32Array' | 'Float32Array' | 'Float64Array' | 'BigInt64Array' | 'BigUint64Array' | false | null
  */
-declare function whichTypedArray<T>(value: T): false | null | whichTypedArray.WhichTypedArray<T>;
-declare function whichTypedArray(value: unknown): false | null | whichTypedArray.TypedArrayName;
+declare function whichTypedArray<T>(
+	value: T & whichTypedArray.TypedArray,
+): whichTypedArray.WhichTypedArray<T>;
+declare function whichTypedArray<T>(
+	value: unknown,
+): false | null | whichTypedArray.TypedArrayName;
 
 import TAs from 'available-typed-arrays';
 
+/** the names the consumer's `lib` declares a global for, so there is a type to compare against */
+type DeclaredName = whichTypedArray.TypedArrayName & keyof typeof globalThis;
+
+/** the names it does not (eg, `Float16Array` under `lib: es2020`), which are still possible at runtime */
+type UndeclaredName = Exclude<whichTypedArray.TypedArrayName, keyof typeof globalThis>;
+
+type Instance<Name extends DeclaredName> = typeof globalThis[Name]['prototype'];
+
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+
+type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends Pick<T, K> ? never : K
+}[keyof T];
+
+/** the key types of `T`'s index signatures, found by `{}` having them covered already */
+type IndexKeys<T> = {
+	[K in keyof T]-?: {} extends Record<K, never> ? K : never
+}[keyof T];
+
+/**
+ * The keys of `T` that can be read off a value by name. An index signature is not a
+ * named member, but a `string`-keyed one cannot be told apart here from the named
+ * string members beside it, so it is left in and they are taken at face value.
+ */
+type NamedKeys<T> = Exclude<keyof T, Exclude<IndexKeys<T>, string>>;
+
+/** `Object`'s members are on every object type, even though `keyof` does not list them */
+type Apparent<T, K> = K extends keyof T
+	? T[K]
+	: K extends keyof Object
+		? Object[K]
+		: unknown;
+
+/**
+ * The typed arrays' symbol-keyed member whose value is a string, which is
+ * `Symbol.toStringTag` in a `lib` that declares symbols and `never` in one that
+ * does not (`lib: es5`). Deriving it this way leaves the tag comparisons below
+ * with no information to go on, rather than naming `Symbol` in a `lib` without it.
+ */
+type TagKey = {
+	[K in keyof whichTypedArray.TypedArray & symbol]: whichTypedArray.TypedArray[K] extends string ? K : never
+}[keyof whichTypedArray.TypedArray & symbol];
+
+/** `unknown` when `T` says nothing about its own tag, which rules no name out */
+type TagOf<T> = [TagKey] extends [never]
+	? unknown
+	: TagKey extends keyof T
+		? T[TagKey & keyof T]
+		: unknown;
+
+/** one value can carry both tags when either is assignable to the other */
+type TagsMeet<A, B> = IsAny<A> extends true
+	? true
+	: IsAny<B> extends true
+		? true
+		: [Extract<A, B>] extends [never]
+			? ([Extract<B, A>] extends [never] ? false : true)
+			: true;
+
+/** how many levels of members `Related` walks before it stops looking for a conflict */
+type Prev = [
+	never,
+	0,
+	1,
+	2,
+	3,
+];
+
+type Depth = 0 | 1 | 2 | 3 | 4;
+
+/**
+ * A rough stand-in for the comparability check TypeScript itself runs to decide
+ * whether `x === someTypedArray` is worth allowing. One value can be a `Source` and
+ * a `Target` at once if the two already share a constituent, or if neither is an
+ * object type and one is assignable to the other; failing that, `D` more levels of
+ * members and signatures are compared, in this direction only - `Meets` runs both.
+ *
+ * It is a heuristic, not that check, and it leans towards saying the two can meet.
+ * A conflict further down than `D` levels is not looked for, so a name can be left
+ * in that no value could produce. It also drops names TypeScript would have allowed:
+ * a `Source` that carries a call signature, or a member declared with its own type
+ * parameters, meets nothing, and only the last signature of an overloaded member is
+ * compared.
+ *
+ * `Stale` marks a comparison standing in for a name this `lib` has no type for, where
+ * a member the `lib` has never heard of is weaker evidence (see `GatedOn`).
+ */
+type Related<Source, Target, D extends Depth, Stale extends boolean> = IsAny<Source> extends true
+	? true
+	: IsAny<Target> extends true
+		? true
+		: [Extract<Source, Target>] extends [never]
+			? (Widens<Source, Target> extends true ? true : Deeply<Source, Target, D, Stale>)
+			: true;
+
+/** neither side being an object type, one value fits both when either is assignable to the other */
+type Widens<Source, Target> = [Source] extends [object]
+	? false
+	: [Target] extends [object]
+		? false
+		: ([Extract<Target, Source>] extends [never] ? false : true);
+
+/** a union on either side only needs one part that can meet one part of the other */
+type Deeply<Source, Target, D extends Depth, Stale extends boolean> = [D] extends [0]
+	? true
+	: true extends (Source extends unknown
+		? (Target extends unknown ? Structurally<Source, Target, D, Stale> : never)
+		: never)
+		? true
+		: false;
+
+type Structurally<Source, Target, D extends Depth, Stale extends boolean> = [Source] extends [(...args: infer SP) => infer SR]
+	? ([Target] extends [(...args: infer TP) => infer TR]
+		? (Related<SR, TR, Prev[D], Stale> extends true ? ParamsRelated<SP, TP, Prev[D], Stale> : false)
+		: false)
+	: [Target] extends [Function]
+		? false
+		: [Source] extends [object]
+			? ([Target] extends [object] ? Membered<Source, Target, D, Stale> : false)
+			: false;
+
+/** each pair of parameters only has to meet, in either direction, as with an overridden method */
+type ParamsRelated<SP extends readonly unknown[], TP extends readonly unknown[], D extends Depth, Stale extends boolean> = false extends {
+	[K in keyof SP]: K extends keyof TP ? Related<SP[K], TP[K & keyof TP], D, Stale> : true
+}[number]
+	? false
+	: true;
+
+type Membered<Source, Target, D extends Depth, Stale extends boolean> = GatedOn<Source, Target, D, Stale> extends true
+	? (TagsMeet<TagOf<Source>, TagOf<Target>> extends true ? EachMember<Source, Target, D, Stale> : false)
+	: false;
+
+/**
+ * Whether a member `Target` requires but `Source` lacks counts against the two
+ * meeting. At the top of a comparison it does. Below that, in a comparison standing
+ * in for a name this `lib` has no type for, one side is the `lib`'s own type for a
+ * typed array or one of its members, and a member missing from that is as easily an
+ * older `lib`'s gap as a real conflict, so it is not counted - which is how such a
+ * name survives an input written in terms of a newer member, as
+ * `{ buffer: { byteLength: number } & { resizable: boolean } }` is.
+ */
+type GatedOn<Source, Target, D extends Depth, Stale extends boolean> = [Stale, D] extends [true, 0 | 1 | 2 | 3]
+	? true
+	: Compatible<Source, Target, Stale>;
+
+/** the members of `Target` that `Source`, or `Object` behind it, also has */
+type SharedKeys<Source, Target> = keyof Target & (keyof Source | keyof Object);
+
+type EachMember<Source, Target, D extends Depth, Stale extends boolean> = false extends {
+	[K in SharedKeys<Source, Target>]: Related<Apparent<Source, K>, Target[K], Prev[D], Stale>
+}[SharedKeys<Source, Target>]
+	? false
+	: true;
+
+/**
+ * `Source` has something to offer for every member `Target` requires. `Target`'s
+ * optional members are left out on purpose: one value can be a `Source` and a
+ * `Target` at once while having none of them.
+ */
+type Compatible<Source, Target, Stale extends boolean> = [Exclude<RequiredKeys<Target>, NamedKeys<Source> | keyof Object>] extends [never]
+	? IndexesCovered<Source, Target, Stale>
+	: false;
+
+/**
+ * Each index signature `Target` has needs one on `Source` with the same keys, or a
+ * value type of `any`, which anything satisfies. Numeric-string keys are the
+ * exception: they reach a `number` index signature, so `Source` having one of those
+ * covers them, as long as what it holds can be what `Target` asks for.
+ */
+type IndexesCovered<Source, Target, Stale extends boolean> = [{
+	[K in IndexKeys<Target>]: IsAny<Target[K & keyof Target]> extends true
+		? never
+		: (K extends IndexKeys<Source>
+			? never
+			: (string extends K
+				? K
+				: (`${number}` extends K
+					? (Related<Source[number & keyof Source], Target[K & keyof Target], 1, Stale> extends true ? never : K)
+					: K)))
+}[IndexKeys<Target>]] extends [never]
+	? true
+	: false;
+
+/**
+ * `T` is not assignable to a plain copy of its own members, which is what a
+ * `private`, `protected` or `#private` member does to a class, and what a call or
+ * construct signature does to any type - none of which a typed array has, so nothing
+ * outside that class can be one.
+ */
+type IsNominal<T> = {
+	[K in keyof T]: T[K]
+} extends T
+	? false
+	: true;
+
+/**
+ * Whether a `T` and an `I` look like they could be one value. A nominal `T` only
+ * gets the one direction: nothing outside its class can be a `T`, but a `T` whose
+ * members are all there can still be a typed array.
+ */
+type Meets<T, I, Nominal, Stale extends boolean> = Related<T, I, 4, Stale> extends true
+	? true
+	: (Nominal extends true ? false : Related<I, T, 4, Stale>);
+
+type MayBe<T, Name extends DeclaredName> = TagsMeet<TagOf<Instance<Name>>, TagOf<T>> extends true
+	? Meets<T, Instance<Name>, IsNominal<T>, false>
+	: false;
+
+type PossibleNames<T> = {
+	[Name in DeclaredName]: MayBe<T, Name> extends true ? Name : never
+}[DeclaredName];
+
+/** the members the typed arrays this `lib` declares actually have */
+type KnownKey = keyof Object | {
+	[Name in DeclaredName]: keyof Instance<Name>
+}[DeclaredName];
+
+type UnknownKeys<T> = Exclude<RequiredKeys<T>, KnownKey>;
+
+type WithoutUnknown<T> = Pick<T, Exclude<keyof T, UnknownKeys<T>>>;
+
+/** of those, the ones holding data rather than a method */
+type UnknownDataKeys<T> = {
+	[K in UnknownKeys<T>]: T[K & keyof T] extends Function ? never : K
+}[UnknownKeys<T>];
+
+type MeetsAny<T, Nominal> = true extends {
+	[Name in DeclaredName]: Meets<T, Instance<Name>, Nominal, true>
+}[DeclaredName]
+	? true
+	: false;
+
+/**
+ * An undeclared name has no type in this `lib`, so there is nothing to compare `T`
+ * to: the declared typed arrays stand in for it, with the members `T` requires that
+ * none of them has set aside, so that a `T` asking for a member only a newer `lib`
+ * knows about - `at` under `lib: es2020` - can still be the name that `lib` lacks.
+ *
+ * Setting a member aside loses whatever it said, and a member the `lib` has not heard
+ * of further down is not counted either (see `GatedOn`), so this is looser than the
+ * test for a declared name. A member that is data rather than a method is kept as
+ * evidence, on the guess that a newer `lib` mostly adds methods; that guess, and the
+ * stand-in itself, are why an undeclared name is the one that survives most often -
+ * `DataView`, whose own methods are all set aside, keeps one.
+ */
+type MayBeUndeclared<T> = IsAny<T> extends true
+	? true
+	: [unknown] extends [T]
+		? true
+		: [T] extends [Function]
+			? false
+			: [T] extends [object]
+				? ([UnknownDataKeys<T>] extends [never] ? MeetsAny<WithoutUnknown<T>, IsNominal<T>> : false)
+				: false;
+
+/** a specific tag names the typed array outright; a `string` tag leaves it to the members */
+type PossibleUndeclaredNames<T> = [UndeclaredName] extends [never]
+	? never
+	: string extends TagOf<T>
+		? (MayBeUndeclared<T> extends true ? UndeclaredName : never)
+		: Extract<UndeclaredName, TagOf<T>>;
+
 declare namespace whichTypedArray {
 	export type TypedArrayName = ReturnType<typeof TAs>[number];
 
-	export type TypedArrayConstructor = typeof globalThis[TypedArrayName];
+	// a consumer's `lib` may not declare every name (eg, `Float16Array`), so only look up the globals it has
+	export type TypedArrayConstructor = typeof globalThis[TypedArrayName & keyof typeof globalThis];
 
 	export type TypedArray = TypedArrayConstructor['prototype'];
 
 	/**
 	 * Distributes over `T`, so a subset of typed arrays maps to the matching
 	 * subset of names (`Int8Array | Uint8Array` -> `'Int8Array' | 'Uint8Array'`,
-	 * never a float16 or bigint name). Any non-typed-array part adds `false | null`.
+	 * never a float16 or bigint name), and a `T` that is not definitely a typed
+	 * array also gets `false | null`.
+	 *
+	 * For everything else - `object`, `ArrayBufferView`, `{ length: 0 }`, a
+	 * duck-typed stand-in - it keeps the names that `T`'s own members do not rule
+	 * out, so comparing the result to one of those names is usually not reported as a
+	 * comparison that can never be true. The rule behind that is a heuristic (see
+	 * `Related`), so it can keep a name no value of `T` could produce, and a `T` whose
+	 * conflict with a name is buried deeply enough will keep that name too. A name
+	 * this `lib` has no type for (see `MayBeUndeclared`) is kept more readily still.
 	 *
 	 * Derived entirely from `TypedArrayName`, so a new entry in `available-typed-arrays` flows through with no other change here.
 	 */
-	export type WhichTypedArray<T> =
-		| {
-			[Name in TypedArrayName]: T extends typeof globalThis[Name]['prototype']
-				? Name
-				: never
-		}[TypedArrayName]
-		| ([T] extends [TypedArray] ? never : false | null);
+	export type WhichTypedArray<T> = T extends unknown
+		?
+			| PossibleNames<T>
+			| PossibleUndeclaredNames<T>
+			| ([T] extends [TypedArray]
+				? (IsAny<T> extends true ? false | null : never)
+				: false | null)
+		: never;
 }
 
 export = whichTypedArray;

package/node_modules/which-typed-array/index.js

@@ -56,7 +56,7 @@ if (hasToStringTag && gOPD && getProto) {
 		var arr = new g[typedArray]();
 		var fn = arr.slice || arr.set;
 		if (fn) {
-			var bound = /** @type {BoundSlice | BoundSet} */ (
+			var bound = /** @type {typeof BoundSlice | typeof BoundSet} */ (
 				// @ts-expect-error TODO FIXME
 				callBind(fn)
 			);
@@ -111,11 +111,8 @@ function isTATag(tag) {
 	return $indexOf(typedArrays, tag) > -1;
 }
 
-/**
- * @type {import('.')}
- * @param {unknown} value
- */
-module.exports = function whichTypedArray(value) {
+/** @type {(value: unknown) => ReturnType<typeof import('.')>} */
+function whichTypedArray(value) {
 	if (!value || typeof value !== 'object') {
 		return false;
 	}
@@ -132,4 +129,6 @@ module.exports = function whichTypedArray(value) {
 	}
 	if (!gOPD) { return null; } // unknown engine
 	return tryTypedArrays(value);
-};
+}
+
+module.exports = whichTypedArray;