@rsdoctor/utils 0.0.0-next-20240620044732

package/dist/cjs/logger.js

@@ -0,0 +1,51 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+__export(logger_exports, {
+  chalk: () => import_chalk.default,
+  debug: () => debug,
+  logger: () => import_rslog.logger
+});
+module.exports = __toCommonJS(logger_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_rslog = require("rslog");
+var import_types = require("@rsdoctor/types");
+function debug(getMsg, prefix = "") {
+  if (!process.env[import_types.Constants.RsdoctorProcessEnvDebugKey]) {
+    return;
+  }
+  import_rslog.logger.level = "verbose";
+  import_rslog.logger.debug(`${prefix} ${getMsg()}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chalk,
+  debug,
+  logger
+});

package/dist/cjs/rule-utils/document/document.js

@@ -0,0 +1,91 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var document_exports = {};
+__export(document_exports, {
+  Document: () => Document
+});
+module.exports = __toCommonJS(document_exports);
+var import_lines_and_columns = require("lines-and-columns");
+var import_lodash = require("lodash");
+class Document {
+  constructor(content) {
+    /** Actual document content. */
+    this._text = "";
+    this._text;
+    this._text = content;
+    this.createFinder();
+  }
+  /** Generate location search */
+  createFinder() {
+    const find = new import_lines_and_columns.LinesAndColumns(this._text);
+    this.positionAt = (offset) => {
+      if (offset >= this._text.length) {
+        offset = this._text.length - 1;
+      }
+      if (offset < 0) {
+        offset = 0;
+      }
+      const result = find.locationForIndex(offset);
+      if (!result) {
+        return;
+      }
+      return {
+        line: result.line + 1,
+        column: result.column
+      };
+    };
+    this.offsetAt = (position) => {
+      return find.indexForLocation({
+        line: position.line - 1,
+        column: position.column
+      }) ?? void 0;
+    };
+  }
+  getText(range) {
+    if (!range) {
+      return this._text;
+    }
+    const start = typeof range.start === "number" ? range.start : this.offsetAt(range.start);
+    const end = typeof range.end === "number" ? range.end : this.offsetAt(range.end);
+    if ((0, import_lodash.isUndefined)(start)) {
+      throw new Error(`Location ${JSON.stringify(start)} is illegal`);
+    }
+    if ((0, import_lodash.isUndefined)(end)) {
+      throw new Error(`Location ${JSON.stringify(end)} is illegal`);
+    }
+    return this._text.slice(start, end);
+  }
+  /** Edit document data */
+  edit(data) {
+    let { _text: content } = this;
+    const startOffset = (0, import_lodash.isNumber)(data.start) ? data.start : this.offsetAt(data.start);
+    const endOffset = (0, import_lodash.isNumber)(data.end) ? data.end : this.offsetAt(data.end);
+    if ((0, import_lodash.isUndefined)(startOffset) || (0, import_lodash.isUndefined)(endOffset)) {
+      return;
+    }
+    const startTxt = content.substring(0, startOffset);
+    const endTxt = content.substring(endOffset, content.length);
+    content = startTxt + data.newText + endTxt;
+    return content;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Document
+});

package/dist/cjs/rule-utils/document/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var document_exports = {};
+module.exports = __toCommonJS(document_exports);
+__reExport(document_exports, require("./document"), module.exports);
+__reExport(document_exports, require("./types"), module.exports);
+__reExport(document_exports, require("./server"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./document"),
+  ...require("./types"),
+  ...require("./server")
+});

package/dist/cjs/rule-utils/document/server.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  clearDocument: () => clearDocument,
+  getDocument: () => getDocument
+});
+module.exports = __toCommonJS(server_exports);
+var import_document = require("./document");
+const store = /* @__PURE__ */ new Map();
+function getDocument(content) {
+  if (store.has(content)) {
+    return store.get(content);
+  }
+  const doc = new import_document.Document(content);
+  store.set(content, doc);
+  return doc;
+}
+function clearDocument() {
+  store.clear();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearDocument,
+  getDocument
+});

package/dist/cjs/rule-utils/document/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/rule-utils/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rule_utils_exports = {};
+module.exports = __toCommonJS(rule_utils_exports);
+__reExport(rule_utils_exports, require("./document"), module.exports);
+__reExport(rule_utils_exports, require("./parser"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./document"),
+  ...require("./parser")
+});

package/dist/cjs/rule-utils/parser/asserts.js

@@ -0,0 +1,156 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var asserts_exports = {};
+__export(asserts_exports, {
+  asserts: () => asserts
+});
+module.exports = __toCommonJS(asserts_exports);
+var import_lodash = require("lodash");
+function isSyntaxNode(node) {
+  return (0, import_lodash.isObject)(node) && "type" in node;
+}
+function assertCreator(type) {
+  return (node) => {
+    return isSyntaxNode(node) && node.type === type;
+  };
+}
+const asserts = {
+  isProgram: assertCreator("Program"),
+  isEmptyStatement: assertCreator("EmptyStatement"),
+  isBlockStatement: assertCreator("BlockStatement"),
+  isStaticBlock: assertCreator("StaticBlock"),
+  isExpressionStatement: assertCreator(
+    "ExpressionStatement"
+  ),
+  isIfStatement: assertCreator("IfStatement"),
+  isLabeledStatement: assertCreator("LabeledStatement"),
+  isBreakStatement: assertCreator("BreakStatement"),
+  isContinueStatement: assertCreator("ContinueStatement"),
+  isWithStatement: assertCreator("WithStatement"),
+  isSwitchStatement: assertCreator("SwitchStatement"),
+  isReturnStatement: assertCreator("ReturnStatement"),
+  isThrowStatement: assertCreator("ThrowStatement"),
+  isTryStatement: assertCreator("TryStatement"),
+  isWhileStatement: assertCreator("WhileStatement"),
+  isDoWhileStatement: assertCreator("DoWhileStatement"),
+  isForStatement: assertCreator("ForStatement"),
+  isForInStatement: assertCreator("ForInStatement"),
+  isForOfStatement: assertCreator("ForOfStatement"),
+  isDebuggerStatement: assertCreator("DebuggerStatement"),
+  isFunctionDeclaration: assertCreator(
+    "FunctionDeclaration"
+  ),
+  isVariableDeclaration: assertCreator(
+    "VariableDeclaration"
+  ),
+  isVariableDeclarator: assertCreator("VariableDeclarator"),
+  isChainExpression: assertCreator("ChainExpression"),
+  isThisExpression: assertCreator("ThisExpression"),
+  isArrayExpression: assertCreator("ArrayExpression"),
+  isObjectExpression: assertCreator("ObjectExpression"),
+  isPrivateIdentifier: assertCreator("PrivateIdentifier"),
+  isProperty: assertCreator("Property"),
+  isPropertyDefinition: assertCreator("PropertyDefinition"),
+  isFunctionExpression: assertCreator("FunctionExpression"),
+  isSequenceExpression: assertCreator("SequenceExpression"),
+  isUnaryExpression: assertCreator("UnaryExpression"),
+  isBinaryExpression: assertCreator("BinaryExpression"),
+  isAssignmentExpression: assertCreator(
+    "AssignmentExpression"
+  ),
+  isUpdateExpression: assertCreator("UpdateExpression"),
+  isLogicalExpression: assertCreator("LogicalExpression"),
+  isConditionalExpression: assertCreator(
+    "ConditionalExpression"
+  ),
+  isNewExpression: assertCreator("NewExpression"),
+  isSwitchCase: assertCreator("SwitchCase"),
+  isCatchClause: assertCreator("CatchClause"),
+  isIdentifier: assertCreator("Identifier"),
+  isLiteral: assertCreator("Literal"),
+  isSuper: assertCreator("Super"),
+  isSpreadElement: assertCreator("SpreadElement"),
+  isArrowFunctionExpression: assertCreator(
+    "ArrowFunctionExpression"
+  ),
+  isYieldExpression: assertCreator("YieldExpression"),
+  isTemplateLiteral: assertCreator("TemplateLiteral"),
+  isTaggedTemplateExpression: assertCreator(
+    "TaggedTemplateExpression"
+  ),
+  isTemplateElement: assertCreator("TemplateElement"),
+  isObjectPattern: assertCreator("ObjectPattern"),
+  isArrayPattern: assertCreator("ArrayPattern"),
+  isRestElement: assertCreator("RestElement"),
+  isAssignmentPattern: assertCreator("AssignmentPattern"),
+  isClassBody: assertCreator("ClassBody"),
+  isClassDeclaration: assertCreator("ClassDeclaration"),
+  isClassExpression: assertCreator("ClassExpression"),
+  isMetaProperty: assertCreator("MetaProperty"),
+  isImportDeclaration: assertCreator("ImportDeclaration"),
+  isImportSpecifier: assertCreator("ImportSpecifier"),
+  isImportExpression: assertCreator("ImportExpression"),
+  isImportDefaultSpecifier: assertCreator(
+    "ImportDefaultSpecifier"
+  ),
+  isImportNamespaceSpecifier: assertCreator(
+    "ImportNamespaceSpecifier"
+  ),
+  isExportNamedDeclaration: assertCreator(
+    "ExportNamedDeclaration"
+  ),
+  isExportSpecifier: assertCreator("ExportSpecifier"),
+  isExportDefaultDeclaration: assertCreator(
+    "ExportDefaultDeclaration"
+  ),
+  isExportAllDeclaration: assertCreator(
+    "ExportAllDeclaration"
+  ),
+  isAwaitExpression: assertCreator("AwaitExpression"),
+  isMethodDefinition: assertCreator("MethodDefinition"),
+  isMemberExpression: assertCreator("MemberExpression"),
+  isComment(node) {
+    return isSyntaxNode(node) && (node.type === "Line" || node.type === "Block");
+  },
+  isDirective(node) {
+    return asserts.isExpressionStatement(node) && "directive" in node;
+  },
+  isSimpleCallExpression(node) {
+    return isSyntaxNode(node) && node.type === "CallExpression";
+  },
+  isAssignmentProperty(node) {
+    return asserts.isProperty(node) && node.kind === "init";
+  },
+  isSimpleLiteral(node) {
+    return asserts.isLiteral(node) && !asserts.isRegExpLiteral(node) && !asserts.isBigIntLiteral(node);
+  },
+  isRegExpLiteral(node) {
+    return asserts.isLiteral(node) && "regex" in node;
+  },
+  isBigIntLiteral(node) {
+    return asserts.isLiteral(node) && "bigint" in node;
+  },
+  isExportStatement(node) {
+    return asserts.isExportAllDeclaration(node) || asserts.isExportDefaultDeclaration(node) || asserts.isExportNamedDeclaration(node);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asserts
+});

package/dist/cjs/rule-utils/parser/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parser_exports = {};
+module.exports = __toCommonJS(parser_exports);
+__reExport(parser_exports, require("./asserts"), module.exports);
+__reExport(parser_exports, require("./parser"), module.exports);
+__reExport(parser_exports, require("./utils"), module.exports);
+__reExport(parser_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./asserts"),
+  ...require("./parser"),
+  ...require("./utils"),
+  ...require("./types")
+});

package/dist/cjs/rule-utils/parser/parser.js

@@ -0,0 +1,92 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parser_exports = {};
+__export(parser_exports, {
+  parser: () => parser
+});
+module.exports = __toCommonJS(parser_exports);
+var import_acorn = require("acorn");
+var import_acorn_import_assertions = require("acorn-import-assertions");
+var walk = __toESM(require("acorn-walk"));
+var import_asserts = require("./asserts");
+var utils = __toESM(require("./utils"));
+const acornParserInternal = import_acorn.Parser.extend(import_acorn_import_assertions.importAssertions);
+let acornParserExport = import_acorn.Parser.extend(import_acorn_import_assertions.importAssertions);
+const parser = {
+  /** AST iterator */
+  walk,
+  /**
+   * Compile code
+   * - Output root node is `Node.Program`
+   */
+  parse: (input, options) => {
+    return acornParserExport.parse(input, options);
+  },
+  /**
+   * Compile the next first expression
+   * - The output root node is `Node.ExpressionStatement`
+   */
+  parseExpressionAt: (input, pos, options) => {
+    return acornParserExport.parseExpressionAt(
+      input,
+      pos,
+      options
+    );
+  },
+  /**
+   * add plugins for acorn
+   */
+  extend(...args) {
+    acornParserExport = acornParserExport.extend(...args);
+    return acornParserExport;
+  },
+  /** Set of assertions */
+  asserts: import_asserts.asserts,
+  utils,
+  /**
+   * @internal
+   * parser for internal packages
+   */
+  internal: {
+    parse: (input, options) => {
+      return acornParserInternal.parse(input, options);
+    },
+    parseExpressionAt: (input, pos, options) => {
+      return acornParserInternal.parseExpressionAt(
+        input,
+        pos,
+        options
+      );
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parser
+});

package/dist/cjs/rule-utils/parser/types.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  ECMAVersion: () => ECMAVersion
+});
+module.exports = __toCommonJS(types_exports);
+var ECMAVersion = /* @__PURE__ */ ((ECMAVersion2) => {
+  ECMAVersion2["ES5"] = "ES5";
+  ECMAVersion2["ES6"] = "ES6";
+  ECMAVersion2["ES7P"] = "ES7+";
+  return ECMAVersion2;
+})(ECMAVersion || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ECMAVersion
+});