xml-model 0.2.9 → 1.0.0-beta.0

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

@@ -0,0 +1,130 @@
+import "../../../../../_virtual/_commonjsHelpers.js";
+import { __exports as importAnalyzer } from "../../../../../_virtual/import-analyzer.js";
+import { __require as requireVisitorBase } from "./visitor-base.js";
+import "../../../../../_virtual/_typescript.js";
+import { __require as requireRttiVisitorBase } from "../rtti-visitor-base.js";
+import require$$0 from "typescript";
+var hasRequiredImportAnalyzer;
+function requireImportAnalyzer() {
+  if (hasRequiredImportAnalyzer) return importAnalyzer;
+  hasRequiredImportAnalyzer = 1;
+  "use strict";
+  var __createBinding = importAnalyzer && importAnalyzer.__createBinding || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  }) : (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    o[k2] = m[k];
+  }));
+  var __setModuleDefault = importAnalyzer && importAnalyzer.__setModuleDefault || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  }) : function(o, v) {
+    o["default"] = v;
+  });
+  var __decorate = importAnalyzer && importAnalyzer.__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 __importStar = importAnalyzer && importAnalyzer.__importStar || function(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __metadata = importAnalyzer && importAnalyzer.__metadata || function(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+  };
+  Object.defineProperty(importAnalyzer, "__esModule", { value: true });
+  importAnalyzer.ImportAnalyzer = void 0;
+  const visitor_base_1 = requireVisitorBase();
+  const ts = __importStar(require$$0);
+  const rtti_visitor_base_1 = requireRttiVisitorBase();
+  class ImportAnalyzer extends rtti_visitor_base_1.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([
+    (0, visitor_base_1.Visit)(ts.SyntaxKind.ImportDeclaration),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+  ], ImportAnalyzer.prototype, "import", null);
+  importAnalyzer.ImportAnalyzer = ImportAnalyzer;
+  return importAnalyzer;
+}
+export {
+  requireImportAnalyzer as __require
+};
+//# sourceMappingURL=import-analyzer.js.map

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

@@ -0,0 +1,98 @@
+import "../../../../../_virtual/_commonjsHelpers.js";
+import { __exports as interfaceAnalyzer } from "../../../../../_virtual/interface-analyzer.js";
+import { __require as requireVisitorBase } from "./visitor-base.js";
+import "../../../../../_virtual/_typescript.js";
+import require$$0 from "typescript";
+var hasRequiredInterfaceAnalyzer;
+function requireInterfaceAnalyzer() {
+  if (hasRequiredInterfaceAnalyzer) return interfaceAnalyzer;
+  hasRequiredInterfaceAnalyzer = 1;
+  "use strict";
+  var __createBinding = interfaceAnalyzer && interfaceAnalyzer.__createBinding || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  }) : (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    o[k2] = m[k];
+  }));
+  var __setModuleDefault = interfaceAnalyzer && interfaceAnalyzer.__setModuleDefault || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  }) : function(o, v) {
+    o["default"] = v;
+  });
+  var __decorate = interfaceAnalyzer && interfaceAnalyzer.__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 __importStar = interfaceAnalyzer && interfaceAnalyzer.__importStar || function(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __metadata = interfaceAnalyzer && interfaceAnalyzer.__metadata || function(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+  };
+  Object.defineProperty(interfaceAnalyzer, "__esModule", { value: true });
+  interfaceAnalyzer.InterfaceAnalyzer = void 0;
+  const visitor_base_1 = requireVisitorBase();
+  const ts = __importStar(require$$0);
+  class InterfaceAnalyzer extends visitor_base_1.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([
+    (0, visitor_base_1.Visit)(ts.SyntaxKind.PropertySignature),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+  ], InterfaceAnalyzer.prototype, "property", null);
+  __decorate([
+    (0, visitor_base_1.Visit)(ts.SyntaxKind.MethodSignature),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+  ], InterfaceAnalyzer.prototype, "method", null);
+  interfaceAnalyzer.InterfaceAnalyzer = InterfaceAnalyzer;
+  return interfaceAnalyzer;
+}
+export {
+  requireInterfaceAnalyzer as __require
+};
+//# sourceMappingURL=interface-analyzer.js.map

package/vite/dist/node_modules/typescript-rtti/dist/transformer/common/visitor-base.js

@@ -0,0 +1,132 @@
+import "../../../../../_virtual/_commonjsHelpers.js";
+import { __exports as visitorBase } from "../../../../../_virtual/visitor-base.js";
+import "../../../../../_virtual/_typescript.js";
+import require$$0 from "typescript";
+var hasRequiredVisitorBase;
+function requireVisitorBase() {
+  if (hasRequiredVisitorBase) return visitorBase;
+  hasRequiredVisitorBase = 1;
+  "use strict";
+  var __createBinding = visitorBase && visitorBase.__createBinding || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  }) : (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    o[k2] = m[k];
+  }));
+  var __setModuleDefault = visitorBase && visitorBase.__setModuleDefault || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  }) : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = visitorBase && visitorBase.__importStar || function(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __classPrivateFieldGet = visitorBase && visitorBase.__classPrivateFieldGet || function(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+  };
+  var __classPrivateFieldSet = visitorBase && visitorBase.__classPrivateFieldSet || function(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+  };
+  var _VisitorBase_instances, _VisitorBase_visitationMap, _VisitorBase_buildMap, _VisitorBase_visitor;
+  Object.defineProperty(visitorBase, "__esModule", { value: true });
+  visitorBase.VisitorBase = visitorBase.Visit = void 0;
+  const ts = __importStar(require$$0);
+  function Visit(kind) {
+    if (!Array.isArray(kind))
+      kind = [kind];
+    let kinds = kind;
+    return (target, propertyKey) => {
+      target[propertyKey].kinds = kinds;
+    };
+  }
+  visitorBase.Visit = Visit;
+  class VisitorBase {
+    constructor(context) {
+      this.context = context;
+      _VisitorBase_instances.add(this);
+      _VisitorBase_visitationMap.set(this, void 0);
+      this.traceVisits = false;
+      _VisitorBase_visitor.set(this, void 0);
+    }
+    /**
+     * Runs for every node, regardless of what receivers are defined.
+     * If `false` is returned, the node (and all its children) are not visited.
+     * Note that if you return nothing (ie `undefined`) the node is visited.
+     * @param node
+     */
+    everyNode(node) {
+    }
+    visitNode(node) {
+      __classPrivateFieldGet(this, _VisitorBase_instances, "m", _VisitorBase_buildMap).call(this);
+      return ts.visitNode(node, __classPrivateFieldGet(this, _VisitorBase_visitor, "f"));
+    }
+    visitEachChild(node) {
+      __classPrivateFieldGet(this, _VisitorBase_instances, "m", _VisitorBase_buildMap).call(this);
+      return ts.visitEachChild(node, __classPrivateFieldGet(this, _VisitorBase_visitor, "f"), this.context);
+    }
+  }
+  visitorBase.VisitorBase = VisitorBase;
+  _VisitorBase_visitationMap = /* @__PURE__ */ new WeakMap(), _VisitorBase_visitor = /* @__PURE__ */ new WeakMap(), _VisitorBase_instances = /* @__PURE__ */ new WeakSet(), _VisitorBase_buildMap = function _VisitorBase_buildMap2() {
+    var _a, _b;
+    if (__classPrivateFieldGet(this, _VisitorBase_visitationMap, "f"))
+      return;
+    __classPrivateFieldSet(this, _VisitorBase_visitationMap, /* @__PURE__ */ new Map(), "f");
+    let methodNames = Object.getOwnPropertyNames(this.constructor.prototype).filter((x) => !["constructor", "visitEachChild"].includes(x)).filter((x) => typeof this.constructor.prototype[x] === "function");
+    for (let methodName of methodNames) {
+      let kinds = (_a = this.constructor.prototype[methodName].kinds) !== null && _a !== void 0 ? _a : [];
+      for (let kind of kinds) {
+        let receivers = (_b = __classPrivateFieldGet(this, _VisitorBase_visitationMap, "f").get(kind)) !== null && _b !== void 0 ? _b : [];
+        receivers.push(methodName);
+        __classPrivateFieldGet(this, _VisitorBase_visitationMap, "f").set(kind, receivers);
+      }
+    }
+    __classPrivateFieldSet(this, _VisitorBase_visitor, (node) => {
+      var _a2;
+      if (!node)
+        return;
+      let continueProcessing = this.everyNode(node);
+      if (continueProcessing === false)
+        return node;
+      let receivers = (_a2 = __classPrivateFieldGet(this, _VisitorBase_visitationMap, "f").get(node.kind)) !== null && _a2 !== void 0 ? _a2 : [];
+      if (receivers.length === 0) {
+        if (this.traceVisits)
+          console.log(`${this.constructor.name}: [Auto] Visiting ${ts.SyntaxKind[node.kind]}`);
+        return ts.visitEachChild(node, __classPrivateFieldGet(this, _VisitorBase_visitor, "f"), this.context);
+      }
+      if (this.traceVisits)
+        console.log(`${this.constructor.name}: Visiting ${ts.SyntaxKind[node.kind]}`);
+      for (let receiver of receivers) {
+        let result = this[receiver](node);
+        if (result === null)
+          return void 0;
+        if (result === void 0)
+          continue;
+        node = result;
+      }
+      return node;
+    }, "f");
+  };
+  return visitorBase;
+}
+export {
+  requireVisitorBase as __require
+};
+//# sourceMappingURL=visitor-base.js.map

package/vite/dist/node_modules/typescript-rtti/dist/transformer/declarations-emitter.js

@@ -0,0 +1,72 @@
+import "../../../../_virtual/_commonjsHelpers.js";
+import { __exports as declarationsEmitter } from "../../../../_virtual/declarations-emitter.js";
+import { __require as requireVisitorBase } from "./common/visitor-base.js";
+import { __require as requireRttiVisitorBase } from "./rtti-visitor-base.js";
+import "../../../../_virtual/_typescript.js";
+import require$$0 from "typescript";
+var hasRequiredDeclarationsEmitter;
+function requireDeclarationsEmitter() {
+  if (hasRequiredDeclarationsEmitter) return declarationsEmitter;
+  hasRequiredDeclarationsEmitter = 1;
+  "use strict";
+  var __createBinding = declarationsEmitter && declarationsEmitter.__createBinding || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  }) : (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    o[k2] = m[k];
+  }));
+  var __setModuleDefault = declarationsEmitter && declarationsEmitter.__setModuleDefault || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  }) : function(o, v) {
+    o["default"] = v;
+  });
+  var __decorate = declarationsEmitter && declarationsEmitter.__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 __importStar = declarationsEmitter && declarationsEmitter.__importStar || function(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __metadata = declarationsEmitter && declarationsEmitter.__metadata || function(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+  };
+  Object.defineProperty(declarationsEmitter, "__esModule", { value: true });
+  declarationsEmitter.DeclarationsEmitter = void 0;
+  const visitor_base_1 = requireVisitorBase();
+  const rtti_visitor_base_1 = requireRttiVisitorBase();
+  const ts = __importStar(require$$0);
+  class DeclarationsEmitter extends rtti_visitor_base_1.RttiVisitor {
+    static emit(sourceFile, ctx) {
+      return new DeclarationsEmitter(ctx).visitNode(sourceFile);
+    }
+    functionDecl(decl) {
+    }
+  }
+  __decorate([
+    (0, visitor_base_1.Visit)(ts.SyntaxKind.FunctionDeclaration),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+  ], DeclarationsEmitter.prototype, "functionDecl", null);
+  declarationsEmitter.DeclarationsEmitter = DeclarationsEmitter;
+  return declarationsEmitter;
+}
+export {
+  requireDeclarationsEmitter as __require
+};
+//# sourceMappingURL=declarations-emitter.js.map

package/vite/dist/node_modules/typescript-rtti/dist/transformer/encode-parameter.js

@@ -0,0 +1,110 @@
+import "../../../../_virtual/_commonjsHelpers.js";
+import { __exports as encodeParameter } from "../../../../_virtual/encode-parameter.js";
+import "../../../../_virtual/_typescript.js";
+import { __require as requireFormat } from "../common/format.js";
+import { __require as requireForwardRef } from "./forward-ref.js";
+import { __require as requireLiteralNode } from "./literal-node.js";
+import { __require as requireUtils } from "./utils.js";
+import require$$0 from "typescript";
+var hasRequiredEncodeParameter;
+function requireEncodeParameter() {
+  if (hasRequiredEncodeParameter) return encodeParameter;
+  hasRequiredEncodeParameter = 1;
+  "use strict";
+  var __createBinding = encodeParameter && encodeParameter.__createBinding || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  }) : (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    o[k2] = m[k];
+  }));
+  var __setModuleDefault = encodeParameter && encodeParameter.__setModuleDefault || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  }) : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = encodeParameter && encodeParameter.__importStar || function(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __importDefault = encodeParameter && encodeParameter.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(encodeParameter, "__esModule", { value: true });
+  encodeParameter.encodeParameter = void 0;
+  const typescript_1 = __importDefault(require$$0);
+  const format = __importStar(requireFormat());
+  const forward_ref_1 = requireForwardRef();
+  const literal_node_1 = requireLiteralNode();
+  const utils_1 = requireUtils();
+  function encodeParameter$1(encoder, param) {
+    if (typescript_1.default.isOmittedExpression(param))
+      return { f: "," };
+    let nameNode = param.name;
+    let bindings;
+    let name;
+    let f = [];
+    let typeExpr;
+    let checker = encoder.ctx.checker;
+    if (typescript_1.default.isArrayBindingPattern(nameNode)) {
+      f.push(format.F_ARRAY_BINDING);
+      bindings = [];
+      for (let element of nameNode.elements) {
+        bindings.push(encodeParameter$1(encoder, element));
+      }
+    } else if (typescript_1.default.isObjectBindingPattern(nameNode)) {
+      f.push(format.F_OBJECT_BINDING);
+      bindings = [];
+      for (let element of nameNode.elements) {
+        bindings.push(encodeParameter$1(encoder, element));
+      }
+    } else {
+      name = nameNode.text;
+    }
+    if (typescript_1.default.isParameter(param)) {
+      if (param.questionToken)
+        f.push(format.F_OPTIONAL);
+      if (param.dotDotDotToken)
+        f.push(format.F_REST);
+      typeExpr = param.type ? encoder.referToTypeNode(param.type) : encoder.referToType(checker.getTypeAtLocation(param.initializer), param.type);
+    } else {
+      typeExpr = encoder.referToType(checker.getTypeAtLocation(param));
+    }
+    for (let modifier of (0, utils_1.getModifiers)(param)) {
+      if (modifier.kind === typescript_1.default.SyntaxKind.ReadonlyKeyword)
+        f.push(format.F_READONLY);
+      if (modifier.kind === typescript_1.default.SyntaxKind.PrivateKeyword)
+        f.push(format.F_PRIVATE);
+      if (modifier.kind === typescript_1.default.SyntaxKind.PublicKeyword)
+        f.push(format.F_PUBLIC);
+      if (modifier.kind === typescript_1.default.SyntaxKind.ProtectedKeyword)
+        f.push(format.F_PROTECTED);
+    }
+    let meta = {
+      n: name,
+      t: (0, literal_node_1.literalNode)((0, forward_ref_1.forwardRef)(typeExpr)),
+      b: bindings,
+      v: param.initializer ? (0, literal_node_1.literalNode)((0, forward_ref_1.functionForwardRef)(param.initializer)) : null
+    };
+    if (f.length > 0)
+      meta.f = f.join("");
+    return meta;
+  }
+  encodeParameter.encodeParameter = encodeParameter$1;
+  return encodeParameter;
+}
+export {
+  requireEncodeParameter as __require
+};
+//# sourceMappingURL=encode-parameter.js.map

package/vite/dist/node_modules/typescript-rtti/dist/transformer/find-relative-path.js

@@ -0,0 +1,51 @@
+import "../../../../_virtual/_commonjsHelpers.js";
+import { __exports as findRelativePath } from "../../../../_virtual/find-relative-path.js";
+var hasRequiredFindRelativePath;
+function requireFindRelativePath() {
+  if (hasRequiredFindRelativePath) return findRelativePath;
+  hasRequiredFindRelativePath = 1;
+  "use strict";
+  Object.defineProperty(findRelativePath, "__esModule", { value: true });
+  findRelativePath.findRelativePathToFile = void 0;
+  function findRelativePathToFile(fromFile, toFile) {
+    fromFile = fromFile.replace(/\\/g, "/");
+    toFile = toFile.replace(/\\/g, "/");
+    if (fromFile.startsWith("./"))
+      fromFile = fromFile.slice(2);
+    if (toFile.startsWith("./"))
+      toFile = toFile.slice(2);
+    let fromAbsolute = /^[A-Za-z]:/.test(fromFile) || /^\//.test(fromFile);
+    let toAbsolute = /^[A-Za-z]:/.test(toFile) || /^\//.test(toFile);
+    if (fromAbsolute !== toAbsolute)
+      throw new Error(`Cannot determine relationship between an absolute and a relative path!`);
+    if (!fromAbsolute && !toAbsolute) {
+      fromFile = `/${fromFile}`;
+      toFile = `/${toFile}`;
+    }
+    let from = fromFile.split("/");
+    let to = toFile.split("/");
+    let parents = 0;
+    let toFileName = to.pop();
+    while (from.length > 0 && !(to.join("/") + "/").startsWith(from.join("/") + "/")) {
+      parents += 1;
+      from.pop();
+    }
+    let result;
+    if (from.length === 0) {
+      return void 0;
+    } else {
+      if (parents > 1) {
+        result = [...Array(parents - 1).fill(".."), ...to.slice(from.length), toFileName].join("/");
+      } else {
+        result = [".", ...to.slice(from.length), toFileName].join("/");
+      }
+    }
+    return result;
+  }
+  findRelativePath.findRelativePathToFile = findRelativePathToFile;
+  return findRelativePath;
+}
+export {
+  requireFindRelativePath as __require
+};
+//# sourceMappingURL=find-relative-path.js.map

package/vite/dist/node_modules/typescript-rtti/dist/transformer/flags.js

@@ -0,0 +1,59 @@
+import "../../../../_virtual/_commonjsHelpers.js";
+import { __exports as flags } from "../../../../_virtual/flags.js";
+import "../../../../_virtual/_typescript.js";
+import { __require as requireFormat } from "../common/format.js";
+import require$$0 from "typescript";
+var hasRequiredFlags;
+function requireFlags() {
+  if (hasRequiredFlags) return flags;
+  hasRequiredFlags = 1;
+  "use strict";
+  var __importDefault = flags && flags.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(flags, "__esModule", { value: true });
+  flags.isExported = flags.isAsync = flags.isAbstract = flags.isReadOnly = flags.getVisibility = void 0;
+  const typescript_1 = __importDefault(require$$0);
+  const format_1 = requireFormat();
+  function getVisibility(modifiers) {
+    if (modifiers) {
+      if (modifiers.some((x) => x.kind === typescript_1.default.SyntaxKind.PublicKeyword))
+        return format_1.F_PUBLIC;
+      if (modifiers.some((x) => x.kind === typescript_1.default.SyntaxKind.PrivateKeyword))
+        return format_1.F_PRIVATE;
+      if (modifiers.some((x) => x.kind === typescript_1.default.SyntaxKind.ProtectedKeyword))
+        return format_1.F_PROTECTED;
+    }
+    return "";
+  }
+  flags.getVisibility = getVisibility;
+  function isReadOnly(modifiers) {
+    if (!modifiers)
+      return "";
+    return modifiers.some((x) => x.kind === typescript_1.default.SyntaxKind.ReadonlyKeyword) ? format_1.F_READONLY : "";
+  }
+  flags.isReadOnly = isReadOnly;
+  function isAbstract(modifiers) {
+    if (!modifiers)
+      return "";
+    return modifiers.some((x) => x.kind === typescript_1.default.SyntaxKind.AbstractKeyword) ? format_1.F_ABSTRACT : "";
+  }
+  flags.isAbstract = isAbstract;
+  function isAsync(modifiers) {
+    if (!modifiers)
+      return "";
+    return modifiers.some((x) => x.kind === typescript_1.default.SyntaxKind.AsyncKeyword) ? format_1.F_ASYNC : "";
+  }
+  flags.isAsync = isAsync;
+  function isExported(modifiers) {
+    if (!modifiers)
+      return "";
+    return modifiers.some((x) => x.kind === typescript_1.default.SyntaxKind.ExportKeyword) ? format_1.F_EXPORTED : "";
+  }
+  flags.isExported = isExported;
+  return flags;
+}
+export {
+  requireFlags as __require
+};
+//# sourceMappingURL=flags.js.map