xml-model 1.2.0 → 1.3.1

package/dist/types.d.ts

@@ -14,3 +14,4 @@ export interface XMLElement {
 export type XMLRoot = {
     elements: XMLElement[];
 };
+//# sourceMappingURL=types.d.ts.map

package/dist/util/is-regexp.d.ts

@@ -9,3 +9,4 @@
  */
 export declare function isRegExp(value: unknown): value is RegExp;
 export default isRegExp;
+//# sourceMappingURL=is-regexp.d.ts.map

package/dist/util/kebab-case.d.ts

@@ -13,3 +13,4 @@
  * @returns The kebab-cased string
  */
 export declare function kebabCase(str: string, keepLeadingDash?: boolean): string;
+//# sourceMappingURL=kebab-case.d.ts.map

package/dist/util/merge-maps.d.ts

@@ -1 +1,2 @@
 export default function mergeMaps<K, V>(...sources: Map<K, V>[]): Map<K, V>;
+//# sourceMappingURL=merge-maps.d.ts.map

package/dist/xml/index.d.ts

@@ -30,3 +30,4 @@ declare const XML: {
     deleteAttribute: typeof deleteAttribute;
 };
 export default XML;
+//# sourceMappingURL=index.d.ts.map

package/dist/xml/xml-js.d.ts

@@ -4,3 +4,4 @@ declare const _default: {
     stringify: typeof stringify;
 };
 export default _default;
+//# sourceMappingURL=xml-js.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xml-model",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "allows transparent XML <-> Object conversion in typescript",
   "license": "MIT",
   "author": "MathisTLD",
@@ -34,6 +34,7 @@
     "prepare": "husky"
   },
   "dependencies": {
+    "typescript-rtti": "0.9.6",
     "xml-js": "^1.6.11"
   },
   "devDependencies": {
@@ -44,15 +45,14 @@
     "marmotte": "^0.1.4",
     "oxfmt": "^0.28.0",
     "oxlint": "^1.43.0",
+    "reflect-metadata": "^0.1.14",
     "typescript": "*",
     "vite": "*",
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
     "@rollup/plugin-typescript": "^12.3.0",
-    "reflect-metadata": "^0.1.14",
-    "typescript": "^5.1.0",
-    "typescript-rtti": "^0.9.6",
+    "typescript": "~5.1.6",
     "vite": "^7.3.1"
   },
   "peerDependenciesMeta": {

package/vite/dist/index.js

@@ -1,6 +1,5 @@
 import typescript from "@rollup/plugin-typescript";
-import _rtti from "./_virtual/index.js";
-const rtti = "default" in _rtti ? _rtti.default : _rtti;
+import transformer from "./node_modules/typescript-rtti/dist.esm/transformer/index.js";
 function FixClassNames() {
   return {
     name: "fix-class-names",
@@ -33,7 +32,7 @@ function TypescriptRTTI(options = {}) {
           type: "program",
           factory: (program) => {
             if (debug) console.debug("[RTTI] Transformer is running!");
-            const transformerFactory = rtti(program);
+            const transformerFactory = transformer(program);
             return (context) => {
               const transform = transformerFactory(context);
               return (source) => {

package/vite/dist/node_modules/typescript-rtti/dist.esm/common/format.js

@@ -0,0 +1,105 @@
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+const F_READONLY = "R";
+const F_ABSTRACT = "A";
+const F_PUBLIC = "$";
+const F_PRIVATE = "#";
+const F_PROTECTED = "@";
+const F_PROPERTY = "P";
+const F_METHOD = "M";
+const F_STATIC = "S";
+const F_CLASS = "C";
+const F_INTERFACE = "I";
+const F_FUNCTION = "F";
+const F_ARROW_FUNCTION = ">";
+const F_OPTIONAL = "?";
+const F_REST = "3";
+const F_ASYNC = "a";
+const F_EXPORTED = "e";
+const F_INFERRED = ".";
+const F_OMITTED = ",";
+const F_ARRAY_BINDING = "[";
+const F_OBJECT_BINDING = "O";
+const T_UNION = "|";
+const T_INTERSECTION = "&";
+const T_ANY = "~";
+const T_UNKNOWN = "U";
+const T_VOID = "V";
+const T_UNDEFINED = "u";
+const T_NULL = "n";
+const T_TUPLE = "T";
+const T_ARRAY = "[";
+const T_THIS = "t";
+const T_GENERIC = "g";
+const T_MAPPED = "m";
+const T_TRUE = "1";
+const T_FALSE = "0";
+const T_CALLSITE = "c";
+const T_STAND_IN = "5";
+const T_OBJECT = "O";
+const T_ENUM = "e";
+const T_FUNCTION = "F";
+const T_INTRINSICS = [T_VOID, T_ANY, T_UNKNOWN, T_UNDEFINED, T_TRUE, T_FALSE, T_THIS, T_NULL];
+const TI_VOID = { TΦ: T_VOID };
+const TI_ANY = { TΦ: T_ANY };
+const TI_UNKNOWN = { TΦ: T_UNKNOWN };
+const TI_UNDEFINED = { TΦ: T_UNDEFINED };
+const TI_TRUE = { TΦ: T_TRUE };
+const TI_FALSE = { TΦ: T_FALSE };
+const TI_THIS = { TΦ: T_THIS };
+const TI_NULL = { TΦ: T_NULL };
+function isLiteralNode(node) {
+  return !!node["$__isTSNode"];
+}
+export {
+  F_ABSTRACT,
+  F_ARRAY_BINDING,
+  F_ARROW_FUNCTION,
+  F_ASYNC,
+  F_CLASS,
+  F_EXPORTED,
+  F_FUNCTION,
+  F_INFERRED,
+  F_INTERFACE,
+  F_METHOD,
+  F_OBJECT_BINDING,
+  F_OMITTED,
+  F_OPTIONAL,
+  F_PRIVATE,
+  F_PROPERTY,
+  F_PROTECTED,
+  F_PUBLIC,
+  F_READONLY,
+  F_REST,
+  F_STATIC,
+  TI_ANY,
+  TI_FALSE,
+  TI_NULL,
+  TI_THIS,
+  TI_TRUE,
+  TI_UNDEFINED,
+  TI_UNKNOWN,
+  TI_VOID,
+  T_ANY,
+  T_ARRAY,
+  T_CALLSITE,
+  T_ENUM,
+  T_FALSE,
+  T_FUNCTION,
+  T_GENERIC,
+  T_INTERSECTION,
+  T_INTRINSICS,
+  T_MAPPED,
+  T_NULL,
+  T_OBJECT,
+  T_STAND_IN,
+  T_THIS,
+  T_TRUE,
+  T_TUPLE,
+  T_UNDEFINED,
+  T_UNION,
+  T_UNKNOWN,
+  T_VOID,
+  isLiteralNode
+};
+//# sourceMappingURL=format.js.map

package/vite/dist/node_modules/typescript-rtti/dist.esm/common/index.js

@@ -0,0 +1,55 @@
+import { createRequire } from "node:module";
+import { F_ABSTRACT, F_ARRAY_BINDING, F_ARROW_FUNCTION, F_ASYNC, F_CLASS, F_EXPORTED, F_FUNCTION, F_INFERRED, F_INTERFACE, F_METHOD, F_OBJECT_BINDING, F_OMITTED, F_OPTIONAL, F_PRIVATE, F_PROPERTY, F_PROTECTED, F_PUBLIC, F_READONLY, F_REST, F_STATIC, TI_ANY, TI_FALSE, TI_NULL, TI_THIS, TI_TRUE, TI_UNDEFINED, TI_UNKNOWN, TI_VOID, T_ANY, T_ARRAY, T_CALLSITE, T_ENUM, T_FALSE, T_FUNCTION, T_GENERIC, T_INTERSECTION, T_INTRINSICS, T_MAPPED, T_NULL, T_OBJECT, T_STAND_IN, T_THIS, T_TRUE, T_TUPLE, T_UNDEFINED, T_UNION, T_UNKNOWN, T_VOID, isLiteralNode } from "./format.js";
+const require$1 = createRequire(import.meta.url);
+export {
+  F_ABSTRACT,
+  F_ARRAY_BINDING,
+  F_ARROW_FUNCTION,
+  F_ASYNC,
+  F_CLASS,
+  F_EXPORTED,
+  F_FUNCTION,
+  F_INFERRED,
+  F_INTERFACE,
+  F_METHOD,
+  F_OBJECT_BINDING,
+  F_OMITTED,
+  F_OPTIONAL,
+  F_PRIVATE,
+  F_PROPERTY,
+  F_PROTECTED,
+  F_PUBLIC,
+  F_READONLY,
+  F_REST,
+  F_STATIC,
+  TI_ANY,
+  TI_FALSE,
+  TI_NULL,
+  TI_THIS,
+  TI_TRUE,
+  TI_UNDEFINED,
+  TI_UNKNOWN,
+  TI_VOID,
+  T_ANY,
+  T_ARRAY,
+  T_CALLSITE,
+  T_ENUM,
+  T_FALSE,
+  T_FUNCTION,
+  T_GENERIC,
+  T_INTERSECTION,
+  T_INTRINSICS,
+  T_MAPPED,
+  T_NULL,
+  T_OBJECT,
+  T_STAND_IN,
+  T_THIS,
+  T_TRUE,
+  T_TUPLE,
+  T_UNDEFINED,
+  T_UNION,
+  T_UNKNOWN,
+  T_VOID,
+  isLiteralNode
+};
+//# sourceMappingURL=index.js.map

package/vite/dist/node_modules/typescript-rtti/dist.esm/transformer/api-call-transformer.js

@@ -0,0 +1,152 @@
+import { Visit } from "./common/visitor-base.js";
+import ts from "typescript";
+import { isStatement, getRttiDocTagFromSignature, hasFlag } from "./utils.js";
+import { RttiVisitor } from "./rtti-visitor-base.js";
+import { serialize } from "./serialize.js";
+import { TypeEncoder } from "./type-encoder.js";
+import { literalNode } from "./literal-node.js";
+import { createRequire } from "node:module";
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+const require$1 = createRequire(import.meta.url);
+class ApiCallTransformer extends RttiVisitor {
+  constructor() {
+    super(...arguments);
+    this.typeEncoder = new TypeEncoder(this.ctx);
+  }
+  static transform(node, ctx) {
+    let transformer = new ApiCallTransformer(ctx);
+    return transformer.visitNode(node);
+  }
+  everyNode(node) {
+    if (isStatement(node) && node.parent && ts.isSourceFile(node.parent)) {
+      this.ctx.currentTopStatement = node;
+    }
+  }
+  isRttiCall(expr, name) {
+    if (!ts.isIdentifier(expr.expression))
+      return false;
+    return ts.isIdentifier(expr.expression) && this.isAnyImportedSymbol(this.checker.getSymbolAtLocation(expr.expression), ["typescript-rtti", "./FΦtypescript-rtti", "./FΦtypescript-rtti.js"], name ? [name] : ["reify", "reflect"]);
+  }
+  isAnyImportedSymbol(symbol, packageName, names) {
+    if (!symbol || !names.includes(symbol.name))
+      return false;
+    return this.isSymbolFromPackage(symbol, packageName);
+  }
+  isImportedSymbol(symbol, packageName, name) {
+    return this.isAnyImportedSymbol(symbol, [packageName], [name]);
+  }
+  isSymbolFromPackage(symbol, packageNames) {
+    let decls = Array.from(symbol.getDeclarations());
+    let importSpecifier = decls.find((x) => x.kind === ts.SyntaxKind.ImportSpecifier);
+    if (!importSpecifier)
+      return false;
+    let modSpecifier = importSpecifier.parent.parent.parent.moduleSpecifier;
+    if (!ts.isStringLiteral(modSpecifier))
+      return false;
+    for (let packageName of packageNames) {
+      let matches = modSpecifier.text === packageName || modSpecifier.text.match(new RegExp(`^https?:.*/${packageName}/index.js$`)) || modSpecifier.text.match(new RegExp(`^https?:.*/${packageName}/index.ts$`)) || modSpecifier.text.match(new RegExp(`^https?:.*/${packageName}/?$`));
+      if (matches)
+        return true;
+    }
+    return false;
+  }
+  isCallSiteTypeRef(typeNode) {
+    if (!typeNode)
+      return false;
+    if (typeNode.kind === ts.SyntaxKind.TypeReference) {
+      let typeRef = typeNode;
+      if (!typeRef.typeName)
+        return false;
+      if (typeRef.typeName.kind === ts.SyntaxKind.Identifier && typeRef.typeName.text === "CallSite") {
+        let symbol = this.checker.getSymbolAtLocation(typeRef.typeName);
+        return this.isImportedSymbol(symbol, "typescript-rtti", "CallSite");
+      }
+    }
+    return false;
+  }
+  isCallSiteParameter(param) {
+    return !!(param === null || param === void 0 ? void 0 : param.questionToken) && this.isCallSiteTypeRef(param === null || param === void 0 ? void 0 : param.type);
+  }
+  typeOfParamSymbol(symbol) {
+    return this.checker.getTypeOfSymbolAtLocation(symbol, symbol.getDeclarations()[0]);
+  }
+  callExpr(expr) {
+    var _a;
+    let signature = this.checker.getResolvedSignature(expr);
+    if (!signature) {
+      debugger;
+      if (globalThis.RTTI_TRACE)
+        console.warn(`RTTI: Could not find signature for call expression '${expr.getText()}'`);
+      return expr;
+    }
+    let params = signature.parameters;
+    let callSiteArgIndex = params.findIndex((x) => this.isCallSiteParameter(x.valueDeclaration));
+    if (callSiteArgIndex < 0) {
+      let callSiteArgFromJsDoc = getRttiDocTagFromSignature(signature, "callsite");
+      if (callSiteArgFromJsDoc)
+        callSiteArgIndex = Number(callSiteArgFromJsDoc);
+    }
+    if (this.isRttiCall(expr, "reflect") && callSiteArgIndex < 0) {
+      callSiteArgIndex = 1;
+    } else if (this.isRttiCall(expr, "reify") && callSiteArgIndex < 0) {
+      callSiteArgIndex = 0;
+    }
+    if (callSiteArgIndex >= 0 && callSiteArgIndex >= expr.arguments.length) {
+      let args = Array.from(expr.arguments);
+      while (callSiteArgIndex > args.length) {
+        args.push(ts.factory.createVoidZero());
+      }
+      args.push(serialize({
+        TΦ: "c",
+        t: void 0,
+        p: expr.arguments.map((x) => literalNode(this.referToType(this.checker.getTypeAtLocation(x)))),
+        r: void 0,
+        tp: ((_a = expr.typeArguments) !== null && _a !== void 0 ? _a : []).map((x) => literalNode(this.referToType(this.checker.getTypeAtLocation(x))))
+      }));
+      return ts.factory.updateCallExpression(this.visitEachChild(expr), expr.expression, expr.typeArguments, args);
+    } else {
+      return this.visitEachChild(expr);
+    }
+  }
+  referToType(type) {
+    if (hasFlag(type.flags, ts.TypeFlags.TypeVariable)) {
+      let symbol = type.symbol;
+      let decl = symbol.declarations[0];
+      if (ts.isTypeParameterDeclaration(decl)) {
+        let parentDecl = decl.parent;
+        if (ts.isFunctionDeclaration(parentDecl) || ts.isArrowFunction(parentDecl) || ts.isMethodDeclaration(parentDecl) || ts.isFunctionExpression(parentDecl)) {
+          let typeIndex = parentDecl.typeParameters.findIndex((tp) => this.checker.getTypeAtLocation(tp) === type);
+          if (typeIndex >= 0) {
+            let callSiteArgIndex = parentDecl.parameters.findIndex((p) => this.isCallSiteParameter(p));
+            if (callSiteArgIndex >= 0) {
+              let callSiteArg = parentDecl.parameters[callSiteArgIndex];
+              if (ts.isIdentifier(callSiteArg.name)) {
+                let callSiteName = callSiteArg.name.text;
+                return ts.factory.createElementAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(callSiteName), "tp"), typeIndex);
+              }
+            }
+          }
+        }
+      }
+    }
+    return this.typeEncoder.referToType(type);
+  }
+}
+__decorate([
+  Visit(ts.SyntaxKind.CallExpression),
+  __metadata("design:type", Function),
+  __metadata("design:paramtypes", [Object]),
+  __metadata("design:returntype", void 0)
+], ApiCallTransformer.prototype, "callExpr", null);
+export {
+  ApiCallTransformer
+};
+//# sourceMappingURL=api-call-transformer.js.map

package/vite/dist/node_modules/typescript-rtti/dist.esm/transformer/common/class-analyzer.js

@@ -0,0 +1,83 @@
+import { VisitorBase, Visit } from "./visitor-base.js";
+import ts from "typescript";
+import { getModifiers } from "../utils.js";
+import { createRequire } from "node:module";
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+const require$1 = createRequire(import.meta.url);
+class ClassAnalyzer extends VisitorBase {
+  constructor() {
+    super(...arguments);
+    this.details = {
+      methodNames: [],
+      propertyNames: [],
+      staticMethodNames: [],
+      staticPropertyNames: []
+    };
+  }
+  isStatic(decl) {
+    return getModifiers(decl).some((x) => x.kind === ts.SyntaxKind.StaticKeyword);
+  }
+  static analyze(decl, context) {
+    try {
+      let analyzer = new ClassAnalyzer(context);
+      analyzer.visitEachChild(decl);
+      return analyzer.details;
+    } catch (e) {
+      console.error(`RTTI: During analyzer for class ${decl.name.getText()}: ${e.message}`);
+      throw e;
+    }
+  }
+  addItem(list, prop) {
+    if (!list.includes(prop))
+      list.push(prop);
+  }
+  property(decl) {
+    this.addItem(this.isStatic(decl) ? this.details.staticPropertyNames : this.details.propertyNames, decl.name);
+  }
+  method(decl) {
+    this.addItem(this.isStatic(decl) ? this.details.staticMethodNames : this.details.methodNames, decl.name);
+  }
+  ctor(decl) {
+    for (let param of decl.parameters) {
+      let paramModifiers = getModifiers(param);
+      let isProperty = paramModifiers && (paramModifiers.some((x) => x.kind === ts.SyntaxKind.PublicKeyword) || paramModifiers.some((x) => x.kind === ts.SyntaxKind.ProtectedKeyword) || paramModifiers.some((x) => x.kind === ts.SyntaxKind.PrivateKeyword) || paramModifiers.some((x) => x.kind === ts.SyntaxKind.ReadonlyKeyword));
+      if (isProperty) {
+        if (ts.isIdentifier(param.name)) {
+          this.addItem(this.details.propertyNames, param.name);
+        } else {
+          throw new Error(`Unexpected binding name as property in constructor for class ${decl.name.getText()}! Please file a bug!`);
+        }
+      }
+    }
+  }
+}
+__decorate([
+  Visit([ts.SyntaxKind.PropertyDeclaration, ts.SyntaxKind.GetAccessor, ts.SyntaxKind.SetAccessor]),
+  __metadata("design:type", Function),
+  __metadata("design:paramtypes", [Object]),
+  __metadata("design:returntype", void 0)
+], ClassAnalyzer.prototype, "property", null);
+__decorate([
+  Visit(ts.SyntaxKind.MethodDeclaration),
+  __metadata("design:type", Function),
+  __metadata("design:paramtypes", [Object]),
+  __metadata("design:returntype", void 0)
+], ClassAnalyzer.prototype, "method", null);
+__decorate([
+  Visit(ts.SyntaxKind.Constructor),
+  __metadata("design:type", Function),
+  __metadata("design:paramtypes", [Object]),
+  __metadata("design:returntype", void 0)
+], ClassAnalyzer.prototype, "ctor", null);
+export {
+  ClassAnalyzer
+};
+//# sourceMappingURL=class-analyzer.js.map

package/vite/dist/node_modules/typescript-rtti/dist.esm/transformer/common/compile-error.js

@@ -0,0 +1,8 @@
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+class CompileError extends Error {
+}
+export {
+  CompileError
+};
+//# sourceMappingURL=compile-error.js.map

package/vite/dist/node_modules/typescript-rtti/dist.esm/transformer/common/import-analyzer.js

@@ -0,0 +1,89 @@
+import { Visit } from "./visitor-base.js";
+import ts from "typescript";
+import { RttiVisitor } from "../rtti-visitor-base.js";
+import { createRequire } from "node:module";
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+const require$1 = createRequire(import.meta.url);
+class ImportAnalyzer extends RttiVisitor {
+  static analyze(file, ctx) {
+    let analyzer = new ImportAnalyzer(ctx);
+    try {
+      analyzer.visitEachChild(file);
+    } catch (e) {
+      console.error(`RTTI: While analyzing imports for file '${file.fileName}': ${e.message}`);
+      throw e;
+    }
+  }
+  import(decl) {
+    var _a, _b;
+    if (decl.importClause) {
+      let bindings = decl.importClause.namedBindings;
+      if (!bindings) {
+        let name = decl.importClause.name.text;
+        this.ctx.importMap.set(name, {
+          name,
+          localName: name,
+          refName: name,
+          modulePath: decl.moduleSpecifier.text,
+          isNamespace: false,
+          isDefault: true,
+          importDeclaration: decl
+        });
+      } else if (bindings) {
+        if (ts.isNamedImports(bindings)) {
+          for (let binding of bindings.elements) {
+            this.ctx.importMap.set(binding.name.text, {
+              name: binding.name.text,
+              symbol: this.checker.getSymbolAtLocation(binding.name),
+              localName: `${(_b = (_a = binding.propertyName) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : binding.name.text}Φ`,
+              refName: binding.name.text,
+              modulePath: decl.moduleSpecifier.text,
+              isNamespace: false,
+              isDefault: false,
+              importDeclaration: decl
+            });
+            let nameAsInterface = `IΦ${binding.name.text}`;
+            this.ctx.importMap.set(nameAsInterface, {
+              name: nameAsInterface,
+              localName: nameAsInterface,
+              refName: nameAsInterface,
+              modulePath: decl.moduleSpecifier.text,
+              isNamespace: false,
+              isDefault: false,
+              importDeclaration: decl
+            });
+          }
+        } else if (ts.isNamespaceImport(bindings)) {
+          this.ctx.importMap.set(bindings.name.text, {
+            name: bindings.name.text,
+            localName: `${bindings.name.text}Φ`,
+            modulePath: decl.moduleSpecifier.text,
+            refName: bindings.name.text,
+            isNamespace: true,
+            isDefault: false,
+            importDeclaration: decl
+          });
+          bindings.name;
+        }
+      }
+    }
+  }
+}
+__decorate([
+  Visit(ts.SyntaxKind.ImportDeclaration),
+  __metadata("design:type", Function),
+  __metadata("design:paramtypes", [Object]),
+  __metadata("design:returntype", void 0)
+], ImportAnalyzer.prototype, "import", null);
+export {
+  ImportAnalyzer
+};
+//# sourceMappingURL=import-analyzer.js.map

package/vite/dist/node_modules/typescript-rtti/dist.esm/transformer/common/interface-analyzer.js

@@ -0,0 +1,58 @@
+import { VisitorBase, Visit } from "./visitor-base.js";
+import ts from "typescript";
+import { createRequire } from "node:module";
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+const require$1 = createRequire(import.meta.url);
+class InterfaceAnalyzer extends VisitorBase {
+  constructor() {
+    super(...arguments);
+    this.details = {
+      methodNames: [],
+      propertyNames: []
+    };
+  }
+  static analyze(decl, context) {
+    try {
+      let analyzer = new InterfaceAnalyzer(context);
+      analyzer.visitEachChild(decl);
+      return analyzer.details;
+    } catch (e) {
+      console.error(`RTTI: During analyzer for interface ${decl.name.getText()}: ${e.message}`);
+      throw e;
+    }
+  }
+  addItem(array, item) {
+    if (!array.includes(item))
+      array.push(item);
+  }
+  property(signature) {
+    this.addItem(this.details.propertyNames, signature.name);
+  }
+  method(signature) {
+    this.addItem(this.details.methodNames, signature.name);
+  }
+}
+__decorate([
+  Visit(ts.SyntaxKind.PropertySignature),
+  __metadata("design:type", Function),
+  __metadata("design:paramtypes", [Object]),
+  __metadata("design:returntype", void 0)
+], InterfaceAnalyzer.prototype, "property", null);
+__decorate([
+  Visit(ts.SyntaxKind.MethodSignature),
+  __metadata("design:type", Function),
+  __metadata("design:paramtypes", [Object]),
+  __metadata("design:returntype", void 0)
+], InterfaceAnalyzer.prototype, "method", null);
+export {
+  InterfaceAnalyzer
+};
+//# sourceMappingURL=interface-analyzer.js.map