xml-model 1.2.0 → 1.3.1

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

@@ -0,0 +1,93 @@
+import ts from "typescript";
+import { createRequire } from "node:module";
+var __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 = 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;
+const require$1 = createRequire(import.meta.url);
+function Visit(kind) {
+  if (!Array.isArray(kind))
+    kind = [kind];
+  let kinds = kind;
+  return (target, propertyKey) => {
+    target[propertyKey].kinds = kinds;
+  };
+}
+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_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");
+};
+export {
+  Visit,
+  VisitorBase
+};
+//# sourceMappingURL=visitor-base.js.map

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

@@ -0,0 +1,31 @@
+import { Visit } from "./common/visitor-base.js";
+import { RttiVisitor } from "./rtti-visitor-base.js";
+import ts from "typescript";
+import { createRequire } from "node:module";
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+const require$1 = createRequire(import.meta.url);
+class DeclarationsEmitter extends RttiVisitor {
+  static emit(sourceFile, ctx) {
+    return new DeclarationsEmitter(ctx).visitNode(sourceFile);
+  }
+  functionDecl(decl) {
+  }
+}
+__decorate([
+  Visit(ts.SyntaxKind.FunctionDeclaration),
+  __metadata("design:type", Function),
+  __metadata("design:paramtypes", [Object]),
+  __metadata("design:returntype", void 0)
+], DeclarationsEmitter.prototype, "functionDecl", null);
+export {
+  DeclarationsEmitter
+};
+//# sourceMappingURL=declarations-emitter.js.map

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

@@ -0,0 +1,64 @@
+import ts from "typescript";
+import { F_ARRAY_BINDING, F_OBJECT_BINDING, F_OPTIONAL, F_REST, F_READONLY, F_PRIVATE, F_PUBLIC, F_PROTECTED } from "../common/format.js";
+import { functionForwardRef, forwardRef } from "./forward-ref.js";
+import { literalNode } from "./literal-node.js";
+import { getModifiers } from "./utils.js";
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+function encodeParameter(encoder, param) {
+  if (ts.isOmittedExpression(param))
+    return { f: "," };
+  let nameNode = param.name;
+  let bindings;
+  let name;
+  let f = [];
+  let typeExpr;
+  let checker = encoder.ctx.checker;
+  if (ts.isArrayBindingPattern(nameNode)) {
+    f.push(F_ARRAY_BINDING);
+    bindings = [];
+    for (let element of nameNode.elements) {
+      bindings.push(encodeParameter(encoder, element));
+    }
+  } else if (ts.isObjectBindingPattern(nameNode)) {
+    f.push(F_OBJECT_BINDING);
+    bindings = [];
+    for (let element of nameNode.elements) {
+      bindings.push(encodeParameter(encoder, element));
+    }
+  } else {
+    name = nameNode.text;
+  }
+  if (ts.isParameter(param)) {
+    if (param.questionToken)
+      f.push(F_OPTIONAL);
+    if (param.dotDotDotToken)
+      f.push(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 getModifiers(param)) {
+    if (modifier.kind === ts.SyntaxKind.ReadonlyKeyword)
+      f.push(F_READONLY);
+    if (modifier.kind === ts.SyntaxKind.PrivateKeyword)
+      f.push(F_PRIVATE);
+    if (modifier.kind === ts.SyntaxKind.PublicKeyword)
+      f.push(F_PUBLIC);
+    if (modifier.kind === ts.SyntaxKind.ProtectedKeyword)
+      f.push(F_PROTECTED);
+  }
+  let meta = {
+    n: name,
+    t: literalNode(forwardRef(typeExpr)),
+    b: bindings,
+    v: param.initializer ? literalNode(functionForwardRef(param.initializer)) : null
+  };
+  if (f.length > 0)
+    meta.f = f.join("");
+  return meta;
+}
+export {
+  encodeParameter
+};
+//# sourceMappingURL=encode-parameter.js.map

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

@@ -0,0 +1,41 @@
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+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;
+}
+export {
+  findRelativePathToFile
+};
+//# sourceMappingURL=find-relative-path.js.map

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

@@ -0,0 +1,43 @@
+import ts from "typescript";
+import { F_PUBLIC, F_PRIVATE, F_PROTECTED, F_READONLY, F_ABSTRACT, F_ASYNC, F_EXPORTED } from "../common/format.js";
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+function getVisibility(modifiers) {
+  if (modifiers) {
+    if (modifiers.some((x) => x.kind === ts.SyntaxKind.PublicKeyword))
+      return F_PUBLIC;
+    if (modifiers.some((x) => x.kind === ts.SyntaxKind.PrivateKeyword))
+      return F_PRIVATE;
+    if (modifiers.some((x) => x.kind === ts.SyntaxKind.ProtectedKeyword))
+      return F_PROTECTED;
+  }
+  return "";
+}
+function isReadOnly(modifiers) {
+  if (!modifiers)
+    return "";
+  return modifiers.some((x) => x.kind === ts.SyntaxKind.ReadonlyKeyword) ? F_READONLY : "";
+}
+function isAbstract(modifiers) {
+  if (!modifiers)
+    return "";
+  return modifiers.some((x) => x.kind === ts.SyntaxKind.AbstractKeyword) ? F_ABSTRACT : "";
+}
+function isAsync(modifiers) {
+  if (!modifiers)
+    return "";
+  return modifiers.some((x) => x.kind === ts.SyntaxKind.AsyncKeyword) ? F_ASYNC : "";
+}
+function isExported(modifiers) {
+  if (!modifiers)
+    return "";
+  return modifiers.some((x) => x.kind === ts.SyntaxKind.ExportKeyword) ? F_EXPORTED : "";
+}
+export {
+  getVisibility,
+  isAbstract,
+  isAsync,
+  isExported,
+  isReadOnly
+};
+//# sourceMappingURL=flags.js.map

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

@@ -0,0 +1,20 @@
+import ts from "typescript";
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+function forwardRef(expr) {
+  if (!expr)
+    throw new Error(`Cannot make forwardRef without an expression`);
+  return ts.factory.createArrowFunction([], [], [], void 0, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), expr);
+}
+function functionForwardRef(expr) {
+  if (!expr)
+    throw new Error(`Cannot make forwardRef without an expression`);
+  return ts.factory.createFunctionExpression([], void 0, "", [], [], void 0, ts.factory.createBlock([
+    ts.factory.createReturnStatement(expr)
+  ]));
+}
+export {
+  forwardRef,
+  functionForwardRef
+};
+//# sourceMappingURL=forward-ref.js.map

package/vite/dist/node_modules/typescript-rtti/dist.esm/transformer/get-exports-for-symbol.js

@@ -0,0 +1,64 @@
+import { externalModules, getDirectoryPath, getDefaultLikeExportInfo, skipAlias, isTypeOnlySymbol, hasFilesystemAccess, fileExists } from "./utils.js";
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+function getExportsForSymbol(program, importingFile, symbol) {
+  const checker = program.getTypeChecker();
+  const compilerOptions = program.getCompilerOptions();
+  const result = [];
+  let exportingModuleSymbol = symbol["parent"];
+  for (let [moduleSymbol, moduleFile] of externalModules(program)) {
+    let isRootDeclaration = moduleSymbol === exportingModuleSymbol;
+    if (moduleFile === importingFile)
+      continue;
+    if (moduleFile && !isRootDeclaration && importingFile.fileName.startsWith(getDirectoryPath(moduleFile.fileName)))
+      continue;
+    const defaultInfo = getDefaultLikeExportInfo(importingFile, moduleSymbol, checker, compilerOptions);
+    if (defaultInfo && skipAlias(defaultInfo.symbol, checker) === symbol) {
+      result.push({
+        moduleSymbol,
+        importKind: defaultInfo.kind,
+        exportedSymbolIsTypeOnly: isTypeOnlySymbol(defaultInfo.symbol, checker),
+        symbol: void 0,
+        sourceFile: moduleFile
+      });
+    }
+    for (const exported of getExportsAndPropertiesOfModule(checker, moduleSymbol)) {
+      if (skipAlias(exported, checker) === symbol) {
+        result.push({
+          moduleSymbol,
+          importKind: 0,
+          exportedSymbolIsTypeOnly: isTypeOnlySymbol(exported, checker),
+          symbol: exported,
+          sourceFile: moduleFile
+        });
+      }
+    }
+  }
+  return result;
+}
+function getPreferredExportForImport(program, importingFile, symbol) {
+  let exports$1 = getExportsForSymbol(program, importingFile, symbol).slice();
+  exports$1 = exports$1.filter((x) => x.sourceFile);
+  exports$1.sort((a, b) => {
+    return a.sourceFile.fileName.length - b.sourceFile.fileName.length;
+  });
+  if (hasFilesystemAccess()) {
+    exports$1 = exports$1.filter((exp) => {
+      if (exp.sourceFile.fileName.endsWith(".d.ts")) {
+        let jsFile = exp.sourceFile.fileName.replace(/\.d\.ts$/, ".js");
+        if (!fileExists(jsFile))
+          return false;
+      }
+      return true;
+    });
+  }
+  return exports$1[0];
+}
+function getExportsAndPropertiesOfModule(checker, moduleSymbol) {
+  return checker["getExportsAndPropertiesOfModule"](moduleSymbol);
+}
+export {
+  getExportsForSymbol,
+  getPreferredExportForImport
+};
+//# sourceMappingURL=get-exports-for-symbol.js.map

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

@@ -0,0 +1,130 @@
+import { rtStore } from "./rt-helper.js";
+import ts from "typescript";
+import { ImportAnalyzer } from "./common/import-analyzer.js";
+import { CompileError } from "./common/compile-error.js";
+import { ApiCallTransformer } from "./api-call-transformer.js";
+import { MetadataEmitter } from "./metadata-emitter.js";
+import { DeclarationsEmitter } from "./declarations-emitter.js";
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+const transformer = (program) => {
+  let compilerOptions = program.getCompilerOptions();
+  if (typeof compilerOptions["rtti$emitStandardMetadata"] === "undefined") {
+    let emitDecoratorMetadata = compilerOptions.emitDecoratorMetadata;
+    compilerOptions["rtti$emitStandardMetadata"] = emitDecoratorMetadata;
+    compilerOptions.emitDecoratorMetadata = false;
+  }
+  let emitStandardMetadata = compilerOptions["rtti$emitStandardMetadata"];
+  if (globalThis.RTTI_TRACE)
+    console.log(`RTTI: Entering program [emitDecoratorMetadata=${emitStandardMetadata}]`);
+  let pkgJsonMap = /* @__PURE__ */ new Map();
+  const rttiTransformer = (context) => {
+    let settings = context.getCompilerOptions().rtti;
+    if (globalThis.RTTI_TRACE)
+      console.log(`RTTI: Transformer setup`);
+    return (sourceFile) => {
+      var _a, _b;
+      if (globalThis.RTTI_TRACE)
+        console.log(`RTTI: Transforming '${sourceFile.fileName}'`);
+      let ctx = {
+        program,
+        checker: program.getTypeChecker(),
+        currentNameScope: void 0,
+        freeImportReference: 0,
+        importMap: /* @__PURE__ */ new Map(),
+        sourceFile,
+        trace: (_a = settings === null || settings === void 0 ? void 0 : settings.trace) !== null && _a !== void 0 ? _a : false,
+        throwOnFailure: (_b = settings === null || settings === void 0 ? void 0 : settings.throwOnFailure) !== null && _b !== void 0 ? _b : false,
+        transformationContext: context,
+        typeMap: /* @__PURE__ */ new Map(),
+        pkgJsonMap,
+        emitStandardMetadata,
+        currentTopStatement: void 0,
+        interfaceSymbols: []
+      };
+      ImportAnalyzer.analyze(sourceFile, ctx);
+      if (sourceFile.isDeclarationFile || sourceFile.fileName.endsWith(".d.ts")) {
+        if (ctx.trace)
+          console.log(`#### Processing declaration ${sourceFile.fileName}`);
+        return DeclarationsEmitter.emit(sourceFile, ctx);
+      }
+      if (ctx.trace)
+        console.log(`#### Processing ${sourceFile.fileName}`);
+      globalThis.RTTI_TRACE = ctx.trace;
+      globalThis.RTTI_THROW_ON_FAILURE = ctx.throwOnFailure;
+      sourceFile = ApiCallTransformer.transform(sourceFile, ctx);
+      function generateInterfaceSymbols(statements) {
+        for (let iface of ctx.interfaceSymbols) {
+          let impoIndex = statements.indexOf(iface.interfaceDecl);
+          if (impoIndex >= 0) {
+            statements.splice(impoIndex, 0, ...iface.symbolDecl);
+          } else {
+            statements.push(...iface.symbolDecl);
+          }
+        }
+        return statements;
+      }
+      function generateImports(statements) {
+        var _a2;
+        let imports = [];
+        let isCommonJS = context.getCompilerOptions().module === ts.ModuleKind.CommonJS;
+        let statementTransforms = /* @__PURE__ */ new Map();
+        for (let statement of statements)
+          statementTransforms.set(ts.getOriginalNode(statement), statement);
+        for (let impo of ctx.importMap.values()) {
+          if (!impo.referenced)
+            continue;
+          if (ctx.trace)
+            console.log(`RTTI: Generating owned import for '${impo.modulePath}'`);
+          let ownedImpo;
+          if (impo.isDefault) {
+            if (isCommonJS) {
+              ownedImpo = ts.factory.createVariableStatement(void 0, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier(impo.localName), void 0, void 0, ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createIdentifier("require"), void 0, [ts.factory.createStringLiteral(impo.modulePath)]), ts.factory.createIdentifier("default")))], ts.NodeFlags.None));
+            } else {
+              ownedImpo = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, ts.factory.createIdentifier(impo.localName), void 0), ts.factory.createStringLiteral(impo.modulePath), void 0);
+            }
+          } else {
+            ownedImpo = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, impo.isNamespace ? ts.factory.createNamespaceImport(ts.factory.createIdentifier(impo.localName)) : ts.factory.createNamedImports([
+              ts.factory.createImportSpecifier(false, ts.factory.createIdentifier(impo.refName), ts.factory.createIdentifier(impo.localName))
+            ])), ts.factory.createStringLiteral(impo.modulePath));
+          }
+          let impoIndex = -1;
+          if (impo.importDeclaration) {
+            let original = (_a2 = statementTransforms.get(impo.importDeclaration)) !== null && _a2 !== void 0 ? _a2 : impo.importDeclaration;
+            impoIndex = statements.indexOf(original);
+            if (impoIndex < 0)
+              impoIndex = statements.indexOf(impo.importDeclaration);
+          }
+          if (impoIndex >= 0) {
+            statements.splice(impoIndex, 0, ownedImpo);
+          } else {
+            statements.splice(0, 0, ownedImpo);
+          }
+        }
+        return statements;
+      }
+      try {
+        sourceFile = MetadataEmitter.emit(sourceFile, ctx);
+        sourceFile = ts.factory.updateSourceFile(sourceFile, [
+          ...generateInterfaceSymbols(generateImports(Array.from(sourceFile.statements)))
+        ], sourceFile.isDeclarationFile, sourceFile.referencedFiles, sourceFile.typeReferenceDirectives, sourceFile.hasNoDefaultLib, sourceFile.libReferenceDirectives);
+      } catch (e) {
+        if (e instanceof CompileError)
+          throw e;
+        console.error(`RTTI: Failed to build source file ${sourceFile.fileName}: ${e.message} [please report]`);
+        console.error(e);
+        if (globalThis.RTTI_THROW_ON_FAILURE)
+          throw e;
+      }
+      sourceFile = ts.factory.updateSourceFile(sourceFile, [rtStore(ctx.typeMap), ...sourceFile.statements], sourceFile.isDeclarationFile, sourceFile.referencedFiles, sourceFile.typeReferenceDirectives, sourceFile.hasNoDefaultLib, sourceFile.libReferenceDirectives);
+      if (globalThis.RTTI_TRACE)
+        console.log(`RTTI: Finished transforming '${sourceFile.fileName}'`);
+      return sourceFile;
+    };
+  };
+  return rttiTransformer;
+};
+export {
+  transformer as default
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,10 @@
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+function legacyDecorator(decorator) {
+  decorator["__Φlegacy"] = true;
+  return decorator;
+}
+export {
+  legacyDecorator
+};
+//# sourceMappingURL=legacy-decorator.js.map

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

@@ -0,0 +1,82 @@
+import ts from "typescript";
+import { typeLiteral } from "./type-literal.js";
+import { hasFlag, hasAnyFlag, isFlagType } from "./utils.js";
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+class LegacyTypeEncoder {
+  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;
+    if (!type)
+      return ts.factory.createIdentifier("Object");
+    if (hasFlag(type.flags, ts.TypeFlags.StringLike)) {
+      return ts.factory.createIdentifier("String");
+    } else if (hasFlag(type.flags, ts.TypeFlags.NumberLike)) {
+      return ts.factory.createIdentifier("Number");
+    } else if (hasFlag(type.flags, ts.TypeFlags.BooleanLike)) {
+      return ts.factory.createIdentifier("Boolean");
+    } else if (hasAnyFlag(type.flags, [ts.TypeFlags.Void, ts.TypeFlags.Undefined, ts.TypeFlags.Null])) {
+      return ts.factory.createVoidZero();
+    } else if (hasFlag(type.flags, ts.TypeFlags.BigIntLike)) {
+      return ts.factory.createIdentifier("BigInt");
+    } else if (isFlagType(type, ts.TypeFlags.Object)) {
+      if (hasFlag(type.objectFlags, ts.ObjectFlags.Reference)) {
+        let typeRef = type;
+        if (typeRef.target !== typeRef) {
+          if ((typeRef.target.objectFlags & ts.ObjectFlags.Tuple) !== 0)
+            return ts.factory.createIdentifier("Array");
+          if (typeRef.target.symbol.name === "Array" && typeRef.typeArguments.length === 1)
+            return ts.factory.createIdentifier("Array");
+          return this.referToType(typeRef.target, typeNode);
+        }
+      }
+      if (hasFlag(type.objectFlags, ts.ObjectFlags.Anonymous)) {
+        let anonymousType = type;
+        if (anonymousType.getCallSignatures().length > 0)
+          return ts.factory.createIdentifier(`Function`);
+        return ts.factory.createIdentifier("Object");
+      } else if (type.isClassOrInterface()) {
+        let reifiedType = type.isClass() || ((_a = type.symbol) === null || _a === void 0 ? void 0 : _a.name) === "Promise" || !!type.symbol.valueDeclaration;
+        if (reifiedType) {
+          return typeLiteral(this, type, typeNode, { hoistImportsInCommonJS: true });
+        }
+      }
+      return ts.factory.createIdentifier("Object");
+    } else if (isFlagType(type, ts.TypeFlags.EnumLike)) {
+      let types = type["types"];
+      if (types && types.length > 0) {
+        if (types.every((x) => hasFlag(x.flags, ts.TypeFlags.StringLike)))
+          return ts.factory.createIdentifier("String");
+        else if (types.every((x) => hasFlag(x.flags, ts.TypeFlags.NumberLike)))
+          return ts.factory.createIdentifier("Number");
+        else if (types.every((x) => hasFlag(x.flags, ts.TypeFlags.BigIntLike)))
+          return ts.factory.createIdentifier("BigInt");
+      }
+    }
+    return ts.factory.createIdentifier("Object");
+  }
+}
+export {
+  LegacyTypeEncoder
+};
+//# sourceMappingURL=legacy-type-encoder.js.map

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

@@ -0,0 +1,9 @@
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+function literalNode(expr) {
+  return { $__isTSNode: true, node: expr };
+}
+export {
+  literalNode
+};
+//# sourceMappingURL=literal-node.js.map

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

@@ -0,0 +1,56 @@
+import ts from "typescript";
+import { getDecorators, getModifiers } from "./utils.js";
+import { createRequire } from "node:module";
+const require$1 = createRequire(import.meta.url);
+class InlineMetadataCollector {
+  collect(node, decorators) {
+    if (decorators.length === 0)
+      return node;
+    if (ts.isPropertyDeclaration(node)) {
+      return ts.factory.updatePropertyDeclaration(node, [...getDecorators(node), ...decorators, ...getModifiers(node)], node.name, node.questionToken || node.exclamationToken, node.type, node.initializer);
+    } else if (ts.isGetAccessor(node)) {
+      return ts.factory.updateGetAccessorDeclaration(node, [...getDecorators(node), ...decorators, ...getModifiers(node)], node.name, node.parameters, node.type, node.body);
+    } else if (ts.isSetAccessor(node)) {
+      return ts.factory.updateSetAccessorDeclaration(node, [...getDecorators(node), ...decorators, ...getModifiers(node)], node.name, node.parameters, node.body);
+    } else if (ts.isMethodDeclaration(node)) {
+      return ts.factory.updateMethodDeclaration(node, [...getDecorators(node), ...decorators, ...getModifiers(node)], node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body);
+    } else if (ts.isClassDeclaration(node)) {
+      return ts.factory.updateClassDeclaration(node, [...getDecorators(node), ...decorators, ...getModifiers(node)], node.name, node.typeParameters, node.heritageClauses, node.members);
+    } else {
+      throw new TypeError(`Not sure how to collect metadata onto ${node}`);
+    }
+  }
+}
+class ExternalMetadataCollector {
+  constructor() {
+    this.inlineCollector = new InlineMetadataCollector();
+    this.decorators = [];
+  }
+  collect(node, addedDecorators) {
+    var _a;
+    let property;
+    if (ts.isMethodDeclaration(node) || ts.isPropertyDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node) || ts.isMethodSignature(node) || ts.isPropertySignature(node)) {
+      property = node.name;
+    }
+    let legacyDecorators = addedDecorators.filter((decorator) => decorator["__Φlegacy"]);
+    let nonLegacyDecorators = addedDecorators.filter((decorator) => !decorator["__Φlegacy"]);
+    this.decorators.push(...nonLegacyDecorators.map((decorator) => {
+      var _a2;
+      return {
+        property,
+        node,
+        decorator,
+        direct: (_a2 = decorator["__Φdirect"]) !== null && _a2 !== void 0 ? _a2 : false
+      };
+    }));
+    if (((_a = getDecorators(node)) === null || _a === void 0 ? void 0 : _a.length) > 0 && legacyDecorators.length > 0) {
+      node = this.inlineCollector.collect(node, legacyDecorators);
+    }
+    return node;
+  }
+}
+export {
+  ExternalMetadataCollector,
+  InlineMetadataCollector
+};
+//# sourceMappingURL=metadata-collector.js.map