Merging sw-cleanup

src/App.vue

@@ -446,16 +446,17 @@ export default class App extends Vue {
               "Subscription or server communication failed:",
               error,
             );
-            alert( "Subscription or server communication failed. Try again in a while." );
+            alert(
+              "Subscription or server communication failed. Try again in a while.",
+            );
           });
       })
       .catch((error) => {
         console.error("An error occurred:", error);
-        alert( "Some error occurred." + error );	
+        alert("Some error occurred." + error);
       });
   }
 
-
   private urlBase64ToUint8Array(base64String: string): Uint8Array {
     const padding = "=".repeat((4 - (base64String.length % 4)) % 4);
     const base64 = (base64String + padding)

src/util.d.ts

@@ -105,7 +105,10 @@ declare module "util" {
     | "date"
     | "regexp"
     | "module";
-    export type CustomInspectFunction = (depth: number, options: InspectOptionsStylized) => any; // TODO: , inspect: inspect
+  export type CustomInspectFunction = (
+    depth: number,
+    options: InspectOptionsStylized,
+  ) => unknown; // TODO: , inspect: inspect
   export interface InspectOptionsStylized extends InspectOptions {
     stylize(text: string, styleType: Style): string;
   }
@@ -166,7 +169,11 @@ declare module "util" {
    * ```
    * @since v10.0.0
    */
-    export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
+  export function formatWithOptions(
+    inspectOptions: InspectOptions,
+    format?: any,
+    ...param: any[]
+  ): string;
   /**
    * Returns the string name for a numeric error code that comes from a Node.js API.
    * The mapping between error codes and error names is platform-dependent.
@@ -437,7 +444,12 @@ declare module "util" {
    * @param object Any JavaScript primitive or `Object`.
    * @return The representation of `object`.
    */
-    export function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): string;
+  export function inspect(
+    object: any,
+    showHidden?: boolean,
+    depth?: number | null,
+    color?: boolean,
+  ): string;
   export function inspect(object: any, options?: InspectOptions): string;
   export namespace inspect {
     let colors: NodeJS.Dict<[number, number]>;
@@ -595,7 +607,10 @@ declare module "util" {
    * @since v0.3.0
    * @legacy Use ES2015 class syntax and `extends` keyword instead.
    */
-    export function inherits(constructor: unknown, superConstructor: unknown): void;
+  export function inherits(
+    constructor: unknown,
+    superConstructor: unknown,
+  ): void;
   export type DebugLoggerFunction = (msg: string, ...param: unknown[]) => void;
   export interface DebugLogger extends DebugLoggerFunction {
     enabled: boolean;
@@ -657,7 +672,10 @@ declare module "util" {
    * @param callback A callback invoked the first time the logging function is called with a function argument that is a more optimized logging function.
    * @return The logging function
    */
-    export function debuglog(section: string, callback?: (fn: DebugLoggerFunction) => void): DebugLogger;
+  export function debuglog(
+    section: string,
+    callback?: (fn: DebugLoggerFunction) => void,
+  ): DebugLogger;
   export const debug: typeof debuglog;
   /**
    * Returns `true` if the given `object` is a `Boolean`. Otherwise, returns `false`.
@@ -747,7 +765,9 @@ declare module "util" {
    * @since v0.11.5
    * @deprecated Since v4.0.0 - Use `value === undefined || value === null` instead.
    */
-    export function isNullOrUndefined(object: unknown): object is null | undefined;
+  export function isNullOrUndefined(
+    object: unknown,
+  ): object is null | undefined;
   /**
    * Returns `true` if the given `object` is a `Number`. Otherwise, returns `false`.
    *
@@ -918,7 +938,11 @@ declare module "util" {
    * @param code A deprecation code. See the `list of deprecated APIs` for a list of codes.
    * @return The deprecated function wrapped to emit a warning.
    */
-    export function deprecate<T extends Function>(fn: T, msg: string, code?: string): T;
+  export function deprecate<T extends Function>(
+    fn: T,
+    msg: string,
+    code?: string,
+  ): T;
   /**
    * Returns `true` if there is deep strict equality between `val1` and `val2`.
    * Otherwise, returns `false`.
@@ -987,7 +1011,9 @@ declare module "util" {
    * @param fn An `async` function
    * @return a callback style function
    */
-    export function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void;
+  export function callbackify(
+    fn: () => Promise<void>,
+  ): (callback: (err: NodeJS.ErrnoException) => void) => void;
   export function callbackify<TResult>(
     fn: () => Promise<TResult>,
   ): (callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
@@ -996,22 +1022,49 @@ declare module "util" {
   ): (arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void;
   export function callbackify<T1, TResult>(
     fn: (arg1: T1) => Promise<TResult>,
-    ): (arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
+  ): (
+    arg1: T1,
+    callback: (err: NodeJS.ErrnoException, result: TResult) => void,
+  ) => void;
   export function callbackify<T1, T2>(
     fn: (arg1: T1, arg2: T2) => Promise<void>,
-    ): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void;
+  ): (
+    arg1: T1,
+    arg2: T2,
+    callback: (err: NodeJS.ErrnoException) => void,
+  ) => void;
   export function callbackify<T1, T2, TResult>(
     fn: (arg1: T1, arg2: T2) => Promise<TResult>,
-    ): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+  ): (
+    arg1: T1,
+    arg2: T2,
+    callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
+  ) => void;
   export function callbackify<T1, T2, T3>(
     fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>,
-    ): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void;
+  ): (
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    callback: (err: NodeJS.ErrnoException) => void,
+  ) => void;
   export function callbackify<T1, T2, T3, TResult>(
     fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>,
-    ): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+  ): (
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
+  ) => void;
   export function callbackify<T1, T2, T3, T4>(
     fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>,
-    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => void;
+  ): (
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    arg4: T4,
+    callback: (err: NodeJS.ErrnoException) => void,
+  ) => void;
   export function callbackify<T1, T2, T3, T4, TResult>(
     fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>,
   ): (
@@ -1023,7 +1076,14 @@ declare module "util" {
   ) => void;
   export function callbackify<T1, T2, T3, T4, T5>(
     fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>,
-    ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException) => void) => void;
+  ): (
+    arg1: T1,
+    arg2: T2,
+    arg3: T3,
+    arg4: T4,
+    arg5: T5,
+    callback: (err: NodeJS.ErrnoException) => void,
+  ) => void;
   export function callbackify<T1, T2, T3, T4, T5, TResult>(
     fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>,
   ): (
@@ -1035,7 +1095,14 @@ declare module "util" {
     callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
   ) => void;
   export function callbackify<T1, T2, T3, T4, T5, T6>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      arg4: T4,
+      arg5: T5,
+      arg6: T6,
+    ) => Promise<void>,
   ): (
     arg1: T1,
     arg2: T2,
@@ -1046,7 +1113,14 @@ declare module "util" {
     callback: (err: NodeJS.ErrnoException) => void,
   ) => void;
   export function callbackify<T1, T2, T3, T4, T5, T6, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      arg4: T4,
+      arg5: T5,
+      arg6: T6,
+    ) => Promise<TResult>,
   ): (
     arg1: T1,
     arg2: T2,
@@ -1056,10 +1130,12 @@ declare module "util" {
     arg6: T6,
     callback: (err: NodeJS.ErrnoException | null, result: TResult) => void,
   ) => void;
-    export interface CustomPromisifyLegacy<TCustom extends Function> extends Function {
+  export interface CustomPromisifyLegacy<TCustom extends Function>
+    extends Function {
     __promisify__: TCustom;
   }
-    export interface CustomPromisifySymbol<TCustom extends Function> extends Function {
+  export interface CustomPromisifySymbol<TCustom extends Function>
+    extends Function {
     [promisify.custom]: TCustom;
   }
   export type CustomPromisify<TCustom extends Function> =
@@ -1134,38 +1210,79 @@ declare module "util" {
    * ```
    * @since v8.0.0
    */
-    export function promisify<TCustom extends Function>(fn: CustomPromisify<TCustom>): TCustom;
+  export function promisify<TCustom extends Function>(
+    fn: CustomPromisify<TCustom>,
+  ): TCustom;
   export function promisify<TResult>(
     fn: (callback: (err: any, result: TResult) => void) => void,
   ): () => Promise<TResult>;
-    export function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>;
+  export function promisify(
+    fn: (callback: (err?: any) => void) => void,
+  ): () => Promise<void>;
   export function promisify<T1, TResult>(
     fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void,
   ): (arg1: T1) => Promise<TResult>;
-    export function promisify<T1>(fn: (arg1: T1, callback: (err?: any) => void) => void): (arg1: T1) => Promise<void>;
+  export function promisify<T1>(
+    fn: (arg1: T1, callback: (err?: any) => void) => void,
+  ): (arg1: T1) => Promise<void>;
   export function promisify<T1, T2, TResult>(
-        fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      callback: (err: any, result: TResult) => void,
+    ) => void,
   ): (arg1: T1, arg2: T2) => Promise<TResult>;
   export function promisify<T1, T2>(
     fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void,
   ): (arg1: T1, arg2: T2) => Promise<void>;
   export function promisify<T1, T2, T3, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      callback: (err: any, result: TResult) => void,
+    ) => void,
   ): (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>;
   export function promisify<T1, T2, T3>(
     fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void,
   ): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>;
   export function promisify<T1, T2, T3, T4, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      arg4: T4,
+      callback: (err: any, result: TResult) => void,
+    ) => void,
   ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>;
   export function promisify<T1, T2, T3, T4>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      arg4: T4,
+      callback: (err?: any) => void,
+    ) => void,
   ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>;
   export function promisify<T1, T2, T3, T4, T5, TResult>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      arg4: T4,
+      arg5: T5,
+      callback: (err: any, result: TResult) => void,
+    ) => void,
   ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>;
   export function promisify<T1, T2, T3, T4, T5>(
-        fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void,
+    fn: (
+      arg1: T1,
+      arg2: T2,
+      arg3: T3,
+      arg4: T4,
+      arg5: T5,
+      callback: (err?: any) => void,
+    ) => void,
   ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>;
   export function promisify(fn: Function): Function;
   export namespace promisify {
@@ -1272,7 +1389,10 @@ declare module "util" {
      */
     encodeInto(src: string, dest: Uint8Array): EncodeIntoResult;
   }
-    import { TextDecoder as _TextDecoder, TextEncoder as _TextEncoder } from "util";
+  import {
+    TextDecoder as _TextDecoder,
+    TextEncoder as _TextEncoder,
+  } from "util";
   global {
     /**
      * `TextDecoder` class is a global reference for `require('util').TextDecoder`
@@ -1282,7 +1402,8 @@ declare module "util" {
     var TextDecoder: typeof globalThis extends {
       onmessage: any;
       TextDecoder: infer TextDecoder;
-        } ? TextDecoder
+    }
+      ? TextDecoder
       : typeof _TextDecoder;
     /**
      * `TextEncoder` class is a global reference for `require('util').TextEncoder`
@@ -1292,7 +1413,8 @@ declare module "util" {
     var TextEncoder: typeof globalThis extends {
       onmessage: any;
       TextEncoder: infer TextEncoder;
-        } ? TextEncoder
+    }
+      ? TextEncoder
       : typeof _TextEncoder;
   }
 
@@ -1325,7 +1447,9 @@ declare module "util" {
    * @param config Used to provide arguments for parsing and to configure the parser. `config` supports the following properties:
    * @return The parsed command line arguments:
    */
-    export function parseArgs<T extends ParseArgsConfig>(config?: T): ParsedResults<T>;
+  export function parseArgs<T extends ParseArgsConfig>(
+    config?: T,
+  ): ParsedResults<T>;
   interface ParseArgsOptionConfig {
     /**
      * Type of argument.
@@ -1388,24 +1512,39 @@ declare module "util" {
     This is technically incorrect but is a much nicer UX for the common case.
     The IfDefaultsTrue version is for things which default to true; the IfDefaultsFalse version is for things which default to false.
     */
-    type IfDefaultsTrue<T, IfTrue, IfFalse> = T extends true ? IfTrue
+  type IfDefaultsTrue<T, IfTrue, IfFalse> = T extends true
-        : T extends false ? IfFalse
+    ? IfTrue
+    : T extends false
+      ? IfFalse
       : IfTrue;
 
   // we put the `extends false` condition first here because `undefined` compares like `any` when `strictNullChecks: false`
-    type IfDefaultsFalse<T, IfTrue, IfFalse> = T extends false ? IfFalse
+  type IfDefaultsFalse<T, IfTrue, IfFalse> = T extends false
-        : T extends true ? IfTrue
+    ? IfFalse
+    : T extends true
+      ? IfTrue
       : IfFalse;
 
-    type ExtractOptionValue<T extends ParseArgsConfig, O extends ParseArgsOptionConfig> = IfDefaultsTrue<
+  type ExtractOptionValue<
+    T extends ParseArgsConfig,
+    O extends ParseArgsOptionConfig,
+  > = IfDefaultsTrue<
     T["strict"],
-        O["type"] extends "string" ? string : O["type"] extends "boolean" ? boolean : string | boolean,
+    O["type"] extends "string"
+      ? string
+      : O["type"] extends "boolean"
+        ? boolean
+        : string | boolean,
     string | boolean
   >;
 
-    type ParsedValues<T extends ParseArgsConfig> =
+  type ParsedValues<T extends ParseArgsConfig> = IfDefaultsTrue<
-        & IfDefaultsTrue<T["strict"], unknown, { [longOption: string]: undefined | string | boolean }>
+    T["strict"],
-        & (T["options"] extends ParseArgsOptionsConfig ? {
+    unknown,
+    { [longOption: string]: undefined | string | boolean }
+  > &
+    (T["options"] extends ParseArgsOptionsConfig
+      ? {
           -readonly [LongOption in keyof T["options"]]: IfDefaultsFalse<
             T["options"][LongOption]["multiple"],
             undefined | Array<ExtractOptionValue<T, T["options"][LongOption]>>,
@@ -1423,7 +1562,8 @@ declare module "util" {
   type PreciseTokenForOptions<
     K extends string,
     O extends ParseArgsOptionConfig,
-    > = O["type"] extends "string" ? {
+  > = O["type"] extends "string"
+    ? {
         kind: "option";
         index: number;
         name: K;
@@ -1431,7 +1571,8 @@ declare module "util" {
         value: string;
         inlineValue: boolean;
       }
-        : O["type"] extends "boolean" ? {
+    : O["type"] extends "boolean"
+      ? {
           kind: "option";
           index: number;
           name: K;
@@ -1445,20 +1586,35 @@ declare module "util" {
     T extends ParseArgsConfig,
     K extends keyof T["options"] = keyof T["options"],
   > = K extends unknown
-        ? T["options"] extends ParseArgsOptionsConfig ? PreciseTokenForOptions<K & string, T["options"][K]>
+    ? T["options"] extends ParseArgsOptionsConfig
+      ? PreciseTokenForOptions<K & string, T["options"][K]>
       : OptionToken
     : never;
 
-    type ParsedOptionToken<T extends ParseArgsConfig> = IfDefaultsTrue<T["strict"], TokenForOptions<T>, OptionToken>;
+  type ParsedOptionToken<T extends ParseArgsConfig> = IfDefaultsTrue<
+    T["strict"],
+    TokenForOptions<T>,
+    OptionToken
+  >;
 
   type ParsedPositionalToken<T extends ParseArgsConfig> = IfDefaultsTrue<
     T["strict"],
-        IfDefaultsFalse<T["allowPositionals"], { kind: "positional"; index: number; value: string }, never>,
+    IfDefaultsFalse<
-        IfDefaultsTrue<T["allowPositionals"], { kind: "positional"; index: number; value: string }, never>
+      T["allowPositionals"],
+      { kind: "positional"; index: number; value: string },
+      never
+    >,
+    IfDefaultsTrue<
+      T["allowPositionals"],
+      { kind: "positional"; index: number; value: string },
+      never
+    >
   >;
 
   type ParsedTokens<T extends ParseArgsConfig> = Array<
-        ParsedOptionToken<T> | ParsedPositionalToken<T> | { kind: "option-terminator"; index: number }
+    | ParsedOptionToken<T>
+    | ParsedPositionalToken<T>
+    | { kind: "option-terminator"; index: number }
   >;
 
   type PreciseParsedResults<T extends ParseArgsConfig> = IfDefaultsFalse<
@@ -1475,7 +1631,14 @@ declare module "util" {
   >;
 
   type OptionToken =
-        | { kind: "option"; index: number; name: string; rawName: string; value: string; inlineValue: boolean }
+    | {
+        kind: "option";
+        index: number;
+        name: string;
+        rawName: string;
+        value: string;
+        inlineValue: boolean;
+      }
     | {
         kind: "option";
         index: number;
@@ -1492,9 +1655,14 @@ declare module "util" {
 
   // If ParseArgsConfig extends T, then the user passed config constructed elsewhere.
   // So we can't rely on the `"not definitely present" implies "definitely not present"` assumption mentioned above.
-    type ParsedResults<T extends ParseArgsConfig> = ParseArgsConfig extends T ? {
+  type ParsedResults<T extends ParseArgsConfig> = ParseArgsConfig extends T
+    ? {
         values: {
-                [longOption: string]: undefined | string | boolean | Array<string | boolean>;
+          [longOption: string]:
+            | undefined
+            | string
+            | boolean
+            | Array<string | boolean>;
         };
         positionals: string[];
         tokens?: Token[];
@@ -1754,7 +1922,7 @@ declare module "util/types" {
    * ```
    * @since v10.0.0
    */
-    function isBooleanObject(object: unknown): object is Boolean;
+  function isBooleanObject(object: unknown): object is boolean;
   /**
    * Returns `true` if the value is any boxed primitive object, e.g. created
    * by `new Boolean()`, `new String()` or `Object(Symbol())`.
@@ -1770,7 +1938,9 @@ declare module "util/types" {
    * ```
    * @since v10.11.0
    */
-    function isBoxedPrimitive(object: unknown): object is String | Number | BigInt | Boolean | Symbol;
+  function isBoxedPrimitive(
+    object: unknown,
+  ): object is string | number | bigint | boolean | symbol;
   /**
    * Returns `true` if the value is a built-in [`DataView`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView) instance.
    *
@@ -1924,7 +2094,10 @@ declare module "util/types" {
    */
   function isMap<T>(
     object: T | {},
-    ): object is T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>)
+  ): object is T extends ReadonlyMap<any, any>
+    ? unknown extends T
+      ? never
+      : ReadonlyMap<any, any>
     : Map<unknown, unknown>;
   /**
    * Returns `true` if the value is an iterator returned for a built-in [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) instance.
@@ -1999,7 +2172,7 @@ declare module "util/types" {
    * ```
    * @since v10.0.0
    */
-    function isNumberObject(object: unknown): object is Number;
+  function isNumberObject(object: unknown): object is number;
   /**
    * Returns `true` if the value is a built-in [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
    *
@@ -2041,7 +2214,11 @@ declare module "util/types" {
    */
   function isSet<T>(
     object: T | {},
-    ): object is T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>;
+  ): object is T extends ReadonlySet<any>
+    ? unknown extends T
+      ? never
+      : ReadonlySet<any>
+    : Set<unknown>;
   /**
    * Returns `true` if the value is an iterator returned for a built-in [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) instance.
    *
@@ -2077,7 +2254,7 @@ declare module "util/types" {
    * ```
    * @since v10.0.0
    */
-    function isStringObject(object: unknown): object is String;
+  function isStringObject(object: unknown): object is string;
   /**
    * Returns `true` if the value is a symbol object, created
    * by calling `Object()` on a `Symbol` primitive.
@@ -2089,7 +2266,7 @@ declare module "util/types" {
    * ```
    * @since v10.0.0
    */
-    function isSymbolObject(object: unknown): object is Symbol;
+  function isSymbolObject(object: unknown): object is symbol;
   /**
    * Returns `true` if the value is a built-in [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) instance.
    *