xml-model 0.3.0 → 1.0.0

package/vite/dist/node_modules/typescript-rtti/dist/transformer/metadata-encoder.js

@@ -0,0 +1,261 @@
+import "../../../../_virtual/_commonjsHelpers.js";
+import { __exports as metadataEncoder } from "../../../../_virtual/metadata-encoder.js";
+import "../../../../_virtual/_typescript.js";
+import { __require as requireFormat } from "../common/format.js";
+import { __require as requireEncodeParameter } from "./encode-parameter.js";
+import { __require as requireFlags } from "./flags.js";
+import { __require as requireForwardRef } from "./forward-ref.js";
+import { __require as requireLegacyTypeEncoder } from "./legacy-type-encoder.js";
+import { __require as requireLiteralNode } from "./literal-node.js";
+import { __require as requireMetadataDecorator } from "./metadata-decorator.js";
+import { __require as requireSerialize } from "./serialize.js";
+import { __require as requireTypeEncoder } from "./type-encoder.js";
+import { __require as requireUtils } from "./utils.js";
+import require$$0 from "typescript";
+var hasRequiredMetadataEncoder;
+function requireMetadataEncoder() {
+  if (hasRequiredMetadataEncoder) return metadataEncoder;
+  hasRequiredMetadataEncoder = 1;
+  "use strict";
+  var __createBinding = metadataEncoder && metadataEncoder.__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 = metadataEncoder && metadataEncoder.__setModuleDefault || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  }) : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = metadataEncoder && metadataEncoder.__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;
+  };
+  Object.defineProperty(metadataEncoder, "__esModule", { value: true });
+  metadataEncoder.MetadataEncoder = void 0;
+  const ts = __importStar(require$$0);
+  const format_1 = requireFormat();
+  const encode_parameter_1 = requireEncodeParameter();
+  const flags_1 = requireFlags();
+  const forward_ref_1 = requireForwardRef();
+  const legacy_type_encoder_1 = requireLegacyTypeEncoder();
+  const literal_node_1 = requireLiteralNode();
+  const metadata_decorator_1 = requireMetadataDecorator();
+  const serialize_1 = requireSerialize();
+  const type_encoder_1 = requireTypeEncoder();
+  const utils_1 = requireUtils();
+  class MetadataEncoder {
+    constructor(ctx) {
+      this.ctx = ctx;
+      this.typeEncoder = new type_encoder_1.TypeEncoder(this.ctx);
+      this.legacyTypeEncoder = new legacy_type_encoder_1.LegacyTypeEncoder(this.ctx);
+    }
+    get emitStandardMetadata() {
+      return this.ctx.emitStandardMetadata;
+    }
+    get checker() {
+      return this.ctx.checker;
+    }
+    get importMap() {
+      return this.ctx.importMap;
+    }
+    typeNode(typeNode, standardName, allowStandardMetadata = true) {
+      return this.type(this.checker.getTypeAtLocation(typeNode), typeNode, standardName, allowStandardMetadata);
+    }
+    type(type, typeNode, standardName, allowStandardMetadata = true) {
+      let decs = [];
+      decs.push((0, metadata_decorator_1.metadataDecorator)("rt:t", (0, literal_node_1.literalNode)((0, forward_ref_1.forwardRef)(this.typeEncoder.referToType(type, typeNode)))));
+      if (this.emitStandardMetadata && allowStandardMetadata)
+        decs.push((0, metadata_decorator_1.legacyMetadataDecorator)(`design:${standardName}`, (0, literal_node_1.literalNode)(this.legacyTypeEncoder.referToType(type, typeNode))));
+      return decs;
+    }
+    prepareElementNames(elementNames) {
+      return elementNames.map((elementName) => (0, literal_node_1.literalNode)((0, utils_1.expressionForPropertyName)(elementName)));
+    }
+    class(klass, details) {
+      var _a;
+      let type = this.checker.getTypeAtLocation(klass);
+      let decs = [
+        ts.factory.createDecorator(ts.factory.createArrowFunction([], [], [
+          ts.factory.createParameterDeclaration([], void 0, "t")
+        ], void 0, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createBinaryExpression(ts.factory.createElementAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("__RΦ"), "t"), type["id"]), ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createIdentifier("t"))))
+      ];
+      if (ts.isClassDeclaration(klass) || ts.isClassExpression(klass))
+        decs.push((0, metadata_decorator_1.metadataDecorator)("rt:SP", this.prepareElementNames(details.staticPropertyNames)));
+      decs.push((0, metadata_decorator_1.metadataDecorator)("rt:P", this.prepareElementNames(details.propertyNames)));
+      if (ts.isClassDeclaration(klass) || ts.isClassExpression(klass))
+        decs.push((0, metadata_decorator_1.metadataDecorator)("rt:Sm", this.prepareElementNames(details.staticMethodNames)));
+      decs.push((0, metadata_decorator_1.metadataDecorator)("rt:m", this.prepareElementNames(details.methodNames)));
+      if (ts.isClassDeclaration(klass) || ts.isClassExpression(klass)) {
+        let constructor = klass.members.find((x) => ts.isConstructorDeclaration(x));
+        if (constructor) {
+          decs.push(...this.params(constructor, klass));
+        }
+      }
+      let impls = (_a = klass.heritageClauses) === null || _a === void 0 ? void 0 : _a.find((x) => x.token === (ts.isInterfaceDeclaration(klass) ? ts.SyntaxKind.ExtendsKeyword : ts.SyntaxKind.ImplementsKeyword));
+      if (impls) {
+        let typeRefs = [];
+        for (let heritageType of impls.types) {
+          let checker = this.checker;
+          let symbol = checker.getSymbolAtLocation(heritageType.expression);
+          let type2 = checker.getTypeAtLocation(heritageType.expression);
+          if (symbol) {
+            let localName = heritageType.expression.getText();
+            typeRefs.push(this.typeEncoder.referToType(type2, heritageType));
+          } else {
+            console.error(`RTTI: Cannot identify type ${heritageType.getText()} on implements clause for class ${klass.name.text} [please report]`);
+            typeRefs.push(void 0);
+          }
+        }
+        decs.push((0, metadata_decorator_1.metadataDecorator)("rt:i", typeRefs.map((tr) => tr ? (0, literal_node_1.literalNode)((0, forward_ref_1.forwardRef)(tr)) : void 0)));
+      }
+      let klassModifiers = ts.canHaveModifiers(klass) ? ts.getModifiers(klass) : [];
+      let fType = ts.isInterfaceDeclaration(klass) ? format_1.F_INTERFACE : format_1.F_CLASS;
+      decs.push((0, metadata_decorator_1.metadataDecorator)("rt:f", `${fType}${(0, flags_1.getVisibility)(klassModifiers)}${(0, flags_1.isAbstract)(klassModifiers)}${(0, flags_1.isExported)(klassModifiers)}`));
+      return decs;
+    }
+    getClassName(node) {
+      if (!node.parent)
+        return `unknown class/interface`;
+      if (ts.isClassDeclaration(node.parent)) {
+        if (node.parent.name)
+          return `class ${node.parent.name.text}`;
+        else if ((0, utils_1.hasModifier)(ts.canHaveModifiers(node.parent) ? ts.getModifiers(node.parent) : [], ts.SyntaxKind.DefaultKeyword))
+          return `default class`;
+        else
+          return `unknown class`;
+      } else if (ts.isClassExpression(node.parent)) {
+        if (node.parent.name)
+          return `class ${node.parent.name.text}`;
+        else
+          return `unnamed class expression`;
+      } else if (ts.isInterfaceDeclaration(node.parent)) {
+        if (node.parent.name)
+          return `interface ${node.parent.name.text}`;
+        else if ((0, utils_1.hasModifier)((0, utils_1.getModifiers)(node.parent), ts.SyntaxKind.DefaultKeyword))
+          return `default interface`;
+        else
+          return `unknown interface`;
+      }
+      return `unknown class`;
+    }
+    property(node) {
+      var _a;
+      let typeNode = node.type;
+      let type;
+      if (!typeNode && ts.isSetAccessor(node) && node.parameters.length > 0) {
+        typeNode = node.parameters[0].type;
+      }
+      this.ctx.locationHint = `Property '${(0, utils_1.propertyNameToString)(node.name)}' of ${this.getClassName(node)}`;
+      if (typeNode) {
+        type = this.checker.getTypeAtLocation(typeNode);
+      } else {
+        type = this.checker.getTypeAtLocation(node);
+      }
+      const nodeModifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : [];
+      return [
+        ...this.type(type, typeNode, "type", (ts.isPropertyDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node)) && ts.canHaveDecorators(node) && ((_a = ts.getDecorators(node)) === null || _a === void 0 ? void 0 : _a.length) > 0),
+        (0, metadata_decorator_1.metadataDecorator)("rt:f", `${format_1.F_PROPERTY}${(0, flags_1.getVisibility)(nodeModifiers)}${(0, flags_1.isReadOnly)(nodeModifiers)}${node.questionToken ? format_1.F_OPTIONAL : ""}`)
+      ];
+    }
+    methodFlags(node) {
+      if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node)) {
+        let type2 = format_1.F_FUNCTION;
+        return `${type2}${(0, flags_1.isAsync)((0, utils_1.getModifiers)(node))}${ts.isArrowFunction(node) ? format_1.F_ARROW_FUNCTION : ""}`;
+      }
+      const nodeModifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : [];
+      let type = format_1.F_METHOD;
+      let flags = `${type}${(0, flags_1.getVisibility)(nodeModifiers)}${(0, flags_1.isAbstract)(nodeModifiers)}${(0, flags_1.isAsync)(nodeModifiers)}`;
+      if (ts.isMethodDeclaration(node) && (0, utils_1.getModifiers)(node).some((x) => x.kind === ts.SyntaxKind.StaticKeyword))
+        flags += format_1.F_STATIC;
+      if (node.questionToken)
+        flags += format_1.F_OPTIONAL;
+      if (!node.type)
+        flags += format_1.F_INFERRED;
+      return flags;
+    }
+    method(node) {
+      let propNameStr = (0, utils_1.propertyNameToString)(node.name);
+      if (ts.isMethodDeclaration(node) || ts.isMethodSignature(node)) {
+        this.ctx.locationHint = `Method ${propNameStr !== null && propNameStr !== void 0 ? propNameStr : "<unknown>"}() of ${this.getClassName(node)}`;
+      } else if (ts.isFunctionDeclaration(node)) {
+        this.ctx.locationHint = `Function ${propNameStr !== null && propNameStr !== void 0 ? propNameStr : "<unknown>"}()`;
+      } else if (ts.isFunctionExpression(node)) {
+        if (node.name)
+          this.ctx.locationHint = `Function ${propNameStr}()`;
+        else
+          this.ctx.locationHint = `Unnamed function expression`;
+      } else if (ts.isArrowFunction(node)) {
+        this.ctx.locationHint = `Arrow function`;
+      }
+      let methodHint = this.ctx.locationHint;
+      let decs = [];
+      let nodeDecorators = [];
+      if (ts.canHaveDecorators(node))
+        nodeDecorators = ts.getDecorators(node);
+      if (this.emitStandardMetadata && ts.isMethodDeclaration(node) && (nodeDecorators === null || nodeDecorators === void 0 ? void 0 : nodeDecorators.length) > 0)
+        decs.push((0, metadata_decorator_1.legacyMetadataDecorator)("design:type", (0, literal_node_1.literalNode)(ts.factory.createIdentifier("Function"))));
+      decs.push(...this.params(node));
+      decs.push((0, metadata_decorator_1.metadataDecorator)("rt:f", this.methodFlags(node)));
+      let allowStandardMetadata = ts.isMethodDeclaration(node) && (nodeDecorators === null || nodeDecorators === void 0 ? void 0 : nodeDecorators.length) > 0;
+      if (node.type) {
+        decs.push(...this.typeNode(node.type, "returntype", allowStandardMetadata));
+      } else {
+        let signature = this.checker.getSignatureFromDeclaration(node);
+        if (signature) {
+          this.ctx.locationHint = `[Return type of] ${methodHint}`;
+          decs.push(...this.type(signature.getReturnType(), void 0, "returntype", allowStandardMetadata));
+        }
+      }
+      return decs;
+    }
+    params(node, containingNode) {
+      var _a, _b;
+      let decs = [];
+      let standardParamTypes = [];
+      let serializedParamMeta = [];
+      for (let param of node.parameters) {
+        let name;
+        if (ts.isIdentifier(param.name))
+          name = param.name.text;
+        if (name === "this")
+          continue;
+        let expr = this.legacyTypeEncoder.referToTypeNode(param.type);
+        standardParamTypes.push(expr);
+        serializedParamMeta.push((0, literal_node_1.literalNode)((0, serialize_1.serialize)((0, encode_parameter_1.encodeParameter)(this.typeEncoder, param))));
+      }
+      decs.push((0, metadata_decorator_1.metadataDecorator)("rt:p", serializedParamMeta));
+      let eligibleForLegacyDecorators = ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node);
+      if (this.emitStandardMetadata && eligibleForLegacyDecorators) {
+        let parent = containingNode !== null && containingNode !== void 0 ? containingNode : node.parent;
+        let isDecorated = false;
+        if (ts.canHaveDecorators(node))
+          isDecorated = ((_a = ts.getDecorators(node)) === null || _a === void 0 ? void 0 : _a.length) > 0;
+        if (ts.isConstructorDeclaration(node) && parent && ts.canHaveDecorators(parent))
+          isDecorated = ((_b = ts.getDecorators(parent)) === null || _b === void 0 ? void 0 : _b.length) > 0;
+        if (isDecorated)
+          decs.push((0, metadata_decorator_1.metadataDecorator)("design:paramtypes", standardParamTypes.map((t) => (0, literal_node_1.literalNode)(t))));
+      }
+      return decs;
+    }
+  }
+  metadataEncoder.MetadataEncoder = MetadataEncoder;
+  return metadataEncoder;
+}
+export {
+  requireMetadataEncoder as __require
+};
+//# sourceMappingURL=metadata-encoder.js.map

package/vite/dist/node_modules/typescript-rtti/dist/transformer/rt-helper.js

@@ -0,0 +1,113 @@
+import "../../../../_virtual/_commonjsHelpers.js";
+import { __exports as rtHelper } from "../../../../_virtual/rt-helper.js";
+import "../../../../_virtual/_typescript.js";
+import { __require as requireLiteralNode } from "./literal-node.js";
+import { __require as requireSerialize } from "./serialize.js";
+import require$$0 from "typescript";
+var hasRequiredRtHelper;
+function requireRtHelper() {
+  if (hasRequiredRtHelper) return rtHelper;
+  hasRequiredRtHelper = 1;
+  "use strict";
+  var __importDefault = rtHelper && rtHelper.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(rtHelper, "__esModule", { value: true });
+  rtHelper.rtStore = void 0;
+  const typescript_1 = __importDefault(require$$0);
+  const literal_node_1 = requireLiteralNode();
+  const serialize_1 = requireSerialize();
+  function rtStore(typeMap) {
+    const factory = typescript_1.default.factory;
+    let typeEntries = Array.from(typeMap.entries()).map(([i, t]) => factory.createPropertyAssignment(factory.createComputedPropertyName(typescript_1.default.factory.createNumericLiteral(i)), t));
+    let typeStore = factory.createObjectLiteralExpression(typeEntries);
+    return factory.createVariableStatement(void 0, factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier("__RΦ"), void 0, void 0, (0, serialize_1.serialize)({
+      m: (0, literal_node_1.literalNode)(factory.createArrowFunction(void 0, void 0, [
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("k"), void 0, void 0, void 0),
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("v"), void 0, void 0, void 0)
+      ], void 0, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createArrowFunction(void 0, void 0, [
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("t"), void 0, void 0, void 0),
+        factory.createParameterDeclaration(void 0, factory.createToken(typescript_1.default.SyntaxKind.DotDotDotToken), factory.createIdentifier("a"), void 0, void 0, void 0)
+      ], void 0, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createConditionalExpression(factory.createBinaryExpression(factory.createIdentifier("t"), factory.createToken(typescript_1.default.SyntaxKind.AmpersandAmpersandToken), factory.createPropertyAccessExpression(factory.createIdentifier("Reflect"), factory.createIdentifier("metadata"))), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), factory.createCallExpression(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Reflect"), factory.createIdentifier("metadata")), void 0, [
+        factory.createIdentifier("k"),
+        factory.createIdentifier("v")
+      ]), void 0, [
+        factory.createIdentifier("t"),
+        factory.createSpreadElement(factory.createIdentifier("a"))
+      ]), factory.createToken(typescript_1.default.SyntaxKind.ColonToken), factory.createVoidExpression(factory.createNumericLiteral("0")))))),
+      f: (0, literal_node_1.literalNode)(factory.createArrowFunction(void 0, void 0, [
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("f"), void 0, void 0, void 0),
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("d"), void 0, void 0, void 0),
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("n"), void 0, void 0, void 0)
+      ], void 0, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createParenthesizedExpression(factory.createBinaryExpression(factory.createBinaryExpression(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("d"), factory.createIdentifier("forEach")), void 0, [factory.createArrowFunction(void 0, void 0, [factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("d"), void 0, void 0, void 0)], void 0, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier("d"), void 0, [factory.createIdentifier("f")]))]), factory.createToken(typescript_1.default.SyntaxKind.CommaToken), factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), factory.createIdentifier("defineProperty")), void 0, [
+        factory.createIdentifier("f"),
+        factory.createStringLiteral("name"),
+        factory.createObjectLiteralExpression([
+          factory.createPropertyAssignment(factory.createIdentifier("value"), factory.createIdentifier("n")),
+          factory.createPropertyAssignment(factory.createIdentifier("writable"), factory.createFalse())
+        ], false)
+      ])), factory.createToken(typescript_1.default.SyntaxKind.CommaToken), factory.createIdentifier("f"))))),
+      c: (0, literal_node_1.literalNode)(factory.createArrowFunction(void 0, void 0, [
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("c"), void 0, void 0, void 0),
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("d"), void 0, void 0, void 0),
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("dp"), void 0, void 0, void 0),
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("dsp"), void 0, void 0, void 0),
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("n"), void 0, void 0, void 0)
+      ], void 0, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createParenthesizedExpression(factory.createBinaryExpression(factory.createBinaryExpression(factory.createBinaryExpression(factory.createBinaryExpression(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("d"), factory.createIdentifier("forEach")), void 0, [factory.createArrowFunction(void 0, void 0, [factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("d"), void 0, void 0, void 0)], void 0, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier("d"), void 0, [factory.createIdentifier("c")]))]), factory.createToken(typescript_1.default.SyntaxKind.CommaToken), factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("dp"), factory.createIdentifier("forEach")), void 0, [factory.createArrowFunction(void 0, void 0, [factory.createParameterDeclaration(void 0, void 0, factory.createArrayBindingPattern([
+        factory.createBindingElement(void 0, void 0, factory.createIdentifier("p"), void 0),
+        factory.createBindingElement(void 0, void 0, factory.createIdentifier("d"), void 0)
+      ]), void 0, void 0, void 0)], void 0, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier("d"), void 0, [
+        factory.createPropertyAccessExpression(factory.createIdentifier("c"), factory.createIdentifier("prototype")),
+        factory.createIdentifier("p")
+      ]))])), factory.createToken(typescript_1.default.SyntaxKind.CommaToken), factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("dsp"), factory.createIdentifier("forEach")), void 0, [factory.createArrowFunction(void 0, void 0, [factory.createParameterDeclaration(void 0, void 0, factory.createArrayBindingPattern([
+        factory.createBindingElement(void 0, void 0, factory.createIdentifier("p"), void 0),
+        factory.createBindingElement(void 0, void 0, factory.createIdentifier("d"), void 0)
+      ]), void 0, void 0, void 0)], void 0, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier("d"), void 0, [
+        factory.createIdentifier("c"),
+        factory.createIdentifier("p")
+      ]))])), factory.createToken(typescript_1.default.SyntaxKind.CommaToken), factory.createConditionalExpression(factory.createIdentifier("n"), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), factory.createIdentifier("defineProperty")), void 0, [
+        factory.createIdentifier("c"),
+        factory.createStringLiteral("name"),
+        factory.createObjectLiteralExpression([
+          factory.createPropertyAssignment(factory.createIdentifier("value"), factory.createIdentifier("n")),
+          factory.createPropertyAssignment(factory.createIdentifier("writable"), factory.createFalse())
+        ], false)
+      ]), factory.createToken(typescript_1.default.SyntaxKind.ColonToken), factory.createIdentifier("undefined"))), factory.createToken(typescript_1.default.SyntaxKind.CommaToken), factory.createIdentifier("c"))))),
+      r: (0, literal_node_1.literalNode)(factory.createArrowFunction(void 0, void 0, [
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("o"), void 0, void 0, void 0),
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("a"), void 0, void 0, void 0)
+      ], void 0, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createParenthesizedExpression(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), factory.createIdentifier("assign")), void 0, [
+        factory.createIdentifier("o"),
+        factory.createIdentifier("a")
+      ])))),
+      a: (0, literal_node_1.literalNode)(factory.createArrowFunction(void 0, void 0, [factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("id"), void 0, void 0, void 0)], void 0, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createBlock([
+        factory.createVariableStatement(void 0, factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier("t"), void 0, void 0, factory.createElementAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__RΦ"), factory.createIdentifier("t")), factory.createIdentifier("id")))], typescript_1.default.NodeFlags.Let)),
+        factory.createIfStatement(factory.createBinaryExpression(factory.createIdentifier("t"), factory.createToken(typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken), factory.createVoidExpression(factory.createNumericLiteral("0"))), factory.createReturnStatement(factory.createVoidExpression(factory.createNumericLiteral("0"))), void 0),
+        factory.createIfStatement(factory.createPropertyAccessExpression(factory.createIdentifier("t"), factory.createIdentifier("RΦ")), factory.createBlock([
+          factory.createVariableStatement(void 0, factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier("r"), void 0, void 0, factory.createPropertyAccessExpression(factory.createIdentifier("t"), factory.createIdentifier("RΦ")))], typescript_1.default.NodeFlags.Let)),
+          factory.createExpressionStatement(factory.createDeleteExpression(factory.createPropertyAccessExpression(factory.createIdentifier("t"), factory.createIdentifier("RΦ")))),
+          factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__RΦ"), factory.createIdentifier("r")), void 0, [
+            factory.createIdentifier("t"),
+            factory.createCallExpression(factory.createIdentifier("r"), void 0, [factory.createIdentifier("t")])
+          ]))
+        ], true), factory.createIfStatement(factory.createPropertyAccessExpression(factory.createIdentifier("t"), factory.createIdentifier("LΦ")), factory.createBlock([
+          factory.createVariableStatement(void 0, factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier("l"), void 0, void 0, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("t"), factory.createIdentifier("LΦ")), void 0, []))], typescript_1.default.NodeFlags.Let)),
+          factory.createExpressionStatement(factory.createDeleteExpression(factory.createPropertyAccessExpression(factory.createIdentifier("t"), factory.createIdentifier("LΦ")))),
+          factory.createExpressionStatement(factory.createBinaryExpression(factory.createElementAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__RΦ"), factory.createIdentifier("t")), factory.createIdentifier("id")), factory.createToken(typescript_1.default.SyntaxKind.EqualsToken), factory.createBinaryExpression(factory.createIdentifier("t"), factory.createToken(typescript_1.default.SyntaxKind.EqualsToken), factory.createIdentifier("l"))))
+        ], true), void 0)),
+        factory.createReturnStatement(factory.createIdentifier("t"))
+      ], true))),
+      oe: (0, literal_node_1.literalNode)(factory.createArrowFunction(void 0, void 0, [
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("o"), void 0, void 0, void 0),
+        factory.createParameterDeclaration(void 0, void 0, factory.createIdentifier("k"), void 0, void 0, void 0)
+      ], void 0, factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), factory.createBlock([factory.createTryStatement(factory.createBlock([factory.createReturnStatement(factory.createElementAccessExpression(factory.createIdentifier("o"), factory.createIdentifier("k")))], true), factory.createCatchClause(factory.createVariableDeclaration(factory.createIdentifier("e"), void 0, void 0, void 0), factory.createBlock([factory.createReturnStatement(factory.createIdentifier("undefined"))], true)), void 0)], true))),
+      t: (0, literal_node_1.literalNode)(typeStore)
+    }))], typescript_1.default.NodeFlags.Const));
+  }
+  rtHelper.rtStore = rtStore;
+  return rtHelper;
+}
+export {
+  requireRtHelper as __require
+};
+//# sourceMappingURL=rt-helper.js.map

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

@@ -0,0 +1,39 @@
+import "../../../../_virtual/_commonjsHelpers.js";
+import { __exports as rttiVisitorBase } from "../../../../_virtual/rtti-visitor-base.js";
+import { __require as requireVisitorBase } from "./common/visitor-base.js";
+var hasRequiredRttiVisitorBase;
+function requireRttiVisitorBase() {
+  if (hasRequiredRttiVisitorBase) return rttiVisitorBase;
+  hasRequiredRttiVisitorBase = 1;
+  "use strict";
+  Object.defineProperty(rttiVisitorBase, "__esModule", { value: true });
+  rttiVisitorBase.RttiVisitor = void 0;
+  const visitor_base_1 = requireVisitorBase();
+  class RttiVisitor extends visitor_base_1.VisitorBase {
+    constructor(ctx) {
+      super(ctx.transformationContext);
+      this.ctx = ctx;
+    }
+    get program() {
+      return this.ctx.program;
+    }
+    get checker() {
+      return this.ctx.checker;
+    }
+    get trace() {
+      return this.ctx.trace;
+    }
+    get sourceFile() {
+      return this.ctx.sourceFile;
+    }
+    get importMap() {
+      return this.ctx.importMap;
+    }
+  }
+  rttiVisitorBase.RttiVisitor = RttiVisitor;
+  return rttiVisitorBase;
+}
+export {
+  requireRttiVisitorBase as __require
+};
+//# sourceMappingURL=rtti-visitor-base.js.map

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

@@ -0,0 +1,46 @@
+import "../../../../_virtual/_commonjsHelpers.js";
+import { __exports as serialize } from "../../../../_virtual/serialize.js";
+import "../../../../_virtual/_typescript.js";
+import { __require as requireCommon } from "../common/index.js";
+import require$$0 from "typescript";
+var hasRequiredSerialize;
+function requireSerialize() {
+  if (hasRequiredSerialize) return serialize;
+  hasRequiredSerialize = 1;
+  "use strict";
+  var __importDefault = serialize && serialize.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(serialize, "__esModule", { value: true });
+  serialize.serialize = void 0;
+  const typescript_1 = __importDefault(require$$0);
+  const common_1 = requireCommon();
+  function serialize$1(object) {
+    if (object === null)
+      return typescript_1.default.factory.createNull();
+    if (object === void 0)
+      return typescript_1.default.factory.createVoidZero();
+    if (object instanceof Array)
+      return typescript_1.default.factory.createArrayLiteralExpression(object.map((x) => serialize$1(x)));
+    if (typeof object === "string")
+      return typescript_1.default.factory.createStringLiteral(object);
+    if (typeof object === "number")
+      return typescript_1.default.factory.createNumericLiteral(object);
+    if (typeof object === "boolean")
+      return object ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createFalse();
+    if (typeof object === "function")
+      throw new Error(`Cannot serialize a function`);
+    if ((0, common_1.isLiteralNode)(object))
+      return object.node;
+    let props = [];
+    for (let key of Object.keys(object))
+      props.push(typescript_1.default.factory.createPropertyAssignment(key, serialize$1(object[key])));
+    return typescript_1.default.factory.createObjectLiteralExpression(props, false);
+  }
+  serialize.serialize = serialize$1;
+  return serialize;
+}
+export {
+  requireSerialize as __require
+};
+//# sourceMappingURL=serialize.js.map

package/vite/dist/node_modules/typescript-rtti/dist/transformer/type-encoder.js

@@ -0,0 +1,96 @@
+import "../../../../_virtual/_commonjsHelpers.js";
+import { __exports as typeEncoder } from "../../../../_virtual/type-encoder.js";
+import "../../../../_virtual/_typescript.js";
+import { __require as requireFormat } from "../common/format.js";
+import { __require as requireLiteralNode } from "./literal-node.js";
+import { __require as requireSerialize } from "./serialize.js";
+import { __require as requireTypeLiteral } from "./type-literal.js";
+import { __require as requireUtils } from "./utils.js";
+import require$$0 from "typescript";
+var hasRequiredTypeEncoder;
+function requireTypeEncoder() {
+  if (hasRequiredTypeEncoder) return typeEncoder;
+  hasRequiredTypeEncoder = 1;
+  "use strict";
+  var __importDefault = typeEncoder && typeEncoder.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(typeEncoder, "__esModule", { value: true });
+  typeEncoder.TypeEncoder = void 0;
+  const typescript_1 = __importDefault(require$$0);
+  const format_1 = requireFormat();
+  const literal_node_1 = requireLiteralNode();
+  const serialize_1 = requireSerialize();
+  const type_literal_1 = requireTypeLiteral();
+  const utils_1 = requireUtils();
+  class TypeEncoder {
+    constructor(ctx) {
+      this.ctx = ctx;
+    }
+    get typeMap() {
+      return this.ctx.typeMap;
+    }
+    get program() {
+      return this.ctx.program;
+    }
+    get sourceFile() {
+      return this.ctx.sourceFile;
+    }
+    get importMap() {
+      return this.ctx.importMap;
+    }
+    get checker() {
+      return this.ctx.checker;
+    }
+    referToTypeNode(typeNode) {
+      return this.referToType(this.checker.getTypeFromTypeNode(typeNode), typeNode);
+    }
+    referToType(type, typeNode) {
+      var _a, _b, _c;
+      if (!type["id"])
+        throw new Error(`Type does not have an ID!`);
+      if (!this.typeMap.has(type["id"])) {
+        this.typeMap.set(type["id"], null);
+        let isEnum = (0, utils_1.hasFlag)(type.flags, typescript_1.default.TypeFlags.Enum) || (0, utils_1.hasFlag)(type.flags, typescript_1.default.TypeFlags.EnumLiteral) && (0, utils_1.hasFlag)((_a = type.aliasSymbol) === null || _a === void 0 ? void 0 : _a.flags, typescript_1.default.SymbolFlags.Enum);
+        let declarations = (_b = type.symbol) === null || _b === void 0 ? void 0 : _b.getDeclarations();
+        let declaration = declarations === null || declarations === void 0 ? void 0 : declarations[0];
+        let sourceFile = declaration === null || declaration === void 0 ? void 0 : declaration.getSourceFile();
+        let isLocal = sourceFile === this.ctx.sourceFile;
+        let isAmbient = (0, utils_1.hasFlag)(
+          declaration === null || declaration === void 0 ? void 0 : declaration.flags,
+          16777216
+          /* InternalNodeFlags.Ambient */
+        );
+        let useStandIn = false;
+        if (isEnum) {
+          useStandIn = isLocal && !(0, utils_1.hasFlag)(type.symbol.flags, typescript_1.default.SymbolFlags.ConstEnum);
+        } else if (type.isClassOrInterface()) {
+          useStandIn = isLocal && !isAmbient;
+        }
+        if (useStandIn) {
+          this.typeMap.set(type["id"], (0, serialize_1.serialize)({
+            TΦ: format_1.T_STAND_IN,
+            name: `${type.symbol.name}`
+          }));
+        } else {
+          let expr = isLocal && isAmbient ? (0, type_literal_1.structuredTypeLiteral)(this, type, typeNode, (_c = type.symbol) === null || _c === void 0 ? void 0 : _c.name) : (0, type_literal_1.typeLiteral)(this, type, typeNode);
+          let propName = typescript_1.default.isObjectLiteralExpression(expr) ? "RΦ" : "LΦ";
+          this.typeMap.set(type["id"], (0, serialize_1.serialize)({
+            [propName]: (0, literal_node_1.literalNode)(typescript_1.default.factory.createArrowFunction([], [], [
+              typescript_1.default.factory.createParameterDeclaration([], void 0, "t", void 0, void 0, void 0)
+            ], void 0, typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), expr))
+          }));
+        }
+      }
+      return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createIdentifier(`__RΦ`), "a"), [], [
+        typescript_1.default.factory.createNumericLiteral(type["id"])
+      ]);
+    }
+  }
+  typeEncoder.TypeEncoder = TypeEncoder;
+  return typeEncoder;
+}
+export {
+  requireTypeEncoder as __require
+};
+//# sourceMappingURL=type-encoder.js.map