pupt-lib 1.3.8 → 1.3.9

package/dist/index.js

@@ -42959,6 +42959,53 @@ function jsxNewlineLiteralPlugin({ types: t }) {
     }
   };
 }
+function customComponentInjectionPlugin({ types: t }) {
+  return {
+    name: "custom-component-injection",
+    visitor: {
+      Program: {
+        exit(path) {
+          const opts = this.opts;
+          const { componentNames, globalKey } = opts;
+          if (!componentNames || componentNames.length === 0) {
+            return;
+          }
+          const declaration = t.variableDeclaration("const", [
+            t.variableDeclarator(
+              t.objectPattern(
+                componentNames.map(
+                  (name) => t.objectProperty(
+                    t.identifier(name),
+                    t.identifier(name),
+                    false,
+                    true
+                    // shorthand
+                  )
+                )
+              ),
+              t.memberExpression(
+                t.identifier("globalThis"),
+                t.identifier(globalKey)
+              )
+            )
+          ]);
+          const body = path.get("body");
+          let lastImportIndex = -1;
+          for (let i = 0; i < body.length; i++) {
+            if (body[i].isImportDeclaration()) {
+              lastImportIndex = i;
+            }
+          }
+          if (lastImportIndex >= 0) {
+            body[lastImportIndex].insertAfter(declaration);
+          } else {
+            path.unshiftContainer("body", declaration);
+          }
+        }
+      }
+    }
+  };
+}
 let BabelInstance = null;
 let pluginsRegistered = false;
 function registerPlugins(Babel) {
@@ -42966,6 +43013,7 @@ function registerPlugins(Babel) {
   Babel.registerPlugin("uses-to-import", usesToImportPlugin);
   Babel.registerPlugin("name-hoisting", nameHoistingPlugin);
   Babel.registerPlugin("jsx-newline-literal", jsxNewlineLiteralPlugin);
+  Babel.registerPlugin("custom-component-injection", customComponentInjectionPlugin);
   pluginsRegistered = true;
 }
 async function getBabel() {
@@ -42976,28 +43024,34 @@ async function getBabel() {
   }
   return BabelInstance;
 }
-function getTransformOptions(filename) {
+function getTransformOptions(filename, options) {
+  const plugins2 = [
+    // Transform <Uses> to import declarations (must run before JSX transform)
+    "uses-to-import",
+    // Hoist named elements to variable declarations (must run before JSX transform)
+    "name-hoisting",
+    // Preserve newlines in multi-line JSX text (must run before JSX transform)
+    "jsx-newline-literal",
+    // Transform JSX to jsx() calls
+    ["transform-react-jsx", {
+      runtime: "automatic",
+      importSource: "pupt-lib"
+    }]
+  ];
+  if (options == null ? void 0 : options.extraPlugins) {
+    for (const plugin of options.extraPlugins) {
+      plugins2.push(plugin);
+    }
+  }
   return {
     presets: ["typescript"],
     filename,
-    plugins: [
-      // Transform <Uses> to import declarations (must run before JSX transform)
-      "uses-to-import",
-      // Hoist named elements to variable declarations (must run before JSX transform)
-      "name-hoisting",
-      // Preserve newlines in multi-line JSX text (must run before JSX transform)
-      "jsx-newline-literal",
-      // Transform JSX to jsx() calls
-      ["transform-react-jsx", {
-        runtime: "automatic",
-        importSource: "pupt-lib"
-      }]
-    ]
+    plugins: plugins2
   };
 }
-async function transformWithBabelAsync(source, filename) {
+async function transformWithBabelAsync(source, filename, options) {
   const Babel = await getBabel();
-  const result = Babel.transform(source, getTransformOptions(filename));
+  const result = Babel.transform(source, getTransformOptions(filename, options));
   if (!(result == null ? void 0 : result.code)) {
     throw new Error(`Failed to transform: ${filename}`);
   }
@@ -43010,11 +43064,12 @@ class Transformer2 {
    *
    * @param source - The TSX source code to transform
    * @param filename - Filename used for error messages and source maps
+   * @param options - Optional transform configuration (e.g., extra plugins)
    * @returns The transformed JavaScript code
    * @throws Error if transformation fails
    */
-  async transformSourceAsync(source, filename) {
-    return transformWithBabelAsync(source, filename);
+  async transformSourceAsync(source, filename, options) {
+    return transformWithBabelAsync(source, filename, options);
   }
 }
 function isNodeEnvironment() {
@@ -43081,34 +43136,83 @@ async function resolveBareSpecifier(specifier) {
     throw new Error(`Cannot resolve module "${specifier}": ${message}`);
   }
 }
+let babelPackagesCache = null;
+async function loadBabelPackages() {
+  if (babelPackagesCache) return babelPackagesCache;
+  const babelModule = await import("./babel-DZMWDenp.js").then((n) => n.b);
+  const Babel = babelModule.default || babelModule;
+  const { parser, generator: generatorMod } = Babel.packages;
+  const generate = typeof generatorMod === "function" ? generatorMod : generatorMod.default;
+  babelPackagesCache = {
+    parse: parser.parse.bind(parser),
+    generate
+  };
+  return babelPackagesCache;
+}
+function walkAst(node, visitor) {
+  if (!node || typeof node !== "object") return;
+  if (node.type) {
+    visitor(node);
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "type" || key === "start" || key === "end" || key === "loc") continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (item && typeof item === "object" && item.type) {
+          walkAst(item, visitor);
+        }
+      }
+    } else if (child && typeof child === "object" && child.type) {
+      walkAst(child, visitor);
+    }
+  }
+}
 async function rewriteAllImports(code) {
-  const importRegex = /from\s+['"]([^'"]+)['"]|import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-  const specifiers = /* @__PURE__ */ new Set();
-  let match;
-  while ((match = importRegex.exec(code)) !== null) {
-    const specifier = match[1] || match[2];
-    if (isBareSpecifier(specifier)) {
-      specifiers.add(specifier);
+  const { parse, generate } = await loadBabelPackages();
+  const ast = parse(code, { sourceType: "module", errorRecovery: true });
+  const nodesToRewrite = [];
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration" && stmt.source) {
+      const specifier = stmt.source.value;
+      if (isBareSpecifier(specifier)) {
+        nodesToRewrite.push({ node: stmt.source, specifier });
+      }
+    }
+  }
+  walkAst(ast, (node) => {
+    var _a2, _b2;
+    if (node.type === "CallExpression" && ((_a2 = node.callee) == null ? void 0 : _a2.type) === "Import" && ((_b2 = node.arguments) == null ? void 0 : _b2.length) > 0 && node.arguments[0].type === "StringLiteral") {
+      const specifier = node.arguments[0].value;
+      if (isBareSpecifier(specifier)) {
+        nodesToRewrite.push({ node: node.arguments[0], specifier });
+      }
     }
+  });
+  if (nodesToRewrite.length === 0) {
+    return code;
   }
+  const uniqueSpecifiers = new Set(nodesToRewrite.map((n) => n.specifier));
   const resolutions = /* @__PURE__ */ new Map();
-  for (const specifier of specifiers) {
+  for (const specifier of uniqueSpecifiers) {
     const resolved = await resolveBareSpecifier(specifier);
     resolutions.set(specifier, resolved);
   }
-  let rewritten = code;
-  for (const [specifier, resolved] of resolutions) {
-    const escaped = specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    rewritten = rewritten.replace(
-      new RegExp(`from\\s+(['"])${escaped}\\1`, "g"),
-      `from $1${resolved}$1`
-    );
-    rewritten = rewritten.replace(
-      new RegExp(`import\\s*\\(\\s*(['"])${escaped}\\1\\s*\\)`, "g"),
-      `import($1${resolved}$1)`
-    );
+  for (const { node, specifier } of nodesToRewrite) {
+    const resolved = resolutions.get(specifier);
+    if (resolved) {
+      node.value = resolved;
+    }
+  }
+  return generate(ast).code;
+}
+async function rewriteImportsForFile(code, filename) {
+  try {
+    return await rewriteAllImports(code);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to evaluate module ${filename}: ${message}`);
   }
-  return rewritten;
 }
 async function evaluateInNode(code, filename) {
   const fs = await import("fs/promises");
@@ -43116,7 +43220,7 @@ async function evaluateInNode(code, filename) {
   const os = await import("os");
   const crypto2 = await import("crypto");
   const { pathToFileURL } = await import("url");
-  const rewrittenCode = await rewriteAllImports(code);
+  const rewrittenCode = await rewriteImportsForFile(code, filename);
   const hash = crypto2.createHash("md5").update(rewrittenCode).digest("hex").slice(0, 8);
   const tempDir = path.join(os.tmpdir(), "pupt-lib");
   await fs.mkdir(tempDir, { recursive: true });
@@ -43178,62 +43282,51 @@ function generateImports() {
   lines.push(aliases);
   return lines.join("\n");
 }
-function extractUses(source) {
-  const uses = [];
-  const remaining = source.replace(/^\s*<Uses\s[^>]*\/>\s*$/gm, (match) => {
-    uses.push(match.trim());
-    return "";
-  });
-  return { uses, remaining };
-}
 function preprocessSource(source, options) {
   const { filename } = options;
   if (!isPromptFile(filename)) {
     return source;
   }
   const imports = generateImports();
-  const { uses, remaining } = extractUses(source);
-  const usesSection = uses.length > 0 ? uses.join("\n") + "\n\n" : "";
   const result = `export default (
-${remaining}
+<>
+${source}
+</>
 );`;
   return `// Preprocessed from: ${filename}
 ${imports}
 
-${usesSection}${result}`;
+${result}`;
 }
 const CUSTOM_COMPONENTS_GLOBAL = "__PUPT_CUSTOM_COMPONENTS__";
 async function createPromptFromSource(source, filename, options = {}) {
   const { components } = options;
-  let processedSource = preprocessSource(source, { filename });
+  const processedSource = preprocessSource(source, { filename });
   if (components && Object.keys(components).length > 0) {
     globalThis[CUSTOM_COMPONENTS_GLOBAL] = components;
-    const componentNames = Object.keys(components);
-    const extractCode = `const { ${componentNames.join(", ")} } = globalThis.${CUSTOM_COMPONENTS_GLOBAL};
-`;
-    let lastImportEnd = 0;
-    const fullImportRegex = /import\s+(?:(?:\{[^}]*\}|[^;{]*)\s+from\s+)?['"][^'"]+['"];?/g;
-    let match;
-    while ((match = fullImportRegex.exec(processedSource)) !== null) {
-      const matchEnd = match.index + match[0].length;
-      if (matchEnd > lastImportEnd) {
-        lastImportEnd = matchEnd;
-      }
-    }
-    if (lastImportEnd > 0) {
-      processedSource = processedSource.slice(0, lastImportEnd) + "\n" + extractCode + processedSource.slice(lastImportEnd);
-    } else {
-      processedSource = extractCode + processedSource;
-    }
   }
+  const extraPlugins = components && Object.keys(components).length > 0 ? [["custom-component-injection", {
+    componentNames: Object.keys(components),
+    globalKey: CUSTOM_COMPONENTS_GLOBAL
+  }]] : void 0;
   try {
     const transformer = new Transformer2();
-    const code = await transformer.transformSourceAsync(processedSource, filename);
+    const code = await transformer.transformSourceAsync(processedSource, filename, { extraPlugins });
     const module = await evaluateModule(code, { filename });
     if (module.default === void 0) {
       throw new Error(`${filename} must have a default export`);
     }
-    return module.default;
+    let element = module.default;
+    if (isPromptFile(filename) && element && element[TYPE] === Fragment) {
+      const children = element[CHILDREN];
+      const meaningful = children.filter(
+        (child) => !(typeof child === "string" && child.trim() === "")
+      );
+      if (meaningful.length === 1) {
+        element = meaningful[0];
+      }
+    }
+    return element;
   } finally {
     if (components) {
       delete globalThis[CUSTOM_COMPONENTS_GLOBAL];

package/dist/src/create-prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-prompt.d.ts","sourceRoot":"","sources":["../../src/create-prompt.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CAC5C;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,+BAA+B,CAAC;AAErE;;GAEG;AACH,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS,CAAC;CAC3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,WAAW,CAAC,CAiEtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,WAAW,CAAC,CAKtB"}
+{"version":3,"file":"create-prompt.d.ts","sourceRoot":"","sources":["../../src/create-prompt.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAY,MAAM,SAAS,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CAC5C;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,+BAA+B,CAAC;AAErE;;GAEG;AACH,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS,CAAC;CAC3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,WAAW,CAAC,CA8DtB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,WAAW,CAAC,CAKtB"}

package/dist/src/services/babel-plugins/custom-component-injection.d.ts

@@ -0,0 +1,5 @@
+import { PluginObj, types as BabelTypes } from '@babel/core';
+export declare function customComponentInjectionPlugin({ types: t }: {
+    types: typeof BabelTypes;
+}): PluginObj;
+//# sourceMappingURL=custom-component-injection.d.ts.map

package/dist/src/services/babel-plugins/custom-component-injection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-component-injection.d.ts","sourceRoot":"","sources":["../../../../src/services/babel-plugins/custom-component-injection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAOlE,wBAAgB,8BAA8B,CAC5C,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,UAAU,CAAA;CAAE,GACzC,SAAS,CAoDX"}

package/dist/src/services/babel-plugins/index.d.ts

@@ -1,4 +1,5 @@
 export { usesToImportPlugin } from './uses-to-import';
 export { nameHoistingPlugin } from './name-hoisting';
 export { jsxNewlineLiteralPlugin } from './jsx-newline-literal';
+export { customComponentInjectionPlugin } from './custom-component-injection';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/services/babel-plugins/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/babel-plugins/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/babel-plugins/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,8BAA8B,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/src/services/module-evaluator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-evaluator.d.ts","sourceRoot":"","sources":["../../../src/services/module-evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAgBH,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAC;CAClB;AA+LD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC,CAexD"}
+{"version":3,"file":"module-evaluator.d.ts","sourceRoot":"","sources":["../../../src/services/module-evaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAgBH,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAC;CAClB;AA4RD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC,CAexD"}

package/dist/src/services/preprocessor.d.ts

@@ -24,8 +24,9 @@ export declare function isPromptFile(filename: string): boolean;
  *
  * .prompt files always receive:
  * - Import injection for all built-in components
- * - Extraction of <Uses> elements to module level (for the babel plugin)
- * - Export default wrapping around the remaining JSX content
+ * - Fragment wrapping around the content (so the uses-to-import Babel plugin
+ *   can find and transform any <Uses> elements within the JSX tree)
+ * - Export default wrapping
  *
  * Non-.prompt files are returned unchanged.
  *

package/dist/src/services/preprocessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preprocessor.d.ts","sourceRoot":"","sources":["../../../src/services/preprocessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAQH,MAAM,WAAW,iBAAiB;IAChC,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEtD;AAkDD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAiBnF"}
+{"version":3,"file":"preprocessor.d.ts","sourceRoot":"","sources":["../../../src/services/preprocessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAQH,MAAM,WAAW,iBAAiB;IAChC,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEtD;AAkCD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAiBnF"}

package/dist/src/services/transformer.d.ts

@@ -4,6 +4,10 @@
  *
  * Works in both Node.js and browser environments.
  */
+export interface TransformOptions {
+    /** Additional Babel plugins to include in the transform. Each entry is [pluginName, options]. */
+    extraPlugins?: Array<[string, Record<string, unknown>]>;
+}
 export declare class Transformer {
     /**
      * Transform a source string containing TSX code.
@@ -11,9 +15,10 @@ export declare class Transformer {
      *
      * @param source - The TSX source code to transform
      * @param filename - Filename used for error messages and source maps
+     * @param options - Optional transform configuration (e.g., extra plugins)
      * @returns The transformed JavaScript code
      * @throws Error if transformation fails
      */
-    transformSourceAsync(source: string, filename: string): Promise<string>;
+    transformSourceAsync(source: string, filename: string, options?: TransformOptions): Promise<string>;
 }
 //# sourceMappingURL=transformer.d.ts.map

package/dist/src/services/transformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../../../src/services/transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAkFH,qBAAa,WAAW;IACtB;;;;;;;;OAQG;IACG,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAG9E"}
+{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../../../src/services/transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,MAAM,WAAW,gBAAgB;IAC/B,iGAAiG;IACjG,YAAY,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CACzD;AA0FD,qBAAa,WAAW;IACtB;;;;;;;;;OASG;IACG,oBAAoB,CACxB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,MAAM,CAAC;CAGnB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pupt-lib",
-  "version": "1.3.8",
+  "version": "1.3.9",
   "description": "TypeScript library for creating AI prompts using JSX syntax",
   "license": "MIT",
   "author": "",