@tryghost/errors 1.2.26 → 1.3.0

package/cjs/GhostError.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var GhostError_exports = {};
+__export(GhostError_exports, {
+  GhostError: () => GhostError
+});
+module.exports = __toCommonJS(GhostError_exports);
+var import_uuid = require("uuid");
+var import_wrap_stack = require("./wrap-stack");
+class GhostError extends Error {
+  constructor(options = {}) {
+    super();
+    __publicField(this, "statusCode");
+    __publicField(this, "errorType");
+    __publicField(this, "level");
+    __publicField(this, "id");
+    __publicField(this, "context");
+    __publicField(this, "help");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    __publicField(this, "errorDetails");
+    __publicField(this, "code");
+    __publicField(this, "property");
+    __publicField(this, "redirect");
+    __publicField(this, "hideStack");
+    this.statusCode = 500;
+    this.errorType = "InternalServerError";
+    this.level = "normal";
+    this.message = "The server has encountered an error.";
+    this.id = (0, import_uuid.v1)();
+    this.id = options.id || this.id;
+    this.statusCode = options.statusCode || this.statusCode;
+    this.level = options.level || this.level;
+    this.context = options.context;
+    this.help = options.help;
+    this.errorType = this.name = options.errorType || this.errorType;
+    this.errorDetails = options.errorDetails;
+    this.code = options.code || null;
+    this.property = options.property || null;
+    this.redirect = options.redirect || null;
+    this.message = options.message || this.message;
+    this.hideStack = options.hideStack || false;
+    if (options.err) {
+      if (typeof options.err === "string") {
+        options.err = new Error(options.err);
+      }
+      Object.getOwnPropertyNames(options.err).forEach((property) => {
+        if (["errorType", "name", "statusCode", "message", "level"].indexOf(property) !== -1) {
+          return;
+        }
+        if (property === "code") {
+          this[property] = this[property] || options.err[property];
+          return;
+        }
+        if (property === "stack" && !this.hideStack) {
+          this[property] = (0, import_wrap_stack.wrapStack)(this, options.err);
+          return;
+        }
+        this[property] = options.err[property] || this[property];
+      });
+    }
+  }
+}

package/cjs/errors.js

@@ -0,0 +1,319 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  BadRequestError: () => BadRequestError,
+  ConflictError: () => ConflictError,
+  DataExportError: () => DataExportError,
+  DataImportError: () => DataImportError,
+  DisabledFeatureError: () => DisabledFeatureError,
+  EmailError: () => EmailError,
+  HelperWarning: () => HelperWarning,
+  HostLimitError: () => HostLimitError,
+  IncorrectUsageError: () => IncorrectUsageError,
+  InternalServerError: () => InternalServerError,
+  MaintenanceError: () => MaintenanceError,
+  MethodNotAllowedError: () => MethodNotAllowedError,
+  MigrationError: () => MigrationError,
+  NoContentError: () => NoContentError,
+  NoPermissionError: () => NoPermissionError,
+  NotFoundError: () => NotFoundError,
+  PasswordResetRequiredError: () => PasswordResetRequiredError,
+  RequestEntityTooLargeError: () => RequestEntityTooLargeError,
+  RequestNotAcceptableError: () => RequestNotAcceptableError,
+  ThemeValidationError: () => ThemeValidationError,
+  TokenRevocationError: () => TokenRevocationError,
+  TooManyRequestsError: () => TooManyRequestsError,
+  UnauthorizedError: () => UnauthorizedError,
+  UnhandledJobError: () => UnhandledJobError,
+  UnsupportedMediaTypeError: () => UnsupportedMediaTypeError,
+  UpdateCollisionError: () => UpdateCollisionError,
+  ValidationError: () => ValidationError,
+  VersionMismatchError: () => VersionMismatchError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_GhostError = require("./GhostError");
+const mergeOptions = (options, defaults) => {
+  const result = { ...defaults };
+  Object.keys(options).forEach((key) => {
+    if (options[key] !== void 0) {
+      result[key] = options[key];
+    }
+  });
+  return result;
+};
+class InternalServerError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 500,
+      level: "critical",
+      errorType: "InternalServerError",
+      message: "The server has encountered an error."
+    }));
+  }
+}
+class IncorrectUsageError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 400,
+      level: "critical",
+      errorType: "IncorrectUsageError",
+      message: "We detected a misuse. Please read the stack trace."
+    }));
+  }
+}
+class NotFoundError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 404,
+      errorType: "NotFoundError",
+      message: "Resource could not be found.",
+      hideStack: true
+    }));
+  }
+}
+class BadRequestError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 400,
+      errorType: "BadRequestError",
+      message: "The request could not be understood."
+    }));
+  }
+}
+class UnauthorizedError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 401,
+      errorType: "UnauthorizedError",
+      message: "You are not authorised to make this request."
+    }));
+  }
+}
+class NoPermissionError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 403,
+      errorType: "NoPermissionError",
+      message: "You do not have permission to perform this request."
+    }));
+  }
+}
+class ValidationError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 422,
+      errorType: "ValidationError",
+      message: "The request failed validation."
+    }));
+  }
+}
+class UnsupportedMediaTypeError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 415,
+      errorType: "UnsupportedMediaTypeError",
+      message: "The media in the request is not supported by the server."
+    }));
+  }
+}
+class TooManyRequestsError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 429,
+      errorType: "TooManyRequestsError",
+      message: "Server has received too many similar requests in a short space of time."
+    }));
+  }
+}
+class MaintenanceError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 503,
+      errorType: "MaintenanceError",
+      message: "The server is temporarily down for maintenance."
+    }));
+  }
+}
+class MethodNotAllowedError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 405,
+      errorType: "MethodNotAllowedError",
+      message: "Method not allowed for resource."
+    }));
+  }
+}
+class RequestNotAcceptableError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 406,
+      errorType: "RequestNotAcceptableError",
+      message: "Request not acceptable for provided Accept-Version header.",
+      hideStack: true
+    }));
+  }
+}
+class RequestEntityTooLargeError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 413,
+      errorType: "RequestEntityTooLargeError",
+      message: "Request was too big for the server to handle."
+    }));
+  }
+}
+class TokenRevocationError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 503,
+      errorType: "TokenRevocationError",
+      message: "Token is no longer available."
+    }));
+  }
+}
+class VersionMismatchError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 400,
+      errorType: "VersionMismatchError",
+      message: "Requested version does not match server version."
+    }));
+  }
+}
+class DataExportError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 500,
+      errorType: "DataExportError",
+      message: "The server encountered an error whilst exporting data."
+    }));
+  }
+}
+class DataImportError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 500,
+      errorType: "DataImportError",
+      message: "The server encountered an error whilst importing data."
+    }));
+  }
+}
+class EmailError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 500,
+      errorType: "EmailError",
+      message: "The server encountered an error whilst sending email."
+    }));
+  }
+}
+class ThemeValidationError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 422,
+      errorType: "ThemeValidationError",
+      message: "The theme has a validation error.",
+      errorDetails: {}
+    }));
+  }
+}
+class DisabledFeatureError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 409,
+      errorType: "DisabledFeatureError",
+      message: "Unable to complete the request, this feature is disabled."
+    }));
+  }
+}
+class UpdateCollisionError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 409,
+      errorType: "UpdateCollisionError",
+      message: "Unable to complete the request, there was a conflict."
+    }));
+  }
+}
+class HostLimitError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "HostLimitError",
+      hideStack: true,
+      statusCode: 403,
+      message: "Unable to complete the request, this resource is limited."
+    }));
+  }
+}
+class HelperWarning extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "HelperWarning",
+      hideStack: true,
+      statusCode: 400,
+      message: "A theme helper has done something unexpected."
+    }));
+  }
+}
+class PasswordResetRequiredError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "PasswordResetRequiredError",
+      statusCode: 401,
+      message: "For security, you need to create a new password. An email has been sent to you with instructions!"
+    }));
+  }
+}
+class UnhandledJobError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "UnhandledJobError",
+      message: "Processed job threw an unhandled error",
+      level: "critical"
+    }));
+  }
+}
+class NoContentError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "NoContentError",
+      statusCode: 204,
+      hideStack: true
+    }));
+  }
+}
+class ConflictError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "ConflictError",
+      statusCode: 409,
+      message: "The server has encountered an conflict."
+    }));
+  }
+}
+class MigrationError extends import_GhostError.GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "MigrationError",
+      message: "An error has occurred applying a database migration.",
+      level: "critical"
+    }));
+  }
+}

package/cjs/index.js

@@ -0,0 +1,45 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 src_exports = {};
+__export(src_exports, {
+  default: () => src_default,
+  utils: () => utils
+});
+module.exports = __toCommonJS(src_exports);
+var ghostErrors = __toESM(require("./errors"));
+var import_utils = require("./utils");
+__reExport(src_exports, require("./errors"), module.exports);
+var src_default = ghostErrors;
+const utils = {
+  serialize: import_utils.serialize,
+  deserialize: import_utils.deserialize,
+  isGhostError: import_utils.isGhostError,
+  prepareStackForUser: import_utils.prepareStackForUser
+};

package/cjs/utils.js

@@ -0,0 +1,204 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  deserialize: () => deserialize,
+  isGhostError: () => isGhostError,
+  prepareStackForUser: () => prepareStackForUser,
+  serialize: () => serialize
+});
+module.exports = __toCommonJS(utils_exports);
+var import_utils_copy = __toESM(require("@stdlib/utils-copy"));
+var import_GhostError = require("./GhostError");
+var errors = __toESM(require("./errors"));
+const errorsWithBase = { ...errors, GhostError: import_GhostError.GhostError };
+const _private = {
+  serialize(err) {
+    try {
+      return {
+        id: err.id,
+        status: err.statusCode,
+        code: err.code || err.errorType,
+        title: err.name,
+        detail: err.message,
+        meta: {
+          context: err.context,
+          help: err.help,
+          errorDetails: err.errorDetails,
+          level: err.level,
+          errorType: err.errorType
+        }
+      };
+    } catch (error) {
+      return {
+        detail: "Something went wrong."
+      };
+    }
+  },
+  deserialize(obj) {
+    return {
+      id: obj.id,
+      message: obj.detail || obj.error_description || obj.message,
+      statusCode: obj.status,
+      code: obj.code || obj.error,
+      level: obj.meta && obj.meta.level,
+      help: obj.meta && obj.meta.help,
+      context: obj.meta && obj.meta.context
+    };
+  },
+  /**
+   * @description Serialize error instance into oauth format.
+   *
+   * @see https://tools.ietf.org/html/rfc6749#page-45
+   *
+   * To not loose any error data when sending errors between internal services, we use the suggested OAuth properties and add ours as well.
+   */
+  OAuthSerialize(err) {
+    const matchTable = {
+      [errors.NoPermissionError.name]: "access_denied",
+      [errors.MaintenanceError.name]: "temporarily_unavailable",
+      [errors.BadRequestError.name]: "invalid_request",
+      [errors.ValidationError.name]: "invalid_request",
+      default: "server_error"
+    };
+    const { detail, code, ...properties } = _private.serialize(err);
+    return {
+      error: err.code || matchTable[err.name] || "server_error",
+      error_description: err.message,
+      ...properties
+    };
+  },
+  /**
+   * @description Deserialize oauth error format into GhostError instance.
+   * @constructor
+   */
+  OAuthDeserialize(errorFormat) {
+    try {
+      return new errorsWithBase[errorFormat.title || errorFormat.name || errors.InternalServerError.name](_private.deserialize(errorFormat));
+    } catch (err) {
+      return new errors.InternalServerError({
+        errorType: errorFormat.title || errorFormat.name,
+        ..._private.deserialize(errorFormat)
+      });
+    }
+  },
+  /**
+   * @description Serialize GhostError instance into jsonapi.org format.
+   * @param err
+   * @return {Object}
+   */
+  JSONAPISerialize(err) {
+    const errorFormat = {
+      errors: [_private.serialize(err)]
+    };
+    errorFormat.errors[0].source = {};
+    if (err.property) {
+      errorFormat.errors[0].source.pointer = "/data/attributes/" + err.property;
+    }
+    return errorFormat;
+  },
+  /**
+   * @description Deserialize JSON api format into GhostError instance.
+   */
+  JSONAPIDeserialize(errorFormat) {
+    errorFormat = errorFormat.errors && errorFormat.errors[0] || {};
+    let internalError;
+    try {
+      internalError = new errorsWithBase[errorFormat.title || errorFormat.name || errors.InternalServerError.name](_private.deserialize(errorFormat));
+    } catch (err) {
+      internalError = new errors.InternalServerError({
+        errorType: errorFormat.title || errorFormat.name,
+        ..._private.deserialize(errorFormat)
+      });
+    }
+    if (errorFormat.source && errorFormat.source.pointer) {
+      internalError.property = errorFormat.source.pointer.split("/")[3];
+    }
+    return internalError;
+  }
+};
+function serialize(err, options) {
+  options = options || { format: "jsonapi" };
+  let errorFormat = {};
+  try {
+    if (options.format === "jsonapi") {
+      errorFormat = _private.JSONAPISerialize(err);
+    } else {
+      errorFormat = _private.OAuthSerialize(err);
+    }
+  } catch (error) {
+    errorFormat.message = "Something went wrong.";
+  }
+  return errorFormat;
+}
+;
+function deserialize(errorFormat) {
+  let internalError = {};
+  if (errorFormat.errors) {
+    internalError = _private.JSONAPIDeserialize(errorFormat);
+  } else {
+    internalError = _private.OAuthDeserialize(errorFormat);
+  }
+  return internalError;
+}
+;
+function prepareStackForUser(error) {
+  const stackbits = error.stack?.split(/\n/) || [];
+  const hideStack = "hideStack" in error && error.hideStack;
+  if (hideStack) {
+    stackbits.splice(1, stackbits.length - 1);
+  } else {
+    stackbits.splice(1, 0, `Stack Trace:`);
+  }
+  if ("help" in error && error.help) {
+    stackbits.splice(1, 0, `${error.help}`);
+  }
+  if ("context" in error && error.context) {
+    stackbits.splice(1, 0, `${error.context}`);
+  }
+  const errorClone = (0, import_utils_copy.default)(error);
+  errorClone.stack = stackbits.join("\n");
+  return errorClone;
+}
+;
+function isGhostError(err) {
+  const errorName = import_GhostError.GhostError.name;
+  const legacyErrorName = "IgnitionError";
+  const recursiveIsGhostError = function recursiveIsGhostError2(obj) {
+    if (!obj || !obj.name) {
+      return false;
+    }
+    if (obj.name === errorName || obj.name === legacyErrorName) {
+      return true;
+    }
+    return recursiveIsGhostError2(Object.getPrototypeOf(obj));
+  };
+  return recursiveIsGhostError(err.constructor);
+}
+;

package/cjs/wrap-stack.js

@@ -0,0 +1,29 @@
+"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 wrap_stack_exports = {};
+__export(wrap_stack_exports, {
+  wrapStack: () => wrapStack
+});
+module.exports = __toCommonJS(wrap_stack_exports);
+function wrapStack(err, internalErr) {
+  const extraLine = (err.stack?.split(/\n/g) || [])[1];
+  const [firstLine, ...rest] = internalErr.stack?.split(/\n/g) || [];
+  return [firstLine, extraLine, ...rest].join("\n");
+}
+;