xml-model 1.2.0 → 1.3.1

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

@@ -0,0 +1,212 @@
+import ts from "typescript";
+import { F_INTERFACE, F_CLASS, F_PROPERTY, F_OPTIONAL, F_FUNCTION, F_ARROW_FUNCTION, F_METHOD, F_STATIC, F_INFERRED } from "../common/format.js";
+import { encodeParameter } from "./encode-parameter.js";
+import { getVisibility, isAbstract, isExported, isReadOnly, isAsync } from "./flags.js";
+import { forwardRef } from "./forward-ref.js";
+import { LegacyTypeEncoder } from "./legacy-type-encoder.js";
+import { literalNode } from "./literal-node.js";
+import { metadataDecorator, legacyMetadataDecorator } from "./metadata-decorator.js";
+import { serialize } from "./serialize.js";
+import { TypeEncoder } from "./type-encoder.js";
+import { expressionForPropertyName, hasModifier, getModifiers, propertyNameToString } from "./utils.js";
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+class MetadataEncoder {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.typeEncoder = new TypeEncoder(this.ctx);
+    this.legacyTypeEncoder = new 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(metadataDecorator("rt:t", literalNode(forwardRef(this.typeEncoder.referToType(type, typeNode)))));
+    if (this.emitStandardMetadata && allowStandardMetadata)
+      decs.push(legacyMetadataDecorator(`design:${standardName}`, literalNode(this.legacyTypeEncoder.referToType(type, typeNode))));
+    return decs;
+  }
+  prepareElementNames(elementNames) {
+    return elementNames.map((elementName) => literalNode(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(metadataDecorator("rt:SP", this.prepareElementNames(details.staticPropertyNames)));
+    decs.push(metadataDecorator("rt:P", this.prepareElementNames(details.propertyNames)));
+    if (ts.isClassDeclaration(klass) || ts.isClassExpression(klass))
+      decs.push(metadataDecorator("rt:Sm", this.prepareElementNames(details.staticMethodNames)));
+    decs.push(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(metadataDecorator("rt:i", typeRefs.map((tr) => tr ? literalNode(forwardRef(tr)) : void 0)));
+    }
+    let klassModifiers = ts.canHaveModifiers(klass) ? ts.getModifiers(klass) : [];
+    let fType = ts.isInterfaceDeclaration(klass) ? F_INTERFACE : F_CLASS;
+    decs.push(metadataDecorator("rt:f", `${fType}${getVisibility(klassModifiers)}${isAbstract(klassModifiers)}${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 (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 (hasModifier(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 '${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),
+      metadataDecorator("rt:f", `${F_PROPERTY}${getVisibility(nodeModifiers)}${isReadOnly(nodeModifiers)}${node.questionToken ? F_OPTIONAL : ""}`)
+    ];
+  }
+  methodFlags(node) {
+    if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node)) {
+      let type2 = F_FUNCTION;
+      return `${type2}${isAsync(getModifiers(node))}${ts.isArrowFunction(node) ? F_ARROW_FUNCTION : ""}`;
+    }
+    const nodeModifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : [];
+    let type = F_METHOD;
+    let flags = `${type}${getVisibility(nodeModifiers)}${isAbstract(nodeModifiers)}${isAsync(nodeModifiers)}`;
+    if (ts.isMethodDeclaration(node) && getModifiers(node).some((x) => x.kind === ts.SyntaxKind.StaticKeyword))
+      flags += F_STATIC;
+    if (node.questionToken)
+      flags += F_OPTIONAL;
+    if (!node.type)
+      flags += F_INFERRED;
+    return flags;
+  }
+  method(node) {
+    let propNameStr = 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(legacyMetadataDecorator("design:type", literalNode(ts.factory.createIdentifier("Function"))));
+    decs.push(...this.params(node));
+    decs.push(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(literalNode(serialize(encodeParameter(this.typeEncoder, param))));
+    }
+    decs.push(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(metadataDecorator("design:paramtypes", standardParamTypes.map((t) => literalNode(t))));
+    }
+    return decs;
+  }
+}
+export {
+  MetadataEncoder
+};
+//# sourceMappingURL=metadata-encoder.js.map

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

@@ -0,0 +1,96 @@
+import ts from "typescript";
+import { literalNode } from "./literal-node.js";
+import { serialize } from "./serialize.js";
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+function rtStore(typeMap) {
+  const factory = ts.factory;
+  let typeEntries = Array.from(typeMap.entries()).map(([i, t]) => factory.createPropertyAssignment(factory.createComputedPropertyName(ts.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, serialize({
+    m: 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(ts.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(ts.SyntaxKind.DotDotDotToken), factory.createIdentifier("a"), void 0, void 0, void 0)
+    ], void 0, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createConditionalExpression(factory.createBinaryExpression(factory.createIdentifier("t"), factory.createToken(ts.SyntaxKind.AmpersandAmpersandToken), factory.createPropertyAccessExpression(factory.createIdentifier("Reflect"), factory.createIdentifier("metadata"))), factory.createToken(ts.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(ts.SyntaxKind.ColonToken), factory.createVoidExpression(factory.createNumericLiteral("0")))))),
+    f: 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(ts.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(ts.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier("d"), void 0, [factory.createIdentifier("f")]))]), factory.createToken(ts.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(ts.SyntaxKind.CommaToken), factory.createIdentifier("f"))))),
+    c: 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(ts.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(ts.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier("d"), void 0, [factory.createIdentifier("c")]))]), factory.createToken(ts.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(ts.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier("d"), void 0, [
+      factory.createPropertyAccessExpression(factory.createIdentifier("c"), factory.createIdentifier("prototype")),
+      factory.createIdentifier("p")
+    ]))])), factory.createToken(ts.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(ts.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier("d"), void 0, [
+      factory.createIdentifier("c"),
+      factory.createIdentifier("p")
+    ]))])), factory.createToken(ts.SyntaxKind.CommaToken), factory.createConditionalExpression(factory.createIdentifier("n"), factory.createToken(ts.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(ts.SyntaxKind.ColonToken), factory.createIdentifier("undefined"))), factory.createToken(ts.SyntaxKind.CommaToken), factory.createIdentifier("c"))))),
+    r: 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(ts.SyntaxKind.EqualsGreaterThanToken), factory.createParenthesizedExpression(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), factory.createIdentifier("assign")), void 0, [
+      factory.createIdentifier("o"),
+      factory.createIdentifier("a")
+    ])))),
+    a: 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(ts.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")))], ts.NodeFlags.Let)),
+      factory.createIfStatement(factory.createBinaryExpression(factory.createIdentifier("t"), factory.createToken(ts.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Φ")))], ts.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, []))], ts.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(ts.SyntaxKind.EqualsToken), factory.createBinaryExpression(factory.createIdentifier("t"), factory.createToken(ts.SyntaxKind.EqualsToken), factory.createIdentifier("l"))))
+      ], true), void 0)),
+      factory.createReturnStatement(factory.createIdentifier("t"))
+    ], true))),
+    oe: 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(ts.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: literalNode(typeStore)
+  }))], ts.NodeFlags.Const));
+}
+export {
+  rtStore
+};
+//# sourceMappingURL=rt-helper.js.map

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

@@ -0,0 +1,28 @@
+import { VisitorBase } from "./common/visitor-base.js";
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+class RttiVisitor extends 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;
+  }
+}
+export {
+  RttiVisitor
+};
+//# sourceMappingURL=rtti-visitor-base.js.map

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

@@ -0,0 +1,31 @@
+import ts from "typescript";
+import "../common/index.js";
+import { createRequire } from "node:module";
+import { isLiteralNode } from "../common/format.js";
+const require$1 = createRequire(import.meta.url);
+function serialize(object) {
+  if (object === null)
+    return ts.factory.createNull();
+  if (object === void 0)
+    return ts.factory.createVoidZero();
+  if (object instanceof Array)
+    return ts.factory.createArrayLiteralExpression(object.map((x) => serialize(x)));
+  if (typeof object === "string")
+    return ts.factory.createStringLiteral(object);
+  if (typeof object === "number")
+    return ts.factory.createNumericLiteral(object);
+  if (typeof object === "boolean")
+    return object ? ts.factory.createTrue() : ts.factory.createFalse();
+  if (typeof object === "function")
+    throw new Error(`Cannot serialize a function`);
+  if (isLiteralNode(object))
+    return object.node;
+  let props = [];
+  for (let key of Object.keys(object))
+    props.push(ts.factory.createPropertyAssignment(key, serialize(object[key])));
+  return ts.factory.createObjectLiteralExpression(props, false);
+}
+export {
+  serialize
+};
+//# sourceMappingURL=serialize.js.map

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

@@ -0,0 +1,76 @@
+import ts from "typescript";
+import { T_STAND_IN } from "../common/format.js";
+import { literalNode } from "./literal-node.js";
+import { serialize } from "./serialize.js";
+import { structuredTypeLiteral, typeLiteral } from "./type-literal.js";
+import { hasFlag } from "./utils.js";
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+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 = hasFlag(type.flags, ts.TypeFlags.Enum) || hasFlag(type.flags, ts.TypeFlags.EnumLiteral) && hasFlag((_a = type.aliasSymbol) === null || _a === void 0 ? void 0 : _a.flags, ts.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 = hasFlag(
+        declaration === null || declaration === void 0 ? void 0 : declaration.flags,
+        16777216
+        /* InternalNodeFlags.Ambient */
+      );
+      let useStandIn = false;
+      if (isEnum) {
+        useStandIn = isLocal && !hasFlag(type.symbol.flags, ts.SymbolFlags.ConstEnum);
+      } else if (type.isClassOrInterface()) {
+        useStandIn = isLocal && !isAmbient;
+      }
+      if (useStandIn) {
+        this.typeMap.set(type["id"], serialize({
+          TΦ: T_STAND_IN,
+          name: `${type.symbol.name}`
+        }));
+      } else {
+        let expr = isLocal && isAmbient ? structuredTypeLiteral(this, type, typeNode, (_c = type.symbol) === null || _c === void 0 ? void 0 : _c.name) : typeLiteral(this, type, typeNode);
+        let propName = ts.isObjectLiteralExpression(expr) ? "RΦ" : "LΦ";
+        this.typeMap.set(type["id"], serialize({
+          [propName]: literalNode(ts.factory.createArrowFunction([], [], [
+            ts.factory.createParameterDeclaration([], void 0, "t", void 0, void 0, void 0)
+          ], void 0, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), expr))
+        }));
+      }
+    }
+    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(`__RΦ`), "a"), [], [
+      ts.factory.createNumericLiteral(type["id"])
+    ]);
+  }
+}
+export {
+  TypeEncoder
+};
+//# sourceMappingURL=type-encoder.js.map