cdk-docker-image-deployment 0.0.1033 → 0.0.1035

package/.jsii

@@ -2988,7 +2988,7 @@
     "stability": "stable"
   },
   "homepage": "https://github.com/cdklabs/cdk-docker-image-deployment#readme",
-  "jsiiVersion": "5.9.53 (build 16812ce)",
+  "jsiiVersion": "5.9.54 (build 042bc62)",
   "keywords": [
     "cdk"
   ],
@@ -3560,6 +3560,6 @@
       "symbolId": "src/source:SourceContext"
     }
   },
-  "version": "0.0.1033",
-  "fingerprint": "9Vl71iK+9F/5Ey5i2KRlXbuJ55RYnmvrL9aKrAb5x4w="
+  "version": "0.0.1035",
+  "fingerprint": "hMWv08hRIfrszk9e56MMklwj+9vIg84Ub+jQ5iqJqdw="
 }

package/lib/destination.js

@@ -16,7 +16,7 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
  *
  */
 class Destination {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-docker-image-deployment.Destination", version: "0.0.1033" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-docker-image-deployment.Destination", version: "0.0.1035" };
     /**
      * Uses an ECR repository in the same account as the stack as the destination for the image.
      */

package/lib/docker-image-deployment.js

@@ -47,7 +47,7 @@ const constructs_1 = require("constructs");
  * `DockerImageDeployment` pushes an image from a local or external source to a specified external destination
  */
 class DockerImageDeployment extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-docker-image-deployment.DockerImageDeployment", version: "0.0.1033" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-docker-image-deployment.DockerImageDeployment", version: "0.0.1035" };
     cb;
     constructor(scope, id, props) {
         super(scope, id);

package/lib/source.js

@@ -60,7 +60,7 @@ const ecr_assets = __importStar(require("aws-cdk-lib/aws-ecr-assets"));
  * ```
  */
 class Source {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-docker-image-deployment.Source", version: "0.0.1033" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-docker-image-deployment.Source", version: "0.0.1035" };
     /**
      * Uses a local image built from a Dockerfile in a local directory as the source.
      *

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"
 		]
 	}

package/package.json

@@ -45,7 +45,7 @@
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
     "aws-cdk-lib": "2.24.0",
-    "commit-and-tag-version": "^12",
+    "commit-and-tag-version": "^13",
     "constructs": "10.5.1",
     "esbuild": "^0.28.2",
     "eslint": "^9",
@@ -58,7 +58,7 @@
     "jsii-docgen": "^10.5.0",
     "jsii-pacmak": "^1.140.0",
     "jsii-rosetta": "~5.9.0",
-    "projen": "^0.103.20",
+    "projen": "^0.103.27",
     "ts-jest": "^27",
     "ts-node": "^10.9.2",
     "typescript": "^4.9.5"
@@ -85,7 +85,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.1033",
+  "version": "0.0.1035",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [

package/node_modules/which-typed-array/eslint.config.mjs

@@ -1,12 +0,0 @@
-import ljharbConfig from '@ljharb/eslint-config/flat';
-
-export default [
-	...ljharbConfig,
-	{
-		rules: {
-			'func-style': ['error', 'declaration'],
-			'max-statements-per-line': ['error', { max: 2 }],
-			'no-extra-parens': 'off',
-		},
-	},
-];

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

@@ -1,105 +0,0 @@
-'use strict';
-
-var test = require('tape');
-var whichTypedArray = require('../');
-var isCallable = require('is-callable');
-var hasToStringTag = require('has-tostringtag/shams')();
-var generators = require('make-generator-function')();
-var arrows = require('make-arrow-function').list();
-var forEach = require('for-each');
-
-var typedArrayNames = [
-	'Int8Array',
-	'Uint8Array',
-	'Uint8ClampedArray',
-	'Int16Array',
-	'Uint16Array',
-	'Int32Array',
-	'Uint32Array',
-	'Float32Array',
-	'Float64Array',
-	'BigInt64Array',
-	'BigUint64Array'
-];
-
-test('not arrays', function (t) {
-	t.test('non-number/string primitives', function (st) {
-		// @ts-expect-error
-		st.equal(false, whichTypedArray(), 'undefined is not typed array');
-		st.equal(false, whichTypedArray(null), 'null is not typed array');
-		st.equal(false, whichTypedArray(false), 'false is not typed array');
-		st.equal(false, whichTypedArray(true), 'true is not typed array');
-		st.end();
-	});
-
-	t.equal(false, whichTypedArray({}), 'object is not typed array');
-	t.equal(false, whichTypedArray(/a/g), 'regex literal is not typed array');
-	t.equal(false, whichTypedArray(new RegExp('a', 'g')), 'regex object is not typed array');
-	t.equal(false, whichTypedArray(new Date()), 'new Date() is not typed array');
-
-	t.test('numbers', function (st) {
-		st.equal(false, whichTypedArray(42), 'number is not typed array');
-		st.equal(false, whichTypedArray(Object(42)), 'number object is not typed array');
-		st.equal(false, whichTypedArray(NaN), 'NaN is not typed array');
-		st.equal(false, whichTypedArray(Infinity), 'Infinity is not typed array');
-		st.end();
-	});
-
-	t.test('strings', function (st) {
-		st.equal(false, whichTypedArray('foo'), 'string primitive is not typed array');
-		st.equal(false, whichTypedArray(Object('foo')), 'string object is not typed array');
-		st.end();
-	});
-
-	t.end();
-});
-
-test('Functions', function (t) {
-	t.equal(false, whichTypedArray(function () {}), 'function is not typed array');
-	t.end();
-});
-
-test('Generators', { skip: generators.length === 0 }, function (t) {
-	forEach(generators, function (genFn) {
-		t.equal(false, whichTypedArray(genFn), 'generator function ' + genFn + ' is not typed array');
-	});
-	t.end();
-});
-
-test('Arrow functions', { skip: arrows.length === 0 }, function (t) {
-	forEach(arrows, function (arrowFn) {
-		t.equal(false, whichTypedArray(arrowFn), 'arrow function ' + arrowFn + ' is not typed array');
-	});
-	t.end();
-});
-
-test('@@toStringTag', { skip: !hasToStringTag }, function (t) {
-	forEach(typedArrayNames, function (typedArray) {
-		// @ts-expect-error TODO: fix
-		if (typeof global[typedArray] === 'function') {
-			// @ts-expect-error TODO: fix
-			var fakeTypedArray = [];
-			// @ts-expect-error TODO: fix
-			fakeTypedArray[Symbol.toStringTag] = typedArray;
-			// @ts-expect-error TODO: fix
-			t.equal(false, whichTypedArray(fakeTypedArray), 'faked ' + typedArray + ' is not typed array');
-		} else {
-			t.comment('# SKIP ' + typedArray + ' is not supported');
-		}
-	});
-	t.end();
-});
-
-test('Typed Arrays', function (t) {
-	forEach(typedArrayNames, function (typedArray) {
-		// @ts-expect-error TODO: fix
-		/** @type {import('../').TypedArrayConstructor} */ var TypedArray = global[typedArray];
-		if (isCallable(TypedArray)) {
-			var arr = new TypedArray(10);
-			t.equal(whichTypedArray(arr), typedArray, 'new ' + typedArray + '(10) is typed array of type ' + typedArray);
-		} else {
-			t.comment('# SKIP ' + typedArray + ' is not supported');
-		}
-	});
-	t.end();
-});