runtime-type-inspector 1.0.0 → 2.0.0

package/src-transpiler/expandType.mjs

@@ -0,0 +1,187 @@
+import ts from 'typescript';
+/**
+ * @todo implement TypeQuery, e.g. for expandType('typeof Number');
+ * @example
+ * const { expandType } = await import("./src-transpiler/expandType.mjs");
+ * expandType('[string, Array|AnyTypedArray, number[]]|[ONNXTensor]');
+ * expandType('(123)                    '); // Outputs: '123'
+ * expandType('  ( ( 123 ) )            '); // Outputs: '123'
+ * expandType('Array<number>            '); // Outputs: {type: 'array', elementType: 'number'}
+ * expandType('Array<(123) >            '); // Outputs: {type: 'array', elementType: '123'}
+ * expandType('Array<"abc" | 123>       '); // Outputs: {type: 'array', elementType: { type: 'union', members: [ '"abc"', '123' ]}}
+ * expandType('  (string ) |(number )   '); // Outputs: {type: 'union', members: [ 'string', 'number']}
+ * expandType(' "apples" | ( "bananas") '); // Outputs: {type: 'union', members: [ '"apples"', '"bananas"']}
+ * expandType('123?                     '); // Outputs: {"type":"union","members":["123","null"]}
+ * expandType('123|null                 '); // Outputs: {"type":"union","members":["123","null"]}
+ * expandType('Map<string, any>');
+ * @param {string} type
+ */
+function expandType(type) {
+  const ast = parseType(type);
+  return toSourceTS(ast);
+}
+/**
+ * @typedef TypeScriptType
+ * @property {object[]|undefined} typeArguments
+ * @property {*} typeName
+ * @property {number} kind
+ */
+/**
+ * @param {string} str - The type string.
+ * @returns {TypeScriptType}
+ */
+function parseType(str) {
+  // TS doesn't like ... notation in this context
+  if (str.startsWith('...')) {
+    str = str.slice(3); // remove dots
+    str += '[]'; // turn into array
+  }
+  // type tmp = (...string) => 123; to have a function context
+  str = `type tmp = ${str};`;
+  const ast = ts.createSourceFile('repl.ts', str, ts.ScriptTarget.Latest, true /*setParentNodes*/);
+  return ast.statements[0].type;
+}
+/**
+ * @param {TypeScriptType} node 
+ * @returns 
+ */
+function toSourceTS(node) {
+  const {typeArguments, typeName} = node;
+  const kind_ = ts.SyntaxKind[node.kind];
+  const {
+    AnyKeyword, ArrayType, BooleanKeyword, FunctionType, Identifier, IntersectionType,
+    JSDocAllType, LastTypeNode, LiteralType, NullKeyword, NumberKeyword, NumericLiteral,
+    ObjectKeyword, Parameter, ParenthesizedType, PropertySignature, StringKeyword,
+    StringLiteral, ThisType, TupleType, TypeLiteral, TypeReference, UndefinedKeyword,
+    UnionType, JSDocNullableType,
+  } = ts.SyntaxKind;
+  // console.log({ typeArguments, typeName, kind_, node });
+  switch (node.kind) {
+    case FunctionType:
+      const parameters = node.parameters.map(toSourceTS);
+      return {type: 'function', parameters};
+    case JSDocNullableType:
+      const t = toSourceTS(node.type);
+      return {type: 'union', members: [t, 'null']};
+    // todo work out more: const jsdoc = `(...a: ...number) => 123
+    // TS even thinks it's two parameters... just go for array/[]
+    case Parameter:
+      const type = node.type ? toSourceTS(node.type) : 'any';
+      const name = toSourceTS(node.name);
+      const ret = {type, name};
+      if (node.dotDotDotToken) {
+        return {type: 'array', elementType: ret};
+      }
+      return ret;
+    case TypeReference:
+      if ((typeName.text === 'Object' || typeName.text === 'Record') && typeArguments?.length === 2) {
+        return {
+          type: 'record',
+          key: toSourceTS(typeArguments[0]),
+          val: toSourceTS(typeArguments[1]),
+        };
+      } else if (typeName.text === 'Object' && (!typeArguments || typeArguments?.length === 0)) {
+        return {type: 'object', properties: {}};
+      } else if (typeName.text === 'Map' && typeArguments?.length === 2) {
+        return {
+          type: 'map',
+          key: toSourceTS(typeArguments[0]),
+          val: toSourceTS(typeArguments[1]),
+        };
+      } else if (typeName.text === 'Array' && typeArguments?.length === 1) {
+        const elementType = toSourceTS(typeArguments[0]);
+        return {type: 'array', elementType};
+      } else if (typeName.text === 'Set' && typeArguments?.length === 1) {
+        const elementType = toSourceTS(typeArguments[0]);
+        return {type: 'set', elementType};
+      } else if (typeName.text === 'Class' && typeArguments?.length === 1) {
+        return {
+          type: 'class',
+          elementType: toSourceTS(typeArguments[0])
+        }
+      } else {
+        if (!typeArguments) {
+          return typeName.getText();
+        }
+        console.warn('unhandled TypeReference', kind_, node);
+        return {
+          type: 'unhandled TypeReference'
+        };
+      }
+      break;
+    case StringKeyword:
+      return node.getText();
+    case NumberKeyword:
+      return node.getText();
+    case IntersectionType:
+      return {
+        type: 'intersection',
+        members: node.types.map(toSourceTS)
+      }
+    case TupleType:
+      return {
+        type: 'tuple',
+        elements: node.elements.map(toSourceTS)
+      }
+    case UnionType:
+      return {
+        type: 'union',
+        members: node.types.map(toSourceTS)
+      }
+    case TypeLiteral:
+      const properties = {};
+      node.members.forEach(member => {
+        const name = toSourceTS(member.name);
+        const type = toSourceTS(member.type);
+        properties[name] = type;
+      });
+      return {
+        type: 'object',
+        properties
+      }
+    case PropertySignature:
+      console.warn('toSourceTS> should not happen, handled by TypeLiteral directly');
+      return `${toSourceTS(node.name)}: ${toSourceTS(node.type)}`;
+    case Identifier:
+      return node.text;
+    case ArrayType:
+      return {
+        type: 'array',
+        elementType: toSourceTS(node.elementType)
+      };
+    case LiteralType:
+      return toSourceTS(node.literal);
+    case AnyKeyword:
+    case BooleanKeyword:
+    case JSDocAllType:
+    case NullKeyword:
+    case NumericLiteral:
+    case StringLiteral:
+    case ThisType:
+    case UndefinedKeyword:
+      return node.getText();
+    case ObjectKeyword:
+      return {
+        type: 'object',
+        properties: {}
+      }
+    case ParenthesizedType:
+      // fall-through for parentheses
+      return toSourceTS(node.type);
+    case LastTypeNode:
+      return toSourceTS(node.qualifier);
+    default:
+        // const test = {};
+        // Object.entries(ts.SyntaxKind).forEach(([name, id]) => {
+        //     test[id] = (test[id] || []);
+        //     test[id].push(name);
+        // });
+        // console.log(test);
+      console.warn('toSourceTS> unhandled kind - make sure to understand you cannot reverse TS enums');
+      console.warn('if they contain range aliases, for example:');
+      console.warn('ts.SyntaxKind.NumericLiteral === ts.SyntaxKind.FirstLiteralToken');
+      console.warn('so this "kind" could be wrong, but requires handling anyway:', kind_, node);
+      debugger;
+  }
+}
+export {expandType, parseType, toSourceTS};

package/src-transpiler/expandTypeDepFree.mjs

@@ -0,0 +1,122 @@
+/**
+ * @todo expandTypeDepFree doesn't support "complicated" types.
+ * For actual builds, we use expandType() anyway (which is based on TypeScript).
+ * But since TypeScript is a huge dependency, I'm looking into BabelFlow/BabelTypescript parser.
+ * Comparing AST's like this usually helps to find bugs or potential issues,
+ * while we can benchmark for best performance too.
+ * @example
+ * const tooComplex = 'Array<string|{chunks?: undefined|Array<{language: string|null, timestamp: Array<number|null>, text: string}>}>';
+ * console.log(expandTypeDepFree(tooComplex));
+ */
+/**
+ * @typedef {object} ExpandTypeReturnValue
+ * @property {'array' | 'union' | 'record' | 'tuple' | 'object'} type
+ * @property {object | string} [elementType]
+ * @property {object | string} [key]
+ * @property {object | string} [val]
+ * @property {(object | string)[]} [members] - For unions.
+ * @property {object | string} [properties] - For objects.
+ * @property {(object | string)[]} [elements] - For tuples.
+ */
+/**
+ * 'DepFree' refers to the fact that this function has no dependencies,
+ * while `expandType` depends on TypeScript itself for maximum compatibility.
+ * @example
+ * expandTypeDepFree('(123)                   '); // Outputs: '123'
+ * expandTypeDepFree('Array<number>           '); // Outputs: { type: 'array', elementType: 'number' }
+ * expandTypeDepFree('Array<(123) >           '); // Outputs: { type: 'array', elementType: '123' }
+ * expandTypeDepFree('  ( ( 123 ) )           '); // Outputs: '123'
+ * expandTypeDepFree('  (string ) |(number )  '); // Outputs: { type: 'union', members: ['string', 'number'] }
+ * expandTypeDepFree(' ((  Object  ) )        '); // Outputs: { type: 'object', properties: {} }
+ * @param {string} type
+ * @returns {string | ExpandTypeReturnValue} Object containing parsed information from type string.
+ */
+function expandTypeDepFree(type) {
+  type = type.trim();
+  // '(123)' -> '123'
+  while (!type.includes('|') && type[0] == '(' && type[type.length - 1] == ')') {
+    type = type.slice(1, -1).trim();
+  }
+  // (1) Rest parameters like ...string
+  if (type[0] === '.' && type[1] === '.' && type[2] === '.') {
+    return {
+      type: 'array',
+      elementType: type.slice(3)
+    }
+  }
+  // (2) Array<...>
+  if (type.startsWith("Array<") && type.endsWith('>')) {
+    const typeSlice = type.slice(6, -1);
+    return {
+      type: "array",
+      elementType: expandTypeDepFree(typeSlice)
+    }
+  }
+  // (3) Object<...> or Record<...>
+  if (
+    (
+      type.startsWith("Object<") ||
+      type.startsWith("Record<")
+    ) && type.endsWith('>')) {
+    const recordSlice = type.slice(7, -1);
+    const firstComma = recordSlice.indexOf(',');
+    if (firstComma === -1) {
+      console.warn("expandTypeDepFree> invalid Object/Record");
+    }
+    const key = recordSlice.slice(0, firstComma).trim();
+    const val = recordSlice.slice(firstComma + 1).trim();
+    return {
+      type: "record",
+      key: expandTypeDepFree(key),
+      val: expandTypeDepFree(val),
+    }
+  }
+  // (4) {...}
+  if (type[0] == '{' && type[type.length - 1] == '}') {
+    const propertiesArray = type.slice(1, -1).split(','); // ['entity: Entity', ' app: AppBase']
+    const properties = {};
+    propertiesArray.forEach(_ => {
+      const [propName, propType] = _.split(":").map(_=>_.trim());
+      if (!propName || !propType) {
+        console.warn('expandTypeDepFree> unexpected type format, fix');
+        return false;
+      }
+      properties[propName] = propType;
+    });
+    return {type: 'object', properties};
+  }
+  // (5) expand unions
+  const members = type.split("|");
+  if (members.length >= 2) {
+    members.forEach((_, i) => members[i]=_.trim());
+    return {
+      type: 'union',
+      members: members.map(expandTypeDepFree),
+    }
+  }
+  // (6) expand [] Arrays
+  // Test arrays: new pc.Mat3().set([1, 2, 3, "asd"])
+  if (type.endsWith("[]")) {
+    const typeSlice = type.slice(0, -2);
+    return {
+      type: 'array',
+      elementType: expandTypeDepFree(typeSlice)
+    }
+  }
+  // (7) expand tuples
+  if (type[0] == '[' && type[type.length - 1] == ']') {
+    const elements = type.slice(1, -1).split(','); // ['null', ' Texture', ' Texture', ' Texture', ' Texture', ' Texture', ' Texture']
+    return {
+      type: 'tuple',
+      elements: elements.map(expandTypeDepFree)
+    }
+  }
+  if (type === 'object' || type === 'Object') {
+    return {
+      type: 'object',
+      properties: {},
+    }
+  }
+  return type;
+}
+export {expandTypeDepFree};

package/src-transpiler/extractNameAndOptionality.mjs

@@ -0,0 +1,23 @@
+/**
+ * @param {string} rest 
+ * @returns {[string, boolean]}
+ */
+function extractNameAndOptionality(rest) {
+  rest = rest.trim();
+  let optional = false;
+  // Examples:
+  //   name: [kwargs={}] The configuration parameters.
+  //   name: [d = 1.0] Sample spacing
+  if (rest[0] === '[') {
+    // Possible improvement: counting opening/closing brackets for perfect match
+    const closer = rest.lastIndexOf(']');
+    // Afterwards name will be: d = 1.0
+    rest = rest.substring(1, closer);
+    // mark it for the type:
+    optional = true;
+  }
+  // Strip the rest (either leftover of optional value or description)
+  const name = rest.split(' ')[0].split('=')[0].trim();
+  return [name, optional];
+}
+export {extractNameAndOptionality};

package/src-transpiler/index.mjs

@@ -0,0 +1,13 @@
+export * from './addTypeChecks.mjs';
+export * from './ast2json.mjs';
+export * from './ast2jsonForComparison.mjs';
+export * from './code2ast2code.mjs';
+export * from './expandType.mjs';
+export * from './expandTypeDepFree.mjs';
+export * from './extractNameAndOptionality.mjs';
+export * from './parseJSDoc.mjs';
+export * from './parseJSDocSetter.mjs';
+export * from './parseJSDocTypedef.mjs';
+export * from './simplifyType.mjs';
+export * from './Stringifier.mjs';
+export * from './StringifierWithTypeAssertions.mjs';

package/src-transpiler/parseJSDoc.mjs

@@ -0,0 +1,69 @@
+import {expandTypeDepFree} from "./expandTypeDepFree.mjs";
+import {simplifyType} from "./simplifyType.mjs";
+/**
+ * @param {string} src 
+ * @returns {{} | undefined}
+ */
+function parseJSDoc(src, expandType = expandTypeDepFree) {
+  // Parse something like: @param {Object} [kwargs={}] Optional arguments.
+  const regex = /@param \{(.*?)\} ([\[\]a-zA-Z0-9_$=\{\}\.'" ]+)/g;
+  const matches = [...src.matchAll(regex)];
+  /** @type {Record<string, any>} */
+  const params = Object.create(null);
+  matches.forEach(_ => {
+    const type = expandType(_[1].trim());
+    let name = _[2].trim();
+    let optional = false;
+    // Examples:
+    //   name: [kwargs={}] The configuration parameters.
+    //   name: [d = 1.0] Sample spacing
+    if (name[0] === '[') {
+      // Possible improvement: counting opening/closing brackets for perfect match
+      const closer = name.lastIndexOf(']');
+      // Afterwards name will be: d = 1.0
+      name = name.substring(1, closer);
+      // mark it for the type:
+      optional = true;
+    }
+    // Strip the rest (either leftover of optional value or description)
+    name = name.split(' ')[0].split('=')[0].trim();
+    const simplifiedType = simplifyType(type, optional);
+    const parts = name.split(".");
+    if (parts.length == 3) { // Something like: @param {number[]} settings.render.skyboxRotation - Rotation of skybox.
+      let parts0 = parts[0]; // settings
+      let parts1 = parts[1]; // render
+      let parts2 = parts[2]; // skyboxRotation
+      const toptype = params[parts0];
+      toptype.properties[parts1].properties = toptype.properties[parts1].properties || {};
+      toptype.properties[parts1].properties[parts2] = simplifiedType;
+    } else if (parts.length == 2) { // Something like: @param {number} description[].components
+      let parts0 = parts[0]; // description[]
+      let parts1 = parts[1]; // components
+      if (parts0.endsWith('[]')) {
+        parts0 = parts0.slice(0, -2); // description[] -> description
+      }
+      const toptype = params[parts0];
+      if (toptype?.type == "union") {
+        const typeObject = toptype.members.find(_ => _?.type == 'object');
+        typeObject.properties[parts1] = simplifiedType;
+        //typeObject.properties = simplifiedType; // todo add test case
+      } else if (toptype?.type == "array") {
+        toptype.elementType.properties[parts1] = simplifiedType;
+      } else if (toptype?.type == "object") {
+        toptype.properties = toptype.properties || {};
+        toptype.properties[parts1] = simplifiedType;
+      } else {
+        console.warn("parseJSDoc> skipping @param, unseen syntax detected, please check if your JSDoc is valid or open an issue about this", {
+          src, toptype, parts0, parts1, simplifiedType
+        })
+      }
+    } else {
+      params[name] = simplifiedType;
+    }
+  });
+  if (Object.keys(params).length === 0) {
+    return;
+  }
+  return params;
+}
+export {parseJSDoc};

package/src-transpiler/parseJSDocSetter.mjs

@@ -0,0 +1,16 @@
+import {expandTypeDepFree} from "./expandTypeDepFree.mjs";
+import {simplifyType} from "./simplifyType.mjs";
+/**
+ * @param {string} src - JSDoc comment of the setter.
+ */
+function parseJSDocSetter(src, expandType = expandTypeDepFree) {
+  const regex = /@type \{(.*?)\}/g;
+  const matches = [...src.matchAll(regex)];
+  if (matches.length === 1) {
+    const match = matches[0];
+    const type = expandType(match[1]);
+    const simplifiedType = simplifyType(type, /*optional*/ false);     
+    return simplifiedType;
+  }
+}
+export {parseJSDocSetter};

package/src-transpiler/parseJSDocTypedef.mjs

@@ -0,0 +1,69 @@
+import {extractNameAndOptionality} from './extractNameAndOptionality.mjs';
+import {simplifyType             } from './simplifyType.mjs';
+/**
+ * @param {string} line 
+ * @returns {{content: string, nextIndex: number}}
+ */
+function extractCurlyContent(line) {
+  const firstCurly = line.indexOf('{');
+  let k = firstCurly + 1;
+  let count = 0;
+  for (; k<line.length; k++) {
+    const c = line[k];
+    if (c === '{') {
+      count++;
+    } else if (c === '}') {
+      count--;
+    }
+    if (count === -1) {
+      break;
+    }
+  }
+  const content = line.substring(firstCurly + 1, k);
+  return {content, nextIndex: k + 1};
+}
+/**
+ * @param {Record<string, object>} typedefs 
+ * @param {Console["warn"]} warn 
+ * @param {import("@babel/types").CommentBlock | import("@babel/types").CommentLine} comment - From import("@babel/types").File["comments"]
+ * @param {Function} expandType
+ */
+function parseJSDocTypedef(typedefs, warn, comment, expandType) {
+  const {type, value} = comment;
+  if (type !== 'CommentBlock') {
+    return;
+  }
+  const lines = value.split('\n');
+  let lastTypedef = undefined;
+  for (let line of lines) {
+    line = line.trim();
+    if (line[0] === '*') {
+      line = line.slice(1).trim();
+    }
+    if (line.startsWith('@typedef')) {
+      const {content: def, nextIndex} = extractCurlyContent(line);
+      let name = line.substring(nextIndex).trim();
+      // Drop description
+      name = name.split(' ')[0];
+      lastTypedef = expandType(def);
+      typedefs[name] = lastTypedef;
+    } else if (line.startsWith('@property')) {
+      // class @property
+      if (!lastTypedef) {
+        continue;
+      }
+      const {content, nextIndex} = extractCurlyContent(line);
+      const rest = line.substring(nextIndex);
+      const propType = expandType(content);
+      const [name, optional] = extractNameAndOptionality(rest);
+      // console.log({name, optional, propType});
+      const finalType = simplifyType(propType, optional);
+      if (lastTypedef?.type === 'object') {
+        lastTypedef.properties[name] = finalType;
+      } else {
+        warn("not an extensible type", lastTypedef);
+      }
+    }
+  }
+}
+export {extractCurlyContent, parseJSDocTypedef};

package/src-transpiler/simplifyType.mjs

@@ -0,0 +1,31 @@
+/**
+ * @typedef DocType
+ * @property {boolean} optional
+ */
+/**
+ * @param {string | DocType} type - The type.
+ * @param {boolean} optional - Optionality
+ * @returns {string | DocType}
+ */
+function simplifyType(type, optional) {
+  // If it's already an object, just set optionality.
+  if (type instanceof Object) {
+    type.optional = optional;
+  } else if (typeof type === 'string') {
+    type = type.trim();
+    if (type != 'object' && type != 'object[]' && type != 'union' && !optional) {
+      // console.log("simplify", type);
+      return type;
+    }
+    type = {type, optional};
+  } else {
+    debugger;
+    console.warn("simplifyType> neither object nor string for type", type);
+  }
+  if (type.type == 'object' && type.properties && Object.keys(type.properties).length === 0) {
+    delete type.properties;
+    // console.log("delete empty", type);
+  }
+  return type;
+}
+export {simplifyType};

package/src-transpiler/stat.mjs

@@ -0,0 +1,13 @@
+/**
+ * @typedef Stat
+ * @property {number} checked
+ * @property {number} unchecked
+ */
+/**
+ * @param {Stat} stat - the Stat.
+ */
+function statReset(stat) {
+  stat.checked = 0;
+  stat.unchecked = 0;
+}
+export {statReset};

package/ui/babel-core.mjs

@@ -0,0 +1,5 @@
+// Instead of loading this as UMD module, we will soon integrate Babel 8, which
+// finally ships as proper ESM modules. But it requires a bit more work (tm).
+await import("../unpkg.com_@babel_standalone@7.22.17_babel.js");
+const { parseSync } = Babel._babel;
+export { parseSync };

package/ui/babel-helper-plugin-utils.mjs

@@ -0,0 +1,7 @@
+// Test: await import("@babel/helper-plugin-utils")
+/** @type {Record<string, any>} */
+const exports = {};
+globalThis.exports = exports;
+await import("../node_modules/@babel/helper-plugin-utils/lib/index.js");
+export const {declare, declarePreset} = exports;
+export default exports;

package/ui/babel-parser.mjs

@@ -0,0 +1,8 @@
+// Note: this is still ugly, but Babel 8 should be "nice" ESM (when it's out)
+// Test: const {parse} = await import("@babel/parser");
+/** @type {Record<string, any>} */
+const exports = {};
+globalThis.exports = exports;
+await import("../node_modules/@babel/parser/lib/index.js");
+export const {parse, parseExpression, tokTypes} = exports;
+export default exports;

package/ui/babel-plugin-syntax-typescript.mjs

@@ -0,0 +1,58 @@
+
+// Test: const {babelPluginSyntaxTypeScript} = await import("@babel/plugin-syntax-typescript");
+/*
+const {parse} = await import("@babel/parser");
+parse('type tmp = 123;', {
+  plugins: [babelPluginSyntaxTypeScript?]
+})
+*/
+import {declare} from '@babel/helper-plugin-utils';
+/**
+ * @param {any[]} plugins 
+ * @param {string} name 
+ */
+function removePlugin(plugins, name) {
+  const indices = [];
+  plugins.forEach((plugin, i) => {
+    const n = Array.isArray(plugin) ? plugin[0] : plugin;
+    if (n === name) {
+      indices.unshift(i);
+    }
+  });
+  for (const i of indices) {
+    plugins.splice(i, 1);
+  }
+};
+const babelPluginSyntaxTypeScript = declare((api, opts) => {
+  api.assertVersion(7);
+  const {
+    disallowAmbiguousJSXLike,
+    dts
+  } = opts;
+  {
+    var {
+      isTSX
+    } = opts;
+  }
+  return {
+    name: "syntax-typescript",
+    manipulateOptions(opts, parserOpts) {
+      {
+        const {
+          plugins
+        } = parserOpts;
+        removePlugin(plugins, "flow");
+        removePlugin(plugins, "jsx");
+        plugins.push("objectRestSpread", "classProperties");
+        if (isTSX) {
+          plugins.push("jsx");
+        }
+      }
+      parserOpts.plugins.push(["typescript", {
+        disallowAmbiguousJSXLike,
+        dts
+      }]);
+    }
+  };
+});
+export {babelPluginSyntaxTypeScript};

package/ui/importmap.js

@@ -0,0 +1,38 @@
+function importFile(content) {
+  return "data:text/javascript;base64," + btoa(content);
+}
+const imports = {
+  //"@babel/core": "./babel-core.mjs",
+  "@babel/parser": "./babel-parser.mjs",
+  //"@babel/helper-plugin-utils": "./babel-helper-plugin-utils.mjs",
+  //"@babel/plugin-syntax-typescript": "./babel-plugin-syntax-typescript.mjs",
+  "fs": importFile("export default {};"),
+  "typescript": importFile("export default ts;"), // UMD import
+  /*
+  "path": importFile("export default {};"),
+  "stream/web": importFile("export default {};"),
+  "sharp": importFile("export default {};"),
+  "onnxruntime-node": importFile("export default {};"),
+  "onnxruntime-web": importFile(`
+    //await import("https://cdnjs.cloudflare.com/ajax/libs/onnxruntime-web/1.15.0/ort.es6.min.js");
+    await import("https://cdnjs.cloudflare.com/ajax/libs/onnxruntime-web/1.14.0/ort.es6.min.js");
+    //http://127.0.0.1/transformer/onnxruntime/js/common/dist/
+    //await import("http://127.0.0.1/transformer/onnxruntime/js/common/dist/ort-common.js");
+    //await import("http://127.0.0.1/transformer/onnxruntime/js/web/dist/ort-webgl.js");
+    //await import("https://cdnjs.cloudflare.com/ajax/libs/onnxruntime-web/1.14.0/ort.es6.min.js");
+    let ONNX = globalThis.ort;
+    export default ONNX;
+    export {
+      ONNX
+    };
+  `),
+  */
+};
+const importmap = document.createElement("script");
+importmap.type = "importmap";
+importmap.textContent = JSON.stringify({imports});
+const parent = document.body || document.head;
+if (!parent) {
+  throw "neither <body> nor <head> available to append importmap";
+}
+parent.append(importmap);