Bump octokit/plugin-retry to v7.1.4

So that `octokit/request-error` can be bumped.

node_modules/@actions/artifact/node_modules/@octokit/auth-token/README.md

@@ -33,11 +33,11 @@ It is useful if you want to support multiple authentication strategies, as it’
 Browsers
 </th><td width=100%>
 
-Load `@octokit/auth-token` directly from [esm.sh](https://esm.sh)
+Load `@octokit/auth-token` directly from [cdn.skypack.dev](https://cdn.skypack.dev)
 
 ```html
 <script type="module">
-  import { createTokenAuth } from "https://esm.sh/@octokit/auth-token";
+  import { createTokenAuth } from "https://cdn.skypack.dev/@octokit/auth-token";
 </script>
 ```
 
@@ -49,7 +49,8 @@ Node
 Install with <code>npm install @octokit/auth-token</code>
 
 ```js
-import { createTokenAuth } from "@octokit/auth-token";
+const { createTokenAuth } = require("@octokit/auth-token");
+// or: import { createTokenAuth } from "@octokit/auth-token";
 ```
 
 </td></tr>
@@ -172,7 +173,7 @@ The `request` option is an instance of [`@octokit/request`](https://github.com/o
 ```js
 const { data: authorizations } = await auth.hook(
   request,
-  "GET /authorizations",
+  "GET /authorizations"
 );
 ```
 
@@ -204,12 +205,14 @@ const TOKEN = "ghp_PersonalAccessToken01245678900000000";
 const auth = createTokenAuth(TOKEN);
 const authentication = await auth();
 
-const response = await request("HEAD /");
+const response = await request("HEAD /", {
+  headers: authentication.headers,
+});
 const scopes = response.headers["x-oauth-scopes"].split(/,\s+/);
 
 if (scopes.length) {
   console.log(
-    `"${TOKEN}" has ${scopes.length} scopes enabled: ${scopes.join(", ")}`,
+    `"${TOKEN}" has ${scopes.length} scopes enabled: ${scopes.join(", ")}`
   );
 } else {
   console.log(`"${TOKEN}" has no scopes enabled`);
@@ -224,12 +227,14 @@ const TOKEN = "ghp_PersonalAccessToken01245678900000000";
 const auth = createTokenAuth(TOKEN);
 const authentication = await auth();
 
-const response = await request("HEAD /");
+const response = await request("HEAD /", {
+  headers: authentication.headers,
+});
 const clientId = response.headers["x-oauth-client-id"];
 
 if (clientId) {
   console.log(
-    `"${token}" is an OAuth token, its app’s client_id is ${clientId}.`,
+    `"${token}" is an OAuth token, its app’s client_id is ${clientId}.`
   );
 } else {
   console.log(`"${token}" is a personal access token`);
@@ -247,11 +252,12 @@ const auth = createTokenAuth(TOKEN);
 const authentication = await auth();
 
 const response = await request("GET /repos/{owner}/{repo}", {
-  owner: "octocat",
-  repo: "hello-world",
+  owner: 'octocat',
+  repo: 'hello-world'
+  headers: authentication.headers
 });
 
-console.log(response.data.permissions);
+console.log(response.data.permissions)
 // {
 //   admin: true,
 //   push: true,

node_modules/@actions/artifact/node_modules/@octokit/auth-token/dist-src/auth.js

@@ -0,0 +1,21 @@
+const REGEX_IS_INSTALLATION_LEGACY = /^v1\./;
+const REGEX_IS_INSTALLATION = /^ghs_/;
+const REGEX_IS_USER_TO_SERVER = /^ghu_/;
+export async function auth(token) {
+    const isApp = token.split(/\./).length === 3;
+    const isInstallation = REGEX_IS_INSTALLATION_LEGACY.test(token) ||
+        REGEX_IS_INSTALLATION.test(token);
+    const isUserToServer = REGEX_IS_USER_TO_SERVER.test(token);
+    const tokenType = isApp
+        ? "app"
+        : isInstallation
+            ? "installation"
+            : isUserToServer
+                ? "user-to-server"
+                : "oauth";
+    return {
+        type: "token",
+        token: token,
+        tokenType,
+    };
+}

node_modules/@actions/artifact/node_modules/@octokit/auth-token/dist-src/hook.js

@@ -0,0 +1,6 @@
+import { withAuthorizationPrefix } from "./with-authorization-prefix";
+export async function hook(token, request, route, parameters) {
+    const endpoint = request.endpoint.merge(route, parameters);
+    endpoint.headers.authorization = withAuthorizationPrefix(token);
+    return request(endpoint);
+}

node_modules/@actions/artifact/node_modules/@octokit/auth-token/dist-src/index.js

@@ -0,0 +1,14 @@
+import { auth } from "./auth";
+import { hook } from "./hook";
+export const createTokenAuth = function createTokenAuth(token) {
+    if (!token) {
+        throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
+    }
+    if (typeof token !== "string") {
+        throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string");
+    }
+    token = token.replace(/^(token|bearer) +/i, "");
+    return Object.assign(auth.bind(null, token), {
+        hook: hook.bind(null, token),
+    });
+};

node_modules/@actions/artifact/node_modules/@octokit/auth-token/dist-src/with-authorization-prefix.js

@@ -0,0 +1,11 @@
+/**
+ * Prefix token for usage in the Authorization header
+ *
+ * @param token OAuth token or JSON Web Token
+ */
+export function withAuthorizationPrefix(token) {
+    if (token.split(/\./).length === 3) {
+        return `bearer ${token}`;
+    }
+    return `token ${token}`;
+}

node_modules/@actions/artifact/node_modules/@octokit/auth-token/dist-types/auth.d.ts

@@ -1,2 +1,2 @@
-import type { Token, Authentication } from "./types.js";
+import { Token, Authentication } from "./types";
 export declare function auth(token: Token): Promise<Authentication>;

node_modules/@actions/artifact/node_modules/@octokit/auth-token/dist-types/hook.d.ts

@@ -1,2 +1,2 @@
-import type { AnyResponse, EndpointOptions, RequestInterface, RequestParameters, Route, Token } from "./types.js";
+import { AnyResponse, EndpointOptions, RequestInterface, RequestParameters, Route, Token } from "./types";
 export declare function hook(token: Token, request: RequestInterface, route: Route | EndpointOptions, parameters?: RequestParameters): Promise<AnyResponse>;

node_modules/@actions/artifact/node_modules/@octokit/auth-token/dist-types/index.d.ts

@@ -1,5 +1,5 @@
-import type { StrategyInterface, Token, Authentication } from "./types.js";
-export type Types = {
+import { StrategyInterface, Token, Authentication } from "./types";
+export declare type Types = {
     StrategyOptions: Token;
     AuthOptions: never;
     Authentication: Authentication;

node_modules/@actions/artifact/node_modules/@octokit/auth-token/dist-types/types.d.ts

@@ -0,0 +1,33 @@
+import * as OctokitTypes from "@octokit/types";
+export declare type AnyResponse = OctokitTypes.OctokitResponse<any>;
+export declare type StrategyInterface = OctokitTypes.StrategyInterface<[
+    Token
+], [
+], Authentication>;
+export declare type EndpointDefaults = OctokitTypes.EndpointDefaults;
+export declare type EndpointOptions = OctokitTypes.EndpointOptions;
+export declare type RequestParameters = OctokitTypes.RequestParameters;
+export declare type RequestInterface = OctokitTypes.RequestInterface;
+export declare type Route = OctokitTypes.Route;
+export declare type Token = string;
+export declare type OAuthTokenAuthentication = {
+    type: "token";
+    tokenType: "oauth";
+    token: Token;
+};
+export declare type InstallationTokenAuthentication = {
+    type: "token";
+    tokenType: "installation";
+    token: Token;
+};
+export declare type AppAuthentication = {
+    type: "token";
+    tokenType: "app";
+    token: Token;
+};
+export declare type UserToServerAuthentication = {
+    type: "token";
+    tokenType: "user-to-server";
+    token: Token;
+};
+export declare type Authentication = OAuthTokenAuthentication | InstallationTokenAuthentication | AppAuthentication | UserToServerAuthentication;

node_modules/@actions/artifact/node_modules/@octokit/auth-token/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@octokit/auth-token",
+  "description": "GitHub API token authentication for browsers and Node.js",
+  "version": "2.5.0",
+  "license": "MIT",
+  "files": [
+    "dist-*/",
+    "bin/"
+  ],
+  "pika": true,
+  "sideEffects": false,
+  "keywords": [
+    "github",
+    "octokit",
+    "authentication",
+    "api"
+  ],
+  "repository": "github:octokit/auth-token.js",
+  "dependencies": {
+    "@octokit/types": "^6.0.3"
+  },
+  "devDependencies": {
+    "@octokit/core": "^3.0.0",
+    "@octokit/request": "^5.3.0",
+    "@pika/pack": "^0.5.0",
+    "@pika/plugin-build-node": "^0.9.0",
+    "@pika/plugin-build-web": "^0.9.0",
+    "@pika/plugin-ts-standard-pkg": "^0.9.0",
+    "@types/fetch-mock": "^7.3.1",
+    "@types/jest": "^27.0.0",
+    "fetch-mock": "^9.0.0",
+    "jest": "^27.0.0",
+    "prettier": "2.4.1",
+    "semantic-release": "^17.0.0",
+    "ts-jest": "^27.0.0-next.12",
+    "typescript": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "source": "dist-src/index.js",
+  "types": "dist-types/index.d.ts",
+  "main": "dist-node/index.js",
+  "module": "dist-web/index.js"
+}

node_modules/@actions/artifact/node_modules/@octokit/core/README.md

@@ -3,7 +3,7 @@
 > Extendable client for GitHub's REST & GraphQL APIs
 
 [![@latest](https://img.shields.io/npm/v/@octokit/core.svg)](https://www.npmjs.com/package/@octokit/core)
-[![Build Status](https://github.com/octokit/core.js/workflows/Test/badge.svg)](https://github.com/octokit/core.js/actions?query=workflow%3ATest+branch%3Amain)
+[![Build Status](https://github.com/octokit/core.js/workflows/Test/badge.svg)](https://github.com/octokit/core.js/actions?query=workflow%3ATest+branch%3Amaster)
 
 <!-- toc -->
 
@@ -32,11 +32,11 @@ If you don't need the Plugin API then using [`@octokit/request`](https://github.
 <tr><th>
 Browsers
 </th><td width=100%>
-Load <code>@octokit/core</code> directly from <a href="https://esm.sh">esm.sh</a>
-
+Load <code>@octokit/core</code> directly from <a href="https://cdn.skypack.dev">cdn.skypack.dev</a>
+        
 ```html
 <script type="module">
-  import { Octokit } from "https://esm.sh/@octokit/core";
+import { Octokit } from "https://cdn.skypack.dev/@octokit/core";
 </script>
 ```
 
@@ -48,15 +48,14 @@ Node
 Install with <code>npm install @octokit/core</code>
 
 ```js
-import { Octokit } from "@octokit/core";
+const { Octokit } = require("@octokit/core");
+// or: import { Octokit } from "@octokit/core";
 ```
 
 </td></tr>
 </tbody>
 </table>
 
-As we use [conditional exports](https://nodejs.org/api/packages.html#conditional-exports), you will need to adapt your `tsconfig.json`. See the TypeScript docs on [package.json "exports"](https://www.typescriptlang.org/docs/handbook/modules/reference.html#packagejson-exports).
-
 ### REST API example
 
 ```js
@@ -84,7 +83,7 @@ const response = await octokit.graphql(
       }
     }
   }`,
-  { login: "octokit" },
+  { login: "octokit" }
 );
 ```
 
@@ -167,7 +166,7 @@ octokit.request("POST /repos/{owner}/{repo}/pulls", {
   owner,
   repo,
   title: "My pull request",
-  base: "main",
+  base: "master",
   head: "my-feature",
   draft: true,
 });
@@ -272,7 +271,7 @@ If you need a deep or conditional merge, you can pass a function instead.
 ```js
 const MyOctokit = Octokit.defaults((options) => {
   return {
-    foo: Object.assign({}, options.foo, { opt1: 1 }),
+    foo: Object.assign({}, options.foo, { opt2: 1 }),
   };
 });
 const octokit = new MyOctokit({
@@ -343,9 +342,8 @@ This is useful if you build reusable [plugins](#plugins).
 If you would like to make the log level configurable using an environment variable or external option, we recommend the [console-log-level](https://github.com/watson/console-log-level) package. Example
 
 ```js
-import consoleLogLevel from "console-log-level";
 const octokit = new Octokit({
-  log: consoleLogLevel({ level: "info" }),
+  log: require("console-log-level")({ level: "info" }),
 });
 ```
 
@@ -384,16 +382,14 @@ A plugin is a function which gets two arguments:
 1. the current instance
 2. the options passed to the constructor.
 
-In order to extend `octokit`'s API, the plugin must return an object with the new methods. Please refrain from adding methods directly to the `octokit` instance, especialy if you depend on keys that do not exist in `@octokit/core`, such as `octokit.rest`.
+In order to extend `octokit`'s API, the plugin must return an object with the new methods.
 
 ```js
 // index.js
-import { Octokit } from "@octokit/core";
-import myPlugin from "./lib/my-plugin.js";
-import octokitPluginExample from "octokit-plugin-example";
+const { Octokit } = require("@octokit/core")
 const MyOctokit = Octokit.plugin(
-  myPlugin,
-  octokitPluginExample
+  require("./lib/my-plugin"),
+  require("octokit-plugin-example")
 );
 
 const octokit = new MyOctokit({ greeting: "Moin moin" });
@@ -401,7 +397,7 @@ octokit.helloWorld(); // logs "Moin moin, world!"
 octokit.request("GET /"); // logs "GET / - 200 in 123ms"
 
 // lib/my-plugin.js
-const plugin = (octokit, options = { greeting: "Hello" }) => {
+module.exports = (octokit, options = { greeting: "Hello" }) => {
   // hook into the request lifecycle
   octokit.hook.wrap("request", async (request, options) => {
     const time = Date.now();
@@ -418,7 +414,6 @@ const plugin = (octokit, options = { greeting: "Hello" }) => {
     helloWorld: () => console.log(`${options.greeting}, world!`);
   }
 };
-export default plugin;
 ```
 
 ## Build your own Octokit with Plugins and Defaults
@@ -426,15 +421,11 @@ export default plugin;
 You can build your own Octokit class with preset default options and plugins. In fact, this is mostly how the `@octokit/<context>` modules work, such as [`@octokit/action`](https://github.com/octokit/action.js):
 
 ```js
-import { Octokit } from "@octokit/core";
-import { paginateRest } from "@octokit/plugin-paginate-rest";
-import { throttling } from "@octokit/plugin-throttling";
-import { retry } from "@octokit/plugin-retry";
-import { createActionAuth } from "@octokit/auth-action";
+const { Octokit } = require("@octokit/core");
 const MyActionOctokit = Octokit.plugin(
-  paginateRest,
-  throttling,
-  retry,
+  require("@octokit/plugin-paginate-rest").paginateRest,
+  require("@octokit/plugin-throttling").throttling,
+  require("@octokit/plugin-retry").retry
 ).defaults({
   throttle: {
     onAbuseLimit: (retryAfter, options) => {
@@ -444,7 +435,7 @@ const MyActionOctokit = Octokit.plugin(
       /* ... */
     },
   },
-  authStrategy: createActionAuth,
+  authStrategy: require("@octokit/auth-action").createActionAuth,
   userAgent: `my-octokit-action/v1.2.3`,
 });
 

node_modules/@actions/artifact/node_modules/@octokit/core/dist-src/index.js

@@ -0,0 +1,125 @@
+import { getUserAgent } from "universal-user-agent";
+import { Collection } from "before-after-hook";
+import { request } from "@octokit/request";
+import { withCustomRequest } from "@octokit/graphql";
+import { createTokenAuth } from "@octokit/auth-token";
+import { VERSION } from "./version";
+export class Octokit {
+    constructor(options = {}) {
+        const hook = new Collection();
+        const requestDefaults = {
+            baseUrl: request.endpoint.DEFAULTS.baseUrl,
+            headers: {},
+            request: Object.assign({}, options.request, {
+                // @ts-ignore internal usage only, no need to type
+                hook: hook.bind(null, "request"),
+            }),
+            mediaType: {
+                previews: [],
+                format: "",
+            },
+        };
+        // prepend default user agent with `options.userAgent` if set
+        requestDefaults.headers["user-agent"] = [
+            options.userAgent,
+            `octokit-core.js/${VERSION} ${getUserAgent()}`,
+        ]
+            .filter(Boolean)
+            .join(" ");
+        if (options.baseUrl) {
+            requestDefaults.baseUrl = options.baseUrl;
+        }
+        if (options.previews) {
+            requestDefaults.mediaType.previews = options.previews;
+        }
+        if (options.timeZone) {
+            requestDefaults.headers["time-zone"] = options.timeZone;
+        }
+        this.request = request.defaults(requestDefaults);
+        this.graphql = withCustomRequest(this.request).defaults(requestDefaults);
+        this.log = Object.assign({
+            debug: () => { },
+            info: () => { },
+            warn: console.warn.bind(console),
+            error: console.error.bind(console),
+        }, options.log);
+        this.hook = hook;
+        // (1) If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance
+        //     is unauthenticated. The `this.auth()` method is a no-op and no request hook is registered.
+        // (2) If only `options.auth` is set, use the default token authentication strategy.
+        // (3) If `options.authStrategy` is set then use it and pass in `options.auth`. Always pass own request as many strategies accept a custom request instance.
+        // TODO: type `options.auth` based on `options.authStrategy`.
+        if (!options.authStrategy) {
+            if (!options.auth) {
+                // (1)
+                this.auth = async () => ({
+                    type: "unauthenticated",
+                });
+            }
+            else {
+                // (2)
+                const auth = createTokenAuth(options.auth);
+                // @ts-ignore  ¯\_(ツ)_/¯
+                hook.wrap("request", auth.hook);
+                this.auth = auth;
+            }
+        }
+        else {
+            const { authStrategy, ...otherOptions } = options;
+            const auth = authStrategy(Object.assign({
+                request: this.request,
+                log: this.log,
+                // we pass the current octokit instance as well as its constructor options
+                // to allow for authentication strategies that return a new octokit instance
+                // that shares the same internal state as the current one. The original
+                // requirement for this was the "event-octokit" authentication strategy
+                // of https://github.com/probot/octokit-auth-probot.
+                octokit: this,
+                octokitOptions: otherOptions,
+            }, options.auth));
+            // @ts-ignore  ¯\_(ツ)_/¯
+            hook.wrap("request", auth.hook);
+            this.auth = auth;
+        }
+        // apply plugins
+        // https://stackoverflow.com/a/16345172
+        const classConstructor = this.constructor;
+        classConstructor.plugins.forEach((plugin) => {
+            Object.assign(this, plugin(this, options));
+        });
+    }
+    static defaults(defaults) {
+        const OctokitWithDefaults = class extends this {
+            constructor(...args) {
+                const options = args[0] || {};
+                if (typeof defaults === "function") {
+                    super(defaults(options));
+                    return;
+                }
+                super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent
+                    ? {
+                        userAgent: `${options.userAgent} ${defaults.userAgent}`,
+                    }
+                    : null));
+            }
+        };
+        return OctokitWithDefaults;
+    }
+    /**
+     * Attach a plugin (or many) to your Octokit instance.
+     *
+     * @example
+     * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
+     */
+    static plugin(...newPlugins) {
+        var _a;
+        const currentPlugins = this.plugins;
+        const NewOctokit = (_a = class extends this {
+            },
+            _a.plugins = currentPlugins.concat(newPlugins.filter((plugin) => !currentPlugins.includes(plugin))),
+            _a);
+        return NewOctokit;
+    }
+}
+Octokit.VERSION = VERSION;
+Octokit.plugins = [];

node_modules/@actions/artifact/node_modules/@octokit/core/dist-src/version.js

@@ -0,0 +1 @@
+export const VERSION = "3.6.0";

node_modules/@actions/artifact/node_modules/@octokit/core/dist-types/index.d.ts

@@ -1,8 +1,7 @@
-import type { HookCollection } from "before-after-hook";
+import { HookCollection } from "before-after-hook";
 import { request } from "@octokit/request";
-import { type graphql } from "@octokit/graphql";
-import type { Constructor, Hooks, OctokitOptions, OctokitPlugin, ReturnTypeOf, UnionToIntersection } from "./types.js";
-export type { OctokitOptions } from "./types.js";
+import { graphql } from "@octokit/graphql";
+import { Constructor, Hooks, OctokitOptions, OctokitPlugin, ReturnTypeOf, UnionToIntersection } from "./types";
 export declare class Octokit {
     static VERSION: string;
     static defaults<S extends Constructor<any>>(this: S, defaults: OctokitOptions | Function): S;

node_modules/@actions/artifact/node_modules/@octokit/core/dist-types/types.d.ts

@@ -1,7 +1,7 @@
-import type * as OctokitTypes from "@octokit/types";
-import type { RequestError } from "@octokit/request-error";
-import type { Octokit } from "./index.js";
-export type RequestParameters = OctokitTypes.RequestParameters;
+import * as OctokitTypes from "@octokit/types";
+import { RequestError } from "@octokit/request-error";
+import { Octokit } from ".";
+export declare type RequestParameters = OctokitTypes.RequestParameters;
 export interface OctokitOptions {
     authStrategy?: any;
     auth?: any;
@@ -18,18 +18,18 @@ export interface OctokitOptions {
     timeZone?: string;
     [option: string]: any;
 }
-export type Constructor<T> = new (...args: any[]) => T;
-export type ReturnTypeOf<T extends AnyFunction | AnyFunction[]> = T extends AnyFunction ? ReturnType<T> : T extends AnyFunction[] ? UnionToIntersection<Exclude<ReturnType<T[number]>, void>> : never;
+export declare type Constructor<T> = new (...args: any[]) => T;
+export declare type ReturnTypeOf<T extends AnyFunction | AnyFunction[]> = T extends AnyFunction ? ReturnType<T> : T extends AnyFunction[] ? UnionToIntersection<Exclude<ReturnType<T[number]>, void>> : never;
 /**
  * @author https://stackoverflow.com/users/2887218/jcalz
  * @see https://stackoverflow.com/a/50375286/10325032
  */
-export type UnionToIntersection<Union> = (Union extends any ? (argument: Union) => void : never) extends (argument: infer Intersection) => void ? Intersection : never;
-type AnyFunction = (...args: any) => any;
-export type OctokitPlugin = (octokit: Octokit, options: OctokitOptions) => {
+export declare type UnionToIntersection<Union> = (Union extends any ? (argument: Union) => void : never) extends (argument: infer Intersection) => void ? Intersection : never;
+declare type AnyFunction = (...args: any) => any;
+export declare type OctokitPlugin = (octokit: Octokit, options: OctokitOptions) => {
     [key: string]: any;
 } | void;
-export type Hooks = {
+export declare type Hooks = {
     request: {
         Options: Required<OctokitTypes.EndpointDefaults>;
         Result: OctokitTypes.OctokitResponse<any>;

node_modules/@actions/artifact/node_modules/@octokit/core/dist-types/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "3.6.0";

node_modules/@actions/artifact/node_modules/@octokit/core/node_modules/@octokit/request-error/README.md

@@ -12,11 +12,11 @@
 <tr><th>
 Browsers
 </th><td width=100%>
-Load <code>@octokit/request-error</code> directly from <a href="https://esm.sh">esm.sh</a>
+Load <code>@octokit/request-error</code> directly from <a href="https://cdn.skypack.dev">cdn.skypack.dev</a>
         
 ```html
 <script type="module">
-import { RequestError } from "https://esm.sh/@octokit/request-error";
+import { RequestError } from "https://cdn.skypack.dev/@octokit/request-error";
 </script>
 ```
 
@@ -38,6 +38,9 @@ const { RequestError } = require("@octokit/request-error");
 
 ```js
 const error = new RequestError("Oops", 500, {
+  headers: {
+    "x-github-request-id": "1:2:3:4",
+  }, // response headers
   request: {
     method: "POST",
     url: "https://api.github.com/foo",
@@ -48,41 +51,17 @@ const error = new RequestError("Oops", 500, {
       authorization: "token secret123",
     },
   },
-  response: {
-    status: 500,
-    url: "https://api.github.com/foo",
-    headers: {
-      "x-github-request-id": "1:2:3:4",
-    },
-    data: {
-      foo: "bar",
-    },
-  },
 });
 
 error.message; // Oops
 error.status; // 500
-error.request; // { method, url, headers, body }
+error.request.method; // POST
+error.request.url; // https://api.github.com/foo
+error.request.body; // { bar: 'baz' }
+error.request.headers; // { authorization: 'token [REDACTED]' }
 error.response; // { url, status, headers, data }
 ```
 
-### Usage with Octokit
-
-```js
-try {
-  // your code here that sends at least one Octokit request
-  await octokit.request("GET /");
-} catch (error) {
-  // Octokit errors always have a `error.status` property which is the http response code
-  if (error.status) {
-    // handle Octokit error
-  } else {
-    // handle all other errors
-    throw error;
-  }
-}
-```
-
 ## LICENSE
 
 [MIT](LICENSE)

node_modules/@actions/artifact/node_modules/@octokit/core/node_modules/@octokit/request-error/dist-src/index.js

@@ -0,0 +1,55 @@
+import { Deprecation } from "deprecation";
+import once from "once";
+const logOnceCode = once((deprecation) => console.warn(deprecation));
+const logOnceHeaders = once((deprecation) => console.warn(deprecation));
+/**
+ * Error with extra properties to help with debugging
+ */
+export class RequestError extends Error {
+    constructor(message, statusCode, options) {
+        super(message);
+        // Maintains proper stack trace (only available on V8)
+        /* istanbul ignore next */
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        this.name = "HttpError";
+        this.status = statusCode;
+        let headers;
+        if ("headers" in options && typeof options.headers !== "undefined") {
+            headers = options.headers;
+        }
+        if ("response" in options) {
+            this.response = options.response;
+            headers = options.response.headers;
+        }
+        // redact request credentials without mutating original request options
+        const requestCopy = Object.assign({}, options.request);
+        if (options.request.headers.authorization) {
+            requestCopy.headers = Object.assign({}, options.request.headers, {
+                authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]"),
+            });
+        }
+        requestCopy.url = requestCopy.url
+            // client_id & client_secret can be passed as URL query parameters to increase rate limit
+            // see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications
+            .replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]")
+            // OAuth tokens can be passed as URL query parameters, although it is not recommended
+            // see https://developer.github.com/v3/#oauth2-token-sent-in-a-header
+            .replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
+        this.request = requestCopy;
+        // deprecations
+        Object.defineProperty(this, "code", {
+            get() {
+                logOnceCode(new Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`."));
+                return statusCode;
+            },
+        });
+        Object.defineProperty(this, "headers", {
+            get() {
+                logOnceHeaders(new Deprecation("[@octokit/request-error] `error.headers` is deprecated, use `error.response.headers`."));
+                return headers || {};
+            },
+        });
+    }
+}

node_modules/@actions/artifact/node_modules/@octokit/core/node_modules/@octokit/request-error/dist-types/index.d.ts

@@ -1,5 +1,5 @@
-import type { RequestOptions, ResponseHeaders, OctokitResponse } from "@octokit/types";
-import type { RequestErrorOptions } from "./types";
+import { RequestOptions, ResponseHeaders, OctokitResponse } from "@octokit/types";
+import { RequestErrorOptions } from "./types";
 /**
  * Error with extra properties to help with debugging
  */

node_modules/@actions/artifact/node_modules/@octokit/core/node_modules/@octokit/request-error/dist-types/types.d.ts

@@ -1,5 +1,5 @@
-import type { RequestOptions, ResponseHeaders, OctokitResponse } from "@octokit/types";
-export type RequestErrorOptions = {
+import { RequestOptions, ResponseHeaders, OctokitResponse } from "@octokit/types";
+export declare type RequestErrorOptions = {
     /** @deprecated set `response` instead */
     headers?: ResponseHeaders;
     request: RequestOptions;

node_modules/@actions/artifact/node_modules/@octokit/core/node_modules/@octokit/request-error/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@octokit/request-error",
+  "description": "Error class for Octokit request errors",
+  "version": "2.1.0",
+  "license": "MIT",
+  "files": [
+    "dist-*/",
+    "bin/"
+  ],
+  "pika": true,
+  "sideEffects": false,
+  "keywords": [
+    "octokit",
+    "github",
+    "api",
+    "error"
+  ],
+  "repository": "github:octokit/request-error.js",
+  "dependencies": {
+    "@octokit/types": "^6.0.3",
+    "deprecation": "^2.0.0",
+    "once": "^1.4.0"
+  },
+  "devDependencies": {
+    "@pika/pack": "^0.5.0",
+    "@pika/plugin-build-node": "^0.9.0",
+    "@pika/plugin-build-web": "^0.9.0",
+    "@pika/plugin-bundle-web": "^0.9.0",
+    "@pika/plugin-ts-standard-pkg": "^0.9.0",
+    "@types/jest": "^26.0.0",
+    "@types/node": "^14.0.4",
+    "@types/once": "^1.4.0",
+    "jest": "^27.0.0",
+    "pika-plugin-unpkg-field": "^1.1.0",
+    "prettier": "2.3.1",
+    "semantic-release": "^17.0.0",
+    "ts-jest": "^27.0.0-next.12",
+    "typescript": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "source": "dist-src/index.js",
+  "types": "dist-types/index.d.ts",
+  "main": "dist-node/index.js",
+  "module": "dist-web/index.js"
+}