runtime-type-inspector 2.0.2 → 2.0.3

package/src-transpiler/expandType.mjs

@@ -1,187 +0,0 @@
-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

@@ -1,122 +0,0 @@
-/**
- * @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

@@ -1,23 +0,0 @@
-/**
- * @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

@@ -1,13 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,31 +0,0 @@
-/**
- * @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

@@ -1,13 +0,0 @@
-/**
- * @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

@@ -1,5 +0,0 @@
-// 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

@@ -1,7 +0,0 @@
-// 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

@@ -1,8 +0,0 @@
-// 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

@@ -1,58 +0,0 @@
-
-// 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

@@ -1,38 +0,0 @@
-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);