repoburg 1.1.0 → 1.1.1

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/ast-utils/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAO9E,eAAO,MAAM,YAAY,kEAGf,SAAS,IAAI,GAAG,IAAI,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEf,CAAC;AAE5B,eAAO,MAAM,aAAa,gFAGhB,SAAS,IAAI,GAAG,IAAI,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEC,CAAC;AAE5C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qGAQ/B,SAAS,IAAI,GAAG,IAAI,GAAG,SAAS,uCASvC,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;6DAQ/B,SAAS,KAAK,GAAG,IAAI,GAAG,SAAS,yCAWzC,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;yGAShC,SAAS,KAAK,GAAG,IAAI,GAAG,SAAS,m0BAGkB,CAAC"}

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/helpers.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotTokenOfTypeWithConditions = exports.isTokenOfTypeWithConditions = exports.isNodeOfTypeWithConditions = exports.isNodeOfTypes = exports.isNodeOfType = void 0;
+const isNodeOfType = (nodeType) => (node) => node?.type === nodeType;
+exports.isNodeOfType = isNodeOfType;
+const isNodeOfTypes = (nodeTypes) => (node) => !!node && nodeTypes.includes(node.type);
+exports.isNodeOfTypes = isNodeOfTypes;
+const isNodeOfTypeWithConditions = (nodeType, conditions) => {
+    const entries = Object.entries(conditions);
+    return (node) => node?.type === nodeType &&
+        entries.every(([key, value]) => node[key] === value);
+};
+exports.isNodeOfTypeWithConditions = isNodeOfTypeWithConditions;
+const isTokenOfTypeWithConditions = (tokenType, conditions) => {
+    const entries = Object.entries(conditions);
+    return (token) => token?.type === tokenType &&
+        entries.every(([key, value]) => token[key] === value);
+};
+exports.isTokenOfTypeWithConditions = isTokenOfTypeWithConditions;
+const isNotTokenOfTypeWithConditions = (tokenType, conditions) => (token) => !(0, exports.isTokenOfTypeWithConditions)(tokenType, conditions)(token);
+exports.isNotTokenOfTypeWithConditions = isNotTokenOfTypeWithConditions;
+//# sourceMappingURL=helpers.js.map

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/ast-utils/helpers.ts"],"names":[],"mappings":";;;AAOO,MAAM,YAAY,GACvB,CAAkC,QAAkB,EAAE,EAAE,CACxD,CACE,IAAsC,EACc,EAAE,CACtD,IAAI,EAAE,IAAI,KAAK,QAAQ,CAAC;AALf,QAAA,YAAY,gBAKG;AAErB,MAAM,aAAa,GACxB,CAA8C,SAAoB,EAAE,EAAE,CACtE,CACE,IAAsC,EACuB,EAAE,CAC/D,CAAC,CAAC,IAAI,IAAI,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAL/B,QAAA,aAAa,iBAKkB;AAErC,MAAM,0BAA0B,GAAG,CAKxC,QAAkB,EAClB,UAAsB,EAGiB,EAAE;IACzC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,CAAiC,CAAC;IAE3E,OAAO,CACL,IAAsC,EACF,EAAE,CACtC,IAAI,EAAE,IAAI,KAAK,QAAQ;QACvB,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAA0B,CAAC,KAAK,KAAK,CAAC,CAAC;AAChF,CAAC,CAAC;AAjBW,QAAA,0BAA0B,8BAiBrC;AAEK,MAAM,2BAA2B,GAAG,CAKzC,SAAoB,EACpB,UAAsB,EAGmB,EAAE;IAC3C,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,CAAkC,CAAC;IAE5E,OAAO,CACL,KAAwC,EACF,EAAE,CACxC,KAAK,EAAE,IAAI,KAAK,SAAS;QACzB,OAAO,CAAC,KAAK,CACX,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,GAA2B,CAAC,KAAK,KAAK,CAC/D,CAAC;AACN,CAAC,CAAC;AAnBW,QAAA,2BAA2B,+BAmBtC;AAEK,MAAM,8BAA8B,GACzC,CAKE,SAAoB,EACpB,UAAsB,EAG4C,EAAE,CACtE,CAAC,KAAK,EAAiE,EAAE,CACvE,CAAC,IAAA,mCAA2B,EAAC,SAAS,EAAE,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC;AAZlD,QAAA,8BAA8B,kCAYoB"}

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './eslint-utils';
+export * from './helpers';
+export * from './misc';
+export * from './predicates';
+//# sourceMappingURL=index.d.ts.map

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ast-utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC"}

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./eslint-utils"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./misc"), exports);
+__exportStar(require("./predicates"), exports);
+//# sourceMappingURL=index.js.map

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ast-utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA+B;AAC/B,4CAA0B;AAC1B,yCAAuB;AACvB,+CAA6B"}

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/misc.d.ts

@@ -0,0 +1,8 @@
+import type { TSESTree } from '../ts-estree';
+declare const LINEBREAK_MATCHER: RegExp;
+/**
+ * Determines whether two adjacent tokens are on the same line
+ */
+declare function isTokenOnSameLine(left: TSESTree.Node | TSESTree.Token, right: TSESTree.Node | TSESTree.Token): boolean;
+export { isTokenOnSameLine, LINEBREAK_MATCHER };
+//# sourceMappingURL=misc.d.ts.map

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/misc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../src/ast-utils/misc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,QAAA,MAAM,iBAAiB,QAA4B,CAAC;AAEpD;;GAEG;AACH,iBAAS,iBAAiB,CACxB,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,KAAK,EACpC,KAAK,EAAE,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,KAAK,GACpC,OAAO,CAET;AAED,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,CAAC"}

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/misc.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LINEBREAK_MATCHER = exports.isTokenOnSameLine = void 0;
+const LINEBREAK_MATCHER = /\r\n|[\r\n\u2028\u2029]/;
+exports.LINEBREAK_MATCHER = LINEBREAK_MATCHER;
+/**
+ * Determines whether two adjacent tokens are on the same line
+ */
+function isTokenOnSameLine(left, right) {
+    return left.loc.end.line === right.loc.start.line;
+}
+exports.isTokenOnSameLine = isTokenOnSameLine;
+//# sourceMappingURL=misc.js.map

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/misc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.js","sourceRoot":"","sources":["../../src/ast-utils/misc.ts"],"names":[],"mappings":";;;AAEA,MAAM,iBAAiB,GAAG,yBAAyB,CAAC;AAYxB,8CAAiB;AAV7C;;GAEG;AACH,SAAS,iBAAiB,CACxB,IAAoC,EACpC,KAAqC;IAErC,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,KAAK,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;AACpD,CAAC;AAEQ,8CAAiB"}

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/predicates.d.ts

@@ -0,0 +1,70 @@
+import type { TSESTree } from '../ts-estree';
+declare const isOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is {
+    value: "?.";
+} & TSESTree.PunctuatorToken;
+declare const isNotOptionalChainPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BooleanToken | TSESTree.BlockComment | TSESTree.LineComment | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken;
+declare const isNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is {
+    value: "!";
+} & TSESTree.PunctuatorToken;
+declare const isNotNonNullAssertionPunctuator: (token: TSESTree.Token | null | undefined) => token is TSESTree.BooleanToken | TSESTree.BlockComment | TSESTree.LineComment | TSESTree.IdentifierToken | TSESTree.JSXIdentifierToken | TSESTree.JSXTextToken | TSESTree.KeywordToken | TSESTree.NullToken | TSESTree.NumericToken | TSESTree.PunctuatorToken | TSESTree.RegularExpressionToken | TSESTree.StringToken | TSESTree.TemplateToken;
+/**
+ * Returns true if and only if the node represents: foo?.() or foo.bar?.()
+ */
+declare const isOptionalCallExpression: (node: TSESTree.Node | null | undefined) => node is {
+    optional: boolean;
+} & TSESTree.CallExpression;
+/**
+ * Returns true if and only if the node represents logical OR
+ */
+declare const isLogicalOrOperator: (node: TSESTree.Node | null | undefined) => node is Partial<TSESTree.LogicalExpression> & TSESTree.LogicalExpression;
+/**
+ * Checks if a node is a type assertion:
+ * ```
+ * x as foo
+ * <foo>x
+ * ```
+ */
+declare const isTypeAssertion: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
+declare const isVariableDeclarator: (node: TSESTree.Node | null | undefined) => node is TSESTree.LetOrConstOrVarDeclarator | TSESTree.UsingInForOfDeclarator | TSESTree.UsingInNomalConextDeclarator;
+declare const isFunction: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression;
+declare const isFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName;
+declare const isFunctionOrFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression | TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructorType | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSFunctionType | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName;
+declare const isTSFunctionType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSFunctionType;
+declare const isTSConstructorType: (node: TSESTree.Node | null | undefined) => node is TSESTree.TSConstructorType;
+declare const isClassOrTypeElement: (node: TSESTree.Node | null | undefined) => node is TSESTree.FunctionExpression | TSESTree.MethodDefinitionComputedName | TSESTree.MethodDefinitionNonComputedName | TSESTree.PropertyDefinitionComputedName | TSESTree.PropertyDefinitionNonComputedName | TSESTree.TSAbstractMethodDefinitionComputedName | TSESTree.TSAbstractMethodDefinitionNonComputedName | TSESTree.TSAbstractPropertyDefinitionComputedName | TSESTree.TSAbstractPropertyDefinitionNonComputedName | TSESTree.TSCallSignatureDeclaration | TSESTree.TSConstructSignatureDeclaration | TSESTree.TSEmptyBodyFunctionExpression | TSESTree.TSIndexSignature | TSESTree.TSMethodSignatureComputedName | TSESTree.TSMethodSignatureNonComputedName | TSESTree.TSPropertySignatureComputedName | TSESTree.TSPropertySignatureNonComputedName;
+/**
+ * Checks if a node is a constructor method.
+ */
+declare const isConstructor: (node: TSESTree.Node | null | undefined) => node is (Partial<TSESTree.MethodDefinitionComputedName> & TSESTree.MethodDefinitionComputedName) | (Partial<TSESTree.MethodDefinitionNonComputedName> & TSESTree.MethodDefinitionNonComputedName);
+/**
+ * Checks if a node is a setter method.
+ */
+declare function isSetter(node: TSESTree.Node | undefined): node is {
+    kind: 'set';
+} & (TSESTree.MethodDefinition | TSESTree.Property);
+declare const isIdentifier: (node: TSESTree.Node | null | undefined) => node is TSESTree.Identifier;
+/**
+ * Checks if a node represents an `await …` expression.
+ */
+declare const isAwaitExpression: (node: TSESTree.Node | null | undefined) => node is TSESTree.AwaitExpression;
+/**
+ * Checks if a possible token is the `await` keyword.
+ */
+declare const isAwaitKeyword: (token: TSESTree.Token | null | undefined) => token is {
+    value: "await";
+} & TSESTree.IdentifierToken;
+/**
+ * Checks if a possible token is the `type` keyword.
+ */
+declare const isTypeKeyword: (token: TSESTree.Token | null | undefined) => token is {
+    value: "type";
+} & TSESTree.IdentifierToken;
+/**
+ * Checks if a possible token is the `import` keyword.
+ */
+declare const isImportKeyword: (token: TSESTree.Token | null | undefined) => token is {
+    value: "import";
+} & TSESTree.KeywordToken;
+declare const isLoop: (node: TSESTree.Node | null | undefined) => node is TSESTree.DoWhileStatement | TSESTree.ForInStatement | TSESTree.ForOfStatement | TSESTree.ForStatement | TSESTree.WhileStatement;
+export { isAwaitExpression, isAwaitKeyword, isConstructor, isClassOrTypeElement, isFunction, isFunctionOrFunctionType, isFunctionType, isIdentifier, isImportKeyword, isLoop, isLogicalOrOperator, isNonNullAssertionPunctuator, isNotNonNullAssertionPunctuator, isNotOptionalChainPunctuator, isOptionalChainPunctuator, isOptionalCallExpression, isSetter, isTSConstructorType, isTSFunctionType, isTypeAssertion, isTypeKeyword, isVariableDeclarator, };
+//# sourceMappingURL=predicates.d.ts.map

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/predicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicates.d.ts","sourceRoot":"","sources":["../../src/ast-utils/predicates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAU7C,QAAA,MAAM,yBAAyB;;4BAG9B,CAAC;AAEF,QAAA,MAAM,4BAA4B,gYAGjC,CAAC;AAEF,QAAA,MAAM,4BAA4B;;4BAGjC,CAAC;AAEF,QAAA,MAAM,+BAA+B,gYAGpC,CAAC;AAEF;;GAEG;AACH,QAAA,MAAM,wBAAwB;;2BAK7B,CAAC;AAEF;;GAEG;AACH,QAAA,MAAM,mBAAmB,sHAGxB,CAAC;AAEF;;;;;;GAMG;AACH,QAAA,MAAM,eAAe,wGAGV,CAAC;AAEZ,QAAA,MAAM,oBAAoB,kKAAkD,CAAC;AAO7E,QAAA,MAAM,UAAU,0MAA+B,CAAC;AAUhD,QAAA,MAAM,cAAc,yTAAmC,CAAC;AAExD,QAAA,MAAM,wBAAwB,gdAGnB,CAAC;AAEZ,QAAA,MAAM,gBAAgB,6EAA8C,CAAC;AAErE,QAAA,MAAM,mBAAmB,gFAAiD,CAAC;AAE3E,QAAA,MAAM,oBAAoB,ixBAef,CAAC;AAEZ;;GAEG;AACH,QAAA,MAAM,aAAa,+OAGlB,CAAC;AAEF;;GAEG;AACH,iBAAS,QAAQ,CACf,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,SAAS,GAC9B,IAAI,IAAI;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GAAG,CAAC,QAAQ,CAAC,gBAAgB,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAO3E;AAED,QAAA,MAAM,YAAY,yEAA0C,CAAC;AAE7D;;GAEG;AACH,QAAA,MAAM,iBAAiB,8EAA+C,CAAC;AAEvE;;GAEG;AACH,QAAA,MAAM,cAAc;;4BAElB,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,aAAa;;4BAEjB,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,eAAe;;yBAEnB,CAAC;AAEH,QAAA,MAAM,MAAM,qLAMD,CAAC;AAEZ,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,oBAAoB,EACpB,UAAU,EACV,wBAAwB,EACxB,cAAc,EACd,YAAY,EACZ,eAAe,EACf,MAAM,EACN,mBAAmB,EACnB,4BAA4B,EAC5B,+BAA+B,EAC/B,4BAA4B,EAC5B,yBAAyB,EACzB,wBAAwB,EACxB,QAAQ,EACR,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,oBAAoB,GACrB,CAAC"}

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/predicates.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVariableDeclarator = exports.isTypeKeyword = exports.isTypeAssertion = exports.isTSFunctionType = exports.isTSConstructorType = exports.isSetter = exports.isOptionalCallExpression = exports.isOptionalChainPunctuator = exports.isNotOptionalChainPunctuator = exports.isNotNonNullAssertionPunctuator = exports.isNonNullAssertionPunctuator = exports.isLogicalOrOperator = exports.isLoop = exports.isImportKeyword = exports.isIdentifier = exports.isFunctionType = exports.isFunctionOrFunctionType = exports.isFunction = exports.isClassOrTypeElement = exports.isConstructor = exports.isAwaitKeyword = exports.isAwaitExpression = void 0;
+const ts_estree_1 = require("../ts-estree");
+const helpers_1 = require("./helpers");
+const isOptionalChainPunctuator = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '?.' });
+exports.isOptionalChainPunctuator = isOptionalChainPunctuator;
+const isNotOptionalChainPunctuator = (0, helpers_1.isNotTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '?.' });
+exports.isNotOptionalChainPunctuator = isNotOptionalChainPunctuator;
+const isNonNullAssertionPunctuator = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '!' });
+exports.isNonNullAssertionPunctuator = isNonNullAssertionPunctuator;
+const isNotNonNullAssertionPunctuator = (0, helpers_1.isNotTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Punctuator, { value: '!' });
+exports.isNotNonNullAssertionPunctuator = isNotNonNullAssertionPunctuator;
+/**
+ * Returns true if and only if the node represents: foo?.() or foo.bar?.()
+ */
+const isOptionalCallExpression = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.CallExpression, 
+// this flag means the call expression itself is option
+// i.e. it is foo.bar?.() and not foo?.bar()
+{ optional: true });
+exports.isOptionalCallExpression = isOptionalCallExpression;
+/**
+ * Returns true if and only if the node represents logical OR
+ */
+const isLogicalOrOperator = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.LogicalExpression, { operator: '||' });
+exports.isLogicalOrOperator = isLogicalOrOperator;
+/**
+ * Checks if a node is a type assertion:
+ * ```
+ * x as foo
+ * <foo>x
+ * ```
+ */
+const isTypeAssertion = (0, helpers_1.isNodeOfTypes)([
+    ts_estree_1.AST_NODE_TYPES.TSAsExpression,
+    ts_estree_1.AST_NODE_TYPES.TSTypeAssertion,
+]);
+exports.isTypeAssertion = isTypeAssertion;
+const isVariableDeclarator = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.VariableDeclarator);
+exports.isVariableDeclarator = isVariableDeclarator;
+const functionTypes = [
+    ts_estree_1.AST_NODE_TYPES.ArrowFunctionExpression,
+    ts_estree_1.AST_NODE_TYPES.FunctionDeclaration,
+    ts_estree_1.AST_NODE_TYPES.FunctionExpression,
+];
+const isFunction = (0, helpers_1.isNodeOfTypes)(functionTypes);
+exports.isFunction = isFunction;
+const functionTypeTypes = [
+    ts_estree_1.AST_NODE_TYPES.TSCallSignatureDeclaration,
+    ts_estree_1.AST_NODE_TYPES.TSConstructorType,
+    ts_estree_1.AST_NODE_TYPES.TSConstructSignatureDeclaration,
+    ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
+    ts_estree_1.AST_NODE_TYPES.TSFunctionType,
+    ts_estree_1.AST_NODE_TYPES.TSMethodSignature,
+];
+const isFunctionType = (0, helpers_1.isNodeOfTypes)(functionTypeTypes);
+exports.isFunctionType = isFunctionType;
+const isFunctionOrFunctionType = (0, helpers_1.isNodeOfTypes)([
+    ...functionTypes,
+    ...functionTypeTypes,
+]);
+exports.isFunctionOrFunctionType = isFunctionOrFunctionType;
+const isTSFunctionType = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.TSFunctionType);
+exports.isTSFunctionType = isTSFunctionType;
+const isTSConstructorType = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.TSConstructorType);
+exports.isTSConstructorType = isTSConstructorType;
+const isClassOrTypeElement = (0, helpers_1.isNodeOfTypes)([
+    // ClassElement
+    ts_estree_1.AST_NODE_TYPES.PropertyDefinition,
+    ts_estree_1.AST_NODE_TYPES.FunctionExpression,
+    ts_estree_1.AST_NODE_TYPES.MethodDefinition,
+    ts_estree_1.AST_NODE_TYPES.TSAbstractPropertyDefinition,
+    ts_estree_1.AST_NODE_TYPES.TSAbstractMethodDefinition,
+    ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
+    ts_estree_1.AST_NODE_TYPES.TSIndexSignature,
+    // TypeElement
+    ts_estree_1.AST_NODE_TYPES.TSCallSignatureDeclaration,
+    ts_estree_1.AST_NODE_TYPES.TSConstructSignatureDeclaration,
+    // AST_NODE_TYPES.TSIndexSignature,
+    ts_estree_1.AST_NODE_TYPES.TSMethodSignature,
+    ts_estree_1.AST_NODE_TYPES.TSPropertySignature,
+]);
+exports.isClassOrTypeElement = isClassOrTypeElement;
+/**
+ * Checks if a node is a constructor method.
+ */
+const isConstructor = (0, helpers_1.isNodeOfTypeWithConditions)(ts_estree_1.AST_NODE_TYPES.MethodDefinition, { kind: 'constructor' });
+exports.isConstructor = isConstructor;
+/**
+ * Checks if a node is a setter method.
+ */
+function isSetter(node) {
+    return (!!node &&
+        (node.type === ts_estree_1.AST_NODE_TYPES.MethodDefinition ||
+            node.type === ts_estree_1.AST_NODE_TYPES.Property) &&
+        node.kind === 'set');
+}
+exports.isSetter = isSetter;
+const isIdentifier = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.Identifier);
+exports.isIdentifier = isIdentifier;
+/**
+ * Checks if a node represents an `await …` expression.
+ */
+const isAwaitExpression = (0, helpers_1.isNodeOfType)(ts_estree_1.AST_NODE_TYPES.AwaitExpression);
+exports.isAwaitExpression = isAwaitExpression;
+/**
+ * Checks if a possible token is the `await` keyword.
+ */
+const isAwaitKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Identifier, {
+    value: 'await',
+});
+exports.isAwaitKeyword = isAwaitKeyword;
+/**
+ * Checks if a possible token is the `type` keyword.
+ */
+const isTypeKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Identifier, {
+    value: 'type',
+});
+exports.isTypeKeyword = isTypeKeyword;
+/**
+ * Checks if a possible token is the `import` keyword.
+ */
+const isImportKeyword = (0, helpers_1.isTokenOfTypeWithConditions)(ts_estree_1.AST_TOKEN_TYPES.Keyword, {
+    value: 'import',
+});
+exports.isImportKeyword = isImportKeyword;
+const isLoop = (0, helpers_1.isNodeOfTypes)([
+    ts_estree_1.AST_NODE_TYPES.DoWhileStatement,
+    ts_estree_1.AST_NODE_TYPES.ForStatement,
+    ts_estree_1.AST_NODE_TYPES.ForInStatement,
+    ts_estree_1.AST_NODE_TYPES.ForOfStatement,
+    ts_estree_1.AST_NODE_TYPES.WhileStatement,
+]);
+exports.isLoop = isLoop;
+//# sourceMappingURL=predicates.js.map

package/backend/node_modules/@typescript-eslint/utils/dist/ast-utils/predicates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicates.js","sourceRoot":"","sources":["../../src/ast-utils/predicates.ts"],"names":[],"mappings":"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"}

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.d.ts

@@ -0,0 +1,11 @@
+import type { RuleCreateFunction, RuleModule } from '../ts-eslint';
+/**
+ * Uses type inference to fetch the TOptions type from the given RuleModule
+ */
+type InferOptionsTypeFromRule<T> = T extends RuleModule<infer _TMessageIds, infer TOptions> ? TOptions : T extends RuleCreateFunction<infer _TMessageIds, infer TOptions> ? TOptions : unknown;
+/**
+ * Uses type inference to fetch the TMessageIds type from the given RuleModule
+ */
+type InferMessageIdsTypeFromRule<T> = T extends RuleModule<infer TMessageIds, infer _TOptions> ? TMessageIds : T extends RuleCreateFunction<infer TMessageIds, infer _TOptions> ? TMessageIds : unknown;
+export { InferOptionsTypeFromRule, InferMessageIdsTypeFromRule };
+//# sourceMappingURL=InferTypesFromRule.d.ts.map

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InferTypesFromRule.d.ts","sourceRoot":"","sources":["../../src/eslint-utils/InferTypesFromRule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAEnE;;GAEG;AACH,KAAK,wBAAwB,CAAC,CAAC,IAC7B,CAAC,SAAS,UAAU,CAAC,MAAM,YAAY,EAAE,MAAM,QAAQ,CAAC,GACpD,QAAQ,GACR,CAAC,SAAS,kBAAkB,CAAC,MAAM,YAAY,EAAE,MAAM,QAAQ,CAAC,GAC9D,QAAQ,GACR,OAAO,CAAC;AAEhB;;GAEG;AACH,KAAK,2BAA2B,CAAC,CAAC,IAChC,CAAC,SAAS,UAAU,CAAC,MAAM,WAAW,EAAE,MAAM,SAAS,CAAC,GACpD,WAAW,GACX,CAAC,SAAS,kBAAkB,CAAC,MAAM,WAAW,EAAE,MAAM,SAAS,CAAC,GAC9D,WAAW,GACX,OAAO,CAAC;AAEhB,OAAO,EAAE,wBAAwB,EAAE,2BAA2B,EAAE,CAAC"}

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=InferTypesFromRule.js.map

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InferTypesFromRule.js","sourceRoot":"","sources":["../../src/eslint-utils/InferTypesFromRule.ts"],"names":[],"mappings":""}

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.d.ts

@@ -0,0 +1,35 @@
+import type { RuleContext, RuleListener, RuleMetaData, RuleMetaDataDocs, RuleModule } from '../ts-eslint/Rule';
+export type { RuleListener, RuleModule };
+export type NamedCreateRuleMetaDocs = Omit<RuleMetaDataDocs, 'url'>;
+export type NamedCreateRuleMeta<TMessageIds extends string> = Omit<RuleMetaData<TMessageIds>, 'docs'> & {
+    docs: NamedCreateRuleMetaDocs;
+};
+export interface RuleCreateAndOptions<TOptions extends readonly unknown[], TMessageIds extends string> {
+    create: (context: Readonly<RuleContext<TMessageIds, TOptions>>, optionsWithDefault: Readonly<TOptions>) => RuleListener;
+    defaultOptions: Readonly<TOptions>;
+}
+export interface RuleWithMeta<TOptions extends readonly unknown[], TMessageIds extends string> extends RuleCreateAndOptions<TOptions, TMessageIds> {
+    meta: RuleMetaData<TMessageIds>;
+}
+export interface RuleWithMetaAndName<TOptions extends readonly unknown[], TMessageIds extends string> extends RuleCreateAndOptions<TOptions, TMessageIds> {
+    meta: NamedCreateRuleMeta<TMessageIds>;
+    name: string;
+}
+/**
+ * Creates reusable function to create rules with default options and docs URLs.
+ *
+ * @param urlCreator Creates a documentation URL for a given rule name.
+ * @returns Function to create a rule with the docs URL format.
+ */
+export declare function RuleCreator(urlCreator: (ruleName: string) => string): <TOptions extends readonly unknown[], TMessageIds extends string>({ name, meta, ...rule }: Readonly<RuleWithMetaAndName<TOptions, TMessageIds>>) => RuleModule<TMessageIds, TOptions, RuleListener>;
+export declare namespace RuleCreator {
+    var withoutDocs: typeof createRule;
+}
+/**
+ * Creates a well-typed TSESLint custom ESLint rule without a docs URL.
+ *
+ * @returns Well-typed TSESLint custom ESLint rule.
+ * @remarks It is generally better to provide a docs URL function to RuleCreator.
+ */
+declare function createRule<TOptions extends readonly unknown[], TMessageIds extends string>({ create, defaultOptions, meta, }: Readonly<RuleWithMeta<TOptions, TMessageIds>>): RuleModule<TMessageIds, TOptions>;
+//# sourceMappingURL=RuleCreator.d.ts.map

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleCreator.d.ts","sourceRoot":"","sources":["../../src/eslint-utils/RuleCreator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACX,MAAM,mBAAmB,CAAC;AAG3B,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,CAAC;AAGzC,MAAM,MAAM,uBAAuB,GAAG,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;AACpE,MAAM,MAAM,mBAAmB,CAAC,WAAW,SAAS,MAAM,IAAI,IAAI,CAChE,YAAY,CAAC,WAAW,CAAC,EACzB,MAAM,CACP,GAAG;IACF,IAAI,EAAE,uBAAuB,CAAC;CAC/B,CAAC;AAEF,MAAM,WAAW,oBAAoB,CACnC,QAAQ,SAAS,SAAS,OAAO,EAAE,EACnC,WAAW,SAAS,MAAM;IAE1B,MAAM,EAAE,CACN,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,EACrD,kBAAkB,EAAE,QAAQ,CAAC,QAAQ,CAAC,KACnC,YAAY,CAAC;IAClB,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,YAAY,CAC3B,QAAQ,SAAS,SAAS,OAAO,EAAE,EACnC,WAAW,SAAS,MAAM,CAC1B,SAAQ,oBAAoB,CAAC,QAAQ,EAAE,WAAW,CAAC;IACnD,IAAI,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB,CAClC,QAAQ,SAAS,SAAS,OAAO,EAAE,EACnC,WAAW,SAAS,MAAM,CAC1B,SAAQ,oBAAoB,CAAC,QAAQ,EAAE,WAAW,CAAC;IACnD,IAAI,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IACvC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,uMAyBnE;yBAzBe,WAAW;;;AA2B3B;;;;;GAKG;AACH,iBAAS,UAAU,CACjB,QAAQ,SAAS,SAAS,OAAO,EAAE,EACnC,WAAW,SAAS,MAAM,EAC1B,EACA,MAAM,EACN,cAAc,EACd,IAAI,GACL,EAAE,QAAQ,CAAC,YAAY,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,GAAG,UAAU,CAC3D,WAAW,EACX,QAAQ,CACT,CAWA"}

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleCreator = void 0;
+const applyDefault_1 = require("./applyDefault");
+/**
+ * Creates reusable function to create rules with default options and docs URLs.
+ *
+ * @param urlCreator Creates a documentation URL for a given rule name.
+ * @returns Function to create a rule with the docs URL format.
+ */
+function RuleCreator(urlCreator) {
+    // This function will get much easier to call when this is merged https://github.com/Microsoft/TypeScript/pull/26349
+    // TODO - when the above PR lands; add type checking for the context.report `data` property
+    return function createNamedRule({ name, meta, ...rule }) {
+        return createRule({
+            meta: {
+                ...meta,
+                docs: {
+                    ...meta.docs,
+                    url: urlCreator(name),
+                },
+            },
+            ...rule,
+        });
+    };
+}
+exports.RuleCreator = RuleCreator;
+/**
+ * Creates a well-typed TSESLint custom ESLint rule without a docs URL.
+ *
+ * @returns Well-typed TSESLint custom ESLint rule.
+ * @remarks It is generally better to provide a docs URL function to RuleCreator.
+ */
+function createRule({ create, defaultOptions, meta, }) {
+    return {
+        create(context) {
+            const optionsWithDefault = (0, applyDefault_1.applyDefault)(defaultOptions, context.options);
+            return create(context, optionsWithDefault);
+        },
+        defaultOptions,
+        meta,
+    };
+}
+RuleCreator.withoutDocs = createRule;
+//# sourceMappingURL=RuleCreator.js.map

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleCreator.js","sourceRoot":"","sources":["../../src/eslint-utils/RuleCreator.ts"],"names":[],"mappings":";;;AAOA,iDAA8C;AAuC9C;;;;;GAKG;AACH,SAAgB,WAAW,CAAC,UAAwC;IAClE,oHAAoH;IACpH,2FAA2F;IAC3F,OAAO,SAAS,eAAe,CAG7B,EACA,IAAI,EACJ,IAAI,EACJ,GAAG,IAAI,EAC8C;QAIrD,OAAO,UAAU,CAAwB;YACvC,IAAI,EAAE;gBACJ,GAAG,IAAI;gBACP,IAAI,EAAE;oBACJ,GAAG,IAAI,CAAC,IAAI;oBACZ,GAAG,EAAE,UAAU,CAAC,IAAI,CAAC;iBACtB;aACF;YACD,GAAG,IAAI;SACR,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAzBD,kCAyBC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAGjB,EACA,MAAM,EACN,cAAc,EACd,IAAI,GAC0C;IAI9C,OAAO;QACL,MAAM,CACJ,OAAqD;YAErD,MAAM,kBAAkB,GAAG,IAAA,2BAAY,EAAC,cAAc,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;YACzE,OAAO,MAAM,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC;QAC7C,CAAC;QACD,cAAc;QACd,IAAI;KACL,CAAC;AACJ,CAAC;AAED,WAAW,CAAC,WAAW,GAAG,UAAU,CAAC"}

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pure function - doesn't mutate either parameter!
+ * Uses the default options and overrides with the options provided by the user
+ * @param defaultOptions the defaults
+ * @param userOptions the user opts
+ * @returns the options with defaults
+ */
+declare function applyDefault<TUser extends readonly unknown[], TDefault extends TUser>(defaultOptions: Readonly<TDefault>, userOptions: Readonly<TUser> | null): TDefault;
+export { applyDefault };
+//# sourceMappingURL=applyDefault.d.ts.map

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyDefault.d.ts","sourceRoot":"","sources":["../../src/eslint-utils/applyDefault.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,iBAAS,YAAY,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,EAAE,QAAQ,SAAS,KAAK,EAC5E,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAClC,WAAW,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,IAAI,GAClC,QAAQ,CAyBV;AAMD,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDefault = void 0;
+const deepMerge_1 = require("./deepMerge");
+/**
+ * Pure function - doesn't mutate either parameter!
+ * Uses the default options and overrides with the options provided by the user
+ * @param defaultOptions the defaults
+ * @param userOptions the user opts
+ * @returns the options with defaults
+ */
+function applyDefault(defaultOptions, userOptions) {
+    // clone defaults
+    const options = JSON.parse(JSON.stringify(defaultOptions));
+    if (userOptions == null) {
+        return options;
+    }
+    // For avoiding the type error
+    //   `This expression is not callable. Type 'unknown' has no call signatures.ts(2349)`
+    options.forEach((opt, i) => {
+        if (userOptions[i] !== undefined) {
+            const userOpt = userOptions[i];
+            if ((0, deepMerge_1.isObjectNotArray)(userOpt) && (0, deepMerge_1.isObjectNotArray)(opt)) {
+                options[i] = (0, deepMerge_1.deepMerge)(opt, userOpt);
+            }
+            else {
+                options[i] = userOpt;
+            }
+        }
+    });
+    return options;
+}
+exports.applyDefault = applyDefault;
+//# sourceMappingURL=applyDefault.js.map

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyDefault.js","sourceRoot":"","sources":["../../src/eslint-utils/applyDefault.ts"],"names":[],"mappings":";;;AAAA,2CAA0D;AAE1D;;;;;;GAMG;AACH,SAAS,YAAY,CACnB,cAAkC,EAClC,WAAmC;IAEnC,iBAAiB;IACjB,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CACxB,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CACR,CAAC;IAEzB,IAAI,WAAW,IAAI,IAAI,EAAE,CAAC;QACxB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,8BAA8B;IAC9B,sFAAsF;IACrF,OAAqB,CAAC,OAAO,CAAC,CAAC,GAAY,EAAE,CAAS,EAAE,EAAE;QACzD,IAAI,WAAW,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;YACjC,MAAM,OAAO,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;YAE/B,IAAI,IAAA,4BAAgB,EAAC,OAAO,CAAC,IAAI,IAAA,4BAAgB,EAAC,GAAG,CAAC,EAAE,CAAC;gBACvD,OAAO,CAAC,CAAC,CAAC,GAAG,IAAA,qBAAS,EAAC,GAAG,EAAE,OAAO,CAAC,CAAC;YACvC,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,OAAO,CAAC;AACjB,CAAC;AAMQ,oCAAY"}

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/context.d.ts

@@ -0,0 +1,10 @@
+import type { Scope, SourceCode } from '../ts-eslint';
+import type { RuleContext } from '../ts-eslint/Rule';
+import type { TSESTree } from '../ts-estree';
+export declare function getAncestors(context: Readonly<RuleContext<string, unknown[]>>): TSESTree.Node[];
+export declare function getCwd(context: Readonly<RuleContext<string, unknown[]>>): string;
+export declare function getDeclaredVariables(context: Readonly<RuleContext<string, unknown[]>>, node: TSESTree.Node): readonly Scope.Variable[];
+export declare function getFilename(context: Readonly<RuleContext<string, unknown[]>>): string;
+export declare function getScope(context: Readonly<RuleContext<string, readonly unknown[]>>): Scope.Scope;
+export declare function getSourceCode(context: Readonly<RuleContext<string, readonly unknown[]>>): Readonly<SourceCode>;
+//# sourceMappingURL=context.d.ts.map

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/eslint-utils/context.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,wBAAgB,YAAY,CAC1B,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,GAChD,QAAQ,CAAC,IAAI,EAAE,CAGjB;AAED,wBAAgB,MAAM,CACpB,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,GAChD,MAAM,CAER;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,EACjD,IAAI,EAAE,QAAQ,CAAC,IAAI,GAClB,SAAS,KAAK,CAAC,QAAQ,EAAE,CAM3B;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,GAChD,MAAM,CAER;AAED,wBAAgB,QAAQ,CACtB,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,GACzD,KAAK,CAAC,KAAK,CAGb;AAED,wBAAgB,aAAa,CAC3B,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,GACzD,QAAQ,CAAC,UAAU,CAAC,CAEtB"}

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/context.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceCode = exports.getScope = exports.getFilename = exports.getDeclaredVariables = exports.getCwd = exports.getAncestors = void 0;
+function getAncestors(context) {
+    // TODO: Use `SourceCode#getAncestors` (we'll be forced to soon)
+    return context.getAncestors();
+}
+exports.getAncestors = getAncestors;
+function getCwd(context) {
+    return context.cwd ?? context.getCwd();
+}
+exports.getCwd = getCwd;
+function getDeclaredVariables(context, node) {
+    const sourceCode = getSourceCode(context);
+    return (sourceCode.getDeclaredVariables?.(node) ??
+        context.getDeclaredVariables(node));
+}
+exports.getDeclaredVariables = getDeclaredVariables;
+function getFilename(context) {
+    return context.filename ?? context.getFilename();
+}
+exports.getFilename = getFilename;
+function getScope(context) {
+    // TODO: Use `SourceCode#getScope` (we'll be forced to soon)
+    return context.getScope();
+}
+exports.getScope = getScope;
+function getSourceCode(context) {
+    return context.sourceCode ?? context.getSourceCode();
+}
+exports.getSourceCode = getSourceCode;
+//# sourceMappingURL=context.js.map

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/eslint-utils/context.ts"],"names":[],"mappings":";;;AAOA,SAAgB,YAAY,CAC1B,OAAiD;IAEjD,gEAAgE;IAChE,OAAO,OAAO,CAAC,YAAY,EAAE,CAAC;AAChC,CAAC;AALD,oCAKC;AAED,SAAgB,MAAM,CACpB,OAAiD;IAEjD,OAAO,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;AACzC,CAAC;AAJD,wBAIC;AAED,SAAgB,oBAAoB,CAClC,OAAiD,EACjD,IAAmB;IAEnB,MAAM,UAAU,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;IAC1C,OAAO,CACL,UAAU,CAAC,oBAAoB,EAAE,CAAC,IAAI,CAAC;QACvC,OAAO,CAAC,oBAAoB,CAAC,IAAI,CAAC,CACnC,CAAC;AACJ,CAAC;AATD,oDASC;AAED,SAAgB,WAAW,CACzB,OAAiD;IAEjD,OAAO,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;AACnD,CAAC;AAJD,kCAIC;AAED,SAAgB,QAAQ,CACtB,OAA0D;IAE1D,4DAA4D;IAC5D,OAAO,OAAO,CAAC,QAAQ,EAAE,CAAC;AAC5B,CAAC;AALD,4BAKC;AAED,SAAgB,aAAa,CAC3B,OAA0D;IAE1D,OAAO,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;AACvD,CAAC;AAJD,sCAIC"}

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.d.ts

@@ -0,0 +1,17 @@
+type ObjectLike<T = unknown> = Record<string, T>;
+/**
+ * Check if the variable contains an object strictly rejecting arrays
+ * @param obj an object
+ * @returns `true` if obj is an object
+ */
+declare function isObjectNotArray<T extends ObjectLike>(obj: unknown): obj is T;
+/**
+ * Pure function - doesn't mutate either parameter!
+ * Merges two objects together deeply, overwriting the properties in first with the properties in second
+ * @param first The first object
+ * @param second The second object
+ * @returns a new object
+ */
+export declare function deepMerge(first?: ObjectLike, second?: ObjectLike): Record<string, unknown>;
+export { isObjectNotArray };
+//# sourceMappingURL=deepMerge.d.ts.map

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepMerge.d.ts","sourceRoot":"","sources":["../../src/eslint-utils/deepMerge.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,CAAC,CAAC,GAAG,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AAEjD;;;;GAIG;AACH,iBAAS,gBAAgB,CAAC,CAAC,SAAS,UAAU,EAAE,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,CAAC,CAEtE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,KAAK,GAAE,UAAe,EACtB,MAAM,GAAE,UAAe,GACtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA0BzB;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/backend/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObjectNotArray = exports.deepMerge = void 0;
+/**
+ * Check if the variable contains an object strictly rejecting arrays
+ * @param obj an object
+ * @returns `true` if obj is an object
+ */
+function isObjectNotArray(obj) {
+    return typeof obj === 'object' && obj != null && !Array.isArray(obj);
+}
+exports.isObjectNotArray = isObjectNotArray;
+/**
+ * Pure function - doesn't mutate either parameter!
+ * Merges two objects together deeply, overwriting the properties in first with the properties in second
+ * @param first The first object
+ * @param second The second object
+ * @returns a new object
+ */
+function deepMerge(first = {}, second = {}) {
+    // get the unique set of keys across both objects
+    const keys = new Set(Object.keys(first).concat(Object.keys(second)));
+    return Array.from(keys).reduce((acc, key) => {
+        const firstHasKey = key in first;
+        const secondHasKey = key in second;
+        const firstValue = first[key];
+        const secondValue = second[key];
+        if (firstHasKey && secondHasKey) {
+            if (isObjectNotArray(firstValue) && isObjectNotArray(secondValue)) {
+                // object type
+                acc[key] = deepMerge(firstValue, secondValue);
+            }
+            else {
+                // value type
+                acc[key] = secondValue;
+            }
+        }
+        else if (firstHasKey) {
+            acc[key] = firstValue;
+        }
+        else {
+            acc[key] = secondValue;
+        }
+        return acc;
+    }, {});
+}
+exports.deepMerge = deepMerge;
+//# sourceMappingURL=deepMerge.js.map