@gomomento/sdk-core 1.12.8

package/dist/src/internal/utils/validators.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBase64 = exports.validateTtlMinutes = exports.validateTopicName = exports.validateListSliceStartEnd = exports.validateListName = exports.validateDictionaryName = exports.validateSortedSetCount = exports.validateSortedSetOffset = exports.validateSortedSetScores = exports.validateSortedSetRanks = exports.validateSortedSetName = exports.validateSetName = exports.validateCacheName = void 0;
+const errors_1 = require("../../errors/errors");
+const string_1 = require("./string");
+function validateCacheName(name) {
+    if (isEmpty(name)) {
+        throw new errors_1.InvalidArgumentError('cache name must not be empty');
+    }
+}
+exports.validateCacheName = validateCacheName;
+function validateSetName(name) {
+    if (isEmpty(name)) {
+        throw new errors_1.InvalidArgumentError('set name must not be empty');
+    }
+}
+exports.validateSetName = validateSetName;
+function validateSortedSetName(name) {
+    if (isEmpty(name)) {
+        throw new errors_1.InvalidArgumentError('sorted set name must not be empty');
+    }
+}
+exports.validateSortedSetName = validateSortedSetName;
+function validateSortedSetRanks(start_rank, end_rank) {
+    if (end_rank === undefined) {
+        return;
+    }
+    if (start_rank > 0 && end_rank > 0 && start_rank > end_rank) {
+        throw new errors_1.InvalidArgumentError('start rank must be less than end rank');
+    }
+    if (start_rank < 0 && end_rank < 0 && start_rank >= end_rank) {
+        throw new errors_1.InvalidArgumentError('negative start rank must be less than negative end rank');
+    }
+}
+exports.validateSortedSetRanks = validateSortedSetRanks;
+function validateSortedSetScores(minScore, maxScore) {
+    if (minScore === undefined)
+        return;
+    if (maxScore === undefined)
+        return;
+    if (minScore > maxScore) {
+        throw new errors_1.InvalidArgumentError('minScore must be less than or equal to maxScore');
+    }
+}
+exports.validateSortedSetScores = validateSortedSetScores;
+function validateSortedSetOffset(offset) {
+    if (offset < 0) {
+        throw new errors_1.InvalidArgumentError('offset must be non-negative (>= 0)');
+    }
+}
+exports.validateSortedSetOffset = validateSortedSetOffset;
+function validateSortedSetCount(count) {
+    if (count < 1) {
+        throw new errors_1.InvalidArgumentError('count must be strictly positive (> 0)');
+    }
+}
+exports.validateSortedSetCount = validateSortedSetCount;
+function validateDictionaryName(name) {
+    if (isEmpty(name)) {
+        throw new errors_1.InvalidArgumentError('dictionary name must not be empty');
+    }
+}
+exports.validateDictionaryName = validateDictionaryName;
+function validateListName(name) {
+    if (isEmpty(name)) {
+        throw new errors_1.InvalidArgumentError('list name must not be empty');
+    }
+}
+exports.validateListName = validateListName;
+function validateListSliceStartEnd(startIndex, endIndex) {
+    if (startIndex === undefined || endIndex === undefined)
+        return;
+    // can't validate bounds for start and index of either or are negative without list length
+    if (startIndex > 0 || endIndex < 0)
+        return;
+    if (endIndex <= startIndex) {
+        throw new errors_1.InvalidArgumentError('endIndex (exclusive) must be larger than startIndex (inclusive)');
+    }
+}
+exports.validateListSliceStartEnd = validateListSliceStartEnd;
+function validateTopicName(name) {
+    if (isEmpty(name)) {
+        throw new errors_1.InvalidArgumentError('topic name must not be empty');
+    }
+}
+exports.validateTopicName = validateTopicName;
+function validateTtlMinutes(ttlMinutes) {
+    if (ttlMinutes < 0) {
+        throw new errors_1.InvalidArgumentError('ttlMinutes must be positive');
+    }
+}
+exports.validateTtlMinutes = validateTtlMinutes;
+function isEmpty(str) {
+    return !str.trim();
+}
+function isBase64(str) {
+    try {
+        return (0, string_1.encodeToBase64)((0, string_1.decodeFromBase64)(str)) === str;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isBase64 = isBase64;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/internal/vendor/printf/README.md

@@ -0,0 +1,31 @@
+The code in this directory is vendored from:
+
+https://github.com/adaltas/node-printf/blob/5d11e642922fe1a125a141d4becfee00f29c67ce/lib/printf.js
+
+We are vendoring it to avoid adding additional transitive dependencies to our library.
+
+The original source code is licensed under the MIT license:
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2008 Adaltas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```

package/dist/src/internal/vendor/printf/printf.d.ts

@@ -0,0 +1,9 @@
+// Type definitions for printf 0.2.5 and above
+// Project: http://www.adaltas.com/projects/node-printf
+// Definitions by: Aluísio Augusto Silva Gonçalves <https://github.com/AluisioASG>
+
+/// <reference types="node" />
+
+export = printf;
+declare function printf(format: string, ...args: any[]): string;
+declare function printf(writeStream: NodeJS.WritableStream, format: string, ...args: any[]): void;

package/dist/src/internal/vendor/printf/printf.js

@@ -0,0 +1,478 @@
+/* eslint-disable */
+
+var util = require('util');
+
+var tokenize = function(/*String*/ str, /*RegExp*/ re, /*Function?*/ parseDelim, /*Object?*/ instance){
+  // summary:
+  //    Split a string by a regular expression with the ability to capture the delimeters
+  // parseDelim:
+  //    Each group (excluding the 0 group) is passed as a parameter. If the function returns
+  //    a value, it's added to the list of tokens.
+  // instance:
+  //    Used as the "this' instance when calling parseDelim
+  var tokens = [];
+  var match, content, lastIndex = 0;
+  while((match = re.exec(str))){
+    content = str.slice(lastIndex, re.lastIndex - match[0].length);
+    if(content.length){
+      tokens.push(content);
+    }
+    if(parseDelim){
+      var parsed = parseDelim.apply(instance, match.slice(1).concat(tokens.length));
+      if(typeof parsed != 'undefined'){
+        if(parsed.specifier === '%'){
+          tokens.push('%');
+        }else{
+          tokens.push(parsed);
+        }
+      }
+    }
+    lastIndex = re.lastIndex;
+  }
+  content = str.slice(lastIndex);
+  if(content.length){
+    tokens.push(content);
+  }
+  return tokens;
+};
+
+var Formatter = function(/*String*/ format){
+  this._mapped = false;
+  this._format = format;
+  this._tokens = tokenize(format, this._re, this._parseDelim, this);
+};
+
+// The old regexp `/\%(?:\(([\w_.]+)\)|([1-9]\d*)\$)?([0 +\-\#]*)(\*|\d+)?(\.)?(\*|\d+)?[hlL]?([\%bscdeEfFgGioOuxX])/` has a cubic worst-case time complexity behavior due to overlapping capture groups `([0 +\-\#]*)(\*|\d+)?(\.)?(\*|\d+)?`. And a pump string of 0 can be consumed by `([0 +\-\#]*), (\*|\d+)?, or (\*|\d+)?`.
+// The solution replace the sub-regexp (\*|\d+)?(\.)?(\*|\d+)? with the sub-regexp `(\*|\d+)?(?:(\.)(\*|\d+)?)?`, see the figure in [#32](https://github.com/adaltas/node-printf/pull/32)
+// There are also performance improvement, see in [#31](https://github.com/adaltas/node-printf/issues/31#issuecomment-776731490)
+Formatter.prototype._re = /\%(?:\(([\w_.]+)\)|([1-9]\d*)\$)?([0 +\-\#]*)(\*|\d+)?(?:(\.)(\*|\d+)?)?[hlL]?([\%bscdeEfFgGioOuxX])/g;
+Formatter.prototype._parseDelim = function(mapping, intmapping, flags, minWidth, period, precision, specifier){
+  if(mapping){
+    this._mapped = true;
+  }
+  return {
+    mapping: mapping,
+    intmapping: intmapping,
+    flags: flags,
+    _minWidth: minWidth, // May be dependent on parameters
+    period: period,
+    _precision: precision, // May be dependent on parameters
+    specifier: specifier
+  };
+};
+Formatter.prototype._specifiers = {
+  b: {
+    base: 2,
+    isInt: true
+  },
+  o: {
+    base: 8,
+    isInt: true
+  },
+  x: {
+    base: 16,
+    isInt: true
+  },
+  X: {
+    extend: ['x'],
+    toUpper: true
+  },
+  d: {
+    base: 10,
+    isInt: true
+  },
+  i: {
+    extend: ['d']
+  },
+  u: {
+    extend: ['d'],
+    isUnsigned: true
+  },
+  c: {
+    setArg: function(token){
+      if(!isNaN(token.arg)){
+        var num = parseInt(token.arg);
+        if(num < 0 || num > 127){
+          throw new Error('invalid character code passed to %c in printf');
+        }
+        token.arg = isNaN(num) ? '' + num : String.fromCharCode(num);
+      }
+    }
+  },
+  s: {
+    setMaxWidth: function(token){
+      token.maxWidth = (token.period == '.') ? token.precision : -1;
+    }
+  },
+  e: {
+    isDouble: true,
+    doubleNotation: 'e'
+  },
+  E: {
+    extend: ['e'],
+    toUpper: true
+  },
+  f: {
+    isDouble: true,
+    doubleNotation: 'f'
+  },
+  F: {
+    extend: ['f']
+  },
+  g: {
+    isDouble: true,
+    doubleNotation: 'g'
+  },
+  G: {
+    extend: ['g'],
+    toUpper: true
+  },
+  O: {
+    isObject: true
+  }
+};
+Formatter.prototype.format = function(/*mixed...*/ filler){
+  if(this._mapped && typeof filler != 'object'){
+    throw new Error('format requires a mapping');
+  }
+
+  var str = '';
+  var position = 0;
+  for(var i = 0, token; i < this._tokens.length; i++){
+    token = this._tokens[i];
+
+    if(typeof token == 'string'){
+      str += token;
+    }else{
+      if(this._mapped){
+        // Identify value of property defined in `token.mapping`
+        var tokens = token.mapping.split('.');
+        var value = filler;
+        for (var j = 0, c = tokens.length; j < c; j++) {
+          value = value[tokens[j]];
+          if (typeof value === 'undefined') {
+            break
+          }
+        }
+        if(typeof value == 'undefined'){
+          throw new Error('missing key \'' + token.mapping + '\'');
+        }
+        token.arg = value;
+      }else{
+        if(token.intmapping){
+          position = parseInt(token.intmapping) - 1;
+        }
+        if(position >= arguments.length){
+          throw new Error('got ' + arguments.length + ' printf arguments, insufficient for \'' + this._format + '\'');
+        }
+        token.arg = arguments[position++];
+      }
+
+      if(!token.compiled){
+        token.compiled = true;
+        token.sign = '';
+        token.zeroPad = false;
+        token.rightJustify = false;
+        token.alternative = false;
+
+        var flags = {};
+        for(var fi = token.flags.length; fi--;){
+          var flag = token.flags.charAt(fi);
+          flags[flag] = true;
+          switch(flag){
+            case ' ':
+              token.sign = ' ';
+              break;
+            case '+':
+              token.sign = '+';
+              break;
+            case '0':
+              token.zeroPad = (flags['-']) ? false : true;
+              break;
+            case '-':
+              token.rightJustify = true;
+              token.zeroPad = false;
+              break;
+            case '#':
+              token.alternative = true;
+              break;
+            default:
+              throw Error('bad formatting flag \'' + token.flags.charAt(fi) + '\'');
+          }
+        }
+
+        token.minWidth = (token._minWidth) ? parseInt(token._minWidth) : 0;
+        token.maxWidth = -1;
+        token.toUpper = false;
+        token.isUnsigned = false;
+        token.isInt = false;
+        token.isDouble = false;
+        token.isObject = false;
+        token.precision = 1;
+        if(token.period == '.'){
+          if(token._precision){
+            token.precision = parseInt(token._precision);
+          }else{
+            token.precision = 0;
+          }
+        }
+
+        var mixins = this._specifiers[token.specifier];
+        if(typeof mixins == 'undefined'){
+          throw new Error('unexpected specifier \'' + token.specifier + '\'');
+        }
+        if(mixins.extend){
+          var s = this._specifiers[mixins.extend];
+          for(var k in s){
+            mixins[k] = s[k];
+          }
+          delete mixins.extend;
+        }
+        for(var l in mixins){
+          token[l] = mixins[l];
+        }
+      }
+
+      if(typeof token.setArg == 'function'){
+        token.setArg(token);
+      }
+
+      if(typeof token.setMaxWidth == 'function'){
+        token.setMaxWidth(token);
+      }
+
+      if(token._minWidth == '*'){
+        if(this._mapped){
+          throw new Error('* width not supported in mapped formats');
+        }
+        token.minWidth = parseInt(arguments[position++]);
+        if(isNaN(token.minWidth)){
+          throw new Error('the argument for * width at position ' + position + ' is not a number in ' + this._format);
+        }
+        // negative width means rightJustify
+        if (token.minWidth < 0) {
+          token.rightJustify = true;
+          token.minWidth = -token.minWidth;
+        }
+      }
+
+      if(token._precision == '*' && token.period == '.'){
+        if(this._mapped){
+          throw new Error('* precision not supported in mapped formats');
+        }
+        token.precision = parseInt(arguments[position++]);
+        if(isNaN(token.precision)){
+          throw Error('the argument for * precision at position ' + position + ' is not a number in ' + this._format);
+        }
+        // negative precision means unspecified
+        if (token.precision < 0) {
+          token.precision = 1;
+          token.period = '';
+        }
+      }
+      if(token.isInt){
+        // a specified precision means no zero padding
+        if(token.period == '.'){
+          token.zeroPad = false;
+        }
+        this.formatInt(token);
+      }else if(token.isDouble){
+        if(token.period != '.'){
+          token.precision = 6;
+        }
+        this.formatDouble(token);
+      }else if(token.isObject){
+        this.formatObject(token);
+      }
+      this.fitField(token);
+      str += '' + token.arg;
+    }
+  }
+
+  return str;
+};
+Formatter.prototype._zeros10 = '0000000000';
+Formatter.prototype._spaces10 = '          ';
+Formatter.prototype.formatInt = function(token) {
+  var i = parseInt(token.arg);
+  if(!isFinite(i)){ // isNaN(f) || f == Number.POSITIVE_INFINITY || f == Number.NEGATIVE_INFINITY)
+    // allow this only if arg is number
+    if(typeof token.arg != 'number'){
+      throw new Error('format argument \'' + token.arg + '\' not an integer; parseInt returned ' + i);
+    }
+    //return '' + i;
+    i = 0;
+  }
+
+  // if not base 10, make negatives be positive
+  // otherwise, (-10).toString(16) is '-a' instead of 'fffffff6'
+  if(i < 0 && (token.isUnsigned || token.base != 10)){
+    i = 0xffffffff + i + 1;
+  }
+
+  if(i < 0){
+    token.arg = (- i).toString(token.base);
+    this.zeroPad(token);
+    token.arg = '-' + token.arg;
+  }else{
+    token.arg = i.toString(token.base);
+    // need to make sure that argument 0 with precision==0 is formatted as ''
+    if(!i && !token.precision){
+      token.arg = '';
+    }else{
+      this.zeroPad(token);
+    }
+    if(token.sign){
+      token.arg = token.sign + token.arg;
+    }
+  }
+  if(token.base == 16){
+    if(token.alternative){
+      token.arg = '0x' + token.arg;
+    }
+    token.arg = token.toUpper ? token.arg.toUpperCase() : token.arg.toLowerCase();
+  }
+  if(token.base == 8){
+    if(token.alternative && token.arg.charAt(0) != '0'){
+      token.arg = '0' + token.arg;
+    }
+  }
+};
+Formatter.prototype.formatDouble = function(token) {
+  var f = parseFloat(token.arg);
+  if(!isFinite(f)){ // isNaN(f) || f == Number.POSITIVE_INFINITY || f == Number.NEGATIVE_INFINITY)
+    // allow this only if arg is number
+    if(typeof token.arg != 'number'){
+      throw new Error('format argument \'' + token.arg + '\' not a float; parseFloat returned ' + f);
+    }
+    // C99 says that for 'f':
+    //   infinity -> '[-]inf' or '[-]infinity' ('[-]INF' or '[-]INFINITY' for 'F')
+    //   NaN -> a string  starting with 'nan' ('NAN' for 'F')
+    // this is not commonly implemented though.
+    //return '' + f;
+    f = 0;
+  }
+
+  switch(token.doubleNotation) {
+    case 'e': {
+      token.arg = f.toExponential(token.precision);
+      break;
+    }
+    case 'f': {
+      token.arg = f.toFixed(token.precision);
+      break;
+    }
+    case 'g': {
+      // C says use 'e' notation if exponent is < -4 or is >= prec
+      // ECMAScript for toPrecision says use exponential notation if exponent is >= prec,
+      // though step 17 of toPrecision indicates a test for < -6 to force exponential.
+      if(Math.abs(f) < 0.0001){
+        //print('forcing exponential notation for f=' + f);
+        token.arg = f.toExponential(token.precision > 0 ? token.precision - 1 : token.precision);
+      }else{
+        token.arg = f.toPrecision(token.precision);
+      }
+
+      // In C, unlike 'f', 'gG' removes trailing 0s from fractional part, unless alternative format flag ('#').
+      // But ECMAScript formats toPrecision as 0.00100000. So remove trailing 0s.
+      if(!token.alternative){
+        //print('replacing trailing 0 in \'' + s + '\'');
+        token.arg = token.arg.replace(/(\..*[^0])0*e/, '$1e');
+        // if fractional part is entirely 0, remove it and decimal point
+        token.arg = token.arg.replace(/\.0*e/, 'e').replace(/\.0$/,'');
+      }
+      break;
+    }
+    default: throw new Error('unexpected double notation \'' + token.doubleNotation + '\'');
+  }
+
+  // C says that exponent must have at least two digits.
+  // But ECMAScript does not; toExponential results in things like '1.000000e-8' and '1.000000e+8'.
+  // Note that s.replace(/e([\+\-])(\d)/, 'e$10$2') won't work because of the '$10' instead of '$1'.
+  // And replace(re, func) isn't supported on IE50 or Safari1.
+  token.arg = token.arg.replace(/e\+(\d)$/, 'e+0$1').replace(/e\-(\d)$/, 'e-0$1');
+
+  // if alt, ensure a decimal point
+  if(token.alternative){
+    token.arg = token.arg.replace(/^(\d+)$/,'$1.');
+    token.arg = token.arg.replace(/^(\d+)e/,'$1.e');
+  }
+
+  if(f >= 0 && token.sign){
+    token.arg = token.sign + token.arg;
+  }
+
+  token.arg = token.toUpper ? token.arg.toUpperCase() : token.arg.toLowerCase();
+};
+Formatter.prototype.formatObject = function(token) {
+  // If no precision is specified, then reset it to null (infinite depth).
+  var precision = (token.period === '.') ? token.precision : null;
+  // Historically, inspect was called with 3 options
+  // token.arg = util.inspect(token.arg, !token.alternative, precision, token.sign);
+  // Now using an object but not sure colors make any sense here
+  token.arg = util.inspect(token.arg, {
+    showHidden: !token.alternative,
+    depth: precision,
+    colors: token.sign,
+    compact: true
+  });
+};
+Formatter.prototype.zeroPad = function(token, /*Int*/ length) {
+  length = (arguments.length == 2) ? length : token.precision;
+  var negative = false;
+  if(typeof token.arg != "string"){
+    token.arg = "" + token.arg;
+  }
+  if (token.arg.substr(0,1) === '-') {
+    negative = true;
+    token.arg = token.arg.substr(1);
+  }
+
+  var tenless = length - 10;
+  while(token.arg.length < tenless){
+    token.arg = (token.rightJustify) ? token.arg + this._zeros10 : this._zeros10 + token.arg;
+  }
+  var pad = length - token.arg.length;
+  token.arg = (token.rightJustify) ? token.arg + this._zeros10.substring(0, pad) : this._zeros10.substring(0, pad) + token.arg;
+  if (negative) token.arg = '-' + token.arg;
+};
+Formatter.prototype.fitField = function(token) {
+  if(token.maxWidth >= 0 && token.arg.length > token.maxWidth){
+    token.arg = token.arg.substring(0, token.maxWidth);
+  }
+  if(token.zeroPad){
+    this.zeroPad(token, token.minWidth);
+    return;
+  }
+  this.spacePad(token);
+};
+Formatter.prototype.spacePad = function(token, /*Int*/ length) {
+  length = (arguments.length == 2) ? length : token.minWidth;
+  if(typeof token.arg != 'string'){
+    token.arg = '' + token.arg;
+  }
+  var tenless = length - 10;
+  while(token.arg.length < tenless){
+    token.arg = (token.rightJustify) ? token.arg + this._spaces10 : this._spaces10 + token.arg;
+  }
+  var pad = length - token.arg.length;
+  token.arg = (token.rightJustify) ? token.arg + this._spaces10.substring(0, pad) : this._spaces10.substring(0, pad) + token.arg;
+};
+
+module.exports = function(){
+  var args = Array.prototype.slice.call(arguments),
+    stream, format;
+  if(args[0] instanceof require('stream').Stream){
+    stream = args.shift();
+  }
+  format = args.shift();
+  var formatter = new Formatter(format);
+  var string = formatter.format.apply(formatter, args);
+  if(stream){
+    stream.write(string);
+  }else{
+    return string;
+  }
+};
+
+module.exports.Formatter = Formatter;

package/dist/src/messages/cache-info.d.ts

@@ -0,0 +1,5 @@
+export declare class CacheInfo {
+    private readonly name;
+    constructor(name: string);
+    getName(): string;
+}

package/dist/src/messages/cache-info.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheInfo = void 0;
+class CacheInfo {
+    constructor(name) {
+        this.name = name;
+    }
+    getName() {
+        return this.name;
+    }
+}
+exports.CacheInfo = CacheInfo;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUtaW5mby5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZXNzYWdlcy9jYWNoZS1pbmZvLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLE1BQWEsU0FBUztJQUdwQixZQUFZLElBQVk7UUFDdEIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7SUFDbkIsQ0FBQztJQUVNLE9BQU87UUFDWixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUM7SUFDbkIsQ0FBQztDQUNGO0FBVkQsOEJBVUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgQ2FjaGVJbmZvIHtcbiAgcHJpdmF0ZSByZWFkb25seSBuYW1lOiBzdHJpbmc7XG5cbiAgY29uc3RydWN0b3IobmFtZTogc3RyaW5nKSB7XG4gICAgdGhpcy5uYW1lID0gbmFtZTtcbiAgfVxuXG4gIHB1YmxpYyBnZXROYW1lKCkge1xuICAgIHJldHVybiB0aGlzLm5hbWU7XG4gIH1cbn1cbiJdfQ==