Changing front

front/app/node_modules/@angular/compiler-cli/bundles/linker/babel/index.js

@@ -0,0 +1,418 @@
+
+      import {createRequire as __cjsCompatRequire} from 'module';
+      const require = __cjsCompatRequire(import.meta.url);
+      const __ESM_IMPORT_META_URL__ = import.meta.url;
+    
+import {
+  ConsoleLogger,
+  LogLevel
+} from "../../chunk-OFXSI6E3.js";
+import {
+  FatalLinkerError,
+  FileLinker,
+  LinkerEnvironment,
+  assert,
+  isFatalLinkerError
+} from "../../chunk-NS3RSQBX.js";
+import "../../chunk-OUTDZGN7.js";
+import "../../chunk-TOW3O33K.js";
+import "../../chunk-DSVWG4QJ.js";
+import {
+  NodeJSFileSystem
+} from "../../chunk-E7DPJFUS.js";
+import "../../chunk-NDREJTCS.js";
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/linker/babel/src/babel_core.mjs
+import * as _babelNamespace from "@babel/core";
+import _babelDefault from "@babel/core";
+var _a;
+var babel = (_a = _babelDefault) != null ? _a : _babelNamespace;
+var _typesNamespace = _babelNamespace.types;
+if (_babelDefault !== void 0) {
+  _typesNamespace = _babelDefault.types;
+}
+var types2 = _typesNamespace;
+var NodePath = babel.NodePath;
+var transformSync = babel.transformSync;
+var parse = babel.parse;
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/linker/babel/src/ast/babel_ast_factory.mjs
+var BabelAstFactory = class {
+  constructor(sourceUrl) {
+    this.sourceUrl = sourceUrl;
+    this.createArrayLiteral = types2.arrayExpression;
+    this.createBlock = types2.blockStatement;
+    this.createConditional = types2.conditionalExpression;
+    this.createExpressionStatement = types2.expressionStatement;
+    this.createIdentifier = types2.identifier;
+    this.createIfStatement = types2.ifStatement;
+    this.createNewExpression = types2.newExpression;
+    this.createParenthesizedExpression = types2.parenthesizedExpression;
+    this.createReturnStatement = types2.returnStatement;
+    this.createThrowStatement = types2.throwStatement;
+    this.createUnaryExpression = types2.unaryExpression;
+  }
+  attachComments(statement, leadingComments) {
+    for (let i = leadingComments.length - 1; i >= 0; i--) {
+      const comment = leadingComments[i];
+      types2.addComment(statement, "leading", comment.toString(), !comment.multiline);
+    }
+  }
+  createAssignment(target, value) {
+    assert(target, isLExpression, "must be a left hand side expression");
+    return types2.assignmentExpression("=", target, value);
+  }
+  createBinaryExpression(leftOperand, operator, rightOperand) {
+    switch (operator) {
+      case "&&":
+      case "||":
+      case "??":
+        return types2.logicalExpression(operator, leftOperand, rightOperand);
+      default:
+        return types2.binaryExpression(operator, leftOperand, rightOperand);
+    }
+  }
+  createCallExpression(callee, args, pure) {
+    const call = types2.callExpression(callee, args);
+    if (pure) {
+      types2.addComment(call, "leading", " @__PURE__ ", false);
+    }
+    return call;
+  }
+  createElementAccess(expression, element) {
+    return types2.memberExpression(expression, element, true);
+  }
+  createFunctionDeclaration(functionName, parameters, body) {
+    assert(body, types2.isBlockStatement, "a block");
+    return types2.functionDeclaration(types2.identifier(functionName), parameters.map((param) => types2.identifier(param)), body);
+  }
+  createFunctionExpression(functionName, parameters, body) {
+    assert(body, types2.isBlockStatement, "a block");
+    const name = functionName !== null ? types2.identifier(functionName) : null;
+    return types2.functionExpression(name, parameters.map((param) => types2.identifier(param)), body);
+  }
+  createLiteral(value) {
+    if (typeof value === "string") {
+      return types2.stringLiteral(value);
+    } else if (typeof value === "number") {
+      return types2.numericLiteral(value);
+    } else if (typeof value === "boolean") {
+      return types2.booleanLiteral(value);
+    } else if (value === void 0) {
+      return types2.identifier("undefined");
+    } else if (value === null) {
+      return types2.nullLiteral();
+    } else {
+      throw new Error(`Invalid literal: ${value} (${typeof value})`);
+    }
+  }
+  createObjectLiteral(properties) {
+    return types2.objectExpression(properties.map((prop) => {
+      const key = prop.quoted ? types2.stringLiteral(prop.propertyName) : types2.identifier(prop.propertyName);
+      return types2.objectProperty(key, prop.value);
+    }));
+  }
+  createPropertyAccess(expression, propertyName) {
+    return types2.memberExpression(expression, types2.identifier(propertyName), false);
+  }
+  createTaggedTemplate(tag, template) {
+    const elements = template.elements.map((element, i) => this.setSourceMapRange(types2.templateElement(element, i === template.elements.length - 1), element.range));
+    return types2.taggedTemplateExpression(tag, types2.templateLiteral(elements, template.expressions));
+  }
+  createTypeOfExpression(expression) {
+    return types2.unaryExpression("typeof", expression);
+  }
+  createVariableDeclaration(variableName, initializer, type) {
+    return types2.variableDeclaration(type, [types2.variableDeclarator(types2.identifier(variableName), initializer)]);
+  }
+  setSourceMapRange(node, sourceMapRange) {
+    if (sourceMapRange === null) {
+      return node;
+    }
+    node.loc = {
+      filename: sourceMapRange.url !== this.sourceUrl ? sourceMapRange.url : void 0,
+      start: {
+        line: sourceMapRange.start.line + 1,
+        column: sourceMapRange.start.column
+      },
+      end: {
+        line: sourceMapRange.end.line + 1,
+        column: sourceMapRange.end.column
+      }
+    };
+    node.start = sourceMapRange.start.offset;
+    node.end = sourceMapRange.end.offset;
+    return node;
+  }
+};
+function isLExpression(expr) {
+  return types2.isLVal(expr);
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/linker/babel/src/ast/babel_ast_host.mjs
+var BabelAstHost = class {
+  constructor() {
+    this.isStringLiteral = types2.isStringLiteral;
+    this.isNumericLiteral = types2.isNumericLiteral;
+    this.isArrayLiteral = types2.isArrayExpression;
+    this.isObjectLiteral = types2.isObjectExpression;
+    this.isCallExpression = types2.isCallExpression;
+  }
+  getSymbolName(node) {
+    if (types2.isIdentifier(node)) {
+      return node.name;
+    } else if (types2.isMemberExpression(node) && types2.isIdentifier(node.property)) {
+      return node.property.name;
+    } else {
+      return null;
+    }
+  }
+  parseStringLiteral(str) {
+    assert(str, types2.isStringLiteral, "a string literal");
+    return str.value;
+  }
+  parseNumericLiteral(num) {
+    assert(num, types2.isNumericLiteral, "a numeric literal");
+    return num.value;
+  }
+  isBooleanLiteral(bool) {
+    return types2.isBooleanLiteral(bool) || isMinifiedBooleanLiteral(bool);
+  }
+  parseBooleanLiteral(bool) {
+    if (types2.isBooleanLiteral(bool)) {
+      return bool.value;
+    } else if (isMinifiedBooleanLiteral(bool)) {
+      return !bool.argument.value;
+    } else {
+      throw new FatalLinkerError(bool, "Unsupported syntax, expected a boolean literal.");
+    }
+  }
+  parseArrayLiteral(array) {
+    assert(array, types2.isArrayExpression, "an array literal");
+    return array.elements.map((element) => {
+      assert(element, isNotEmptyElement, "element in array not to be empty");
+      assert(element, isNotSpreadElement, "element in array not to use spread syntax");
+      return element;
+    });
+  }
+  parseObjectLiteral(obj) {
+    assert(obj, types2.isObjectExpression, "an object literal");
+    const result = /* @__PURE__ */ new Map();
+    for (const property of obj.properties) {
+      assert(property, types2.isObjectProperty, "a property assignment");
+      assert(property.value, types2.isExpression, "an expression");
+      assert(property.key, isObjectExpressionPropertyName, "a property name");
+      const key = types2.isIdentifier(property.key) ? property.key.name : property.key.value;
+      result.set(`${key}`, property.value);
+    }
+    return result;
+  }
+  isFunctionExpression(node) {
+    return types2.isFunction(node);
+  }
+  parseReturnValue(fn) {
+    assert(fn, this.isFunctionExpression, "a function");
+    if (!types2.isBlockStatement(fn.body)) {
+      return fn.body;
+    }
+    if (fn.body.body.length !== 1) {
+      throw new FatalLinkerError(fn.body, "Unsupported syntax, expected a function body with a single return statement.");
+    }
+    const stmt = fn.body.body[0];
+    assert(stmt, types2.isReturnStatement, "a function body with a single return statement");
+    if (stmt.argument === null || stmt.argument === void 0) {
+      throw new FatalLinkerError(stmt, "Unsupported syntax, expected function to return a value.");
+    }
+    return stmt.argument;
+  }
+  parseCallee(call) {
+    assert(call, types2.isCallExpression, "a call expression");
+    assert(call.callee, types2.isExpression, "an expression");
+    return call.callee;
+  }
+  parseArguments(call) {
+    assert(call, types2.isCallExpression, "a call expression");
+    return call.arguments.map((arg) => {
+      assert(arg, isNotSpreadArgument, "argument not to use spread syntax");
+      assert(arg, types2.isExpression, "argument to be an expression");
+      return arg;
+    });
+  }
+  getRange(node) {
+    if (node.loc == null || node.start == null || node.end == null) {
+      throw new FatalLinkerError(node, "Unable to read range for node - it is missing location information.");
+    }
+    return {
+      startLine: node.loc.start.line - 1,
+      startCol: node.loc.start.column,
+      startPos: node.start,
+      endPos: node.end
+    };
+  }
+};
+function isNotEmptyElement(e) {
+  return e !== null;
+}
+function isNotSpreadElement(e) {
+  return !types2.isSpreadElement(e);
+}
+function isObjectExpressionPropertyName(n) {
+  return types2.isIdentifier(n) || types2.isStringLiteral(n) || types2.isNumericLiteral(n);
+}
+function isNotSpreadArgument(arg) {
+  return !types2.isSpreadElement(arg);
+}
+function isMinifiedBooleanLiteral(node) {
+  return types2.isUnaryExpression(node) && node.prefix && node.operator === "!" && types2.isNumericLiteral(node.argument) && (node.argument.value === 0 || node.argument.value === 1);
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/linker/babel/src/babel_declaration_scope.mjs
+var BabelDeclarationScope = class {
+  constructor(declarationScope) {
+    this.declarationScope = declarationScope;
+  }
+  getConstantScopeRef(expression) {
+    let bindingExpression = expression;
+    while (types2.isMemberExpression(bindingExpression)) {
+      bindingExpression = bindingExpression.object;
+    }
+    if (!types2.isIdentifier(bindingExpression)) {
+      return null;
+    }
+    const binding = this.declarationScope.getBinding(bindingExpression.name);
+    if (binding === void 0) {
+      return null;
+    }
+    const path = binding.scope.path;
+    if (!path.isFunctionDeclaration() && !path.isFunctionExpression() && !(path.isProgram() && path.node.sourceType === "module")) {
+      return null;
+    }
+    return path;
+  }
+};
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/linker/babel/src/es2015_linker_plugin.mjs
+function createEs2015LinkerPlugin({ fileSystem, logger, ...options }) {
+  let fileLinker = null;
+  return {
+    visitor: {
+      Program: {
+        enter(path) {
+          var _a2, _b;
+          assertNull(fileLinker);
+          const file = path.hub.file;
+          const filename = (_a2 = file.opts.filename) != null ? _a2 : file.opts.filenameRelative;
+          if (!filename) {
+            throw new Error("No filename (nor filenameRelative) provided by Babel. This is required for the linking of partially compiled directives and components.");
+          }
+          const sourceUrl = fileSystem.resolve((_b = file.opts.cwd) != null ? _b : ".", filename);
+          const linkerEnvironment = LinkerEnvironment.create(fileSystem, logger, new BabelAstHost(), new BabelAstFactory(sourceUrl), options);
+          fileLinker = new FileLinker(linkerEnvironment, sourceUrl, file.code);
+        },
+        exit() {
+          assertNotNull(fileLinker);
+          for (const { constantScope, statements } of fileLinker.getConstantStatements()) {
+            insertStatements(constantScope, statements);
+          }
+          fileLinker = null;
+        }
+      },
+      CallExpression(call) {
+        if (fileLinker === null) {
+          return;
+        }
+        try {
+          const calleeName = getCalleeName(call);
+          if (calleeName === null) {
+            return;
+          }
+          const args = call.node.arguments;
+          if (!fileLinker.isPartialDeclaration(calleeName) || !isExpressionArray(args)) {
+            return;
+          }
+          const declarationScope = new BabelDeclarationScope(call.scope);
+          const replacement = fileLinker.linkPartialDeclaration(calleeName, args, declarationScope);
+          call.replaceWith(replacement);
+        } catch (e) {
+          const node = isFatalLinkerError(e) ? e.node : call.node;
+          throw buildCodeFrameError(call.hub.file, e.message, node);
+        }
+      }
+    }
+  };
+}
+function insertStatements(path, statements) {
+  if (path.isProgram()) {
+    insertIntoProgram(path, statements);
+  } else {
+    insertIntoFunction(path, statements);
+  }
+}
+function insertIntoFunction(fn, statements) {
+  const body = fn.get("body");
+  body.unshiftContainer("body", statements);
+}
+function insertIntoProgram(program, statements) {
+  const body = program.get("body");
+  const importStatements = body.filter((statement) => statement.isImportDeclaration());
+  if (importStatements.length === 0) {
+    program.unshiftContainer("body", statements);
+  } else {
+    importStatements[importStatements.length - 1].insertAfter(statements);
+  }
+}
+function getCalleeName(call) {
+  const callee = call.node.callee;
+  if (types2.isIdentifier(callee)) {
+    return callee.name;
+  } else if (types2.isMemberExpression(callee) && types2.isIdentifier(callee.property)) {
+    return callee.property.name;
+  } else if (types2.isMemberExpression(callee) && types2.isStringLiteral(callee.property)) {
+    return callee.property.value;
+  } else {
+    return null;
+  }
+}
+function isExpressionArray(nodes) {
+  return nodes.every((node) => types2.isExpression(node));
+}
+function assertNull(obj) {
+  if (obj !== null) {
+    throw new Error("BUG - expected `obj` to be null");
+  }
+}
+function assertNotNull(obj) {
+  if (obj === null) {
+    throw new Error("BUG - expected `obj` not to be null");
+  }
+}
+function buildCodeFrameError(file, message, node) {
+  const filename = file.opts.filename || "(unknown file)";
+  const error = file.buildCodeFrameError(node, message);
+  return `${filename}: ${error.message}`;
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/linker/babel/src/babel_plugin.mjs
+function defaultLinkerPlugin(api, options) {
+  api.assertVersion(7);
+  return createEs2015LinkerPlugin({
+    ...options,
+    fileSystem: new NodeJSFileSystem(),
+    logger: new ConsoleLogger(LogLevel.info)
+  });
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler-cli/linker/babel/index.mjs
+var babel_default = defaultLinkerPlugin;
+export {
+  createEs2015LinkerPlugin,
+  babel_default as default
+};
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+//# sourceMappingURL=index.js.map

front/app/node_modules/@angular/compiler-cli/bundles/linker/babel/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../../packages/compiler-cli/linker/babel/src/babel_core.ts", "../../../../../../../../packages/compiler-cli/linker/babel/src/ast/babel_ast_factory.ts", "../../../../../../../../packages/compiler-cli/linker/babel/src/ast/babel_ast_host.ts", "../../../../../../../../packages/compiler-cli/linker/babel/src/babel_declaration_scope.ts", "../../../../../../../../packages/compiler-cli/linker/babel/src/es2015_linker_plugin.ts", "../../../../../../../../packages/compiler-cli/linker/babel/src/babel_plugin.ts", "../../../../../../../../packages/compiler-cli/linker/babel/index.ts"],
+  "mappings": "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 truncated
+  "names": ["types", "types", "types", "types", "_a", "types"]
+}

front/app/node_modules/@angular/compiler-cli/bundles/linker/index.js

@@ -0,0 +1,29 @@
+
+      import {createRequire as __cjsCompatRequire} from 'module';
+      const require = __cjsCompatRequire(import.meta.url);
+      const __ESM_IMPORT_META_URL__ = import.meta.url;
+    
+import {
+  DEFAULT_LINKER_OPTIONS,
+  FatalLinkerError,
+  FileLinker,
+  LinkerEnvironment,
+  assert,
+  isFatalLinkerError,
+  needsLinking
+} from "../chunk-NS3RSQBX.js";
+import "../chunk-OUTDZGN7.js";
+import "../chunk-TOW3O33K.js";
+import "../chunk-DSVWG4QJ.js";
+import "../chunk-E7DPJFUS.js";
+import "../chunk-NDREJTCS.js";
+export {
+  DEFAULT_LINKER_OPTIONS,
+  FatalLinkerError,
+  FileLinker,
+  LinkerEnvironment,
+  assert,
+  isFatalLinkerError,
+  needsLinking
+};
+//# sourceMappingURL=index.js.map

front/app/node_modules/@angular/compiler-cli/bundles/linker/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": [],
+  "mappings": "",
+  "names": []
+}