@pezkuwi/typegen 16.5.5 → 16.5.6

package/util/imports.js

@@ -0,0 +1,121 @@
+import * as codecClasses from '@pezkuwi/types/codec';
+import * as extrinsicClasses from '@pezkuwi/types/extrinsic';
+import * as genericClasses from '@pezkuwi/types/generic';
+import * as primitiveClasses from '@pezkuwi/types/primitive';
+import { getTypeDef, TypeDefInfo } from '@pezkuwi/types-create';
+function splitAlternatives(type) {
+    const alternatives = [];
+    let beginOfAlternative = 1;
+    let level = 0;
+    // we assume that the string starts with '['
+    for (let i = 1, count = type.length; i < count; i++) {
+        if (level === 0) {
+            switch (type[i]) {
+                case ']':
+                case ',':
+                case '|':
+                    alternatives.push(type.substring(beginOfAlternative, i).trim());
+                    beginOfAlternative = i + 1;
+                    break;
+            }
+        }
+        switch (type[i]) {
+            case '[':
+            case '(':
+            case '<':
+                level++;
+                break;
+            case ']':
+            case ')':
+            case '>':
+                level--;
+                break;
+        }
+    }
+    return alternatives;
+}
+/** @internal */
+export function setImports(allDefs, imports, types) {
+    const { codecTypes, extrinsicTypes, genericTypes, ignoredTypes, localTypes, metadataTypes, primitiveTypes, typesTypes } = imports;
+    types.filter((t) => !!t).forEach((type) => {
+        if (ignoredTypes.includes(type)) {
+            // do nothing
+        }
+        else if (['AnyNumber', 'CallFunction', 'Codec', 'IExtrinsic', 'IMethod', 'ITuple'].includes(type)) {
+            typesTypes[type] = true;
+        }
+        else if (['Metadata', 'PortableRegistry'].includes(type)) {
+            metadataTypes[type] = true;
+        }
+        else if (codecClasses[type]) {
+            codecTypes[type] = true;
+        }
+        else if (extrinsicClasses[type]) {
+            extrinsicTypes[type] = true;
+        }
+        else if (genericClasses[type]) {
+            genericTypes[type] = true;
+        }
+        else if (primitiveClasses[type]) {
+            primitiveTypes[type] = true;
+        }
+        else if (type.startsWith('[') && type.includes('|')) {
+            const splitTypes = splitAlternatives(type);
+            setImports(allDefs, imports, splitTypes);
+        }
+        else if (type.includes('<') || type.includes('(') || type.includes('[')) {
+            // If the type is a bit special (tuple, fixed u8, nested type...), then we
+            // need to parse it with `getTypeDef`.
+            const typeDef = getTypeDef(type);
+            setImports(allDefs, imports, [TypeDefInfo[typeDef.info]]);
+            // TypeDef.sub is a `TypeDef | TypeDef[]`
+            if (Array.isArray(typeDef.sub)) {
+                typeDef.sub.forEach((subType) => setImports(allDefs, imports, [subType.lookupName || subType.type]));
+            }
+            else if (typeDef.sub && (typeDef.info !== TypeDefInfo.VecFixed || typeDef.sub.type !== 'u8')) {
+                // typeDef.sub is a TypeDef in this case
+                setImports(allDefs, imports, [typeDef.sub.lookupName || typeDef.sub.type]);
+            }
+        }
+        else {
+            // find this module inside the exports from the rest
+            const [moduleName] = Object.entries(allDefs).find(([, { types }]) => Object.keys(types).includes(type)) || [null];
+            if (moduleName) {
+                localTypes[moduleName][type] = true;
+            }
+        }
+    });
+}
+/** @internal */
+export function createImports(importDefinitions, { types } = { types: {} }) {
+    const definitions = {};
+    const typeToModule = {};
+    Object.entries(importDefinitions).forEach(([packagePath, packageDef]) => {
+        Object.entries(packageDef).forEach(([name, moduleDef]) => {
+            const fullName = `${packagePath}/${name}`;
+            definitions[fullName] = moduleDef;
+            Object.keys(moduleDef.types).forEach((type) => {
+                if (typeToModule[type]) {
+                    console.warn(`\t\tWARN: Overwriting duplicated type '${type}' ${typeToModule[type]} -> ${fullName}`);
+                }
+                typeToModule[type] = fullName;
+            });
+        });
+    });
+    return {
+        codecTypes: {},
+        definitions,
+        extrinsicTypes: {},
+        genericTypes: {},
+        ignoredTypes: Object.keys(types),
+        localTypes: Object.keys(definitions).reduce((local, mod) => {
+            local[mod] = {};
+            return local;
+        }, {}),
+        lookupTypes: {},
+        metadataTypes: {},
+        primitiveTypes: {},
+        typeToModule,
+        typesTypes: {}
+    };
+}

package/{src/util/index.ts → util/index.d.ts}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export * from './assert.js';
 export * from './derived.js';
 export * from './docs.js';
@@ -10,9 +7,10 @@ export * from './imports.js';
 export * from './initMeta.js';
 export * from './register.js';
 export * from './wsMeta.js';
-
-interface Cmp { name: { toString(): string } }
-
-export function compareName (a: Cmp, b: Cmp): number {
-  return a.name.toString().localeCompare(b.name.toString());
+interface Cmp {
+    name: {
+        toString(): string;
+    };
 }
+export declare function compareName(a: Cmp, b: Cmp): number;
+export declare function rebrandTypeName(typeName: string): string;

package/util/index.js

@@ -0,0 +1,34 @@
+export * from './assert.js';
+export * from './derived.js';
+export * from './docs.js';
+export * from './file.js';
+export * from './formatting.js';
+export * from './imports.js';
+export * from './initMeta.js';
+export * from './register.js';
+export * from './wsMeta.js';
+export function compareName(a, b) {
+    return a.name.toString().localeCompare(b.name.toString());
+}
+export function rebrandTypeName(typeName) {
+    return typeName
+        // Main projects
+        .replace(/Polkadot/g, 'Pezkuwi')
+        .replace(/Substrate/g, 'Bizinikiwi')
+        .replace(/Cumulus/g, 'Pezcumulus')
+        // Networks
+        .replace(/Kusama/g, 'Dicle')
+        .replace(/Westend/g, 'Zagros')
+        .replace(/Rococo/g, 'Pezkuwichain')
+        // Chain types
+        .replace(/Parachain/g, 'Teyrchain')
+        // Module prefixes (in PascalCase type names)
+        .replace(/Frame(?=[A-Z])/g, 'Pezframe')
+        .replace(/Pallet(?=[A-Z])/g, 'Pezpallet')
+        // Primitives prefixes (sp_ becomes Sp in type names)
+        .replace(/^Sp(?=[A-Z])/g, 'Pezsp')
+        .replace(/([^a-zA-Z])Sp(?=[A-Z])/g, '$1Pezsp')
+        // Client prefixes (sc_ becomes Sc in type names)
+        .replace(/^Sc(?=[A-Z])/g, 'Pezsc')
+        .replace(/([^a-zA-Z])Sc(?=[A-Z])/g, '$1Pezsc');
+}

package/util/initMeta.d.ts

@@ -0,0 +1,12 @@
+import type { HexString } from '@pezkuwi/util/types';
+import type { ExtraTypes } from '../generate/types.js';
+import { Metadata, TypeRegistry } from '@pezkuwi/types';
+interface Result {
+    metadata: Metadata;
+    registry: TypeRegistry;
+}
+/**
+ * This helper method has been transitioned to work with V14, V15 and up.
+ */
+export declare function initMeta(staticMeta: HexString, extraTypes?: ExtraTypes): Result;
+export {};

package/util/initMeta.js

@@ -0,0 +1,19 @@
+import { Metadata, TypeRegistry } from '@pezkuwi/types';
+import { registerDefinitions } from './register.js';
+/**
+ * This helper method has been transitioned to work with V14, V15 and up.
+ */
+export function initMeta(staticMeta, extraTypes = {}) {
+    const registry = new TypeRegistry();
+    registerDefinitions(registry, extraTypes);
+    let metadata;
+    try {
+        const opaqueMetadata = registry.createType('Option<OpaqueMetadata>', registry.createType('Raw', staticMeta).toU8a()).unwrap();
+        metadata = new Metadata(registry, opaqueMetadata.toHex());
+    }
+    catch {
+        metadata = new Metadata(registry, staticMeta);
+    }
+    registry.setMetadata(metadata);
+    return { metadata, registry };
+}

package/util/register.d.ts

@@ -0,0 +1,4 @@
+import type { TypeRegistry } from '@pezkuwi/types/create';
+export declare function registerDefinitions(registry: TypeRegistry, extras: Record<string, Record<string, {
+    types: Record<string, any>;
+}>>): void;

package/util/register.js

@@ -0,0 +1,7 @@
+export function registerDefinitions(registry, extras) {
+    Object.values(extras).forEach((def) => {
+        Object.values(def).forEach(({ types }) => {
+            registry.register(types);
+        });
+    });
+}

package/util/wsMeta.d.ts

@@ -0,0 +1,4 @@
+import type { HexString } from '@pezkuwi/util/types';
+export declare function getMetadataViaWs(endpoint: string, metadataVer?: number): Promise<HexString>;
+export declare function getRpcMethodsViaWs(endpoint: string): Promise<string[]>;
+export declare function getRuntimeVersionViaWs(endpoint: string): Promise<[apiHash: string, apiVersion: number][]>;

package/util/wsMeta.js

@@ -0,0 +1,55 @@
+import { promiseTracker } from '@pezkuwi/api/promise/decorateMethod';
+import { TypeRegistry } from '@pezkuwi/types';
+import { stringify, u8aToHex } from '@pezkuwi/util';
+import { WebSocket } from '@pezkuwi/x-ws';
+async function getWsData(endpoint, method, params) {
+    return new Promise((resolve, reject) => {
+        const tracker = promiseTracker(resolve, reject);
+        try {
+            const websocket = new WebSocket(endpoint);
+            websocket.onclose = (event) => {
+                if (event.code !== 1000) {
+                    tracker.reject(new Error(`disconnected, code: '${event.code}' reason: '${event.reason}'`));
+                }
+            };
+            websocket.onerror = (event) => {
+                tracker.reject(new Error(`WebSocket error:: ${stringify(event)}`));
+            };
+            websocket.onopen = () => {
+                console.log('connected');
+                params
+                    ? websocket.send(`{"id":"1","jsonrpc":"2.0","method":"${method}","params":[${params.map((param) => `"${param}"`).join(',')}]}`)
+                    : websocket.send(`{"id":"1","jsonrpc":"2.0","method":"${method}","params":[]}`);
+            };
+            websocket.onmessage = (message) => {
+                try {
+                    tracker.resolve(JSON.parse(message.data).result);
+                }
+                catch (error) {
+                    tracker.reject(error);
+                }
+                websocket.close();
+            };
+        }
+        catch (error) {
+            tracker.reject(error);
+        }
+    });
+}
+export async function getMetadataViaWs(endpoint, metadataVer) {
+    const registry = new TypeRegistry();
+    if (metadataVer) {
+        return await getWsData(endpoint, 'state_call', ['Metadata_metadata_at_version', u8aToHex(registry.createType('u32', metadataVer).toU8a())]);
+    }
+    else {
+        return await getWsData(endpoint, 'state_getMetadata');
+    }
+}
+export async function getRpcMethodsViaWs(endpoint) {
+    const result = await getWsData(endpoint, 'rpc_methods');
+    return result.methods;
+}
+export async function getRuntimeVersionViaWs(endpoint) {
+    const result = await getWsData(endpoint, 'state_getRuntimeVersion');
+    return result.apis;
+}

package/build/scripts/polkadot-types-chain-info.mjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { main } from '@pezkuwi/typegen/extractChain';
-
-main();

package/build/scripts/polkadot-types-from-chain.mjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { main } from '@pezkuwi/typegen/fromChain';
-
-main();

package/build/scripts/polkadot-types-from-defs.mjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { main } from '@pezkuwi/typegen/fromDefs';
-
-main();

package/scripts/polkadot-types-internal-interfaces.mjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { main } from '@pezkuwi/typegen/interfacesTs';
-
-main();

package/scripts/polkadot-types-internal-metadata.mjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { main } from '@pezkuwi/typegen/metadataMd';
-
-main();

package/src/augment.ts

@@ -1,5 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import '@pezkuwi/api-augment';
-import '@pezkuwi/rpc-augment';

package/src/bundle.ts

@@ -1,5 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { packageInfo } from './packageInfo.js';
-export { formatType } from './util/formatting.js';

package/src/extractChain.ts

@@ -1,54 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// Connects to the local chain and outputs a re-usable calls-only chain definition in  the form
-// export default { chain: 'Development', genesisHash: '0x27b6d5e0f4fdce1c4d20b82406f193acacce0c19e0d2c0e7ca47725c2572a06a', ss58Format: 42, tokenDecimals: 0, tokenSymbol: 'UNIT'; metaCalls: 'bWV0...4AAA==' };
-
-import process from 'node:process';
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
-
-import { ApiPromise, WsProvider } from '@pezkuwi/api';
-
-/** @internal */
-async function run (ws: string): Promise<void> {
-  const provider = new WsProvider(ws);
-  const api = await ApiPromise.create({ provider, throwOnConnect: true });
-  const [chain, props] = await Promise.all([
-    api.rpc.system.chain(),
-    api.rpc.system.properties()
-  ]);
-
-  // output the chain info, for easy re-use
-  console.error(`// Generated via 'yarn run chain:info ${ws}'\n\nexport default {\n  chain: '${chain.toString()}',\n  genesisHash: '${api.genesisHash.toHex()}',\n  specVersion: ${api.runtimeVersion.specVersion.toNumber()},\n  ss58Format: ${props.ss58Format.unwrapOr(42).toString()},\n  tokenDecimals: ${props.tokenDecimals.unwrapOr(0).toString()},\n  tokenSymbol: '${props.tokenSymbol.unwrapOr('UNIT').toString()}',\n  metaCalls: '${Buffer.from(api.runtimeMetadata.asCallsOnly.toU8a()).toString('base64')}'\n};`);
-
-  // show any missing types
-  api.runtimeMetadata.getUniqTypes(false);
-}
-
-interface ArgV { ws: string }
-
-export function main (): void {
-  // retrieve and parse arguments - we do this globally, since this is a single command
-  const { ws } = yargs(hideBin(process.argv))
-    .usage('Usage: [options]')
-    .wrap(120)
-    .strict()
-    .options({
-      ws: {
-        default: 'ws://127.0.0.1:9944',
-        description: 'The API endpoint to connect to, e.g. wss://kusama-rpc.polkadot.io',
-        required: true,
-        type: 'string'
-      }
-    }).argv as ArgV;
-
-  run(ws)
-    .then((): void => {
-      process.exit(0);
-    })
-    .catch((error: Error) => {
-      console.error('FATAL:', error.message);
-      process.exit(-1);
-    });
-}

package/src/fromChain.ts

@@ -1,123 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Definitions, DefinitionsTypes } from '@pezkuwi/types/types';
-import type { HexString } from '@pezkuwi/util/types';
-
-import fs from 'node:fs';
-import path from 'node:path';
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
-
-import { formatNumber, isHex } from '@pezkuwi/util';
-
-import { generateDefaultConsts, generateDefaultErrors, generateDefaultEvents, generateDefaultQuery, generateDefaultRpc, generateDefaultRuntime, generateDefaultTx } from './generate/index.js';
-import { assertDir, assertFile, getMetadataViaWs, HEADER, writeFile } from './util/index.js';
-
-async function generate (metaHex: HexString, pkg: string | undefined, output: string, isStrict?: boolean): Promise<void> {
-  console.log(`Generating from metadata, ${formatNumber((metaHex.length - 2) / 2)} bytes`);
-
-  const outputPath = assertDir(path.join(process.cwd(), output));
-  let extraTypes: Record<string, any> = {};
-  let customLookupDefinitions: Definitions = { rpc: {}, types: {} };
-
-  if (pkg) {
-    try {
-      const defCont = await import(
-        assertFile(path.join(outputPath, 'definitions.ts'))
-      ) as Record<string, any>;
-
-      extraTypes = {
-        [pkg]: defCont
-      };
-    } catch (error) {
-      console.error('ERROR: No custom definitions found:', (error as Error).message);
-    }
-  }
-
-  try {
-    const lookCont = await import(
-      assertFile(path.join(outputPath, 'lookup.ts'))
-    ) as { default: DefinitionsTypes };
-
-    customLookupDefinitions = {
-      rpc: {},
-      types: lookCont.default
-    };
-  } catch (error) {
-    console.error('ERROR: No lookup definitions found:', (error as Error).message);
-  }
-
-  generateDefaultConsts(path.join(outputPath, 'augment-api-consts.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
-  generateDefaultErrors(path.join(outputPath, 'augment-api-errors.ts'), metaHex, extraTypes, isStrict);
-  generateDefaultEvents(path.join(outputPath, 'augment-api-events.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
-  generateDefaultQuery(path.join(outputPath, 'augment-api-query.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
-  generateDefaultRpc(path.join(outputPath, 'augment-api-rpc.ts'), extraTypes);
-  generateDefaultRuntime(path.join(outputPath, 'augment-api-runtime.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
-  generateDefaultTx(path.join(outputPath, 'augment-api-tx.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
-
-  writeFile(path.join(outputPath, 'augment-api.ts'), (): string =>
-    [
-      HEADER('chain'),
-      ...[
-        ...['consts', 'errors', 'events', 'query', 'tx', 'rpc', 'runtime']
-          .filter((key) => !!key)
-          .map((key) => `./augment-api-${key}.js`)
-      ].map((path) => `import '${path}';\n`)
-    ].join('')
-  );
-
-  process.exit(0);
-}
-
-interface ArgV { endpoint: string; output: string; package?: string; strict?: boolean }
-
-async function mainPromise (): Promise<void> {
-  const { endpoint, output, package: pkg, strict: isStrict } = yargs(hideBin(process.argv)).strict().options({
-    endpoint: {
-      description: 'The endpoint to connect to (e.g. wss://kusama-rpc.polkadot.io) or relative path to a file containing the JSON output of an RPC state_getMetadata call',
-      required: true,
-      type: 'string'
-    },
-    output: {
-      description: 'The target directory to write the data to',
-      required: true,
-      type: 'string'
-    },
-    package: {
-      description: 'Optional package in output location (for extra definitions)',
-      type: 'string'
-    },
-    strict: {
-      description: 'Turns on strict mode, no output of catch-all generic versions',
-      type: 'boolean'
-    }
-  }).argv as ArgV;
-
-  let metaHex: HexString;
-
-  if (endpoint.startsWith('wss://') || endpoint.startsWith('ws://')) {
-    metaHex = await getMetadataViaWs(endpoint);
-  } else {
-    metaHex = (
-      JSON.parse(
-        fs.readFileSync(assertFile(path.join(process.cwd(), endpoint)), 'utf-8')
-      ) as { result: HexString }
-    ).result;
-
-    if (!isHex(metaHex)) {
-      throw new Error('Invalid metadata file');
-    }
-  }
-
-  await generate(metaHex, pkg, output, isStrict);
-}
-
-export function main (): void {
-  mainPromise().catch((error) => {
-    console.error();
-    console.error(error);
-    console.error();
-    process.exit(1);
-  });
-}

package/src/fromDefs.ts

@@ -1,106 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from '@pezkuwi/util/types';
-
-import fs from 'node:fs';
-import path from 'node:path';
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
-
-import * as substrateDefs from '@pezkuwi/types/interfaces/definitions';
-import { isHex } from '@pezkuwi/util';
-
-import { generateDefaultLookup } from './generate/index.js';
-import { generateInterfaceTypes } from './generate/interfaceRegistry.js';
-import { generateTsDef } from './generate/tsDef.js';
-import { assertDir, assertFile, getMetadataViaWs } from './util/index.js';
-
-interface ArgV { input: string; package: string; endpoint?: string; }
-
-async function mainPromise (): Promise<void> {
-  const { endpoint, input, package: pkg } = yargs(hideBin(process.argv)).strict().options({
-    endpoint: {
-      description: 'The endpoint to connect to (e.g. wss://kusama-rpc.polkadot.io) or relative path to a file containing the JSON output of an RPC state_getMetadata call',
-      type: 'string'
-    },
-    input: {
-      description: 'The directory to use for the user definitions',
-      required: true,
-      type: 'string'
-    },
-    package: {
-      description: 'The package name & path to use for the user types',
-      required: true,
-      type: 'string'
-    }
-  }).argv as ArgV;
-
-  const inputPath = assertDir(path.join(process.cwd(), input));
-  let userDefs: Record<string, any> = {};
-
-  try {
-    const defCont = await import(
-      assertFile(path.join(inputPath, 'definitions.ts'))
-    ) as Record<string, any>;
-
-    userDefs = defCont;
-  } catch (error) {
-    console.error('ERROR: Unable to load user definitions:', (error as Error).message);
-  }
-
-  const userKeys = Object.keys(userDefs);
-  const filteredBase = Object
-    .entries(substrateDefs as Record<string, unknown>)
-    .filter(([key]) => {
-      if (userKeys.includes(key)) {
-        console.warn(`Override found for ${key} in user types, ignoring in @polkadot/types`);
-
-        return false;
-      }
-
-      return true;
-    })
-    .reduce((defs: Record<string, any>, [key, value]) => {
-      defs[key] = value;
-
-      return defs;
-    }, {});
-
-  const allDefs = {
-    '@pezkuwi/types/interfaces': filteredBase,
-    [pkg]: userDefs
-  };
-
-  generateTsDef(allDefs, inputPath, pkg);
-  generateInterfaceTypes(allDefs, path.join(inputPath, 'augment-types.ts'));
-
-  if (endpoint) {
-    let metaHex: HexString;
-
-    if (endpoint.startsWith('wss://') || endpoint.startsWith('ws://')) {
-      metaHex = await getMetadataViaWs(endpoint);
-    } else {
-      metaHex = (
-        JSON.parse(
-          fs.readFileSync(assertFile(path.join(process.cwd(), endpoint)), 'utf-8')
-        ) as { result: HexString }
-      ).result;
-
-      if (!isHex(metaHex)) {
-        throw new Error('Invalid metadata file');
-      }
-    }
-
-    generateDefaultLookup(inputPath, metaHex);
-  }
-}
-
-export function main (): void {
-  mainPromise().catch((error) => {
-    console.error();
-    console.error(error);
-    console.error();
-    process.exit(1);
-  });
-}