xml-model 1.3.2 → 2.0.0-beta.1

package/dist/types.d.ts

@@ -1,17 +0,0 @@
-export type { Constructor } from 'typescript-rtti';
-export type UnknownRecord = Record<string | number | symbol, unknown>;
-export type UnknownObject = object;
-export interface XMLAttributes {
-    [key: string]: string | number | undefined;
-}
-export interface XMLElement {
-    type?: string;
-    name?: string;
-    attributes?: XMLAttributes;
-    elements?: Array<XMLElement>;
-    text?: string | number | boolean;
-}
-export type XMLRoot = {
-    elements: XMLElement[];
-};
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,12 +0,0 @@
-/**
- * Stolen from https://github.com/sindresorhus/is-regexp/blob/main/index.js
- *
- * see https://github.com/sindresorhus/is#why-not-just-use-instanceof-instead-of-this-package
- *
- * could use `import { isRegExp } from "node:util/types"` but I want isomorphic lib
- * @param value
- * @returns
- */
-export declare function isRegExp(value: unknown): value is RegExp;
-export default isRegExp;
-//# sourceMappingURL=is-regexp.d.ts.map

package/dist/util/is-regexp.js

@@ -1,8 +0,0 @@
-function isRegExp(value) {
-  return Object.prototype.toString.call(value) === "[object RegExp]";
-}
-export {
-  isRegExp as default,
-  isRegExp
-};
-//# sourceMappingURL=is-regexp.js.map

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

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

package/dist/util/merge-maps.js

@@ -1,23 +0,0 @@
-function mergeMaps(...sources) {
-  const res = /* @__PURE__ */ new Map();
-  sources.forEach((source) => {
-    const overrides = /* @__PURE__ */ new Map();
-    const additions = /* @__PURE__ */ new Map();
-    source.forEach((val, key) => (res.has(key) ? overrides : additions).set(key, val));
-    if (overrides.size) {
-      const entries = Array.from(res.entries());
-      entries.forEach((entry) => {
-        const key = entry[0];
-        if (overrides.has(key)) entry[1] = overrides.get(key);
-      });
-      res.clear();
-      entries.forEach(([key, val]) => res.set(key, val));
-    }
-    additions.forEach((val, key) => res.set(key, val));
-  });
-  return res;
-}
-export {
-  mergeMaps as default
-};
-//# sourceMappingURL=merge-maps.js.map

package/dist/vite/index.d.ts

@@ -1,53 +0,0 @@
-import { RollupTypescriptOptions } from '@rollup/plugin-typescript';
-/**
- * When Building, class names are changed but the library relies on them
- * so they need to be preserved
- * @returns
- */
-export declare function FixClassNames(): {
-    name: string;
-    enforce: "post";
-    transform(this: import('rollup').TransformPluginContext, code: string, id: string): {
-        code: string;
-        map: any;
-    };
-    config(this: import('vite').ConfigPluginContext): {
-        esbuild: {
-            keepNames: true;
-        };
-    };
-};
-export type RTTIPluginOptions = {
-    /**
-     * options for @rollup/plugin-typescript
-     *
-     * Plugin might not work if you override the `transformers` property as these options are assigned and not deep merged
-     */
-    typescript?: RollupTypescriptOptions;
-    /** Files where the rtti transformer should be applied
-     *
-     * If not set, will include every files by default
-     */
-    include?: RegExp;
-    /** Files where the rtti transformer should not be applied */
-    exclude?: RegExp;
-    /** Print debug logs */
-    debug?: boolean;
-};
-export declare function TypescriptRTTI(options?: RTTIPluginOptions): import('rollup').Plugin<any>;
-export type XMLModelVitePluginOptions = RTTIPluginOptions;
-export declare function XMLModelVitePlugin(options?: RTTIPluginOptions): (import('rollup').Plugin<any> | {
-    name: string;
-    enforce: "post";
-    transform(this: import('rollup').TransformPluginContext, code: string, id: string): {
-        code: string;
-        map: any;
-    };
-    config(this: import('vite').ConfigPluginContext): {
-        esbuild: {
-            keepNames: true;
-        };
-    };
-})[];
-export default XMLModelVitePlugin;
-//# sourceMappingURL=index.d.ts.map

package/dist/vite/index.js

@@ -1,63 +0,0 @@
-import typescript from "@rollup/plugin-typescript";
-import transformer from "./node_modules/typescript-rtti/dist.esm/transformer/index.js";
-function FixClassNames() {
-  return {
-    name: "fix-class-names",
-    enforce: "post",
-    transform(code, id) {
-      if (!id.endsWith(".ts") && !id.endsWith(".tsx")) return;
-      const fixed = code.replace(/let\s+(\w+)\s*=\s*class\s+(?!extends)\w+/g, "let $1 = class $1");
-      return { code: fixed, map: null };
-    },
-    config() {
-      return {
-        esbuild: {
-          // if not using this ClassName is changed back to ClassName2 on build
-          keepNames: true
-        }
-      };
-    }
-  };
-}
-function TypescriptRTTI(options = {}) {
-  const { typescript: rollupPluginTypescriptOptions, include, exclude, debug = false } = options;
-  const doTransform = !include && !exclude ? () => true : (path) => {
-    if (exclude?.test(path)) return false;
-    return include ? include.test(path) : true;
-  };
-  return typescript({
-    transformers: {
-      before: [
-        {
-          type: "program",
-          factory: (program) => {
-            if (debug) console.debug("[RTTI] Transformer is running!");
-            const transformerFactory = transformer(program);
-            return (context) => {
-              const transform = transformerFactory(context);
-              return (source) => {
-                if (doTransform(source.fileName)) {
-                  if (debug) console.debug(`[RTTI] transforming ${source.fileName}`);
-                  return transform(source);
-                } else return source;
-              };
-            };
-          }
-        }
-      ]
-    },
-    // set declaration to `false` to let plugin dts handle the declarations
-    declaration: false,
-    ...rollupPluginTypescriptOptions
-  });
-}
-function XMLModelVitePlugin(options = {}) {
-  return [FixClassNames(), TypescriptRTTI(options)];
-}
-export {
-  FixClassNames,
-  TypescriptRTTI,
-  XMLModelVitePlugin,
-  XMLModelVitePlugin as default
-};
-//# sourceMappingURL=index.js.map

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

@@ -1,105 +0,0 @@
-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/dist/vite/node_modules/typescript-rtti/dist.esm/common/index.js

@@ -1,55 +0,0 @@
-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/dist/vite/node_modules/typescript-rtti/dist.esm/transformer/api-call-transformer.js

@@ -1,152 +0,0 @@
-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/dist/vite/node_modules/typescript-rtti/dist.esm/transformer/common/class-analyzer.js

@@ -1,83 +0,0 @@
-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/dist/vite/node_modules/typescript-rtti/dist.esm/transformer/common/compile-error.js

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

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

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