@highstate/designer 0.4.4 → 0.4.5

package/.output/server/node_modules/@babel/parser/lib/index.js

@@ -307,7 +307,7 @@ var StrictModeErrors = {
   StrictWith: "'with' in strict mode."
 };
 const UnparenthesizedPipeBodyDescriptions = new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]);
-var PipelineOperatorErrors = {
+var PipelineOperatorErrors = Object.assign({
   PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.",
   PipeTopicRequiresHackPipes: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.',
   PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
@@ -319,14 +319,15 @@ var PipelineOperatorErrors = {
     type
   }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({
     type
-  })}; please wrap it in parentheses.`,
+  })}; please wrap it in parentheses.`
+}, {
   PipelineBodyNoArrow: 'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized.',
   PipelineBodySequenceExpression: "Pipeline body may not be a comma-separated sequence expression.",
   PipelineHeadSequenceExpression: "Pipeline head should not be a comma-separated sequence expression.",
   PipelineTopicUnused: "Pipeline is in topic style but does not use topic reference.",
   PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.",
   PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.'
-};
+});
 const _excluded = ["message"];
 function defineHidden(obj, key, value) {
   Object.defineProperty(obj, key, {
@@ -632,8 +633,7 @@ var estree = superClass => class ESTreeParserMixin extends superClass {
     if (typeParameters) {
       delete node.typeParameters;
       funcNode.typeParameters = typeParameters;
-      funcNode.start = typeParameters.start;
-      funcNode.loc.start = typeParameters.loc.start;
+      this.resetStartLocationFromNode(funcNode, typeParameters);
     }
     if (type === "ClassPrivateMethod") {
       node.computed = false;
@@ -7849,7 +7849,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     }
     this.expect(11);
     if (this.eat(16)) {
-      node.qualifier = this.tsParseEntityName();
+      node.qualifier = this.tsParseEntityName(1 | 2);
     }
     if (this.match(47)) {
       {
@@ -7858,19 +7858,30 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     }
     return this.finishNode(node, "TSImportType");
   }
-  tsParseEntityName(allowReservedWords = true) {
-    let entity = this.parseIdentifier(allowReservedWords);
+  tsParseEntityName(flags) {
+    let entity;
+    if (flags & 1 && this.match(78)) {
+      if (flags & 2) {
+        entity = this.parseIdentifier(true);
+      } else {
+        const node = this.startNode();
+        this.next();
+        entity = this.finishNode(node, "ThisExpression");
+      }
+    } else {
+      entity = this.parseIdentifier(!!(flags & 1));
+    }
     while (this.eat(16)) {
       const node = this.startNodeAtNode(entity);
       node.left = entity;
-      node.right = this.parseIdentifier(allowReservedWords);
+      node.right = this.parseIdentifier(!!(flags & 1));
       entity = this.finishNode(node, "TSQualifiedName");
     }
     return entity;
   }
   tsParseTypeReference() {
     const node = this.startNode();
-    node.typeName = this.tsParseEntityName();
+    node.typeName = this.tsParseEntityName(1);
     if (!this.hasPrecedingLineBreak() && this.match(47)) {
       {
         node.typeParameters = this.tsParseTypeArguments();
@@ -7897,7 +7908,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     if (this.match(83)) {
       node.exprName = this.tsParseImportType();
     } else {
-      node.exprName = this.tsParseEntityName();
+      {
+        node.exprName = this.tsParseEntityName(1 | 2);
+      }
     }
     if (!this.hasPrecedingLineBreak() && this.match(47)) {
       {
@@ -8157,10 +8170,11 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     return this.finishNode(node, "TSTupleType");
   }
   tsParseTupleElementType() {
+    const restStartLoc = this.state.startLoc;
+    const rest = this.eat(21);
     const {
       startLoc
     } = this.state;
-    const rest = this.eat(21);
     let labeled;
     let label;
     let optional;
@@ -8175,7 +8189,6 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       type = this.tsParseType();
     } else if (chAfterWord === 63) {
       optional = true;
-      const startLoc = this.state.startLoc;
       const wordName = this.state.value;
       const typeOrLabel = this.tsParseNonArrayType();
       if (this.lookaheadCharCode() === 58) {
@@ -8197,7 +8210,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     if (labeled) {
       let labeledNode;
       if (label) {
-        labeledNode = this.startNodeAtNode(label);
+        labeledNode = this.startNodeAt(startLoc);
         labeledNode.optional = optional;
         labeledNode.label = label;
         labeledNode.elementType = type;
@@ -8206,7 +8219,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
           this.raise(TSErrors.TupleOptionalAfterType, this.state.lastTokStartLoc);
         }
       } else {
-        labeledNode = this.startNodeAtNode(type);
+        labeledNode = this.startNodeAt(startLoc);
         labeledNode.optional = optional;
         this.raise(TSErrors.InvalidTupleMemberLabel, type);
         labeledNode.label = type;
@@ -8214,12 +8227,12 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
       }
       type = this.finishNode(labeledNode, "TSNamedTupleMember");
     } else if (optional) {
-      const optionalTypeNode = this.startNodeAtNode(type);
+      const optionalTypeNode = this.startNodeAt(startLoc);
       optionalTypeNode.typeAnnotation = type;
       type = this.finishNode(optionalTypeNode, "TSOptionalType");
     }
     if (rest) {
-      const restNode = this.startNodeAt(startLoc);
+      const restNode = this.startNodeAt(restStartLoc);
       restNode.typeAnnotation = type;
       type = this.finishNode(restNode, "TSRestType");
     }
@@ -8258,9 +8271,11 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     return this.finishNode(node, "TSLiteralType");
   }
   tsParseTemplateLiteralType() {
-    const node = this.startNode();
-    node.literal = super.parseTemplate(false);
-    return this.finishNode(node, "TSLiteralType");
+    {
+      const node = this.startNode();
+      node.literal = super.parseTemplate(false);
+      return this.finishNode(node, "TSLiteralType");
+    }
   }
   parseTemplateSubstitution() {
     if (this.state.inType) return this.tsParseType();
@@ -8327,15 +8342,18 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     this.unexpected();
   }
   tsParseArrayTypeOrHigher() {
+    const {
+      startLoc
+    } = this.state;
     let type = this.tsParseNonArrayType();
     while (!this.hasPrecedingLineBreak() && this.eat(0)) {
       if (this.match(3)) {
-        const node = this.startNodeAtNode(type);
+        const node = this.startNodeAt(startLoc);
         node.elementType = type;
         this.expect(3);
         type = this.finishNode(node, "TSArrayType");
       } else {
-        const node = this.startNodeAtNode(type);
+        const node = this.startNodeAt(startLoc);
         node.objectType = type;
         node.indexType = this.tsParseType();
         this.expect(3);
@@ -8588,8 +8606,8 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     const originalStartLoc = this.state.startLoc;
     const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
       const node = this.startNode();
-      node.expression = this.tsParseEntityName();
       {
+        node.expression = this.tsParseEntityName(1 | 2);
         if (this.match(47)) {
           node.typeParameters = this.tsParseTypeArguments();
         }
@@ -8775,7 +8793,9 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     return this.finishNode(node, "TSModuleDeclaration");
   }
   tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) {
-    node.isExport = isExport || false;
+    {
+      node.isExport = isExport || false;
+    }
     node.id = maybeDefaultIdentifier || this.parseIdentifier();
     this.checkIdentifier(node.id, 4096);
     this.expect(29);
@@ -8791,7 +8811,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     return this.isContextual(119) && this.lookaheadCharCode() === 40;
   }
   tsParseModuleReference() {
-    return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);
+    return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(0);
   }
   tsParseExternalModuleReference() {
     const node = this.startNode();
@@ -9243,15 +9263,18 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
   }
   parseExport(node, decorators) {
     if (this.match(83)) {
-      this.next();
       const nodeImportEquals = node;
+      this.next();
       let maybeDefaultIdentifier = null;
       if (this.isContextual(130) && this.isPotentialImportPhase(false)) {
         maybeDefaultIdentifier = this.parseMaybeImportPhase(nodeImportEquals, false);
       } else {
         nodeImportEquals.importKind = "value";
       }
-      return this.tsParseImportEqualsDeclaration(nodeImportEquals, maybeDefaultIdentifier, true);
+      const declaration = this.tsParseImportEqualsDeclaration(nodeImportEquals, maybeDefaultIdentifier, true);
+      {
+        return declaration;
+      }
     } else if (this.eat(29)) {
       const assign = node;
       assign.expression = super.parseExpression();
@@ -9451,7 +9474,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) {
       node.exportKind = "type";
     }
-    if (isDeclare) {
+    if (isDeclare && declaration.type !== "TSImportEqualsDeclaration") {
       this.resetStartLocation(declaration, startLoc);
       declaration.declare = true;
     }
@@ -10618,18 +10641,19 @@ class ExpressionParser extends LValParser {
             return this.withTopicBindingContext(() => {
               return this.parseHackPipeBody();
             });
-          case "smart":
-            return this.withTopicBindingContext(() => {
-              if (this.prodParam.hasYield && this.isContextual(108)) {
-                throw this.raise(Errors.PipeBodyIsTighter, this.state.startLoc);
-              }
-              return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);
-            });
           case "fsharp":
             return this.withSoloAwaitPermittingContext(() => {
               return this.parseFSharpPipelineBody(prec);
             });
         }
+        if (this.getPluginOption("pipelineOperator", "proposal") === "smart") {
+          return this.withTopicBindingContext(() => {
+            if (this.prodParam.hasYield && this.isContextual(108)) {
+              throw this.raise(Errors.PipeBodyIsTighter, this.state.startLoc);
+            }
+            return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);
+          });
+        }
       default:
         return this.parseExprOpBaseRightExpr(op, prec);
     }
@@ -11125,12 +11149,19 @@ class ExpressionParser extends LValParser {
   }
   finishTopicReference(node, startLoc, pipeProposal, tokenType) {
     if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {
-      const nodeType = pipeProposal === "smart" ? "PipelinePrimaryTopicReference" : "TopicReference";
-      if (!this.topicReferenceIsAllowedInCurrentContext()) {
-        this.raise(pipeProposal === "smart" ? Errors.PrimaryTopicNotAllowed : Errors.PipeTopicUnbound, startLoc);
+      if (pipeProposal === "hack") {
+        if (!this.topicReferenceIsAllowedInCurrentContext()) {
+          this.raise(Errors.PipeTopicUnbound, startLoc);
+        }
+        this.registerTopicReference();
+        return this.finishNode(node, "TopicReference");
+      } else {
+        if (!this.topicReferenceIsAllowedInCurrentContext()) {
+          this.raise(Errors.PrimaryTopicNotAllowed, startLoc);
+        }
+        this.registerTopicReference();
+        return this.finishNode(node, "PipelinePrimaryTopicReference");
       }
-      this.registerTopicReference();
-      return this.finishNode(node, nodeType);
     } else {
       throw this.raise(Errors.PipeTopicUnconfiguredToken, startLoc, {
         token: tokenLabelName(tokenType)

package/.output/server/node_modules/@babel/parser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babel/parser",
-  "version": "7.26.5",
+  "version": "7.26.9",
   "description": "A JavaScript parser",
   "author": "The Babel Team (https://babel.dev/team)",
   "homepage": "https://babel.dev/docs/en/next/babel-parser",
@@ -35,7 +35,7 @@
   },
   "# dependencies": "This package doesn't actually have runtime dependencies. @babel/types is only needed for type definitions.",
   "dependencies": {
-    "@babel/types": "^7.26.5"
+    "@babel/types": "^7.26.9"
   },
   "devDependencies": {
     "@babel/code-frame": "^7.26.2",

package/.output/server/node_modules/@grpc/grpc-js/build/src/admin.js

@@ -0,0 +1,30 @@
+"use strict";
+/*
+ * Copyright 2021 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAdminService = registerAdminService;
+exports.addAdminServicesToServer = addAdminServicesToServer;
+const registeredAdminServices = [];
+function registerAdminService(getServiceDefinition, getHandlers) {
+    registeredAdminServices.push({ getServiceDefinition, getHandlers });
+}
+function addAdminServicesToServer(server) {
+    for (const { getServiceDefinition, getHandlers } of registeredAdminServices) {
+        server.addService(getServiceDefinition(), getHandlers());
+    }
+}
+//# sourceMappingURL=admin.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/backoff-timeout.js

@@ -0,0 +1,174 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackoffTimeout = void 0;
+const INITIAL_BACKOFF_MS = 1000;
+const BACKOFF_MULTIPLIER = 1.6;
+const MAX_BACKOFF_MS = 120000;
+const BACKOFF_JITTER = 0.2;
+/**
+ * Get a number uniformly at random in the range [min, max)
+ * @param min
+ * @param max
+ */
+function uniformRandom(min, max) {
+    return Math.random() * (max - min) + min;
+}
+class BackoffTimeout {
+    constructor(callback, options) {
+        this.callback = callback;
+        /**
+         * The delay time at the start, and after each reset.
+         */
+        this.initialDelay = INITIAL_BACKOFF_MS;
+        /**
+         * The exponential backoff multiplier.
+         */
+        this.multiplier = BACKOFF_MULTIPLIER;
+        /**
+         * The maximum delay time
+         */
+        this.maxDelay = MAX_BACKOFF_MS;
+        /**
+         * The maximum fraction by which the delay time can randomly vary after
+         * applying the multiplier.
+         */
+        this.jitter = BACKOFF_JITTER;
+        /**
+         * Indicates whether the timer is currently running.
+         */
+        this.running = false;
+        /**
+         * Indicates whether the timer should keep the Node process running if no
+         * other async operation is doing so.
+         */
+        this.hasRef = true;
+        /**
+         * The time that the currently running timer was started. Only valid if
+         * running is true.
+         */
+        this.startTime = new Date();
+        /**
+         * The approximate time that the currently running timer will end. Only valid
+         * if running is true.
+         */
+        this.endTime = new Date();
+        if (options) {
+            if (options.initialDelay) {
+                this.initialDelay = options.initialDelay;
+            }
+            if (options.multiplier) {
+                this.multiplier = options.multiplier;
+            }
+            if (options.jitter) {
+                this.jitter = options.jitter;
+            }
+            if (options.maxDelay) {
+                this.maxDelay = options.maxDelay;
+            }
+        }
+        this.nextDelay = this.initialDelay;
+        this.timerId = setTimeout(() => { }, 0);
+        clearTimeout(this.timerId);
+    }
+    runTimer(delay) {
+        var _a, _b;
+        this.endTime = this.startTime;
+        this.endTime.setMilliseconds(this.endTime.getMilliseconds() + this.nextDelay);
+        clearTimeout(this.timerId);
+        this.timerId = setTimeout(() => {
+            this.callback();
+            this.running = false;
+        }, delay);
+        if (!this.hasRef) {
+            (_b = (_a = this.timerId).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        }
+    }
+    /**
+     * Call the callback after the current amount of delay time
+     */
+    runOnce() {
+        this.running = true;
+        this.startTime = new Date();
+        this.runTimer(this.nextDelay);
+        const nextBackoff = Math.min(this.nextDelay * this.multiplier, this.maxDelay);
+        const jitterMagnitude = nextBackoff * this.jitter;
+        this.nextDelay =
+            nextBackoff + uniformRandom(-jitterMagnitude, jitterMagnitude);
+    }
+    /**
+     * Stop the timer. The callback will not be called until `runOnce` is called
+     * again.
+     */
+    stop() {
+        clearTimeout(this.timerId);
+        this.running = false;
+    }
+    /**
+     * Reset the delay time to its initial value. If the timer is still running,
+     * retroactively apply that reset to the current timer.
+     */
+    reset() {
+        this.nextDelay = this.initialDelay;
+        if (this.running) {
+            const now = new Date();
+            const newEndTime = this.startTime;
+            newEndTime.setMilliseconds(newEndTime.getMilliseconds() + this.nextDelay);
+            clearTimeout(this.timerId);
+            if (now < newEndTime) {
+                this.runTimer(newEndTime.getTime() - now.getTime());
+            }
+            else {
+                this.running = false;
+            }
+        }
+    }
+    /**
+     * Check whether the timer is currently running.
+     */
+    isRunning() {
+        return this.running;
+    }
+    /**
+     * Set that while the timer is running, it should keep the Node process
+     * running.
+     */
+    ref() {
+        var _a, _b;
+        this.hasRef = true;
+        (_b = (_a = this.timerId).ref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    /**
+     * Set that while the timer is running, it should not keep the Node process
+     * running.
+     */
+    unref() {
+        var _a, _b;
+        this.hasRef = false;
+        (_b = (_a = this.timerId).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    /**
+     * Get the approximate timestamp of when the timer will fire. Only valid if
+     * this.isRunning() is true.
+     */
+    getEndTime() {
+        return this.endTime;
+    }
+}
+exports.BackoffTimeout = BackoffTimeout;
+//# sourceMappingURL=backoff-timeout.js.map

package/.output/server/node_modules/@grpc/grpc-js/build/src/call-credentials.js

@@ -0,0 +1,153 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallCredentials = void 0;
+const metadata_1 = require("./metadata");
+function isCurrentOauth2Client(client) {
+    return ('getRequestHeaders' in client &&
+        typeof client.getRequestHeaders === 'function');
+}
+/**
+ * A class that represents a generic method of adding authentication-related
+ * metadata on a per-request basis.
+ */
+class CallCredentials {
+    /**
+     * Creates a new CallCredentials object from a given function that generates
+     * Metadata objects.
+     * @param metadataGenerator A function that accepts a set of options, and
+     * generates a Metadata object based on these options, which is passed back
+     * to the caller via a supplied (err, metadata) callback.
+     */
+    static createFromMetadataGenerator(metadataGenerator) {
+        return new SingleCallCredentials(metadataGenerator);
+    }
+    /**
+     * Create a gRPC credential from a Google credential object.
+     * @param googleCredentials The authentication client to use.
+     * @return The resulting CallCredentials object.
+     */
+    static createFromGoogleCredential(googleCredentials) {
+        return CallCredentials.createFromMetadataGenerator((options, callback) => {
+            let getHeaders;
+            if (isCurrentOauth2Client(googleCredentials)) {
+                getHeaders = googleCredentials.getRequestHeaders(options.service_url);
+            }
+            else {
+                getHeaders = new Promise((resolve, reject) => {
+                    googleCredentials.getRequestMetadata(options.service_url, (err, headers) => {
+                        if (err) {
+                            reject(err);
+                            return;
+                        }
+                        if (!headers) {
+                            reject(new Error('Headers not set by metadata plugin'));
+                            return;
+                        }
+                        resolve(headers);
+                    });
+                });
+            }
+            getHeaders.then(headers => {
+                const metadata = new metadata_1.Metadata();
+                for (const key of Object.keys(headers)) {
+                    metadata.add(key, headers[key]);
+                }
+                callback(null, metadata);
+            }, err => {
+                callback(err);
+            });
+        });
+    }
+    static createEmpty() {
+        return new EmptyCallCredentials();
+    }
+}
+exports.CallCredentials = CallCredentials;
+class ComposedCallCredentials extends CallCredentials {
+    constructor(creds) {
+        super();
+        this.creds = creds;
+    }
+    async generateMetadata(options) {
+        const base = new metadata_1.Metadata();
+        const generated = await Promise.all(this.creds.map(cred => cred.generateMetadata(options)));
+        for (const gen of generated) {
+            base.merge(gen);
+        }
+        return base;
+    }
+    compose(other) {
+        return new ComposedCallCredentials(this.creds.concat([other]));
+    }
+    _equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (other instanceof ComposedCallCredentials) {
+            return this.creds.every((value, index) => value._equals(other.creds[index]));
+        }
+        else {
+            return false;
+        }
+    }
+}
+class SingleCallCredentials extends CallCredentials {
+    constructor(metadataGenerator) {
+        super();
+        this.metadataGenerator = metadataGenerator;
+    }
+    generateMetadata(options) {
+        return new Promise((resolve, reject) => {
+            this.metadataGenerator(options, (err, metadata) => {
+                if (metadata !== undefined) {
+                    resolve(metadata);
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    compose(other) {
+        return new ComposedCallCredentials([this, other]);
+    }
+    _equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (other instanceof SingleCallCredentials) {
+            return this.metadataGenerator === other.metadataGenerator;
+        }
+        else {
+            return false;
+        }
+    }
+}
+class EmptyCallCredentials extends CallCredentials {
+    generateMetadata(options) {
+        return Promise.resolve(new metadata_1.Metadata());
+    }
+    compose(other) {
+        return other;
+    }
+    _equals(other) {
+        return other instanceof EmptyCallCredentials;
+    }
+}
+//# sourceMappingURL=call-credentials.js.map