prostgles-server 4.2.179 → 4.2.180

package/documentation/utils/getSerializableType.ts

@@ -0,0 +1,479 @@
+import * as ts from "typescript";
+import { AnyObject, isDefined } from "prostgles-types";
+
+type TS_Base = {
+  alias?: string;
+  aliasSymbolescapedName?: string;
+  intersectionParent?: string;
+  comments?: string;
+};
+
+export type TS_Literal = TS_Base & {
+  type: "literal";
+  value: string;
+};
+
+export type TS_Primitive = TS_Base & {
+  type: "primitive";
+  subType: "string" | "number" | "boolean" | "any" | "null" | "undefined";
+};
+
+export type TS_Object = TS_Base & {
+  type: "object";
+  properties: Record<string, TS_Type & { optional: boolean }>;
+};
+
+export type TS_Array = TS_Base & {
+  type: "array";
+  itemType: TS_Type;
+};
+
+export type TS_Tuple = TS_Base & {
+  type: "tuple";
+  itemTypes: TS_Type[];
+};
+
+export type TS_Function = TS_Base & {
+  type: "function";
+  arguments: (TS_Type & { name: string; optional: boolean })[];
+  returnType: TS_Type;
+};
+
+export type TS_Promise = TS_Base & {
+  type: "promise";
+  innerType: Exclude<TS_Type, TS_Promise>;
+};
+
+export type TS_Union = TS_Base & {
+  type: "union";
+  types: TS_Type[];
+};
+
+export type TS_Reference = TS_Base & {
+  type: "reference";
+  alias: string;
+};
+
+export type TS_Type =
+  | TS_Primitive
+  | TS_Literal
+  | TS_Object
+  | TS_Array
+  | TS_Tuple
+  | TS_Function
+  | TS_Union
+  | TS_Promise
+  | TS_Reference;
+
+export type VisitedTypesMap = Map<
+  string,
+  { resolvedType: TS_Type; type: ts.Type; referenceType?: TS_Type }
+>;
+
+export const getSerializableType = (
+  myType: ts.Type,
+  checker: ts.TypeChecker,
+  visited: VisitedTypesMap = new Map(),
+  parentAliases: string[],
+  opts: ResolveTypeOptions | undefined,
+  depth: number
+): { resolvedType: TS_Type; visited: VisitedTypesMap } => {
+  let alias = "unknown";
+  const { escapedName } = myType.aliasSymbol ?? {};
+  const aliasSymbolescapedName = escapedName?.toString();
+  const symbol = myType.aliasSymbol ?? myType.symbol;
+  const comments = symbol ? getSymbolComments(symbol, checker) : undefined;
+  try {
+    alias = checker.typeToString(myType);
+  } catch (e) {
+    console.log("Error resolving type", myType, e);
+  }
+
+  /* Circular resolved type */
+  const visitedType = visited.get(alias);
+  if (visitedType) {
+    return { resolvedType: visitedType.referenceType ?? visitedType.resolvedType, visited };
+  }
+  const withAlias = (_type: TS_Type) => {
+    const finalComments = _type.comments || comments;
+    const resolvedType: TS_Type = sortObjectsByKeyOrder(
+      {
+        alias: _type.alias ?? alias,
+        aliasSymbolescapedName,
+        ..._type,
+        ...(finalComments && { comments: finalComments }),
+      },
+      ["type", "alias", "aliasSymbolescapedName", "comments"]
+    );
+
+    let referenceType: TS_Type | undefined;
+    if (
+      opts?.excludedTypes.includes(alias) ||
+      (escapedName && opts?.excludedTypes.includes(escapedName)) ||
+      (opts?.maxDepth !== undefined && depth >= opts.maxDepth)
+    ) {
+      referenceType =
+        resolvedType.type === "primitive" ?
+          resolvedType
+        : {
+            type: "reference",
+            alias,
+            aliasSymbolescapedName,
+            comments: resolvedType.comments,
+          };
+    }
+
+    visited.set(alias, { resolvedType, referenceType, type: myType });
+
+    return { resolvedType: referenceType ?? resolvedType, visited };
+  };
+
+  const unresolvedParentAliases = parentAliases?.filter((a) => !visited.get(a)) ?? [];
+
+  /* Circular unresolved type */
+  if (unresolvedParentAliases.includes(alias)) {
+    return withAlias({
+      type: "reference",
+      alias,
+    });
+  }
+  const nextUnresolvedParentAliases = unresolvedParentAliases.concat(alias);
+
+  // if (alias === "[FullFilter<T, S>, Partial<UpsertDataToPGCast<T>>][]") {
+  //   debugger;
+  // }
+
+  if (myType.isUnion()) {
+    const unionTypes = myType.types.map((t) => {
+      const resolvedUnionMember = getSerializableType(
+        t,
+        checker,
+        visited,
+        nextUnresolvedParentAliases,
+        opts,
+        depth + 1
+      );
+      return resolvedUnionMember.resolvedType;
+    });
+
+    /**
+     * "boolean | undefined" ends up in types as
+     * { intrinsicName: "true" } | { intrinsicName: "false" } | { intrinsicName: "undefined" }
+     * So we need to check for "true" and "false" and merge them into "boolean"
+     */
+    const booleanTypes = unionTypes.filter(
+      (t) => t.type === "primitive" && t.subType === "boolean"
+    );
+    const dedupedTypes =
+      booleanTypes.length > 1 ?
+        unionTypes
+          .filter((t) => t.type !== "primitive" || t.subType !== "boolean")
+          .concat(booleanTypes[0]!)
+      : unionTypes;
+
+    const result = withAlias({
+      type: "union",
+      types: dedupedTypes,
+    });
+
+    return result;
+  }
+
+  if ((myType.flags & ts.TypeFlags.String) !== 0) {
+    return withAlias({ type: "primitive", subType: "string" });
+  }
+
+  if ((myType.flags & ts.TypeFlags.NumberLike) !== 0) {
+    return withAlias({ type: "primitive", subType: "number" });
+  }
+
+  if ((myType.flags & ts.TypeFlags.BooleanLike) !== 0) {
+    return withAlias({ type: "primitive", subType: "boolean" });
+  }
+
+  if ((myType.flags & ts.TypeFlags.Null) !== 0) {
+    return withAlias({ type: "primitive", subType: "null" });
+  }
+
+  if ((myType.flags & ts.TypeFlags.Undefined) !== 0) {
+    return withAlias({ type: "primitive", subType: "undefined" });
+  }
+
+  if (checker.isArrayType(myType)) {
+    const itemType = checker.getTypeArguments(myType as ts.TypeReference)[0];
+    if (itemType && checker.isTupleType(itemType)) {
+      const tupleTypes =
+        (itemType as unknown as { resolvedTypeArguments: ts.Type[] }).resolvedTypeArguments.map(
+          (d: ts.Type) => {
+            return getSerializableType(
+              d,
+              checker,
+              visited,
+              nextUnresolvedParentAliases,
+              opts,
+              depth + 1
+            ).resolvedType;
+          }
+        ) ?? [];
+      return withAlias({
+        type: "tuple",
+        itemTypes: tupleTypes,
+      });
+    }
+    const resolvedItemType: TS_Type =
+      itemType ?
+        getSerializableType(
+          itemType,
+          checker,
+          visited,
+          nextUnresolvedParentAliases,
+          opts,
+          depth + 1
+        ).resolvedType
+      : { type: "primitive", subType: "any" };
+
+    return withAlias({
+      type: "array",
+      itemType: resolvedItemType,
+    });
+  }
+
+  const [firstSignature] = myType.getCallSignatures();
+  if (firstSignature) {
+    const parameters = firstSignature.parameters
+      .map((param) => {
+        const { valueDeclaration } = param;
+        if (!valueDeclaration) return undefined;
+        const paramType = checker.getTypeOfSymbolAtLocation(param, valueDeclaration);
+        const resolvedParamType = getSerializableType(
+          paramType,
+          checker,
+          visited,
+          nextUnresolvedParentAliases,
+          opts,
+          depth + 1
+        ).resolvedType;
+        const paramComments = getSymbolComments(param, checker);
+        const optional = Boolean(
+          (ts as any).isParameterDeclaration(param.valueDeclaration) &&
+            checker.isOptionalParameter(valueDeclaration as ts.ParameterDeclaration)
+        );
+        const name = param.escapedName.toString() || param.name;
+        const resolvedParam =
+          optional ? simplifyUnionForOptionalType(resolvedParamType) : resolvedParamType;
+        return {
+          name,
+          optional,
+          ...resolvedParam,
+          comments: resolvedParam.comments || paramComments,
+        };
+      })
+      .filter(isDefined);
+    const returnType = getSerializableType(
+      checker.getReturnTypeOfSignature(firstSignature),
+      checker,
+      visited,
+      nextUnresolvedParentAliases,
+      opts,
+      depth + 1
+    ).resolvedType;
+
+    return withAlias({
+      type: "function",
+      arguments: parameters,
+      returnType,
+    });
+  }
+
+  if ((myType.flags & ts.TypeFlags.Object) !== 0) {
+    const objectType = myType as ts.ObjectType;
+
+    if (objectType.objectFlags & ts.ObjectFlags.Reference) {
+      const typeReference = objectType as ts.TypeReference;
+      const target = typeReference.target;
+
+      if (target.symbol?.escapedName === "Promise") {
+        const _innerType = checker.getTypeArguments(typeReference)[0];
+        const defaultType: TS_Type = { type: "primitive", subType: "any" };
+        const resolvedInnerType =
+          _innerType &&
+          getSerializableType(
+            _innerType,
+            checker,
+            visited,
+            nextUnresolvedParentAliases,
+            opts,
+            depth + 1
+          ).resolvedType;
+        const innerType: Exclude<TS_Type, TS_Promise> =
+          resolvedInnerType?.type === "promise" ? defaultType : (resolvedInnerType ?? defaultType);
+        return withAlias({
+          type: "promise",
+          innerType,
+        });
+      }
+    }
+
+    const properties: TS_Object["properties"] = {};
+    myType.getProperties().forEach((symbol) => {
+      const propertyType = checker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration!);
+      const resolvedPropertyType = getSerializableType(
+        propertyType,
+        checker,
+        visited,
+        nextUnresolvedParentAliases,
+        opts,
+        depth + 1
+      ).resolvedType;
+      const propertyComments = resolvedPropertyType.comments || getSymbolComments(symbol, checker);
+      const optional = Boolean(symbol.flags & ts.SymbolFlags.Optional);
+      properties[symbol.name] = {
+        ...(optional ? simplifyUnionForOptionalType(resolvedPropertyType) : resolvedPropertyType),
+        optional,
+        comments: propertyComments || undefined,
+      };
+    });
+    const comments =
+      myType.aliasSymbol?.declarations &&
+      getNonInternalTSDeclarations(myType.aliasSymbol?.declarations)
+        //@ts-ignore
+        ?.flatMap((d) => (!d.jsDoc ? [] : d.jsDoc.map((jd) => jd.comment)))
+        .join("\n");
+    return withAlias({
+      type: "object",
+      properties,
+      comments,
+    });
+  }
+
+  /**
+   * A & B
+   */
+  if (myType.isIntersection()) {
+    const intersectionTypes = myType.types.map((t) => {
+      const { resolvedType: intersectionType } = getSerializableType(
+        t,
+        checker,
+        visited,
+        nextUnresolvedParentAliases,
+        opts,
+        depth + 1
+      );
+      intersectionType.intersectionParent = aliasSymbolescapedName || alias;
+      return intersectionType;
+    });
+    if (intersectionTypes.every((t) => t.type === "object")) {
+      const properties = (intersectionTypes as TS_Object[]).reduce((acc, t) => {
+        return { ...acc, ...t.properties };
+      }, {});
+      return withAlias({
+        type: "object",
+        properties,
+      });
+    }
+    return withAlias({
+      type: "union",
+      types: intersectionTypes,
+    });
+  }
+
+  /**
+   * Type parameter. E.g.:
+   * function example<T>(arg: T){ }
+   */
+  if (myType.isTypeParameter()) {
+    const extendedType = myType.getConstraint();
+    if (extendedType) {
+      const { resolvedType: resolvedExtendedType } = getSerializableType(
+        extendedType,
+        checker,
+        visited,
+        nextUnresolvedParentAliases,
+        opts,
+        depth + 1
+      );
+      return withAlias(resolvedExtendedType);
+    }
+  }
+
+  if (myType.isStringLiteral()) {
+    return withAlias({ type: "literal", value: myType.value });
+  }
+
+  return withAlias({ type: "primitive", subType: "any" });
+};
+
+type ResolveTypeOptions = {
+  excludedTypes: string[];
+  maxDepth?: number;
+};
+export const resolveType = (
+  myType: ts.Type,
+  checker: ts.TypeChecker,
+  opts: ResolveTypeOptions
+): { resolvedType: TS_Type; constituentTypes?: TS_Type[] } => {
+  const { resolvedType } = getSerializableType(myType, checker, undefined, [], opts, 0);
+  if (resolvedType.type === "reference" && opts.excludedTypes.includes(resolvedType.alias)) {
+    return { resolvedType: { type: "primitive", subType: "any" } };
+  }
+  return { resolvedType, constituentTypes: [] };
+};
+
+const getNonInternalTSDeclarations = (declarations: ts.Declaration[]): ts.Declaration[] => {
+  return declarations.filter((d) => {
+    return !d.getSourceFile().fileName.includes("/node_modules/typescript/");
+  });
+};
+
+const sortObjectsByKeyOrder = <T extends AnyObject, K extends keyof T & string>(
+  obj: T,
+  keyOrder: K[]
+): T => {
+  const newKeyOrder = arraySort(Object.keys(obj), keyOrder);
+
+  return newKeyOrder.reduce(
+    (acc, key) => ({
+      ...acc,
+      [key]: obj[key],
+    }),
+    {} as T
+  );
+};
+
+const arraySort = (arrayToSort: string[], keyOrder: string[]): string[] => {
+  const keyOrderMap = new Map(keyOrder.map((value, index) => [value, index]));
+
+  return arrayToSort.sort((a, b) => {
+    const aIndex = keyOrderMap.get(a) ?? Infinity;
+    const bIndex = keyOrderMap.get(b) ?? Infinity;
+
+    return aIndex - bIndex;
+  });
+};
+
+const simplifyUnionForOptionalType = (resolvedParamType: TS_Type) => {
+  if (resolvedParamType.type === "union" && resolvedParamType.types.length === 2) {
+    const indexOfUndefined = resolvedParamType.types.findIndex(
+      (t) => t.type === "primitive" && t.subType === "undefined"
+    );
+    if (indexOfUndefined === -1) return resolvedParamType;
+
+    const unionTypes = resolvedParamType.types;
+    const nonUndefined = unionTypes.find((_, i) => indexOfUndefined !== i);
+    if (
+      nonUndefined &&
+      (nonUndefined.type !== "primitive" || nonUndefined.subType !== "undefined")
+    ) {
+      return nonUndefined;
+    }
+  }
+  return resolvedParamType;
+};
+
+const getSymbolComments = (symbol: ts.Symbol, checker: ts.TypeChecker): string => {
+  const comments = symbol.getDocumentationComment(checker);
+  return comments
+    .map((comment) => comment.text)
+    .join(" ")
+    .trim();
+};

package/documentation/utils/loadTsFile.ts

@@ -0,0 +1,45 @@
+import * as path from "path";
+import * as ts from "typescript";
+
+export const loadTsFile = (filePath: string) => {
+  // Normalize file path
+  const absolutePath = path.resolve(filePath);
+
+  // Create compiler host and program
+  const configPath = ts.findConfigFile(
+    path.dirname(absolutePath),
+    ts.sys.fileExists,
+    "tsconfig.json"
+  );
+
+  if (!configPath) {
+    throw new Error("Could not find a valid 'tsconfig.json'.");
+  }
+
+  // Parse the config file
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+  const parsedConfig = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    path.dirname(configPath)
+  );
+
+  // Create program
+  const program = ts.createProgram({
+    rootNames: [absolutePath],
+    options: parsedConfig.options,
+  });
+
+  const checker = program.getTypeChecker();
+  const sourceFile = program.getSourceFile(absolutePath);
+
+  if (!sourceFile) {
+    throw new Error(`Could not find source file: ${absolutePath}`);
+  }
+
+  return {
+    program,
+    checker,
+    sourceFile,
+  };
+};

package/documentation/utils/moduleResolver.ts

@@ -0,0 +1,31 @@
+import * as ts from "typescript";
+
+/**
+ * Resolves a moduleSpecifier to its resolved file path using TypeScript's module resolution.
+ *
+ * @param moduleSpecifier - The module path (e.g., "./Auth").
+ * @param currentFilePath - The path of the current file where the module is imported.
+ * @returns The resolved file path, or `undefined` if not found.
+ */
+export const resolveModuleWithTypescript = (moduleSpecifier: string, currentFilePath: string) => {
+  const compilerOptions: ts.CompilerOptions = {
+    moduleResolution: ts.ModuleResolutionKind.Node16,
+    baseUrl: "./", // Adjust as needed
+  };
+  const host: ts.ModuleResolutionHost = {
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile,
+    directoryExists: ts.sys.directoryExists,
+    getCurrentDirectory: ts.sys.getCurrentDirectory,
+    getDirectories: ts.sys.getDirectories,
+  };
+
+  const { resolvedModule } = ts.resolveModuleName(
+    moduleSpecifier,
+    currentFilePath,
+    compilerOptions,
+    host
+  );
+
+  return resolvedModule?.resolvedFileName;
+};

package/documentation/utils/node_modules/.package-lock.json

@@ -0,0 +1,67 @@
+{
+  "name": "generate-docs",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "..": {
+      "name": "prostgles-server",
+      "version": "4.2.179",
+      "extraneous": true,
+      "license": "MIT",
+      "dependencies": {
+        "@aws-sdk/client-ses": "^3.699.0",
+        "@aws-sdk/credential-provider-node": "^3.699.0",
+        "@types/passport": "^1.0.17",
+        "@types/passport-facebook": "^3.0.3",
+        "@types/passport-github2": "^1.2.9",
+        "@types/passport-google-oauth20": "^2.0.16",
+        "@types/passport-microsoft": "^1.0.3",
+        "body-parser": "^1.20.3",
+        "check-disk-space": "^3.4.0",
+        "file-type": "^18.5.0",
+        "nodemailer": "^6.9.16",
+        "passport": "^0.7.0",
+        "passport-facebook": "^3.0.0",
+        "passport-github2": "^0.1.12",
+        "passport-google-oauth20": "^2.0.0",
+        "passport-microsoft": "^2.1.0",
+        "pg": "^8.11.5",
+        "pg-cursor": "^2.11.0",
+        "pg-promise": "^11.9.1",
+        "prostgles-types": "^4.0.115"
+      },
+      "devDependencies": {
+        "@types/express": "^4.17.21",
+        "@types/json-schema": "^7.0.15",
+        "@types/node": "^22.8.1",
+        "@types/nodemailer": "^6.4.17",
+        "@types/pg": "^8.11.5",
+        "@types/pg-cursor": "^2.7.2",
+        "@types/sharp": "^0.30.4",
+        "@typescript-eslint/eslint-plugin": "^8.15.0",
+        "@typescript-eslint/parser": "^8.15.0",
+        "eslint": "^8.51.0",
+        "socket.io": "^4.8.1",
+        "typescript": "^5.3.3"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "20.17.10",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.17.10.tgz",
+      "integrity": "sha512-/jrvh5h6NXhEauFFexRin69nA0uHJ5gwk4iDivp/DeoEua3uwCUto6PC86IpRITBOs4+6i2I56K5x5b6WYGXHA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.19.2"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.19.8",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz",
+      "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==",
+      "dev": true,
+      "license": "MIT"
+    }
+  }
+}

package/documentation/utils/node_modules/@types/node/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/documentation/utils/node_modules/@types/node/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/node`
+
+# Summary
+This package contains type definitions for node (https://nodejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v20.
+
+### Additional Details
+ * Last updated: Wed, 11 Dec 2024 09:35:14 GMT
+ * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
+
+# Credits
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Victor Perin](https://github.com/victorperin), [NodeJS Contributors](https://github.com/NodeJS), [Linus Unnebäck](https://github.com/LinusU), [wafuwafu13](https://github.com/wafuwafu13), [Matteo Collina](https://github.com/mcollina), and [Dmitry Semigradsky](https://github.com/Semigradsky).

package/documentation/utils/node_modules/@types/node/assert/strict.d.ts

@@ -0,0 +1,8 @@
+declare module "assert/strict" {
+    import { strict } from "node:assert";
+    export = strict;
+}
+declare module "node:assert/strict" {
+    import { strict } from "node:assert";
+    export = strict;
+}