@mastra/core 0.2.0-alpha.98 → 0.2.0

package/dist/base.d.ts

@@ -1,46 +1,6 @@
-import * as _opentelemetry_api from '@opentelemetry/api';
-import { R as RegisteredLogger, L as Logger, a as LogLevel } from './index-CBZ2mk2H.js';
-import { T as Telemetry } from './telemetry-oCUM52DG.js';
+import '@opentelemetry/api';
+import './index-B2JCcAQt.js';
+export { M as MastraBase } from './base-BbtPAA6f.js';
 import 'pino';
 import 'stream';
-import '@opentelemetry/sdk-node';
 import '@opentelemetry/sdk-trace-base';
-
-declare class MastraBase {
-    component: RegisteredLogger;
-    protected logger: Logger;
-    name?: string;
-    telemetry?: Telemetry;
-    constructor({ component, name }: {
-        component?: RegisteredLogger;
-        name?: string;
-    });
-    /**
-     * Set the logger for the agent
-     * @param logger
-     */
-    __setLogger(logger: Logger): void;
-    /**
-     * Internal logging helper that formats and sends logs to the configured logger
-     * @param level - Severity level of the log
-     * @param message - Main log message
-     * @param opts - Optional object for the log
-     */
-    log(level: LogLevel, message: string, opts?: Record<string, any>): void;
-    /**
-     * Set the telemetry for the
-     * @param telemetry
-     */
-    __setTelemetry(telemetry: Telemetry): void;
-    /**
-     * Get the telemetry on the vector
-     * @returns telemetry
-     */
-    __getTelemetry(): Telemetry | undefined;
-    get experimental_telemetry(): {
-        tracer: _opentelemetry_api.Tracer;
-        isEnabled: boolean;
-    } | undefined;
-}
-
-export { MastraBase };

package/dist/base.js

@@ -1,3 +1,3 @@
-export { MastraBase } from './chunk-G4MCO7XF.js';
-import './chunk-ICMEXHKD.js';
-import './chunk-AJJZUHB4.js';
+export { MastraBase } from './chunk-AWEACB2T.js';
+import './chunk-O2VP5JBC.js';
+import './chunk-C6A6W6XS.js';

package/dist/bundler/index.d.ts

@@ -1,10 +1,8 @@
-import { MastraBase } from '../base.js';
+import { M as MastraBase } from '../base-BbtPAA6f.js';
 import '@opentelemetry/api';
-import '../index-CBZ2mk2H.js';
+import '../index-B2JCcAQt.js';
 import 'pino';
 import 'stream';
-import '../telemetry-oCUM52DG.js';
-import '@opentelemetry/sdk-node';
 import '@opentelemetry/sdk-trace-base';
 
 interface IBundler {
@@ -22,6 +20,7 @@ declare abstract class MastraBundler extends MastraBase implements IBundler {
     loadEnvVars(): Promise<Map<string, string>>;
     abstract prepare(outputDirectory: string): Promise<void>;
     abstract writePackageJson(outputDirectory: string, dependencies: Map<string, string>): Promise<void>;
+    abstract writeInstrumentationFile(outputDirectory: string): Promise<void>;
     abstract getEnvFiles(): Promise<string[]>;
     abstract bundle(entryFile: string, outputDirectory: string): Promise<void>;
 }

package/dist/bundler/index.js

@@ -1,4 +1,4 @@
-export { MastraBundler } from '../chunk-MCB4M5W4.js';
-import '../chunk-G4MCO7XF.js';
-import '../chunk-ICMEXHKD.js';
-import '../chunk-AJJZUHB4.js';
+export { MastraBundler } from '../chunk-22LC46YN.js';
+import '../chunk-AWEACB2T.js';
+import '../chunk-O2VP5JBC.js';
+import '../chunk-C6A6W6XS.js';

package/dist/{chunk-MCB4M5W4.js → chunk-22LC46YN.js}

@@ -1,14 +1,10 @@
-import { MastraBase } from './chunk-G4MCO7XF.js';
-import { __name } from './chunk-AJJZUHB4.js';
+import { MastraBase } from './chunk-AWEACB2T.js';
 import { parse } from 'dotenv';
 import { readFile } from 'fs/promises';
 
-var _MastraBundler = class _MastraBundler extends MastraBase {
+var MastraBundler = class extends MastraBase {
   constructor({ name, component = "BUNDLER" }) {
-    super({
-      component,
-      name
-    });
+    super({ component, name });
   }
   async loadEnvVars() {
     const envVars = /* @__PURE__ */ new Map();
@@ -22,7 +18,5 @@ var _MastraBundler = class _MastraBundler extends MastraBase {
     return envVars;
   }
 };
-__name(_MastraBundler, "MastraBundler");
-var MastraBundler = _MastraBundler;
 
 export { MastraBundler };

package/dist/{chunk-MG3WAQV7.js → chunk-2JL6DQMZ.js}

@@ -1,11 +1,23 @@
-import { Agent } from './chunk-QXH6EK72.js';
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
+import { Agent } from './chunk-K4DFI76V.js';
 import { CohereClient } from 'cohere-ai';
+import 'ai';
 
-var _CohereRelevanceScorer = class _CohereRelevanceScorer {
+// src/relevance/relevance-score-provider.ts
+function createSimilarityPrompt(query, text) {
+  return `Rate the semantic similarity between the following the query and the text on a scale from 0 to 1 (decimals allowed), where 1 means exactly the same meaning and 0 means completely different:
+
+Query: ${query}
+
+Text: ${text}
+
+Relevance score (0-1):`;
+}
+
+// src/relevance/cohere/index.ts
+var CohereRelevanceScorer = class {
+  client;
+  model;
   constructor(model, apiKey) {
-    __publicField(this, "client");
-    __publicField(this, "model");
     this.client = new CohereClient({
       token: apiKey || process.env.COHERE_API_KEY || ""
     });
@@ -14,34 +26,16 @@ var _CohereRelevanceScorer = class _CohereRelevanceScorer {
   async getRelevanceScore(query, text) {
     const response = await this.client.rerank({
       query,
-      documents: [
-        text
-      ],
+      documents: [text],
       model: this.model,
       topN: 1
     });
     return response.results[0].relevanceScore;
   }
 };
-__name(_CohereRelevanceScorer, "CohereRelevanceScorer");
-var CohereRelevanceScorer = _CohereRelevanceScorer;
-
-// src/relevance/relevance-score-provider.ts
-function createSimilarityPrompt(query, text) {
-  return `Rate the semantic similarity between the following the query and the text on a scale from 0 to 1 (decimals allowed), where 1 means exactly the same meaning and 0 means completely different:
-
-Query: ${query}
-
-Text: ${text}
-
-Relevance score (0-1):`;
-}
-__name(createSimilarityPrompt, "createSimilarityPrompt");
-
-// src/relevance/mastra-agent/index.ts
-var _MastraAgentRelevanceScorer = class _MastraAgentRelevanceScorer {
+var MastraAgentRelevanceScorer = class {
+  agent;
   constructor(name, model) {
-    __publicField(this, "agent");
     this.agent = new Agent({
       name: `Relevance Scorer ${name}`,
       instructions: `You are a specialized agent for evaluating the relevance of text to queries.
@@ -63,7 +57,5 @@ Always return just the number, no explanation.`,
     return parseFloat(response.text);
   }
 };
-__name(_MastraAgentRelevanceScorer, "MastraAgentRelevanceScorer");
-var MastraAgentRelevanceScorer = _MastraAgentRelevanceScorer;
 
 export { CohereRelevanceScorer, MastraAgentRelevanceScorer, createSimilarityPrompt };

package/dist/chunk-2SAHBQEF.js

@@ -0,0 +1,3 @@
+import 'ai';
+import 'json-schema';
+import 'zod';

package/dist/chunk-3HBFW3Q7.js

@@ -0,0 +1,24 @@
+import 'zod';
+
+// src/tools/tool.ts
+var Tool = class {
+  id;
+  description;
+  inputSchema;
+  outputSchema;
+  execute;
+  mastra;
+  constructor(opts) {
+    this.id = opts.id;
+    this.description = opts.description;
+    this.inputSchema = opts.inputSchema;
+    this.outputSchema = opts.outputSchema;
+    this.execute = opts.execute;
+    this.mastra = opts.mastra;
+  }
+};
+function createTool(opts) {
+  return new Tool(opts);
+}
+
+export { Tool, createTool };

package/dist/{chunk-KNPBNSJ7.js → chunk-55GTEVHJ.js}

@@ -1,7 +1,7 @@
-import { __name } from './chunk-AJJZUHB4.js';
 import { z } from 'zod';
 
-var delay = /* @__PURE__ */ __name((ms) => new Promise((resolve) => setTimeout(resolve, ms)), "delay");
+// src/utils.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function jsonSchemaPropertiesToTSTypes(value) {
   if (!value.type) {
     return z.object({});
@@ -29,8 +29,10 @@ Examples: ${value.examples.join(", ")}` : ""));
 Examples: ${value.examples.join(", ")}` : ""));
       break;
     case "object":
-      zodType = jsonSchemaToModel(value).describe((value.description || "") + (value.examples ? `
-Examples: ${value.examples.join(", ")}` : ""));
+      zodType = jsonSchemaToModel(value).describe(
+        (value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : "")
+      );
       break;
     case "null":
       zodType = z.null().describe(value.description || "");
@@ -40,7 +42,6 @@ Examples: ${value.examples.join(", ")}` : ""));
   }
   return zodType;
 }
-__name(jsonSchemaPropertiesToTSTypes, "jsonSchemaPropertiesToTSTypes");
 function jsonSchemaToModel(jsonSchema) {
   const properties = jsonSchema.properties;
   const requiredFields = jsonSchema.required || [];
@@ -57,7 +58,10 @@ function jsonSchemaToModel(jsonSchema) {
 Examples: ${value.examples.join(", ")}` : ""));
     } else if (value.allOf) {
       const allOfTypes = value.allOf.map((schema) => jsonSchemaPropertiesToTSTypes(schema));
-      zodType = z.intersection(allOfTypes[0], allOfTypes.slice(1).reduce((acc, schema) => acc.and(schema), allOfTypes[0])).describe((value.description || "") + (value.examples ? `
+      zodType = z.intersection(
+        allOfTypes[0],
+        allOfTypes.slice(1).reduce((acc, schema) => acc.and(schema), allOfTypes[0])
+      ).describe((value.description || "") + (value.examples ? `
 Examples: ${value.examples.join(", ")}` : ""));
     } else {
       if (!value.type) {
@@ -76,11 +80,8 @@ Examples: ${value.examples.join(", ")}` : ""));
   }
   return z.object(zodSchema);
 }
-__name(jsonSchemaToModel, "jsonSchemaToModel");
 function deepMerge(target, source) {
-  const output = {
-    ...target
-  };
+  const output = { ...target };
   if (!source) return output;
   Object.keys(source).forEach((key) => {
     const targetValue = output[key];
@@ -95,7 +96,6 @@ function deepMerge(target, source) {
   });
   return output;
 }
-__name(deepMerge, "deepMerge");
 async function* maskStreamTags(stream, tag, options = {}) {
   const { onStart, onEnd, onMask } = options;
   const openTag = `<${tag}>`;
@@ -104,7 +104,7 @@ async function* maskStreamTags(stream, tag, options = {}) {
   let fullContent = "";
   let isMasking = false;
   let isBuffering = false;
-  const startsWith = /* @__PURE__ */ __name((text, pattern) => text.trim().startsWith(pattern.trim()), "startsWith");
+  const startsWith = (text, pattern) => text.trim().startsWith(pattern.trim());
   for await (const chunk of stream) {
     fullContent += chunk;
     if (isBuffering) buffer += chunk;
@@ -140,6 +140,5 @@ async function* maskStreamTags(stream, tag, options = {}) {
     yield chunk;
   }
 }
-__name(maskStreamTags, "maskStreamTags");
 
 export { deepMerge, delay, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, maskStreamTags };

package/dist/chunk-65VPTVVP.js

@@ -0,0 +1,218 @@
+import { DefaultStorage } from './chunk-U6J2FOU4.js';
+import { DefaultVectorDB } from './chunk-OJ26F3J4.js';
+import { defaultEmbedder } from './chunk-ZJOXJFJI.js';
+import { deepMerge } from './chunk-55GTEVHJ.js';
+import { MastraBase } from './chunk-AWEACB2T.js';
+
+// src/memory/memory.ts
+var MastraMemory = class extends MastraBase {
+  MAX_CONTEXT_TOKENS;
+  storage;
+  vector;
+  embedder;
+  threadConfig = {
+    lastMessages: 40,
+    semanticRecall: true
+  };
+  constructor(config) {
+    super({ component: "MEMORY", name: config.name });
+    this.storage = config.storage || new DefaultStorage({
+      config: {
+        url: "file:memory.db"
+      }
+    });
+    if (config.vector) {
+      this.vector = config.vector;
+    } else {
+      this.vector = new DefaultVectorDB({
+        connectionUrl: "file:memory-vector.db"
+        // file name needs to be different than default storage or it wont work properly
+      });
+    }
+    if (config.embedder) {
+      this.embedder = config.embedder;
+    } else {
+      this.embedder = defaultEmbedder("bge-small-en-v1.5");
+    }
+    if (config.options) {
+      this.threadConfig = this.getMergedThreadConfig(config.options);
+    }
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  setVector(vector) {
+    this.vector = vector;
+  }
+  setEmbedder(embedder) {
+    this.embedder = embedder;
+  }
+  /**
+   * Get a system message to inject into the conversation.
+   * This will be called before each conversation turn.
+   * Implementations can override this to inject custom system messages.
+   */
+  async getSystemMessage(_input) {
+    return null;
+  }
+  async createEmbeddingIndex() {
+    const defaultDimensions = 1536;
+    const dimensionsByModelId = {
+      "bge-small-en-v1.5": 384,
+      "bge-base-en-v1.5": 768
+    };
+    const dimensions = dimensionsByModelId[this.embedder.modelId] || defaultDimensions;
+    const isDefault = dimensions === defaultDimensions;
+    const indexName = isDefault ? "memory_messages" : `memory_messages_${dimensions}`;
+    await this.vector.createIndex(indexName, dimensions);
+    return { indexName };
+  }
+  getMergedThreadConfig(config) {
+    return deepMerge(this.threadConfig, config || {});
+  }
+  estimateTokens(text) {
+    return Math.ceil(text.split(" ").length * 1.3);
+  }
+  parseMessages(messages) {
+    return messages.map((msg) => ({
+      ...msg,
+      content: typeof msg.content === "string" && (msg.content.startsWith("[") || msg.content.startsWith("{")) ? JSON.parse(msg.content) : msg.content
+    }));
+  }
+  convertToUIMessages(messages) {
+    function addToolMessageToChat({
+      toolMessage,
+      messages: messages2,
+      toolResultContents
+    }) {
+      const chatMessages2 = messages2.map((message) => {
+        if (message.toolInvocations) {
+          return {
+            ...message,
+            toolInvocations: message.toolInvocations.map((toolInvocation) => {
+              const toolResult = toolMessage.content.find((tool) => tool.toolCallId === toolInvocation.toolCallId);
+              if (toolResult) {
+                return {
+                  ...toolInvocation,
+                  state: "result",
+                  result: toolResult.result
+                };
+              }
+              return toolInvocation;
+            })
+          };
+        }
+        return message;
+      });
+      const resultContents = [...toolResultContents, ...toolMessage.content];
+      return { chatMessages: chatMessages2, toolResultContents: resultContents };
+    }
+    const { chatMessages } = messages.reduce(
+      (obj, message) => {
+        if (message.role === "tool") {
+          return addToolMessageToChat({
+            toolMessage: message,
+            messages: obj.chatMessages,
+            toolResultContents: obj.toolResultContents
+          });
+        }
+        let textContent = "";
+        let toolInvocations = [];
+        if (typeof message.content === "string") {
+          textContent = message.content;
+        } else if (Array.isArray(message.content)) {
+          for (const content of message.content) {
+            if (content.type === "text") {
+              textContent += content.text;
+            } else if (content.type === "tool-call") {
+              const toolResult = obj.toolResultContents.find((tool) => tool.toolCallId === content.toolCallId);
+              toolInvocations.push({
+                state: toolResult ? "result" : "call",
+                toolCallId: content.toolCallId,
+                toolName: content.toolName,
+                args: content.args,
+                result: toolResult?.result
+              });
+            }
+          }
+        }
+        obj.chatMessages.push({
+          id: message.id,
+          role: message.role,
+          content: textContent,
+          toolInvocations
+        });
+        return obj;
+      },
+      { chatMessages: [], toolResultContents: [] }
+    );
+    return chatMessages;
+  }
+  /**
+   * Helper method to create a new thread
+   * @param title - Optional title for the thread
+   * @param metadata - Optional metadata for the thread
+   * @returns Promise resolving to the created thread
+   */
+  async createThread({
+    threadId,
+    resourceId,
+    title,
+    metadata,
+    memoryConfig
+  }) {
+    const thread = {
+      id: threadId || this.generateId(),
+      title: title || "New Thread",
+      resourceId,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      metadata
+    };
+    return this.saveThread({ thread, memoryConfig });
+  }
+  /**
+   * Helper method to add a single message to a thread
+   * @param threadId - The thread to add the message to
+   * @param content - The message content
+   * @param role - The role of the message sender
+   * @param type - The type of the message
+   * @param toolNames - Optional array of tool names that were called
+   * @param toolCallArgs - Optional array of tool call arguments
+   * @param toolCallIds - Optional array of tool call ids
+   * @returns Promise resolving to the saved message
+   */
+  async addMessage({
+    threadId,
+    config,
+    content,
+    role,
+    type,
+    toolNames,
+    toolCallArgs,
+    toolCallIds
+  }) {
+    const message = {
+      id: this.generateId(),
+      content,
+      role,
+      createdAt: /* @__PURE__ */ new Date(),
+      threadId,
+      type,
+      toolNames,
+      toolCallArgs,
+      toolCallIds
+    };
+    const savedMessages = await this.saveMessages({ messages: [message], memoryConfig: config });
+    return savedMessages[0];
+  }
+  /**
+   * Generates a unique identifier
+   * @returns A unique string ID
+   */
+  generateId() {
+    return crypto.randomUUID();
+  }
+};
+
+export { MastraMemory };

package/dist/chunk-AWEACB2T.js

@@ -0,0 +1,66 @@
+import { RegisteredLogger, createLogger } from './chunk-O2VP5JBC.js';
+
+// src/base.ts
+var MastraBase = class {
+  component = RegisteredLogger.LLM;
+  logger;
+  name;
+  telemetry;
+  constructor({ component, name }) {
+    this.component = component || RegisteredLogger.LLM;
+    this.name = name;
+    this.logger = createLogger({ name: `${this.component} - ${this.name}` });
+  }
+  /**
+   * Set the logger for the agent
+   * @param logger
+   */
+  __setLogger(logger) {
+    this.logger = logger;
+    this.logger.debug(`Logger updated [component=${this.component}] [name=${this.name}]`);
+  }
+  /**
+   * Internal logging helper that formats and sends logs to the configured logger
+   * @param level - Severity level of the log
+   * @param message - Main log message
+   * @param opts - Optional object for the log
+   */
+  log(level, message, opts) {
+    if (!this.logger) return;
+    const logMessage = {
+      type: this.component,
+      message,
+      destinationPath: this.name ? `${this.component}/${this.name}` : this.component,
+      ...opts || {}
+    };
+    const logMethod = level.toLowerCase();
+    this.logger[logMethod]?.(logMessage);
+  }
+  /**
+   * Set the telemetry for the
+   * @param telemetry
+   */
+  __setTelemetry(telemetry) {
+    this.telemetry = telemetry;
+    this.logger.debug(`Telemetry updated [component=${this.component}] [tracer=${this.telemetry.tracer}]`);
+  }
+  /**
+   * 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
+    } : undefined;
+  }
+};
+
+export { MastraBase };

package/dist/chunk-C6A6W6XS.js

@@ -0,0 +1,49 @@
+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 !== undefined && 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++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === undefined) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+export { __decorateElement, __decoratorStart, __runInitializers };