@cdklabs/cdk-construct-connect-datalake 0.0.27 → 0.0.28

package/node_modules/@smithy/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/core",
-  "version": "3.34.1",
+  "version": "3.35.0",
   "homepage": "https://github.com/smithy-lang/smithy-typescript/tree/main/packages/core",
   "license": "Apache-2.0",
   "author": {
@@ -241,7 +241,7 @@
     "test:integration:watch": "yarn g:vitest watch -c vitest.config.integ.mts"
   },
   "dependencies": {
-    "@smithy/types": "^4.18.0",
+    "@smithy/types": "^4.19.0",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@smithy/signature-v4/dist-cjs/index.js

@@ -339,7 +339,10 @@ const getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) =>
                 continue;
             }
         }
-        canonical[canonicalHeaderName] = headers[headerName].trim().replace(/\s+/g, " ");
+        canonical[canonicalHeaderName] = headers[headerName]
+            .replace(/[\r\n]/g, " ")
+            .replace(/[ \t]+/g, " ")
+            .replace(/^ | $/g, "");
     }
     return canonical;
 };

package/node_modules/@smithy/signature-v4/dist-es/getCanonicalHeaders.js

@@ -14,7 +14,10 @@ export const getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHead
                 continue;
             }
         }
-        canonical[canonicalHeaderName] = headers[headerName].trim().replace(/\s+/g, " ");
+        canonical[canonicalHeaderName] = headers[headerName]
+            .replace(/[\r\n]/g, " ")
+            .replace(/[ \t]+/g, " ")
+            .replace(/^ | $/g, "");
     }
     return canonical;
 };

package/node_modules/@smithy/signature-v4/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/signature-v4",
-  "version": "5.7.3",
+  "version": "5.7.4",
   "description": "A standalone implementation of the AWS Signature V4 request signing algorithm",
   "homepage": "https://github.com/smithy-lang/smithy-typescript/tree/main/packages/signature-v4",
   "license": "Apache-2.0",
@@ -38,8 +38,8 @@
     "test:watch": "yarn g:vitest watch"
   },
   "dependencies": {
-    "@smithy/core": "^3.33.3",
-    "@smithy/types": "^4.17.2",
+    "@smithy/core": "^3.35.0",
+    "@smithy/types": "^4.19.0",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@smithy/types/dist-types/metrics.d.ts

@@ -15,10 +15,11 @@ export type RequestOutcome = "Success" | "Fault";
 export type MetricUnit = "Seconds" | "Microseconds" | "Milliseconds" | "Bytes" | "Kilobytes" | "Megabytes" | "Gigabytes" | "Terabytes" | "Bits" | "Kilobits" | "Megabits" | "Gigabits" | "Terabits" | "Percent" | "Count" | "None" | "Bytes/Second" | "Kilobytes/Second" | "Megabytes/Second" | "Gigabytes/Second" | "Terabytes/Second" | "Bits/Second" | "Kilobits/Second" | "Megabits/Second" | "Gigabits/Second" | "Terabits/Second" | "Count/Second";
 /**
  * Backend-agnostic recorder for per-request metrics. The framework drives the
- * lifecycle and records request-level metrics through this interface; user
- * handlers record their own business metrics through the same methods. Concrete
- * recorders (e.g. an EMF recorder, or a future OpenTelemetry recorder) translate
- * these abstract calls into their own primitives.
+ * lifecycle of recorders obtained from a factory and records request-level
+ * metrics through this interface; user handlers record their own business
+ * metrics through the same methods. Concrete recorders (e.g. an EMF recorder,
+ * or a future OpenTelemetry recorder) translate these abstract calls into their
+ * own primitives.
  *
  * @typeParam Native - the concrete backend handle returned by
  *   {@link MetricsRecorder.getMetrics}, e.g. an OpenTelemetry `Meter`. The
@@ -30,13 +31,13 @@ export type MetricUnit = "Seconds" | "Microseconds" | "Milliseconds" | "Bytes" |
 export interface MetricsRecorder<Native> {
     /**
      * Open the recorder for the current request. Called by the framework once at
-     * the start of request handling.
+     * the start of request handling when it owns the recorder.
      */
     begin(): void;
     /**
      * Close the recorder for the current request. Called by the framework once at
-     * the end of request handling; this is where an implementation typically
-     * flushes its event.
+     * the end of request handling when it owns the recorder; this is where an
+     * implementation typically flushes its event.
      */
     end(): void;
     /**

package/node_modules/@smithy/types/dist-types/middleware.d.ts

@@ -4,6 +4,7 @@ import type { Command } from "./command";
 import type { EndpointV2 } from "./endpoint";
 import type { SmithyFeatures } from "./feature-ids";
 import type { Logger } from "./logger";
+import type { MetricsRecorder } from "./metrics";
 import type { UserAgent } from "./util";
 /**
  * @public
@@ -505,6 +506,10 @@ export interface HandlerExecutionContext {
         commandInstance?: Command<any, any, any, any, any>;
         selectedHttpAuthScheme?: SelectedHttpAuthScheme;
         features?: SmithyFeatures;
+        /**
+         * Transferred from request options to the Smithy context.
+         */
+        metricsRecorder?: MetricsRecorder<unknown>;
         /**
          * @deprecated
          * Do not assign arbitrary members to the Smithy Context,

package/node_modules/@smithy/types/dist-types/ts3.4/metrics.d.ts

@@ -15,10 +15,11 @@ export type RequestOutcome = "Success" | "Fault";
 export type MetricUnit = "Seconds" | "Microseconds" | "Milliseconds" | "Bytes" | "Kilobytes" | "Megabytes" | "Gigabytes" | "Terabytes" | "Bits" | "Kilobits" | "Megabits" | "Gigabits" | "Terabits" | "Percent" | "Count" | "None" | "Bytes/Second" | "Kilobytes/Second" | "Megabytes/Second" | "Gigabytes/Second" | "Terabytes/Second" | "Bits/Second" | "Kilobits/Second" | "Megabits/Second" | "Gigabits/Second" | "Terabits/Second" | "Count/Second";
 /**
  * Backend-agnostic recorder for per-request metrics. The framework drives the
- * lifecycle and records request-level metrics through this interface; user
- * handlers record their own business metrics through the same methods. Concrete
- * recorders (e.g. an EMF recorder, or a future OpenTelemetry recorder) translate
- * these abstract calls into their own primitives.
+ * lifecycle of recorders obtained from a factory and records request-level
+ * metrics through this interface; user handlers record their own business
+ * metrics through the same methods. Concrete recorders (e.g. an EMF recorder,
+ * or a future OpenTelemetry recorder) translate these abstract calls into their
+ * own primitives.
  *
  * @typeParam Native - the concrete backend handle returned by
  *   {@link MetricsRecorder.getMetrics}, e.g. an OpenTelemetry `Meter`. The
@@ -30,13 +31,13 @@ export type MetricUnit = "Seconds" | "Microseconds" | "Milliseconds" | "Bytes" |
 export interface MetricsRecorder<Native> {
     /**
      * Open the recorder for the current request. Called by the framework once at
-     * the start of request handling.
+     * the start of request handling when it owns the recorder.
      */
     begin(): void;
     /**
      * Close the recorder for the current request. Called by the framework once at
-     * the end of request handling; this is where an implementation typically
-     * flushes its event.
+     * the end of request handling when it owns the recorder; this is where an
+     * implementation typically flushes its event.
      */
     end(): void;
     /**

package/node_modules/@smithy/types/dist-types/ts3.4/middleware.d.ts

@@ -4,6 +4,7 @@ import { Command } from "./command";
 import { EndpointV2 } from "./endpoint";
 import { SmithyFeatures } from "./feature-ids";
 import { Logger } from "./logger";
+import { MetricsRecorder } from "./metrics";
 import { UserAgent } from "./util";
 /**
  * @public
@@ -505,6 +506,10 @@ export interface HandlerExecutionContext {
         commandInstance?: Command<any, any, any, any, any>;
         selectedHttpAuthScheme?: SelectedHttpAuthScheme;
         features?: SmithyFeatures;
+        /**
+         * Transferred from request options to the Smithy context.
+         */
+        metricsRecorder?: MetricsRecorder<unknown>;
         /**
          * @deprecated
          * Do not assign arbitrary members to the Smithy Context,

package/node_modules/@smithy/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/types",
-  "version": "4.18.0",
+  "version": "4.19.0",
   "homepage": "https://github.com/smithy-lang/smithy-typescript/tree/main/packages/types",
   "license": "Apache-2.0",
   "author": {

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;

package/node_modules/which-typed-array/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "which-typed-array",
-	"version": "1.1.22",
+	"version": "1.1.24",
 	"author": {
 		"name": "Jordan Harband",
 		"email": "ljharb@gmail.com",
@@ -31,9 +31,10 @@
 		"test:harmony": "nyc node --harmony --es-staging test",
 		"posttest": "npx npm@'>=10.2' audit --production",
 		"lint": "eslint .",
-		"postlint": "tsc -p . && attw -P",
+		"postlint": "tsc -p . && tsc -p test/es2020 && attw -P",
 		"version": "auto-changelog && git add CHANGELOG.md",
-		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
+		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"",
+		"dependencies": "node -p \"process.env.npm_command\" | npx \"dt-clean@^1.2.2\" --auto"
 	},
 	"repository": {
 		"type": "git",
@@ -69,18 +70,16 @@
 		"has-tostringtag": "^1.0.2"
 	},
 	"devDependencies": {
-		"@arethetypeswrong/cli": "^0.18.3",
-		"@ljharb/eslint-config": "^22.2.3",
+		"@arethetypeswrong/cli": "^0.18.5",
+		"@ljharb/eslint-config": "^22.2.4",
 		"@ljharb/tsconfig": "^0.3.2",
 		"@types/call-bind": "^1.0.5",
-		"@types/for-each": "^0.3.3",
-		"@types/gopd": "^1.0.3",
 		"@types/is-callable": "^1.1.2",
 		"@types/make-arrow-function": "^1.2.2",
 		"@types/make-generator-function": "^2.0.3",
-		"@types/tape": "^5.8.1",
-		"auto-changelog": "^2.6.0",
-		"eslint": "^10.4.1",
+		"@types/node": "^22.20.3",
+		"auto-changelog": "^2.6.1",
+		"eslint": "^10.10.0",
 		"in-publish": "^2.0.1",
 		"is-callable": "^1.2.7",
 		"jiti": "^0.0.0",
@@ -89,7 +88,7 @@
 		"npmignore": "^0.3.5",
 		"nyc": "^10.3.2",
 		"safe-publish-latest": "^2.0.0",
-		"tape": "^5.9.0",
+		"tape": "^5.10.2",
 		"typescript": "next"
 	},
 	"testling": {
@@ -124,6 +123,8 @@
 	"publishConfig": {
 		"ignore": [
 			".github/workflows",
+			"eslint.config.mjs",
+			"test",
 			"types.d.ts"
 		]
 	}