@duplojs/http 0.4.0 → 0.5.0

package/dist/core/steps/presetChecker.d.ts

@@ -2,9 +2,11 @@ import { type Kind } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
 import { type PresetChecker } from "../presetChecker";
+import { type Metadata } from "../metadata";
 export interface PresetCheckerStepDefinition {
     readonly presetChecker: PresetChecker;
     input(input: Floor): unknown;
+    readonly metadata: readonly Metadata[];
 }
 export declare const presetCheckerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>>;
 export type _PresetCheckerStep = (Kind<typeof presetCheckerStepKind.definition> & StepKind);

package/dist/core/steps/process.d.ts

@@ -1,10 +1,12 @@
 import { type Kind } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Process } from "../process";
+import { type Metadata } from "../metadata";
 export interface ProcessStepDefinition {
     readonly process: Process;
     readonly options?: Record<string, unknown> | ((input: any) => Record<string, unknown>);
     readonly imports?: readonly string[];
+    readonly metadata: readonly Metadata[];
 }
 export declare const processStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>;
 export type _ProcessStep = (Kind<typeof processStepKind.definition> & StepKind);

package/dist/plugins/codeGenerator/{stepsToDataParser.cjs → aggregateStepContract.cjs}

@@ -2,6 +2,8 @@
 
 require('../../core/steps/index.cjs');
 var utils = require('@duplojs/utils');
+var metadata = require('./metadata.cjs');
+var identifier = require('../../core/steps/identifier.cjs');
 var process = require('../../core/steps/process.cjs');
 var extract = require('../../core/steps/extract.cjs');
 var presetChecker = require('../../core/steps/presetChecker.cjs');
@@ -9,12 +11,13 @@ var checker = require('../../core/steps/checker.cjs');
 var cut = require('../../core/steps/cut.cjs');
 var handler = require('../../core/steps/handler.cjs');
 
-function stepsToDataParser(steps, params) {
-    const processContracts = utils.pipe(steps, utils.A.filter(process.processStepKind.has), utils.A.map((element) => stepsToDataParser(element.definition.process.definition.steps, params)), utils.O.to({
+function aggregateStepContract(steps, params) {
+    const filteredStep = utils.A.filter(steps, (step) => utils.A.find(step.definition.metadata, metadata.IgnoreByCodeGeneratorMetadata.is) === undefined);
+    const processContracts = utils.pipe(filteredStep, utils.A.filter(identifier.stepIdentifier(process.processStepKind)), utils.A.filter((step) => utils.A.find(step.definition.process.definition.metadata, metadata.IgnoreByCodeGeneratorMetadata.is) === undefined), utils.A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), utils.O.to({
         entrypointContract: utils.A.map((result) => result.entrypointContract),
         endpointContract: utils.A.flatMap((result) => result.endpointContract),
     }));
-    const entrypointContract = utils.pipe(steps, utils.A.filter(extract.extractStepKind.has), utils.A.map((extractStep) => extractStep.definition.shape), utils.A.concat(processContracts.entrypointContract), utils.A.reduce(utils.A.reduceFrom({
+    const entrypointContract = utils.pipe(filteredStep, utils.A.filter(extract.extractStepKind.has), utils.A.map((extractStep) => extractStep.definition.shape), utils.A.concat(processContracts.entrypointContract), utils.A.reduce(utils.A.reduceFrom({
         body: {},
         headers: {},
         params: {},
@@ -43,7 +46,7 @@ function stepsToDataParser(steps, params) {
         }
         return utils.O.entry(key, currentExtractDataParser);
     }), utils.O.fromEntries, (object) => nextWithObject(lastValue, object))));
-    const endpointContract = utils.pipe(steps, utils.A.flatMap((step) => utils.P.match(step)
+    const endpointContract = utils.pipe(filteredStep, utils.A.flatMap((step) => utils.P.match(step)
         .when(process.processStepKind.has, () => [])
         .when(extract.extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
         .when(presetChecker.presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)
@@ -63,4 +66,4 @@ function stepsToDataParser(steps, params) {
     };
 }
 
-exports.stepsToDataParser = stepsToDataParser;
+exports.aggregateStepContract = aggregateStepContract;

package/dist/plugins/codeGenerator/{stepsToDataParser.d.ts → aggregateStepContract.d.ts}

@@ -10,5 +10,5 @@ export interface StepsToDataParserResult {
     entrypointContract: EntrypointReduceResult;
     endpointContract: DP.DataParser[];
 }
-export declare function stepsToDataParser(steps: readonly Steps[], params: StepsToDataParserParams): StepsToDataParserResult;
+export declare function aggregateStepContract(steps: readonly Steps[], params: StepsToDataParserParams): StepsToDataParserResult;
 export {};

package/dist/plugins/codeGenerator/{stepsToDataParser.mjs → aggregateStepContract.mjs}

@@ -1,5 +1,7 @@
 import '../../core/steps/index.mjs';
-import { pipe, A, O, DP, P, hasSomeKinds } from '@duplojs/utils';
+import { A, pipe, O, DP, P, hasSomeKinds } from '@duplojs/utils';
+import { IgnoreByCodeGeneratorMetadata } from './metadata.mjs';
+import { stepIdentifier } from '../../core/steps/identifier.mjs';
 import { processStepKind } from '../../core/steps/process.mjs';
 import { extractStepKind } from '../../core/steps/extract.mjs';
 import { presetCheckerStepKind } from '../../core/steps/presetChecker.mjs';
@@ -7,12 +9,13 @@ import { checkerStepKind } from '../../core/steps/checker.mjs';
 import { cutStepKind } from '../../core/steps/cut.mjs';
 import { handlerStepKind } from '../../core/steps/handler.mjs';
 
-function stepsToDataParser(steps, params) {
-    const processContracts = pipe(steps, A.filter(processStepKind.has), A.map((element) => stepsToDataParser(element.definition.process.definition.steps, params)), O.to({
+function aggregateStepContract(steps, params) {
+    const filteredStep = A.filter(steps, (step) => A.find(step.definition.metadata, IgnoreByCodeGeneratorMetadata.is) === undefined);
+    const processContracts = pipe(filteredStep, A.filter(stepIdentifier(processStepKind)), A.filter((step) => A.find(step.definition.process.definition.metadata, IgnoreByCodeGeneratorMetadata.is) === undefined), A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), O.to({
         entrypointContract: A.map((result) => result.entrypointContract),
         endpointContract: A.flatMap((result) => result.endpointContract),
     }));
-    const entrypointContract = pipe(steps, A.filter(extractStepKind.has), A.map((extractStep) => extractStep.definition.shape), A.concat(processContracts.entrypointContract), A.reduce(A.reduceFrom({
+    const entrypointContract = pipe(filteredStep, A.filter(extractStepKind.has), A.map((extractStep) => extractStep.definition.shape), A.concat(processContracts.entrypointContract), A.reduce(A.reduceFrom({
         body: {},
         headers: {},
         params: {},
@@ -41,7 +44,7 @@ function stepsToDataParser(steps, params) {
         }
         return O.entry(key, currentExtractDataParser);
     }), O.fromEntries, (object) => nextWithObject(lastValue, object))));
-    const endpointContract = pipe(steps, A.flatMap((step) => P.match(step)
+    const endpointContract = pipe(filteredStep, A.flatMap((step) => P.match(step)
         .when(processStepKind.has, () => [])
         .when(extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
         .when(presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)
@@ -61,4 +64,4 @@ function stepsToDataParser(steps, params) {
     };
 }
 
-export { stepsToDataParser };
+export { aggregateStepContract };

package/dist/plugins/codeGenerator/index.cjs

@@ -4,10 +4,12 @@ require('@duplojs/data-parser-tools/toTypescript');
 require('./types/index.cjs');
 var plugin = require('./plugin.cjs');
 var routeToDataParser = require('./routeToDataParser.cjs');
-var stepsToDataParser = require('./stepsToDataParser.cjs');
+var aggregateStepContract = require('./aggregateStepContract.cjs');
+var metadata = require('./metadata.cjs');
 
 
 
 exports.codeGeneratorPlugin = plugin.codeGeneratorPlugin;
 exports.routeToDataParser = routeToDataParser.routeToDataParser;
-exports.stepsToDataParser = stepsToDataParser.stepsToDataParser;
+exports.aggregateStepContract = aggregateStepContract.aggregateStepContract;
+exports.IgnoreByCodeGeneratorMetadata = metadata.IgnoreByCodeGeneratorMetadata;

package/dist/plugins/codeGenerator/index.d.ts

@@ -2,4 +2,5 @@ import "@duplojs/data-parser-tools/toTypescript";
 export * from "./types";
 export * from "./plugin";
 export * from "./routeToDataParser";
-export * from "./stepsToDataParser";
+export * from "./aggregateStepContract";
+export * from "./metadata";

package/dist/plugins/codeGenerator/index.mjs

@@ -2,4 +2,5 @@ import '@duplojs/data-parser-tools/toTypescript';
 import './types/index.mjs';
 export { codeGeneratorPlugin } from './plugin.mjs';
 export { routeToDataParser } from './routeToDataParser.mjs';
-export { stepsToDataParser } from './stepsToDataParser.mjs';
+export { aggregateStepContract } from './aggregateStepContract.mjs';
+export { IgnoreByCodeGeneratorMetadata } from './metadata.mjs';

package/dist/plugins/codeGenerator/metadata.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+require('../../core/metadata/index.cjs');
+var base = require('../../core/metadata/base.cjs');
+
+const IgnoreByCodeGeneratorMetadata = base.createMetadata("ignore-by-code-generator");
+
+exports.IgnoreByCodeGeneratorMetadata = IgnoreByCodeGeneratorMetadata;

package/dist/plugins/codeGenerator/metadata.d.ts

@@ -0,0 +1 @@
+export declare const IgnoreByCodeGeneratorMetadata: import("../../core/metadata").MetadataHandler<"ignore-by-code-generator", unknown>;

package/dist/plugins/codeGenerator/metadata.mjs

@@ -0,0 +1,6 @@
+import '../../core/metadata/index.mjs';
+import { createMetadata } from '../../core/metadata/base.mjs';
+
+const IgnoreByCodeGeneratorMetadata = createMetadata("ignore-by-code-generator");
+
+export { IgnoreByCodeGeneratorMetadata };

package/dist/plugins/codeGenerator/routeToDataParser.cjs

@@ -1,13 +1,18 @@
 'use strict';
 
-var stepsToDataParser = require('./stepsToDataParser.cjs');
+var aggregateStepContract = require('./aggregateStepContract.cjs');
 var utils = require('@duplojs/utils');
+var metadata = require('./metadata.cjs');
 
 function routeToDataParser(route, params) {
+    const isIgnore = utils.A.find(route.definition.metadata, metadata.IgnoreByCodeGeneratorMetadata.is);
+    if (isIgnore) {
+        return [];
+    }
     return utils.pipe([
         ...route.definition.preflightSteps,
         ...route.definition.steps,
-    ], (steps) => stepsToDataParser.stepsToDataParser(steps, {
+    ], (steps) => aggregateStepContract.aggregateStepContract(steps, {
         defaultExtractContract: params.defaultExtractContract,
     }), utils.O.transformProperty("entrypointContract", utils.innerPipe(utils.O.entries, utils.A.select(({ element: [key, value], select, skip }) => {
         if (utils.DP.dataParserKind.has(value)) {

package/dist/plugins/codeGenerator/routeToDataParser.mjs

@@ -1,11 +1,16 @@
-import { stepsToDataParser } from './stepsToDataParser.mjs';
-import { pipe, O, innerPipe, A, DP } from '@duplojs/utils';
+import { aggregateStepContract } from './aggregateStepContract.mjs';
+import { A, pipe, O, innerPipe, DP } from '@duplojs/utils';
+import { IgnoreByCodeGeneratorMetadata } from './metadata.mjs';
 
 function routeToDataParser(route, params) {
+    const isIgnore = A.find(route.definition.metadata, IgnoreByCodeGeneratorMetadata.is);
+    if (isIgnore) {
+        return [];
+    }
     return pipe([
         ...route.definition.preflightSteps,
         ...route.definition.steps,
-    ], (steps) => stepsToDataParser(steps, {
+    ], (steps) => aggregateStepContract(steps, {
         defaultExtractContract: params.defaultExtractContract,
     }), O.transformProperty("entrypointContract", innerPipe(O.entries, A.select(({ element: [key, value], select, skip }) => {
         if (DP.dataParserKind.has(value)) {

package/dist/plugins/openApiGenerator/aggregateStepContract.cjs

@@ -2,6 +2,8 @@
 
 require('../../core/steps/index.cjs');
 var utils = require('@duplojs/utils');
+var metadata = require('./metadata.cjs');
+var identifier = require('../../core/steps/identifier.cjs');
 var process = require('../../core/steps/process.cjs');
 var extract = require('../../core/steps/extract.cjs');
 var presetChecker = require('../../core/steps/presetChecker.cjs');
@@ -10,11 +12,12 @@ var cut = require('../../core/steps/cut.cjs');
 var handler = require('../../core/steps/handler.cjs');
 
 function aggregateStepContract(steps, params) {
-    const processContracts = utils.pipe(steps, utils.A.filter(process.processStepKind.has), utils.A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), utils.O.to({
+    const filteredStep = utils.A.filter(steps, (step) => utils.A.find(step.definition.metadata, metadata.IgnoreByOpenApiGeneratorMetadata.is) === undefined);
+    const processContracts = utils.pipe(filteredStep, utils.A.filter(identifier.stepIdentifier(process.processStepKind)), utils.A.filter((step) => utils.A.find(step.definition.process.definition.metadata, metadata.IgnoreByOpenApiGeneratorMetadata.is) === undefined), utils.A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), utils.O.to({
         entrypointContract: utils.A.map((result) => result.entrypointContract),
         endpointContract: utils.A.flatMap((result) => result.endpointContract),
     }));
-    const entrypointContract = utils.pipe(steps, utils.A.filter(extract.extractStepKind.has), utils.A.map((extractStep) => extractStep.definition.shape), utils.A.concat(processContracts.entrypointContract), utils.A.reduce(utils.A.reduceFrom({
+    const entrypointContract = utils.pipe(filteredStep, utils.A.filter(extract.extractStepKind.has), utils.A.map((extractStep) => extractStep.definition.shape), utils.A.concat(processContracts.entrypointContract), utils.A.reduce(utils.A.reduceFrom({
         body: {},
         headers: {},
         params: {},
@@ -43,7 +46,7 @@ function aggregateStepContract(steps, params) {
         }
         return utils.O.entry(key, currentExtractDataParser);
     }), utils.O.fromEntries, (object) => nextWithObject(lastValue, object))));
-    const endpointContract = utils.pipe(steps, utils.A.flatMap((step) => utils.P.match(step)
+    const endpointContract = utils.pipe(filteredStep, utils.A.flatMap((step) => utils.P.match(step)
         .when(process.processStepKind.has, () => [])
         .when(extract.extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
         .when(presetChecker.presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)

package/dist/plugins/openApiGenerator/aggregateStepContract.mjs

@@ -1,5 +1,7 @@
 import '../../core/steps/index.mjs';
-import { pipe, A, O, DP, P, hasSomeKinds } from '@duplojs/utils';
+import { A, pipe, O, DP, P, hasSomeKinds } from '@duplojs/utils';
+import { IgnoreByOpenApiGeneratorMetadata } from './metadata.mjs';
+import { stepIdentifier } from '../../core/steps/identifier.mjs';
 import { processStepKind } from '../../core/steps/process.mjs';
 import { extractStepKind } from '../../core/steps/extract.mjs';
 import { presetCheckerStepKind } from '../../core/steps/presetChecker.mjs';
@@ -8,11 +10,12 @@ import { cutStepKind } from '../../core/steps/cut.mjs';
 import { handlerStepKind } from '../../core/steps/handler.mjs';
 
 function aggregateStepContract(steps, params) {
-    const processContracts = pipe(steps, A.filter(processStepKind.has), A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), O.to({
+    const filteredStep = A.filter(steps, (step) => A.find(step.definition.metadata, IgnoreByOpenApiGeneratorMetadata.is) === undefined);
+    const processContracts = pipe(filteredStep, A.filter(stepIdentifier(processStepKind)), A.filter((step) => A.find(step.definition.process.definition.metadata, IgnoreByOpenApiGeneratorMetadata.is) === undefined), A.map((element) => aggregateStepContract(element.definition.process.definition.steps, params)), O.to({
         entrypointContract: A.map((result) => result.entrypointContract),
         endpointContract: A.flatMap((result) => result.endpointContract),
     }));
-    const entrypointContract = pipe(steps, A.filter(extractStepKind.has), A.map((extractStep) => extractStep.definition.shape), A.concat(processContracts.entrypointContract), A.reduce(A.reduceFrom({
+    const entrypointContract = pipe(filteredStep, A.filter(extractStepKind.has), A.map((extractStep) => extractStep.definition.shape), A.concat(processContracts.entrypointContract), A.reduce(A.reduceFrom({
         body: {},
         headers: {},
         params: {},
@@ -41,7 +44,7 @@ function aggregateStepContract(steps, params) {
         }
         return O.entry(key, currentExtractDataParser);
     }), O.fromEntries, (object) => nextWithObject(lastValue, object))));
-    const endpointContract = pipe(steps, A.flatMap((step) => P.match(step)
+    const endpointContract = pipe(filteredStep, A.flatMap((step) => P.match(step)
         .when(processStepKind.has, () => [])
         .when(extractStepKind.has, ({ definition }) => definition.responseContract ?? params.defaultExtractContract)
         .when(presetCheckerStepKind.has, ({ definition }) => definition.presetChecker.definition.responseContract)

package/dist/plugins/openApiGenerator/index.cjs

@@ -7,6 +7,7 @@ var routeToOpenApi = require('./routeToOpenApi.cjs');
 var aggregateStepContract = require('./aggregateStepContract.cjs');
 var makeOpenApiRoute = require('./makeOpenApiRoute.cjs');
 var makeOpenApiPage = require('./makeOpenApiPage.cjs');
+var metadata = require('./metadata.cjs');
 
 
 
@@ -15,3 +16,4 @@ exports.routeToOpenApi = routeToOpenApi.routeToOpenApi;
 exports.aggregateStepContract = aggregateStepContract.aggregateStepContract;
 exports.makeOpenApiRoute = makeOpenApiRoute.makeOpenApiRoute;
 exports.makeOpenApiPage = makeOpenApiPage.makeOpenApiPage;
+exports.IgnoreByOpenApiGeneratorMetadata = metadata.IgnoreByOpenApiGeneratorMetadata;

package/dist/plugins/openApiGenerator/index.d.ts

@@ -5,3 +5,4 @@ export * from "./routeToOpenApi";
 export * from "./aggregateStepContract";
 export * from "./makeOpenApiRoute";
 export * from "./makeOpenApiPage";
+export * from "./metadata";

package/dist/plugins/openApiGenerator/index.mjs

@@ -5,3 +5,4 @@ export { routeToOpenApi } from './routeToOpenApi.mjs';
 export { aggregateStepContract } from './aggregateStepContract.mjs';
 export { makeOpenApiRoute } from './makeOpenApiRoute.mjs';
 export { makeOpenApiPage } from './makeOpenApiPage.mjs';
+export { IgnoreByOpenApiGeneratorMetadata } from './metadata.mjs';

package/dist/plugins/openApiGenerator/makeOpenApiRoute.d.ts

@@ -3,6 +3,7 @@ import type { RoutePath } from "../../core/route";
 import { DP } from "@duplojs/utils";
 export declare function makeOpenApiRoute(routePath: RoutePath, openApiPage: string): import("../../core/route").Route<{
     readonly method: "GET";
+    readonly metadata: readonly [];
     readonly hooks: readonly [];
     readonly preflightSteps: readonly [];
     readonly paths: readonly [`/${string}`];
@@ -14,5 +15,6 @@ export declare function makeOpenApiRoute(routePath: RoutePath, openApiPage: stri
             readonly checkers: readonly [];
         }>>>;
         theFunction(floor: {}, param: import("../../core/steps").HandlerStepFunctionParams<import("../../core/request").Request, import("../../core/response").PredictedResponse<"200", "swaggerUi", string>>): import("@duplojs/utils").MaybePromise<import("../../core/response").PredictedResponse<"200", "swaggerUi", string>>;
+        readonly metadata: readonly [];
     }>];
 }>;

package/dist/plugins/openApiGenerator/metadata.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+require('../../core/metadata/index.cjs');
+var base = require('../../core/metadata/base.cjs');
+
+const IgnoreByOpenApiGeneratorMetadata = base.createMetadata("ignore-by-open-api-generator");
+
+exports.IgnoreByOpenApiGeneratorMetadata = IgnoreByOpenApiGeneratorMetadata;

package/dist/plugins/openApiGenerator/metadata.d.ts

@@ -0,0 +1 @@
+export declare const IgnoreByOpenApiGeneratorMetadata: import("../../core/metadata").MetadataHandler<"ignore-by-open-api-generator", unknown>;

package/dist/plugins/openApiGenerator/metadata.mjs

@@ -0,0 +1,6 @@
+import '../../core/metadata/index.mjs';
+import { createMetadata } from '../../core/metadata/base.mjs';
+
+const IgnoreByOpenApiGeneratorMetadata = createMetadata("ignore-by-open-api-generator");
+
+export { IgnoreByOpenApiGeneratorMetadata };

package/dist/plugins/openApiGenerator/routeToOpenApi.cjs

@@ -3,6 +3,7 @@
 var aggregateStepContract = require('./aggregateStepContract.cjs');
 var utils = require('@duplojs/utils');
 var toJsonSchema = require('@duplojs/data-parser-tools/toJsonSchema');
+var metadata = require('./metadata.cjs');
 
 function factoryJsonSchema(params) {
     const identifier = params.schema.definition.identifier
@@ -33,6 +34,10 @@ const methodMapper = {
     OPTIONS: "options",
 };
 function routeToOpenApi(route, params) {
+    const isIgnore = utils.A.find(route.definition.metadata, metadata.IgnoreByOpenApiGeneratorMetadata.is);
+    if (isIgnore) {
+        return [];
+    }
     const aggregateStepResult = aggregateStepContract.aggregateStepContract([
         ...route.definition.preflightSteps,
         ...route.definition.steps,

package/dist/plugins/openApiGenerator/routeToOpenApi.mjs

@@ -1,6 +1,7 @@
 import { aggregateStepContract } from './aggregateStepContract.mjs';
-import { O, pipe, A, DP, when, justReturn, whenNot, P, isType, S } from '@duplojs/utils';
+import { O, A, pipe, DP, when, justReturn, whenNot, P, isType, S } from '@duplojs/utils';
 import { render, defaultTransformers } from '@duplojs/data-parser-tools/toJsonSchema';
+import { IgnoreByOpenApiGeneratorMetadata } from './metadata.mjs';
 
 function factoryJsonSchema(params) {
     const identifier = params.schema.definition.identifier
@@ -31,6 +32,10 @@ const methodMapper = {
     OPTIONS: "options",
 };
 function routeToOpenApi(route, params) {
+    const isIgnore = A.find(route.definition.metadata, IgnoreByOpenApiGeneratorMetadata.is);
+    if (isIgnore) {
+        return [];
+    }
     const aggregateStepResult = aggregateStepContract([
         ...route.definition.preflightSteps,
         ...route.definition.steps,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/http",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",