@mastra/auth 0.1.0

package/dist/chunk-N62AETLJ.js

@@ -0,0 +1,7 @@
+import * as child_process from 'child_process';
+import * as util from 'util';
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/execAsync.js
+var execAsync = util.promisify(child_process.exec);
+
+export { execAsync };

package/dist/getMachineId-bsd-IPBZSYCM.js

@@ -0,0 +1,21 @@
+import { execAsync } from './chunk-N62AETLJ.js';
+import { diag } from './chunk-JLXWUSDO.js';
+import { promises } from 'fs';
+
+async function getMachineId() {
+  try {
+    const result = await promises.readFile("/etc/hostid", { encoding: "utf8" });
+    return result.trim();
+  } catch (e) {
+    diag.debug(`error reading machine id: ${e}`);
+  }
+  try {
+    const result = await execAsync("kenv -q smbios.system.uuid");
+    return result.stdout.trim();
+  } catch (e) {
+    diag.debug(`error reading machine id: ${e}`);
+  }
+  return void 0;
+}
+
+export { getMachineId };

package/dist/getMachineId-bsd-ZYXRAQYU.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var chunk6FSLIWKJ_cjs = require('./chunk-6FSLIWKJ.cjs');
+var chunkF3KPPQ4I_cjs = require('./chunk-F3KPPQ4I.cjs');
+var fs = require('fs');
+
+async function getMachineId() {
+  try {
+    const result = await fs.promises.readFile("/etc/hostid", { encoding: "utf8" });
+    return result.trim();
+  } catch (e) {
+    chunkF3KPPQ4I_cjs.diag.debug(`error reading machine id: ${e}`);
+  }
+  try {
+    const result = await chunk6FSLIWKJ_cjs.execAsync("kenv -q smbios.system.uuid");
+    return result.stdout.trim();
+  } catch (e) {
+    chunkF3KPPQ4I_cjs.diag.debug(`error reading machine id: ${e}`);
+  }
+  return void 0;
+}
+
+exports.getMachineId = getMachineId;

package/dist/getMachineId-darwin-GWWBITF5.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var chunk6FSLIWKJ_cjs = require('./chunk-6FSLIWKJ.cjs');
+var chunkF3KPPQ4I_cjs = require('./chunk-F3KPPQ4I.cjs');
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-darwin.js
+async function getMachineId() {
+  try {
+    const result = await chunk6FSLIWKJ_cjs.execAsync('ioreg -rd1 -c "IOPlatformExpertDevice"');
+    const idLine = result.stdout.split("\n").find((line) => line.includes("IOPlatformUUID"));
+    if (!idLine) {
+      return void 0;
+    }
+    const parts = idLine.split('" = "');
+    if (parts.length === 2) {
+      return parts[1].slice(0, -1);
+    }
+  } catch (e) {
+    chunkF3KPPQ4I_cjs.diag.debug(`error reading machine id: ${e}`);
+  }
+  return void 0;
+}
+
+exports.getMachineId = getMachineId;

package/dist/getMachineId-darwin-UJH25LDA.js

@@ -0,0 +1,22 @@
+import { execAsync } from './chunk-N62AETLJ.js';
+import { diag } from './chunk-JLXWUSDO.js';
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-darwin.js
+async function getMachineId() {
+  try {
+    const result = await execAsync('ioreg -rd1 -c "IOPlatformExpertDevice"');
+    const idLine = result.stdout.split("\n").find((line) => line.includes("IOPlatformUUID"));
+    if (!idLine) {
+      return void 0;
+    }
+    const parts = idLine.split('" = "');
+    if (parts.length === 2) {
+      return parts[1].slice(0, -1);
+    }
+  } catch (e) {
+    diag.debug(`error reading machine id: ${e}`);
+  }
+  return void 0;
+}
+
+export { getMachineId };

package/dist/getMachineId-linux-OCNXKJLY.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var chunkF3KPPQ4I_cjs = require('./chunk-F3KPPQ4I.cjs');
+var fs = require('fs');
+
+async function getMachineId() {
+  const paths = ["/etc/machine-id", "/var/lib/dbus/machine-id"];
+  for (const path of paths) {
+    try {
+      const result = await fs.promises.readFile(path, { encoding: "utf8" });
+      return result.trim();
+    } catch (e) {
+      chunkF3KPPQ4I_cjs.diag.debug(`error reading machine id: ${e}`);
+    }
+  }
+  return void 0;
+}
+
+exports.getMachineId = getMachineId;

package/dist/getMachineId-linux-YF3RLZNP.js

@@ -0,0 +1,17 @@
+import { diag } from './chunk-JLXWUSDO.js';
+import { promises } from 'fs';
+
+async function getMachineId() {
+  const paths = ["/etc/machine-id", "/var/lib/dbus/machine-id"];
+  for (const path of paths) {
+    try {
+      const result = await promises.readFile(path, { encoding: "utf8" });
+      return result.trim();
+    } catch (e) {
+      diag.debug(`error reading machine id: ${e}`);
+    }
+  }
+  return void 0;
+}
+
+export { getMachineId };

package/dist/getMachineId-unsupported-2CK5R6AJ.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var chunkF3KPPQ4I_cjs = require('./chunk-F3KPPQ4I.cjs');
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-unsupported.js
+async function getMachineId() {
+  chunkF3KPPQ4I_cjs.diag.debug("could not read machine-id: unsupported platform");
+  return void 0;
+}
+
+exports.getMachineId = getMachineId;

package/dist/getMachineId-unsupported-UOUTBEEW.js

@@ -0,0 +1,9 @@
+import { diag } from './chunk-JLXWUSDO.js';
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-unsupported.js
+async function getMachineId() {
+  diag.debug("could not read machine-id: unsupported platform");
+  return void 0;
+}
+
+export { getMachineId };

package/dist/getMachineId-win-NDZADH6M.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var chunk6FSLIWKJ_cjs = require('./chunk-6FSLIWKJ.cjs');
+var chunkF3KPPQ4I_cjs = require('./chunk-F3KPPQ4I.cjs');
+var process = require('process');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var process__namespace = /*#__PURE__*/_interopNamespace(process);
+
+async function getMachineId() {
+  const args = "QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid";
+  let command = "%windir%\\System32\\REG.exe";
+  if (process__namespace.arch === "ia32" && "PROCESSOR_ARCHITEW6432" in process__namespace.env) {
+    command = "%windir%\\sysnative\\cmd.exe /c " + command;
+  }
+  try {
+    const result = await chunk6FSLIWKJ_cjs.execAsync(`${command} ${args}`);
+    const parts = result.stdout.split("REG_SZ");
+    if (parts.length === 2) {
+      return parts[1].trim();
+    }
+  } catch (e) {
+    chunkF3KPPQ4I_cjs.diag.debug(`error reading machine id: ${e}`);
+  }
+  return void 0;
+}
+
+exports.getMachineId = getMachineId;

package/dist/getMachineId-win-PKATJI4A.js

@@ -0,0 +1,23 @@
+import { execAsync } from './chunk-N62AETLJ.js';
+import { diag } from './chunk-JLXWUSDO.js';
+import * as process from 'process';
+
+async function getMachineId() {
+  const args = "QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid";
+  let command = "%windir%\\System32\\REG.exe";
+  if (process.arch === "ia32" && "PROCESSOR_ARCHITEW6432" in process.env) {
+    command = "%windir%\\sysnative\\cmd.exe /c " + command;
+  }
+  try {
+    const result = await execAsync(`${command} ${args}`);
+    const parts = result.stdout.split("REG_SZ");
+    if (parts.length === 2) {
+      return parts[1].trim();
+    }
+  } catch (e) {
+    diag.debug(`error reading machine id: ${e}`);
+  }
+  return void 0;
+}
+
+export { getMachineId };

package/dist/index.cjs

@@ -0,0 +1,380 @@
+'use strict';
+
+var chunkF3KPPQ4I_cjs = require('./chunk-F3KPPQ4I.cjs');
+var jwt = require('jsonwebtoken');
+var jwksClient = require('jwks-rsa');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var jwt__default = /*#__PURE__*/_interopDefault(jwt);
+var jwksClient__default = /*#__PURE__*/_interopDefault(jwksClient);
+
+async function decodeToken(accessToken) {
+  const decoded = jwt__default.default.decode(accessToken, { complete: true });
+  return decoded;
+}
+function getTokenIssuer(decoded) {
+  if (!decoded) throw new Error("Invalid token");
+  if (!decoded.payload || typeof decoded.payload !== "object") throw new Error("Invalid token payload");
+  if (!decoded.payload.iss) throw new Error("Invalid token header");
+  return decoded.payload.iss;
+}
+async function verifyHmac(accessToken, secret) {
+  const decoded = jwt__default.default.decode(accessToken, { complete: true });
+  if (!decoded) throw new Error("Invalid token");
+  return jwt__default.default.verify(accessToken, secret);
+}
+async function verifyJwks(accessToken, jwksUri) {
+  const decoded = jwt__default.default.decode(accessToken, { complete: true });
+  if (!decoded) throw new Error("Invalid token");
+  const client = jwksClient__default.default({ jwksUri });
+  const key = await client.getSigningKey(decoded.header.kid);
+  const signingKey = key.getPublicKey();
+  return jwt__default.default.verify(accessToken, signingKey);
+}
+
+// ../core/dist/chunk-EWDGXKOQ.js
+function hasActiveTelemetry(tracerName = "default-tracer") {
+  try {
+    return !!chunkF3KPPQ4I_cjs.trace.getTracer(tracerName);
+  } catch {
+    return false;
+  }
+}
+function getBaggageValues(ctx) {
+  const currentBaggage = chunkF3KPPQ4I_cjs.propagation.getBaggage(ctx);
+  const requestId = currentBaggage?.getEntry("http.request_id")?.value;
+  const componentName = currentBaggage?.getEntry("componentName")?.value;
+  const runId = currentBaggage?.getEntry("runId")?.value;
+  return {
+    requestId,
+    componentName,
+    runId
+  };
+}
+function withSpan(options) {
+  return function(_target, propertyKey, descriptor) {
+    if (!descriptor || typeof descriptor === "number") return;
+    const originalMethod = descriptor.value;
+    const methodName = String(propertyKey);
+    descriptor.value = function(...args) {
+      if (options?.skipIfNoTelemetry && !hasActiveTelemetry(options?.tracerName)) {
+        return originalMethod.apply(this, args);
+      }
+      const tracer = chunkF3KPPQ4I_cjs.trace.getTracer(options?.tracerName ?? "default-tracer");
+      let spanName;
+      let spanKind;
+      if (typeof options === "string") {
+        spanName = options;
+      } else if (options) {
+        spanName = options.spanName || methodName;
+        spanKind = options.spanKind;
+      } else {
+        spanName = methodName;
+      }
+      const span = tracer.startSpan(spanName, { kind: spanKind });
+      let ctx = chunkF3KPPQ4I_cjs.trace.setSpan(chunkF3KPPQ4I_cjs.context.active(), span);
+      args.forEach((arg, index) => {
+        try {
+          span.setAttribute(`${spanName}.argument.${index}`, JSON.stringify(arg));
+        } catch {
+          span.setAttribute(`${spanName}.argument.${index}`, "[Not Serializable]");
+        }
+      });
+      const { requestId, componentName, runId } = getBaggageValues(ctx);
+      if (requestId) {
+        span.setAttribute("http.request_id", requestId);
+      }
+      if (componentName) {
+        span.setAttribute("componentName", componentName);
+        span.setAttribute("runId", runId);
+      } else if (this && this.name) {
+        span.setAttribute("componentName", this.name);
+        span.setAttribute("runId", this.runId);
+        ctx = chunkF3KPPQ4I_cjs.propagation.setBaggage(
+          ctx,
+          chunkF3KPPQ4I_cjs.propagation.createBaggage({
+            // @ts-ignore
+            componentName: { value: this.name },
+            // @ts-ignore
+            runId: { value: this.runId },
+            // @ts-ignore
+            "http.request_id": { value: requestId }
+          })
+        );
+      }
+      let result;
+      try {
+        result = chunkF3KPPQ4I_cjs.context.with(ctx, () => originalMethod.apply(this, args));
+        if (result instanceof Promise) {
+          return result.then((resolvedValue) => {
+            try {
+              span.setAttribute(`${spanName}.result`, JSON.stringify(resolvedValue));
+            } catch {
+              span.setAttribute(`${spanName}.result`, "[Not Serializable]");
+            }
+            return resolvedValue;
+          }).finally(() => span.end());
+        }
+        try {
+          span.setAttribute(`${spanName}.result`, JSON.stringify(result));
+        } catch {
+          span.setAttribute(`${spanName}.result`, "[Not Serializable]");
+        }
+        return result;
+      } catch (error) {
+        span.setStatus({
+          code: chunkF3KPPQ4I_cjs.SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : "Unknown error"
+        });
+        if (error instanceof Error) {
+          span.recordException(error);
+        }
+        throw error;
+      } finally {
+        if (!(result instanceof Promise)) {
+          span.end();
+        }
+      }
+    };
+    return descriptor;
+  };
+}
+function InstrumentClass(options) {
+  return function(target) {
+    const methods = Object.getOwnPropertyNames(target.prototype);
+    methods.forEach((method) => {
+      if (options?.excludeMethods?.includes(method) || method === "constructor") return;
+      if (options?.methodFilter && !options.methodFilter(method)) return;
+      const descriptor = Object.getOwnPropertyDescriptor(target.prototype, method);
+      if (descriptor && typeof descriptor.value === "function") {
+        Object.defineProperty(
+          target.prototype,
+          method,
+          withSpan({
+            spanName: options?.prefix ? `${options.prefix}.${method}` : method,
+            skipIfNoTelemetry: true,
+            spanKind: options?.spanKind || chunkF3KPPQ4I_cjs.SpanKind.INTERNAL,
+            tracerName: options?.tracerName
+          })(target, method, descriptor)
+        );
+      }
+    });
+    return target;
+  };
+}
+
+// ../core/dist/chunk-XXVGT7SJ.js
+var RegisteredLogger = {
+  LLM: "LLM"};
+var LogLevel = {
+  DEBUG: "debug",
+  INFO: "info",
+  WARN: "warn",
+  ERROR: "error"};
+var MastraLogger = class {
+  name;
+  level;
+  transports;
+  constructor(options = {}) {
+    this.name = options.name || "Mastra";
+    this.level = options.level || LogLevel.ERROR;
+    this.transports = new Map(Object.entries(options.transports || {}));
+  }
+  getTransports() {
+    return this.transports;
+  }
+  async getLogs(transportId) {
+    if (!transportId || !this.transports.has(transportId)) {
+      return [];
+    }
+    return this.transports.get(transportId).getLogs() ?? [];
+  }
+  async getLogsByRunId({ transportId, runId }) {
+    if (!transportId || !this.transports.has(transportId) || !runId) {
+      return [];
+    }
+    return this.transports.get(transportId).getLogsByRunId({ runId }) ?? [];
+  }
+};
+var ConsoleLogger = class extends MastraLogger {
+  constructor(options = {}) {
+    super(options);
+  }
+  debug(message, ...args) {
+    if (this.level === LogLevel.DEBUG) {
+      console.debug(message, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) {
+      console.info(message, ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.level === LogLevel.WARN || this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) {
+      console.warn(message, ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.level === LogLevel.ERROR || this.level === LogLevel.WARN || this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) {
+      console.error(message, ...args);
+    }
+  }
+  async getLogs(_transportId) {
+    return [];
+  }
+  async getLogsByRunId(_args) {
+    return [];
+  }
+};
+
+// ../core/dist/chunk-JOCKZ2US.js
+var MastraBase = class {
+  component = RegisteredLogger.LLM;
+  logger;
+  name;
+  telemetry;
+  constructor({ component, name }) {
+    this.component = component || RegisteredLogger.LLM;
+    this.name = name;
+    this.logger = new ConsoleLogger({ name: `${this.component} - ${this.name}` });
+  }
+  /**
+   * Set the logger for the agent
+   * @param logger
+   */
+  __setLogger(logger) {
+    this.logger = logger;
+    if (this.component !== RegisteredLogger.LLM) {
+      this.logger.debug(`Logger updated [component=${this.component}] [name=${this.name}]`);
+    }
+  }
+  /**
+   * Set the telemetry for the
+   * @param telemetry
+   */
+  __setTelemetry(telemetry) {
+    this.telemetry = telemetry;
+    if (this.component !== RegisteredLogger.LLM) {
+      this.logger.debug(`Telemetry updated [component=${this.component}] [name=${this.telemetry.name}]`);
+    }
+  }
+  /**
+   * Get the telemetry on the vector
+   * @returns telemetry
+   */
+  __getTelemetry() {
+    return this.telemetry;
+  }
+  /* 
+    get experimental_telemetry config
+    */
+  get experimental_telemetry() {
+    return this.telemetry ? {
+      // tracer: this.telemetry.tracer,
+      tracer: this.telemetry.getBaggageTracer(),
+      isEnabled: !!this.telemetry.tracer
+    } : void 0;
+  }
+};
+
+// ../core/dist/chunk-C6A6W6XS.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+});
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it, done, ctx, k = flags & 7, p = false;
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(target , name));
+  __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn(it) && (target = it);
+  }
+  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+
+// ../core/dist/server/index.js
+var _MastraAuthProvider_decorators;
+var _init;
+var _a;
+_MastraAuthProvider_decorators = [InstrumentClass({
+  prefix: "auth",
+  excludeMethods: ["__setTools", "__setLogger", "__setTelemetry", "#log"]
+})];
+var MastraAuthProvider = class extends (_a = MastraBase) {
+  constructor(options) {
+    super({
+      component: "AUTH",
+      name: options?.name
+    });
+    if (options?.authorizeUser) {
+      this.authorizeUser = options.authorizeUser.bind(this);
+    }
+  }
+  registerOptions(opts) {
+    if (opts?.authorizeUser) {
+      this.authorizeUser = opts.authorizeUser.bind(this);
+    }
+  }
+};
+MastraAuthProvider = /* @__PURE__ */ ((_) => {
+  _init = __decoratorStart(_a);
+  MastraAuthProvider = __decorateElement(_init, 0, "MastraAuthProvider", _MastraAuthProvider_decorators, MastraAuthProvider);
+  __runInitializers(_init, 1, MastraAuthProvider);
+  return MastraAuthProvider;
+})();
+var MastraJwtAuth = class extends MastraAuthProvider {
+  secret;
+  constructor(options) {
+    super({ name: options?.name ?? "jwt" });
+    this.secret = options?.secret ?? process.env.JWT_AUTH_SECRET ?? "";
+    if (!this.secret) {
+      throw new Error("JWT auth secret is required");
+    }
+    this.registerOptions(options);
+  }
+  async authenticateToken(token) {
+    return jwt__default.default.verify(token, this.secret);
+  }
+  async authorizeUser(user) {
+    return !!user;
+  }
+};
+
+exports.MastraJwtAuth = MastraJwtAuth;
+exports.decodeToken = decodeToken;
+exports.getTokenIssuer = getTokenIssuer;
+exports.verifyHmac = verifyHmac;
+exports.verifyJwks = verifyJwks;

package/dist/index.d.cts

@@ -0,0 +1,6 @@
+export { decodeToken } from './_tsup-dts-rollup.cjs';
+export { getTokenIssuer } from './_tsup-dts-rollup.cjs';
+export { verifyHmac } from './_tsup-dts-rollup.cjs';
+export { verifyJwks } from './_tsup-dts-rollup.cjs';
+export { JwtPayload } from './_tsup-dts-rollup.cjs';
+export { MastraJwtAuth } from './_tsup-dts-rollup.cjs';

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { decodeToken } from './_tsup-dts-rollup.js';
+export { getTokenIssuer } from './_tsup-dts-rollup.js';
+export { verifyHmac } from './_tsup-dts-rollup.js';
+export { verifyJwks } from './_tsup-dts-rollup.js';
+export { JwtPayload } from './_tsup-dts-rollup.js';
+export { MastraJwtAuth } from './_tsup-dts-rollup.js';