m3api-rest 0.1.0

package/.browserslistrc

@@ -0,0 +1,11 @@
+Node 18.2.0
+Chrome 63
+ChromeAndroid 63
+Firefox 60
+FirefoxAndroid 60
+Edge 79
+Opera 50
+# OperaAndroid 46 according to MDN but caniuse-lite situation confusing
+Safari 12
+ios_saf 12
+Samsung 12 # actually 8 but caniuse-lite only knows 12

package/CHANGES.md

@@ -0,0 +1,20 @@
+# Changelog
+
+This file records the changes in each m3api-rest release.
+
+The annotated tag (and GitLab release) for each version also lists the changes,
+but this file may sometimes contain later improvements (e.g. typo fixes).
+
+## v0.1.0 (2026-01-01)
+
+Initial release, including:
+
+- `getJson()` and `postForJson()` functions,
+  for making GET and POST requests returning JSON data.
+- ``` path`` ``` template literal tag function,
+  for encoding request paths.
+- `getResponseStatus()` function,
+  for getting the HTTP status code of a response.
+- `RestApiServerError`, `RestApiClientError`,
+  `UnexpectedResponseStatus`, `InvalidResponseBody`,
+  and `UnknownResponseError` error classes thrown by these functions.

package/CODE_OF_CONDUCT.md

@@ -0,0 +1 @@
+The development of this software is covered by a [Code of Conduct](https://www.mediawiki.org/wiki/Special:MyLanguage/Code_of_Conduct).

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2025 Lucas Werkmeister
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,156 @@
+# m3api-rest
+
+m3api-rest is an extension package for [m3api],
+allowing you to interact with the MediaWiki REST API.
+
+## Request functions
+
+m3api-rest includes functions to make GET and POST requests that return JSON responses.
+Other request methods and response content types will be added in future versions.
+All functions start with the HTTP method name (in lowercase);
+for GET functions, this is directly followed by the response type (e.g. `getJson`),
+while other functions have the word “for” in between (e.g. `postForJson`)
+to clarify that this is the response content type, not the request content type.
+(The content type of the request body is specified by the type of the body passed into the function;
+currently `postForJson` only supports `URLSearchParams` bodies,
+but in future versions the same function will support multiple body types.)
+
+### `getJson`
+
+Make a GET request for some JSON data.
+Usage examples:
+
+```js
+import Session from 'm3api';
+import { getJson, path } from 'm3api-rest';
+
+const session = new Session( 'en.wikipedia.org', {}, {
+	userAgent: 'm3api-rest-README-example',
+} );
+
+const title = 'Main page';
+const page = await getJson( session, path`/v1/page/${ title }` );
+console.log( page ); // { id: 217225, title: 'Main page', ... }
+```
+
+```js
+const searchResults = await getJson( session, '/v1/search/page', {
+	q: 'search query',
+	limit: 10,
+} );
+console.log( searchResults ); // { pages: [ { title: 'Web query', ... }, ... ] }
+```
+
+See also below for details on the different ways to specify parameters.
+
+### `postForJson`
+
+Make a POST request that will return some JSON data.
+Usage example:
+
+```js
+const wikitext = '== ==\nThis is <span id=id>bad</span> <span id=id>wikitext</span>.';
+const lints = await postForJson( session, '/v1/transform/wikitext/to/lint', new URLSearchParams( {
+	wikitext,
+} ) );
+console.log( lints ); // [ { type: 'empty-heading', ... }, { type: 'duplicate-ids', ... } ]
+```
+
+(Note that some endpoints, including `POST /v1/page`, cannot be used yet,
+because m3api-rest can currently only send `application/x-www-form-urlencoded` request bodies
+but those endpoints require `application/json`.
+This will be fixed in a future version.)
+
+## Specifying parameters
+
+REST API endpoints have different kinds of parameters.
+Many endpoints take parameters in the path, written like `/v1/page/{title}` (`title` is a parameter);
+many endpoints take query parameters after the path, like `/v1/search/page?q=search` (`q` is a parameter);
+and non-GET endpoints (POST etc.) take body parameters in several encodings.
+m3api-rest supports several ways to specify these parameters.
+
+### Path parameters
+
+Path parameters can be specified using a tagged template literal (string template)
+using the `path` function,
+which will encode the parameter value if necessary.
+
+```js
+import { path } from 'm3api-rest';
+
+const title = 'AC/DC';
+const url = path`/v1/page/${ title }`; // /v1/page/AC%2FDC
+```
+
+To use it, take the endpoint URL and change `{parameters}` to `${substitutions}`
+(or `${ substitutions }` with spaces, depending on your code style).
+
+Alternatively, you can pass the original endpoint URL into the request function unmodified,
+and the request function will pull the parameters out of the params passed into it.
+For example:
+
+```js
+const page = await getJson( session, '/v1/page/{title}', {
+	// this object contains the params for the request
+	title: 'AC/DC', // this is a path parameter
+	redirect: true, // this is a query parameter, see below
+} );
+// makes a request to /v1/page/AC%2FDC?redirect=true
+```
+
+### Query parameters
+
+The GET request functions, e.g. `getJson`, take an object with query parameters after the path:
+
+```js
+const searchResults = await getJson( session, '/v1/search/page', {
+	q: 'search query',
+	limit: 10,
+} );
+// makes a request to /v1/search/page?q=search%20query&limit=10
+```
+
+As mentioned above, you can also specify path parameters here.
+
+Request functions for other methods don’t take an object with query parameters,
+since they already take a request body.
+Instead, if the endpoint still takes query parameters (which is uncommon, but possible),
+you should pass them into the `path` as an object:
+
+```js
+const params = { fakeQueryParam: 'abc' };
+await postForJson( path`/v0/fake/endpoint?${ params }`, new URLSearchParams( {
+	fakeBodyParam: 'xyz',
+} ) );
+// makes a request to /v0/fake/endpoint?fakeQueryParam=abc with fakeBodyParam=xyz in the body
+```
+
+This is also possible for GET requests, but you should probably prefer passing the query parameters separately there.
+
+### Body parameters
+
+The non-GET request functions, e.g. `postForJson`, take a value for the body after the path.
+The type of the value encodes the content type with which the body will be sent.
+Currently, the only supported type is `URLSearchParams`,
+which will send the body as `application/x-www-form-urlencoded`;
+support for other body types
+(`FormData` for `multipart/form-data`, plain object for `application/json`)
+will be added in a future version.
+
+```js
+const lints = await postForJson( session, '/v1/transform/wikitext/to/lint', new URLSearchParams( {
+	wikitext: 'some wikitext',
+} ) );
+/// makes a request to /v1/transform/wikitext/to/lint with wikitext=some%20wikitext
+```
+
+As mentioned above, you can also specify path parameters here.
+
+## License
+
+Published under the [ISC License][].
+By contributing to this software,
+you agree to publish your contribution under the same license.
+
+[m3api]: https://www.npmjs.com/package/m3api
+[ISC License]: https://spdx.org/licenses/ISC.html

package/index.js

@@ -0,0 +1,471 @@
+/**
+ * An Error representing an HTTP 5xx response from the REST API.
+ */
+export class RestApiServerError extends Error {
+
+	/**
+	 * @param {number} status The invalid status code received from the API.
+	 * @param {string|Object} body The response body received from the API.
+	 */
+	constructor( status, body ) {
+		super( `REST API server error: ${ status }\n\n${ JSON.stringify( body ) }` );
+
+		if ( Error.captureStackTrace ) {
+			Error.captureStackTrace( this, RestApiServerError );
+		}
+
+		this.name = 'RestApiServerError';
+
+		/**
+		 * The invalid status code received from the API.
+		 *
+		 * @member {number}
+		 */
+		this.status = status;
+
+		/**
+		 * The body of the response.
+		 *
+		 * Depending on the response’s content type,
+		 * this may be a string or a JSON-decoded object.
+		 *
+		 * @member {string|Object}
+		 */
+		this.body = body;
+	}
+
+}
+
+/**
+ * An Error representing an HTTP 4xx response from the REST API.
+ */
+export class RestApiClientError extends Error {
+
+	/**
+	 * @param {number} status The invalid status code received from the API.
+	 * @param {string|Object} body The response body received from the API.
+	 */
+	constructor( status, body ) {
+		super( `REST API client error: ${ status }\n\n${ JSON.stringify( body ) }` );
+
+		if ( Error.captureStackTrace ) {
+			Error.captureStackTrace( this, RestApiClientError );
+		}
+
+		this.name = 'RestApiClientError';
+
+		/**
+		 * The invalid status code received from the API.
+		 *
+		 * @member {number}
+		 */
+		this.status = status;
+
+		/**
+		 * The body of the response.
+		 *
+		 * Depending on the response’s content type,
+		 * this may be a string or a JSON-decoded object.
+		 *
+		 * @member {string|Object}
+		 */
+		this.body = body;
+	}
+
+}
+
+/**
+ * An Error representing an unexpected HTTP response status (1xx or 3xx) from the REST API.
+ * 3xx responses are unexpected because the JavaScript runtime should have followed the redirect;
+ * 1xx responses are unexpected because it should have awaited the non-informational response.
+ */
+export class UnexpectedResponseStatus extends Error {
+
+	/**
+	 * @param {number} status The unexpected status code received from the API.
+	 * @param {string|Object} body The response body received from the API.
+	 */
+	constructor( status, body ) {
+		super( `Unexpected REST API response status: ${ status }\n\n${ JSON.stringify( body ) }` );
+
+		if ( Error.captureStackTrace ) {
+			Error.captureStackTrace( this, UnexpectedResponseStatus );
+		}
+
+		this.name = 'UnexpectedResponseStatus';
+
+		/**
+		 * The unexpected status code received from the API.
+		 *
+		 * @member {number}
+		 */
+		this.status = status;
+
+		/**
+		 * The body of the response.
+		 *
+		 * Depending on the response’s content type,
+		 * this may be a string or a JSON-decoded object.
+		 *
+		 * @member {string|Object}
+		 */
+		this.body = body;
+	}
+
+}
+
+/**
+ * An Error representing an invalid body in the REST API response.
+ */
+export class InvalidResponseBody extends Error {
+
+	/**
+	 * @param {*} body The invalid response body received from the API.
+	 */
+	constructor( body ) {
+		super( `Invalid REST API response body: ${ JSON.stringify( body ) }` );
+
+		if ( Error.captureStackTrace ) {
+			Error.captureStackTrace( this, InvalidResponseBody );
+		}
+
+		this.name = 'InvalidResponseBody';
+
+		/**
+		 * The body of the response.
+		 * Objects and arrays are expected response bodies,
+		 * so an unexpected body is probably some kind of primitive value,
+		 * such as a string, number or boolean.
+		 *
+		 * @member {*}
+		 */
+		this.body = body;
+	}
+
+}
+
+/**
+ * An Error thrown if {@link getResponseStatus} is called with an unknown response.
+ *
+ * {@link getResponseStatus} must be called with a value that was previously returned
+ * by one of the request functions ({@link getJson} etc.).
+ * If this error is thrown, then {@link getResponseStatus} was called with some other value,
+ * and the response status cannot be determined.
+ * This may be the result of calling the function incorrectly.
+ *
+ * The following example shows how {@link getResponseStatus} can be used correctly:
+ * ```
+ * const title = 'Main Page';
+ * const page = await getJson( session, path`/v1/page/${ title }/bare` );
+ * const status = getResponseStatus( page );
+ * const { id, latest } = page;
+ * ```
+ *
+ * For comparison, the following usage of {@link getResponseStatus} is **incorrect**:
+ * ```
+ * const title = 'Main Page';
+ * const { id, latest } = await getJson( session, path`/v1/page/${ title }/bare` );
+ * const status = getResponseStatus( { id, latest } ); // this does not work
+ * ```
+ */
+export class UnknownResponseError extends Error {
+
+	/**
+	 * @param {*} response The unknown response passed into {@link getResponseStatus}.
+	 */
+	constructor( response ) {
+		super( `Unknown REST API response: ${ JSON.stringify( response ) }` );
+
+		if ( Error.captureStackTrace ) {
+			Error.captureStackTrace( this, UnknownResponseError );
+		}
+
+		this.name = 'UnknownResponseError';
+
+		/**
+		 * The unknown response passed into {@link getResponseStatus}.
+		 *
+		 * @member {*}
+		 */
+		this.response = response;
+	}
+
+}
+
+/**
+ * An Error thrown if a request path contains an unsubstituted parameter.
+ *
+ * For example, if {@link getJson} is called with the path `/v1/page/{title}`,
+ * the `title` must be specified in the params, like this:
+ * ```
+ * const title = 'Main Page';
+ * const page = await getJson( session, '/v1/page/{title}', { title } );
+ * ```
+ *
+ * Alternatively, you can directly interpolate the title using {@link path}:
+ * ```
+ * const title = 'Main Page';
+ * const page = await getJson( session, path`/v1/page/${ title }` );
+ * ```
+ *
+ * But the following is invalid and will result in this error being thrown:
+ * ```
+ * const page = await getJson( session, '/v1/page/{title}' ); // which title?
+ * // ^ throws InvalidPathParams
+ * ```
+ *
+ * (Another, less common condition under which this error may be thrown
+ * is that a path parameter was assigned multiple values;
+ * this is possible with functions like {@link postForJson},
+ * where the params of type {@link URLSearchParams} can contain
+ * multiple values for the same name.)
+ */
+export class InvalidPathParams extends Error {
+
+	constructor( message, path, paramName, params ) {
+		super( message );
+
+		if ( Error.captureStackTrace ) {
+			Error.captureStackTrace( this, InvalidPathParams );
+		}
+
+		this.name = 'InvalidPathParams';
+
+		this.path = path;
+
+		this.paramName = paramName;
+
+		this.params = params;
+	}
+
+}
+
+/**
+ * Check the status code of the response and potentially throw an error based on it.
+ *
+ * @private
+ * @param {Object} internalResponse
+ */
+function checkResponseStatus( internalResponse ) {
+	const { status, body } = internalResponse;
+	if ( !Number.isInteger( status ) || status < 100 || status > 599 ) {
+		// invalid status: RFC 9110 section 15 says treat it like 5xx
+		throw new RestApiServerError( status, body );
+	}
+	if ( status >= 500 ) {
+		throw new RestApiServerError( status, body );
+	}
+	if ( status >= 400 ) {
+		throw new RestApiClientError( status, body );
+	}
+	if ( status < 200 || status >= 300 ) {
+		throw new UnexpectedResponseStatus( status, body );
+	}
+}
+
+const responseStatuses = new WeakMap();
+
+/**
+ * Get the HTTP status code for this response.
+ *
+ * @param {Object|Array} response A response object returned by one of the request functions
+ * ({@link getJson} etc.). Note that it must be exactly the object returned by the function
+ * (compared by identity, i.e. `===`), not a serialization of it or anything similar.
+ * @return {number} The HTTP status code, i.e. an integer between 100 and 599.
+ * (And for a successful response, really only between 200 and 299.)
+ */
+export function getResponseStatus( response ) {
+	const status = responseStatuses.get( response );
+	if ( status === undefined ) {
+		throw new UnknownResponseError( response );
+	}
+	return status;
+}
+
+/**
+ * Get the body of the response and check that it’s valid JSON.
+ *
+ * @private
+ * @param {Object} internalResponse
+ * @return {Object|Array}
+ */
+function getResponseJson( internalResponse ) {
+	const { status, body } = internalResponse;
+	if ( typeof body === 'object' && body !== null ) {
+		responseStatuses.set( body, status );
+		return body;
+	} else {
+		throw new InvalidResponseBody( body );
+	}
+}
+
+/**
+ * Encode a path for a REST API endpoint.
+ *
+ * This function should be used as a tag for a tagged template literal (template string).
+ * Usage example:
+ * ```
+ * const title = 'AC/DC';
+ * const json = await getJson( session, path`/v1/page/${ title }` );
+ * // makes a request to /v1/page/AC%2FDC
+ * ```
+ *
+ * Each parameter in the template can either be a string or an object of query params,
+ * for example:
+ * ```
+ * const id = 376020677;
+ * const params = { stash: false, flavor: 'view' };
+ * const json = await getJson( session, path`/v1/revision/${ id }/html?${ params }` );
+ * ```
+ *
+ * Alternatively, query params for GET requests can be specified separately:
+ * ```
+ * const id = 376020677;
+ * const json = await getJson( session, path`/v1/revision/${ id }/html`, {
+ *     stash: false,
+ *     flavor: 'view',
+ * } );
+ * ```
+ *
+ * (Calling this function like a regular function is not very useful,
+ * so you can ignore the parameters documented below.)
+ *
+ * @param {string|object[]} strings
+ * @param {Array} values
+ * @return {string}
+ */
+export function path( strings, ...values ) {
+	return String.raw( { raw: strings }, ...values.map( ( value ) => {
+		if ( typeof value === 'object' ) {
+			return new URLSearchParams( value );
+		}
+		return encodeURIComponent( value );
+	} ) );
+}
+
+/**
+ * Substitute template expressions in the path,
+ * taking values from the given params.
+ *
+ * @param {string} path The path with optional `{param}` expressions.
+ * @param {Object|URLSearchParams} params The input params. Not modified.
+ * @return {Object} The potentially modified path and params.
+ */
+function substitutePathParams( path, params ) {
+	let copiedParams = null;
+	const substitutedPath = path.replace( /\{[^{}]+\}/g, ( match ) => {
+		const paramName = match.slice( 1, -1 );
+		if ( params instanceof URLSearchParams ) {
+			if ( copiedParams === null ) {
+				copiedParams = new URLSearchParams( params );
+			}
+			const values = copiedParams.getAll( paramName );
+			if ( values.length !== 1 ) {
+				throw new InvalidPathParams(
+					values.length === 0 ?
+						`Unspecified path param ${ match }` :
+						`Ambiguous path param ${ match }`,
+					path,
+					paramName,
+					params,
+				);
+			}
+			copiedParams.delete( paramName );
+			return encodeURIComponent( values[ 0 ] );
+		} else {
+			if ( copiedParams === null ) {
+				copiedParams = { ...params };
+			}
+			const value = copiedParams[ paramName ];
+			if ( value === undefined ) {
+				throw new InvalidPathParams(
+					`Unspecified path param ${ match }`,
+					path,
+					paramName,
+					params,
+				);
+			}
+			delete copiedParams[ paramName ];
+			return encodeURIComponent( value );
+		}
+	} );
+
+	return { path: substitutedPath, params: copiedParams || params };
+}
+
+/**
+ * Split a given URL for the m3api internal interface.
+ *
+ * @param {string} url
+ * @return {Object}
+ */
+function splitUrlForInternalInterface( url ) {
+	url = new URL( url );
+	const urlParams = {};
+	for ( const [ key, value ] of url.searchParams.entries() ) {
+		urlParams[ key ] = value;
+	}
+	url.search = '';
+	return { url: String( url ), urlParams };
+}
+
+/**
+ * Make a GET request to a REST API endpoint and return the JSON-decoded body.
+ *
+ * @param {Session} session The m3api session to use for this request.
+ * @param {string} path The resource path, e.g. `/v1/search`.
+ * Does not include the domain, script path, or `rest.php` endpoint.
+ * Use the {@link path} tag function to build the path.
+ * @param {Object} [params] Parameters for the request URL.
+ * This may include both parameters for the path and query parameters.
+ * @param {Options} [options] Request options.
+ * @return {Object|Array} The body of the API response, JSON-decoded.
+ */
+export async function getJson( session, path, params, options = {} ) {
+	( { path, params } = substitutePathParams( path, params ) );
+	const restUrl = session.apiUrl.replace( /api\.php$/, 'rest.php' );
+	const { url, urlParams } = splitUrlForInternalInterface( restUrl + path );
+	params = { ...urlParams, ...params };
+	const headers = {
+		accept: 'application/json',
+		...session.getRequestHeaders( options ),
+	};
+	const internalResponse = await session.internalGet( url, params, headers );
+	checkResponseStatus( internalResponse );
+	return getResponseJson( internalResponse );
+}
+
+/**
+ * Make a POST request to a REST API endpoint and return the JSON-decoded body.
+ *
+ * @param {Session} session The m3api session to use for this request.
+ * @param {string} path The resourcee path, e.g. `/v1/page`.
+ * Does not include the domain, script path, or `rest.php` endpoint.
+ * Use the {@link path} tag function to build the path.
+ * @param {URLSearchParams} params The request body.
+ * Will be sent using the `application/x-www-form-urlencoded` content type.
+ * (Future versions of this library will support additional request body content types,
+ * but that requires changes to m3api first.)
+ * You may also include parameters for the path here.
+ * @param {Options} [options] Request options.
+ * @return {Object|Array} The body of the API response, JSON-decoded.
+ */
+export async function postForJson( session, path, params, options = {} ) {
+	( { path, params } = substitutePathParams( path, params ) );
+	const restUrl = session.apiUrl.replace( /api\.php$/, 'rest.php' );
+	const { url, urlParams } = splitUrlForInternalInterface( restUrl + path );
+	const bodyParams = {};
+	for ( const [ key, value ] of params ) {
+		if ( Object.prototype.hasOwnProperty.call( bodyParams, key ) ) {
+			throw new Error( `Duplicate param name not yet supported: ${ key }` );
+		}
+		bodyParams[ key ] = value;
+	}
+	const headers = {
+		// accept: 'application/json', // skip this for now due to T412610
+		...session.getRequestHeaders( options ),
+	};
+	const internalResponse = await session.internalPost( url, urlParams, bodyParams, headers );
+	checkResponseStatus( internalResponse );
+	return getResponseJson( internalResponse );
+}

package/jsdoc/conf.json

@@ -0,0 +1,27 @@
+{
+	"source": {
+		"include": [
+			"."
+		],
+		"exclude": [
+			"test"
+		]
+	},
+	"templates": {
+		"default": {
+			"layoutFile": "jsdoc/layout.tmpl",
+			"staticFiles": {
+				"include": [
+					"jsdoc/version-warning.css"
+				]
+			}
+		}
+	},
+	"opts": {
+		"destination": "doc",
+		"readme": "README.md"
+	},
+	"plugins": [
+		"plugins/markdown"
+	]
+}

package/jsdoc/layout.tmpl

@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>m3api-rest: <?js= title ?></title>
+
+    <script defer src="scripts/prettify/prettify.js"></script>
+    <script defer src="scripts/prettify/lang-css.js"></script>
+    <link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css">
+    <link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css">
+    <link type="text/css" rel="stylesheet" href="version-warning.css">
+</head>
+
+<body>
+
+<div id="main">
+
+    <!-- VERSION-WARNING -->
+
+    <h1 class="page-title"><?js= title ?></h1>
+
+    <?js= content ?>
+</div>
+
+<nav>
+    <?js= this.nav ?>
+</nav>
+
+<br class="clear">
+
+<footer>
+    Documentation generated by <a href="https://github.com/jsdoc/jsdoc">JSDoc <?js= env.version.number ?></a>
+</footer>
+
+<script>document.addEventListener('DOMContentLoaded', function () { prettyPrint(); });</script>
+<script async src="scripts/linenumber.js"></script>
+</body>
+</html>

package/jsdoc/version-warning.css

@@ -0,0 +1,27 @@
+body {
+    --body-margin: 8px; /* copied from Firefox */
+    margin: var( --body-margin );
+}
+
+.version-warning {
+    --version-warning-margin-y: 2px;
+    --version-warning-margin-x: 24px; /* matching other doc elements */
+    top: calc(var(--body-margin) + var(--version-warning-margin-y));
+    position: sticky;
+    padding: 0.5em 3em;
+    margin: var(--version-warning-margin-y) var(--version-warning-margin-x);
+    border-radius: 4px;
+    text-align: center;
+    font-size: 16px; /* absolute px to match other doc elements */
+    color: #fff; /* Base100 */
+    background: repeating-linear-gradient(
+        135deg,
+        #36c 0px 56px, /* Accent50 */
+        #2a4b8d 56px 112px /* Accent30 */
+    );
+}
+
+.version-warning a {
+    color: #fff; /* Base100 */
+    text-decoration: underline;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "m3api-rest",
+	"version": "0.1.0",
+	"description": "m3api extension package to interact with the MediaWiki REST API.",
+	"main": "index.js",
+	"type": "module",
+	"scripts": {
+		"test": "npm-run-all test:*",
+		"test:lint": "eslint .",
+		"test:unit": "mocha test/unit/",
+		"test:integration": "mocha test/integration/",
+		"doc": "jsdoc -c jsdoc/conf.json"
+	},
+	"homepage": "https://gitlab.wikimedia.org/repos/m3api/m3api-rest#m3api-rest",
+	"bugs": "https://phabricator.wikimedia.org/tag/m3api/",
+	"repository": {
+		"type": "git",
+		"url": "git+https://gitlab.wikimedia.org/repos/m3api/m3api-rest.git"
+	},
+	"keywords": [
+		"mediawiki"
+	],
+	"author": "Lucas Werkmeister <mail@lucaswerkmeister.de>",
+	"license": "ISC",
+	"engines": {
+		"node": ">=18.2.0"
+	},
+	"peerDependencies": {
+		"m3api": "~1.0.0"
+	},
+	"devDependencies": {
+		"chai": "^6.0.1",
+		"chai-as-promised": "^8.0.1",
+		"chai-string": "^2.0.0",
+		"eslint": "^8.44.0",
+		"eslint-config-wikimedia": "^0.31.0",
+		"eslint-plugin-chai-friendly": "^1.0.1",
+		"jsdoc": "^4.0.3",
+		"m3api": "~1.0.0",
+		"mocha": "^11.1.0",
+		"npm-run-all": "^4.1.5"
+	},
+	"mocha": {
+		"recursive": true
+	}
+}