完成世界书、骰子、apiconfig页面处理

frontend/node_modules/@babel/traverse/lib/path/comments.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addComment = addComment;
+exports.addComments = addComments;
+exports.shareCommentsWithSiblings = shareCommentsWithSiblings;
+var _t = require("@babel/types");
+const {
+  addComment: _addComment,
+  addComments: _addComments
+} = _t;
+function shareCommentsWithSiblings() {
+  if (typeof this.key === "string") return;
+  const node = this.node;
+  if (!node) return;
+  const trailing = node.trailingComments;
+  const leading = node.leadingComments;
+  if (!trailing && !leading) return;
+  const prev = this.getSibling(this.key - 1);
+  const next = this.getSibling(this.key + 1);
+  const hasPrev = Boolean(prev.node);
+  const hasNext = Boolean(next.node);
+  if (hasPrev) {
+    if (leading) {
+      prev.addComments("trailing", removeIfExisting(leading, prev.node.trailingComments));
+    }
+    if (trailing && !hasNext) prev.addComments("trailing", trailing);
+  }
+  if (hasNext) {
+    if (trailing) {
+      next.addComments("leading", removeIfExisting(trailing, next.node.leadingComments));
+    }
+    if (leading && !hasPrev) next.addComments("leading", leading);
+  }
+}
+function removeIfExisting(list, toRemove) {
+  if (!(toRemove != null && toRemove.length)) return list;
+  const set = new Set(toRemove);
+  return list.filter(el => {
+    return !set.has(el);
+  });
+}
+function addComment(type, content, line) {
+  _addComment(this.node, type, content, line);
+}
+function addComments(type, comments) {
+  _addComments(this.node, type, comments);
+}
+
+//# sourceMappingURL=comments.js.map

frontend/node_modules/@babel/traverse/lib/path/comments.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_t","require","addComment","_addComment","addComments","_addComments","shareCommentsWithSiblings","key","node","trailing","trailingComments","leading","leadingComments","prev","getSibling","next","hasPrev","Boolean","hasNext","removeIfExisting","list","toRemove","length","set","Set","filter","el","has","type","content","line","comments"],"sources":["../../src/path/comments.ts"],"sourcesContent":["// This file contains methods responsible for dealing with comments.\nimport type * as t from \"@babel/types\";\nimport type NodePath from \"./index.ts\";\nimport {\n  addComment as _addComment,\n  addComments as _addComments,\n} from \"@babel/types\";\n\n/**\n * Share comments amongst siblings.\n */\n\nexport function shareCommentsWithSiblings(this: NodePath) {\n  // NOTE: this assumes numbered keys\n  if (typeof this.key === \"string\") return;\n\n  const node = this.node;\n  if (!node) return;\n\n  const trailing = node.trailingComments;\n  const leading = node.leadingComments;\n  if (!trailing && !leading) return;\n\n  const prev = this.getSibling(this.key! - 1);\n  const next = this.getSibling(this.key! + 1);\n  const hasPrev = Boolean(prev.node);\n  const hasNext = Boolean(next.node);\n\n  if (hasPrev) {\n    if (leading) {\n      prev.addComments(\n        \"trailing\",\n        removeIfExisting(leading, prev.node.trailingComments),\n      );\n    }\n    if (trailing && !hasNext) prev.addComments(\"trailing\", trailing);\n  }\n  if (hasNext) {\n    if (trailing) {\n      next.addComments(\n        \"leading\",\n        removeIfExisting(trailing, next.node.leadingComments),\n      );\n    }\n    if (leading && !hasPrev) next.addComments(\"leading\", leading);\n  }\n}\n\nfunction removeIfExisting<T>(list: T[], toRemove?: T[] | null): T[] {\n  if (!toRemove?.length) return list;\n  const set = new Set(toRemove);\n  return list.filter(el => {\n    return !set.has(el);\n  });\n}\n\nexport function addComment(\n  this: NodePath,\n  type: t.CommentTypeShorthand,\n  content: string,\n  line?: boolean,\n) {\n  _addComment(this.node, type, content, line);\n}\n\n/**\n * Give node `comments` of the specified `type`.\n */\n\nexport function addComments(\n  this: NodePath,\n  type: t.CommentTypeShorthand,\n  comments: t.Comment[],\n) {\n  _addComments(this.node, type, comments);\n}\n"],"mappings":";;;;;;;;AAGA,IAAAA,EAAA,GAAAC,OAAA;AAGsB;EAFpBC,UAAU,EAAIC,WAAW;EACzBC,WAAW,EAAIC;AAAY,IAAAL,EAAA;AAOtB,SAASM,yBAAyBA,CAAA,EAAiB;EAExD,IAAI,OAAO,IAAI,CAACC,GAAG,KAAK,QAAQ,EAAE;EAElC,MAAMC,IAAI,GAAG,IAAI,CAACA,IAAI;EACtB,IAAI,CAACA,IAAI,EAAE;EAEX,MAAMC,QAAQ,GAAGD,IAAI,CAACE,gBAAgB;EACtC,MAAMC,OAAO,GAAGH,IAAI,CAACI,eAAe;EACpC,IAAI,CAACH,QAAQ,IAAI,CAACE,OAAO,EAAE;EAE3B,MAAME,IAAI,GAAG,IAAI,CAACC,UAAU,CAAC,IAAI,CAACP,GAAG,GAAI,CAAC,CAAC;EAC3C,MAAMQ,IAAI,GAAG,IAAI,CAACD,UAAU,CAAC,IAAI,CAACP,GAAG,GAAI,CAAC,CAAC;EAC3C,MAAMS,OAAO,GAAGC,OAAO,CAACJ,IAAI,CAACL,IAAI,CAAC;EAClC,MAAMU,OAAO,GAAGD,OAAO,CAACF,IAAI,CAACP,IAAI,CAAC;EAElC,IAAIQ,OAAO,EAAE;IACX,IAAIL,OAAO,EAAE;MACXE,IAAI,CAACT,WAAW,CACd,UAAU,EACVe,gBAAgB,CAACR,OAAO,EAAEE,IAAI,CAACL,IAAI,CAACE,gBAAgB,CACtD,CAAC;IACH;IACA,IAAID,QAAQ,IAAI,CAACS,OAAO,EAAEL,IAAI,CAACT,WAAW,CAAC,UAAU,EAAEK,QAAQ,CAAC;EAClE;EACA,IAAIS,OAAO,EAAE;IACX,IAAIT,QAAQ,EAAE;MACZM,IAAI,CAACX,WAAW,CACd,SAAS,EACTe,gBAAgB,CAACV,QAAQ,EAAEM,IAAI,CAACP,IAAI,CAACI,eAAe,CACtD,CAAC;IACH;IACA,IAAID,OAAO,IAAI,CAACK,OAAO,EAAED,IAAI,CAACX,WAAW,CAAC,SAAS,EAAEO,OAAO,CAAC;EAC/D;AACF;AAEA,SAASQ,gBAAgBA,CAAIC,IAAS,EAAEC,QAAqB,EAAO;EAClE,IAAI,EAACA,QAAQ,YAARA,QAAQ,CAAEC,MAAM,GAAE,OAAOF,IAAI;EAClC,MAAMG,GAAG,GAAG,IAAIC,GAAG,CAACH,QAAQ,CAAC;EAC7B,OAAOD,IAAI,CAACK,MAAM,CAACC,EAAE,IAAI;IACvB,OAAO,CAACH,GAAG,CAACI,GAAG,CAACD,EAAE,CAAC;EACrB,CAAC,CAAC;AACJ;AAEO,SAASxB,UAAUA,CAExB0B,IAA4B,EAC5BC,OAAe,EACfC,IAAc,EACd;EACA3B,WAAW,CAAC,IAAI,CAACK,IAAI,EAAEoB,IAAI,EAAEC,OAAO,EAAEC,IAAI,CAAC;AAC7C;AAMO,SAAS1B,WAAWA,CAEzBwB,IAA4B,EAC5BG,QAAqB,EACrB;EACA1B,YAAY,CAAC,IAAI,CAACG,IAAI,EAAEoB,IAAI,EAAEG,QAAQ,CAAC;AACzC","ignoreList":[]}

frontend/node_modules/@babel/traverse/lib/path/inference/index.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._getTypeAnnotation = _getTypeAnnotation;
+exports.baseTypeStrictlyMatches = baseTypeStrictlyMatches;
+exports.couldBeBaseType = couldBeBaseType;
+exports.getTypeAnnotation = getTypeAnnotation;
+exports.isBaseType = isBaseType;
+exports.isGenericType = isGenericType;
+var inferers = require("./inferers.js");
+var _t = require("@babel/types");
+const {
+  anyTypeAnnotation,
+  isAnyTypeAnnotation,
+  isArrayTypeAnnotation,
+  isBooleanTypeAnnotation,
+  isEmptyTypeAnnotation,
+  isFlowBaseAnnotation,
+  isGenericTypeAnnotation,
+  isIdentifier,
+  isMixedTypeAnnotation,
+  isNumberTypeAnnotation,
+  isStringTypeAnnotation,
+  isTSArrayType,
+  isTSTypeAnnotation,
+  isTSTypeReference,
+  isTupleTypeAnnotation,
+  isTypeAnnotation,
+  isUnionTypeAnnotation,
+  isVoidTypeAnnotation,
+  stringTypeAnnotation,
+  voidTypeAnnotation
+} = _t;
+function getTypeAnnotation() {
+  let type = this.getData("typeAnnotation");
+  if (type != null) {
+    return type;
+  }
+  type = _getTypeAnnotation.call(this) || anyTypeAnnotation();
+  if (isTypeAnnotation(type) || isTSTypeAnnotation(type)) {
+    type = type.typeAnnotation;
+  }
+  this.setData("typeAnnotation", type);
+  return type;
+}
+const typeAnnotationInferringNodes = new WeakSet();
+function _getTypeAnnotation() {
+  const node = this.node;
+  if (!node) {
+    if (this.key === "init" && this.parentPath.isVariableDeclarator()) {
+      const declar = this.parentPath.parentPath;
+      const declarParent = declar.parentPath;
+      if (declar.key === "left" && declarParent.isForInStatement()) {
+        return stringTypeAnnotation();
+      }
+      if (declar.key === "left" && declarParent.isForOfStatement()) {
+        return anyTypeAnnotation();
+      }
+      return voidTypeAnnotation();
+    } else {
+      return;
+    }
+  }
+  if (node.typeAnnotation) {
+    return node.typeAnnotation;
+  }
+  if (typeAnnotationInferringNodes.has(node)) {
+    return;
+  }
+  typeAnnotationInferringNodes.add(node);
+  try {
+    var _inferer;
+    let inferer = inferers[node.type];
+    if (inferer) {
+      return inferer.call(this, node);
+    }
+    inferer = inferers[this.parentPath.type];
+    if ((_inferer = inferer) != null && _inferer.validParent) {
+      return this.parentPath.getTypeAnnotation();
+    }
+  } finally {
+    typeAnnotationInferringNodes.delete(node);
+  }
+}
+function isBaseType(baseName, soft) {
+  return _isBaseType(baseName, this.getTypeAnnotation(), soft);
+}
+function _isBaseType(baseName, type, soft) {
+  if (baseName === "string") {
+    return isStringTypeAnnotation(type);
+  } else if (baseName === "number") {
+    return isNumberTypeAnnotation(type);
+  } else if (baseName === "boolean") {
+    return isBooleanTypeAnnotation(type);
+  } else if (baseName === "any") {
+    return isAnyTypeAnnotation(type);
+  } else if (baseName === "mixed") {
+    return isMixedTypeAnnotation(type);
+  } else if (baseName === "empty") {
+    return isEmptyTypeAnnotation(type);
+  } else if (baseName === "void") {
+    return isVoidTypeAnnotation(type);
+  } else {
+    if (soft) {
+      return false;
+    } else {
+      throw new Error(`Unknown base type ${baseName}`);
+    }
+  }
+}
+function couldBeBaseType(name) {
+  const type = this.getTypeAnnotation();
+  if (isAnyTypeAnnotation(type)) return true;
+  if (isUnionTypeAnnotation(type)) {
+    for (const type2 of type.types) {
+      if (isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
+        return true;
+      }
+    }
+    return false;
+  } else {
+    return _isBaseType(name, type, true);
+  }
+}
+function baseTypeStrictlyMatches(rightArg) {
+  const left = this.getTypeAnnotation();
+  const right = rightArg.getTypeAnnotation();
+  if (!isAnyTypeAnnotation(left) && isFlowBaseAnnotation(left)) {
+    return right.type === left.type;
+  }
+  return false;
+}
+function isGenericType(genericName) {
+  const type = this.getTypeAnnotation();
+  if (genericName === "Array") {
+    if (isTSArrayType(type) || isArrayTypeAnnotation(type) || isTupleTypeAnnotation(type)) {
+      return true;
+    }
+  }
+  return isGenericTypeAnnotation(type) && isIdentifier(type.id, {
+    name: genericName
+  }) || isTSTypeReference(type) && isIdentifier(type.typeName, {
+    name: genericName
+  });
+}
+
+//# sourceMappingURL=index.js.map

frontend/node_modules/@babel/traverse/lib/path/lib/removal-hooks.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hooks = void 0;
+const hooks = exports.hooks = [function (self, parent) {
+  const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
+  if (removeParent) {
+    parent.remove();
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {
+    parent.replaceWith(parent.node.expressions[0]);
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isBinary()) {
+    if (self.key === "left") {
+      parent.replaceWith(parent.node.right);
+    } else {
+      parent.replaceWith(parent.node.left);
+    }
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isIfStatement() && self.key === "consequent" || self.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) {
+    self.replaceWith({
+      type: "BlockStatement",
+      directives: [],
+      body: []
+    });
+    return true;
+  }
+}];
+
+//# sourceMappingURL=removal-hooks.js.map