nuxt-ignis 0.5.0 → 0.5.2

package/.output/server/node_modules/nth-check/lib/esm/index.js

@@ -0,0 +1,63 @@
+import { parse } from "./parse.js";
+import { compile, generate } from "./compile.js";
+export { parse, compile, generate };
+/**
+ * Parses and compiles a formula to a highly optimized function.
+ * Combination of {@link parse} and {@link compile}.
+ *
+ * If the formula doesn't match any elements,
+ * it returns [`boolbase`](https://github.com/fb55/boolbase)'s `falseFunc`.
+ * Otherwise, a function accepting an _index_ is returned, which returns
+ * whether or not the passed _index_ matches the formula.
+ *
+ * Note: The nth-rule starts counting at `1`, the returned function at `0`.
+ *
+ * @param formula The formula to compile.
+ * @example
+ * const check = nthCheck("2n+3");
+ *
+ * check(0); // `false`
+ * check(1); // `false`
+ * check(2); // `true`
+ * check(3); // `false`
+ * check(4); // `true`
+ * check(5); // `false`
+ * check(6); // `true`
+ */
+export default function nthCheck(formula) {
+    return compile(parse(formula));
+}
+/**
+ * Parses and compiles a formula to a generator that produces a sequence of indices.
+ * Combination of {@link parse} and {@link generate}.
+ *
+ * @param formula The formula to compile.
+ * @returns A function that produces a sequence of indices.
+ * @example <caption>Always increasing</caption>
+ *
+ * ```js
+ * const gen = nthCheck.sequence('2n+3')
+ *
+ * gen() // `1`
+ * gen() // `3`
+ * gen() // `5`
+ * gen() // `8`
+ * gen() // `11`
+ * ```
+ *
+ * @example <caption>With end value</caption>
+ *
+ * ```js
+ *
+ * const gen = nthCheck.sequence('-2n+5');
+ *
+ * gen() // 0
+ * gen() // 2
+ * gen() // 4
+ * gen() // null
+ * ```
+ */
+export function sequence(formula) {
+    return generate(parse(formula));
+}
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/nth-check/lib/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/.output/server/node_modules/nth-check/lib/esm/parse.js

@@ -0,0 +1,73 @@
+// Following http://www.w3.org/TR/css3-selectors/#nth-child-pseudo
+// Whitespace as per https://www.w3.org/TR/selectors-3/#lex is " \t\r\n\f"
+const whitespace = new Set([9, 10, 12, 13, 32]);
+const ZERO = "0".charCodeAt(0);
+const NINE = "9".charCodeAt(0);
+/**
+ * Parses an expression.
+ *
+ * @throws An `Error` if parsing fails.
+ * @returns An array containing the integer step size and the integer offset of the nth rule.
+ * @example nthCheck.parse("2n+3"); // returns [2, 3]
+ */
+export function parse(formula) {
+    formula = formula.trim().toLowerCase();
+    if (formula === "even") {
+        return [2, 0];
+    }
+    else if (formula === "odd") {
+        return [2, 1];
+    }
+    // Parse [ ['-'|'+']? INTEGER? {N} [ S* ['-'|'+'] S* INTEGER ]?
+    let idx = 0;
+    let a = 0;
+    let sign = readSign();
+    let number = readNumber();
+    if (idx < formula.length && formula.charAt(idx) === "n") {
+        idx++;
+        a = sign * (number !== null && number !== void 0 ? number : 1);
+        skipWhitespace();
+        if (idx < formula.length) {
+            sign = readSign();
+            skipWhitespace();
+            number = readNumber();
+        }
+        else {
+            sign = number = 0;
+        }
+    }
+    // Throw if there is anything else
+    if (number === null || idx < formula.length) {
+        throw new Error(`n-th rule couldn't be parsed ('${formula}')`);
+    }
+    return [a, sign * number];
+    function readSign() {
+        if (formula.charAt(idx) === "-") {
+            idx++;
+            return -1;
+        }
+        if (formula.charAt(idx) === "+") {
+            idx++;
+        }
+        return 1;
+    }
+    function readNumber() {
+        const start = idx;
+        let value = 0;
+        while (idx < formula.length &&
+            formula.charCodeAt(idx) >= ZERO &&
+            formula.charCodeAt(idx) <= NINE) {
+            value = value * 10 + (formula.charCodeAt(idx) - ZERO);
+            idx++;
+        }
+        // Return `null` if we didn't read anything.
+        return idx === start ? null : value;
+    }
+    function skipWhitespace() {
+        while (idx < formula.length &&
+            whitespace.has(formula.charCodeAt(idx))) {
+            idx++;
+        }
+    }
+}
+//# sourceMappingURL=parse.js.map

package/.output/server/node_modules/oauth4webapi/build/index.js

@@ -1,7 +1,7 @@
 let USER_AGENT;
 if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
     const NAME = 'oauth4webapi';
-    const VERSION = 'v3.8.2';
+    const VERSION = 'v3.8.3';
     USER_AGENT = `${NAME}/${VERSION}`;
 }
 function looseInstanceOf(input, expected) {
@@ -813,11 +813,11 @@ export class WWWAuthenticateChallengeError extends Error {
     }
 }
 const tokenMatch = "[a-zA-Z0-9!#$%&\\'\\*\\+\\-\\.\\^_`\\|~]+";
-const token68Match = '[a-zA-Z0-9\\-\\._\\~\\+\\/]+[=]{0,2}';
-const quotedMatch = '"((?:[^"\\\\]|\\\\.)*)"';
+const token68Match = '[a-zA-Z0-9\\-\\._\\~\\+\\/]+={0,2}';
+const quotedMatch = '"((?:[^"\\\\]|\\\\[\\s\\S])*)"';
 const quotedParamMatcher = '(' + tokenMatch + ')\\s*=\\s*' + quotedMatch;
 const paramMatcher = '(' + tokenMatch + ')\\s*=\\s*(' + tokenMatch + ')';
-const schemeRE = new RegExp('^[,\\s]*(' + tokenMatch + ')\\s(.*)');
+const schemeRE = new RegExp('^[,\\s]*(' + tokenMatch + ')');
 const quotedParamRE = new RegExp('^[,\\s]*' + quotedParamMatcher + '[,\\s]*(.*)');
 const unquotedParamRE = new RegExp('^[,\\s]*' + paramMatcher + '[,\\s]*(.*)');
 const token68ParamRE = new RegExp('^(' + token68Match + ')(?:$|[,\\s])(.*)');
@@ -834,42 +834,53 @@ function parseWwwAuthenticateChallenges(response) {
     while (rest) {
         let match = rest.match(schemeRE);
         const scheme = match?.['1'].toLowerCase();
-        rest = match?.['2'];
         if (!scheme) {
             return undefined;
         }
+        const afterScheme = rest.substring(match[0].length);
+        if (afterScheme && !afterScheme.match(/^[\s,]/)) {
+            return undefined;
+        }
+        const spaceMatch = afterScheme.match(/^\s+(.*)$/);
+        const hasParameters = !!spaceMatch;
+        rest = spaceMatch ? spaceMatch[1] : undefined;
         const parameters = {};
         let token68;
-        while (rest) {
-            let key;
-            let value;
-            if ((match = rest.match(quotedParamRE))) {
-                ;
-                [, key, value, rest] = match;
-                if (value.includes('\\')) {
-                    try {
-                        value = JSON.parse(`"${value}"`);
+        if (hasParameters) {
+            while (rest) {
+                let key;
+                let value;
+                if ((match = rest.match(quotedParamRE))) {
+                    ;
+                    [, key, value, rest] = match;
+                    if (value.includes('\\')) {
+                        try {
+                            value = JSON.parse(`"${value}"`);
+                        }
+                        catch { }
                     }
-                    catch { }
+                    parameters[key.toLowerCase()] = value;
+                    continue;
                 }
-                parameters[key.toLowerCase()] = value;
-                continue;
-            }
-            if ((match = rest.match(unquotedParamRE))) {
-                ;
-                [, key, value, rest] = match;
-                parameters[key.toLowerCase()] = value;
-                continue;
-            }
-            if ((match = rest.match(token68ParamRE))) {
-                if (Object.keys(parameters).length) {
+                if ((match = rest.match(unquotedParamRE))) {
+                    ;
+                    [, key, value, rest] = match;
+                    parameters[key.toLowerCase()] = value;
+                    continue;
+                }
+                if ((match = rest.match(token68ParamRE))) {
+                    if (Object.keys(parameters).length) {
+                        break;
+                    }
+                    ;
+                    [, token68, rest] = match;
                     break;
                 }
-                ;
-                [, token68, rest] = match;
-                break;
+                return undefined;
             }
-            return undefined;
+        }
+        else {
+            rest = afterScheme || undefined;
         }
         const challenge = { scheme, parameters };
         if (token68) {

package/.output/server/node_modules/oauth4webapi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oauth4webapi",
-  "version": "3.8.2",
+  "version": "3.8.3",
   "description": "Low-Level OAuth 2 / OpenID Connect Client API for JavaScript Runtimes",
   "keywords": [
     "access token",
@@ -69,7 +69,6 @@
     "tap:browsers": "./tap/.browsers.sh",
     "tap:bun": "./tap/.bun.sh",
     "tap:deno": "./tap/.deno.sh",
-    "tap:edge-runtime": "./tap/.edge-runtime.sh",
     "tap:electron": "./tap/.electron.sh",
     "tap:node": "bash -c './tap/.node.sh'",
     "tap:workerd": "./tap/.workerd.sh",
@@ -77,29 +76,29 @@
   },
   "devDependencies": {
     "@koa/cors": "^5.0.0",
-    "@types/koa__cors": "^5.0.0",
-    "@types/node": "^22.18.6",
+    "@types/koa__cors": "^5.0.1",
+    "@types/node": "^24.10.1",
     "@types/qunit": "^2.19.13",
     "archiver": "^7.0.1",
     "ava": "^6.4.1",
-    "esbuild": "^0.25.10",
-    "happy-dom": "^18.0.1",
-    "http-cookie-agent": "^7.0.2",
-    "jose": "^6.1.0",
-    "oidc-provider": "^9.5.1",
-    "patch-package": "^8.0.0",
+    "esbuild": "^0.25.12",
+    "happy-dom": "^20.0.10",
+    "http-cookie-agent": "^7.0.3",
+    "jose": "^6.1.2",
+    "oidc-provider": "^9.5.2",
+    "patch-package": "^8.0.1",
     "prettier": "^3.6.2",
-    "prettier-plugin-jsdoc": "^1.3.3",
-    "qunit": "^2.24.1",
+    "prettier-plugin-jsdoc": "^1.5.0",
+    "qunit": "^2.24.2",
     "raw-body": "^3.0.1",
-    "selfsigned": "^3.0.1",
+    "selfsigned": "^4.0.0",
     "timekeeper": "^2.3.1",
     "tough-cookie": "^5.1.2",
-    "tsx": "^4.20.5",
+    "tsx": "^4.20.6",
     "typedoc": "^0.28.11",
     "typedoc-plugin-markdown": "^4.8.1",
     "typedoc-plugin-mdn-links": "^5.0.9",
-    "typescript": "^5.9.2",
+    "typescript": "^5.9.3",
     "undici": "^7.16.0"
   }
 }

package/.output/server/node_modules/ofetch/dist/node.mjs

@@ -1,8 +1,8 @@
 import http from 'node:http';
 import https from 'node:https';
-import nodeFetch, { Headers as Headers$1, AbortController as AbortController$1 } from 'node-fetch-native';
-import { c as createFetch } from './shared/ofetch.03887fc3.mjs';
-export { F as FetchError, a as createFetchError } from './shared/ofetch.03887fc3.mjs';
+import nodeFetch, { AbortController as AbortController$1, Headers as Headers$1 } from 'node-fetch-native';
+import { c as createFetch } from './shared/ofetch.CWycOUEr.mjs';
+export { F as FetchError, a as createFetchError } from './shared/ofetch.CWycOUEr.mjs';
 import 'destr';
 import 'ufo';
 

package/.output/server/node_modules/ofetch/dist/shared/ofetch.CWycOUEr.mjs

@@ -0,0 +1,349 @@
+import destr from 'destr';
+import { withBase, withQuery } from 'ufo';
+
+class FetchError extends Error {
+  constructor(message, opts) {
+    super(message, opts);
+    this.name = "FetchError";
+    if (opts?.cause && !this.cause) {
+      this.cause = opts.cause;
+    }
+  }
+}
+function createFetchError(ctx) {
+  const errorMessage = ctx.error?.message || ctx.error?.toString() || "";
+  const method = ctx.request?.method || ctx.options?.method || "GET";
+  const url = ctx.request?.url || String(ctx.request) || "/";
+  const requestStr = `[${method}] ${JSON.stringify(url)}`;
+  const statusStr = ctx.response ? `${ctx.response.status} ${ctx.response.statusText}` : "<no response>";
+  const message = `${requestStr}: ${statusStr}${errorMessage ? ` ${errorMessage}` : ""}`;
+  const fetchError = new FetchError(
+    message,
+    ctx.error ? { cause: ctx.error } : void 0
+  );
+  for (const key of ["request", "options", "response"]) {
+    Object.defineProperty(fetchError, key, {
+      get() {
+        return ctx[key];
+      }
+    });
+  }
+  for (const [key, refKey] of [
+    ["data", "_data"],
+    ["status", "status"],
+    ["statusCode", "status"],
+    ["statusText", "statusText"],
+    ["statusMessage", "statusText"]
+  ]) {
+    Object.defineProperty(fetchError, key, {
+      get() {
+        return ctx.response && ctx.response[refKey];
+      }
+    });
+  }
+  return fetchError;
+}
+
+const payloadMethods = new Set(
+  Object.freeze(["PATCH", "POST", "PUT", "DELETE"])
+);
+function isPayloadMethod(method = "GET") {
+  return payloadMethods.has(method.toUpperCase());
+}
+function isJSONSerializable(value) {
+  if (value === void 0) {
+    return false;
+  }
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean" || t === null) {
+    return true;
+  }
+  if (t !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return true;
+  }
+  if (value.buffer) {
+    return false;
+  }
+  if (value instanceof FormData || value instanceof URLSearchParams) {
+    return false;
+  }
+  return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
+}
+const textTypes = /* @__PURE__ */ new Set([
+  "image/svg",
+  "application/xml",
+  "application/xhtml",
+  "application/html"
+]);
+const JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
+function detectResponseType(_contentType = "") {
+  if (!_contentType) {
+    return "json";
+  }
+  const contentType = _contentType.split(";").shift() || "";
+  if (JSON_RE.test(contentType)) {
+    return "json";
+  }
+  if (contentType === "text/event-stream") {
+    return "stream";
+  }
+  if (textTypes.has(contentType) || contentType.startsWith("text/")) {
+    return "text";
+  }
+  return "blob";
+}
+function resolveFetchOptions(request, input, defaults, Headers) {
+  const headers = mergeHeaders(
+    input?.headers ?? request?.headers,
+    defaults?.headers,
+    Headers
+  );
+  let query;
+  if (defaults?.query || defaults?.params || input?.params || input?.query) {
+    query = {
+      ...defaults?.params,
+      ...defaults?.query,
+      ...input?.params,
+      ...input?.query
+    };
+  }
+  return {
+    ...defaults,
+    ...input,
+    query,
+    params: query,
+    headers
+  };
+}
+function mergeHeaders(input, defaults, Headers) {
+  if (!defaults) {
+    return new Headers(input);
+  }
+  const headers = new Headers(defaults);
+  if (input) {
+    for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers(input)) {
+      headers.set(key, value);
+    }
+  }
+  return headers;
+}
+async function callHooks(context, hooks) {
+  if (hooks) {
+    if (Array.isArray(hooks)) {
+      for (const hook of hooks) {
+        await hook(context);
+      }
+    } else {
+      await hooks(context);
+    }
+  }
+}
+
+const retryStatusCodes = /* @__PURE__ */ new Set([
+  408,
+  // Request Timeout
+  409,
+  // Conflict
+  425,
+  // Too Early (Experimental)
+  429,
+  // Too Many Requests
+  500,
+  // Internal Server Error
+  502,
+  // Bad Gateway
+  503,
+  // Service Unavailable
+  504
+  // Gateway Timeout
+]);
+const nullBodyResponses = /* @__PURE__ */ new Set([101, 204, 205, 304]);
+function createFetch(globalOptions = {}) {
+  const {
+    fetch = globalThis.fetch,
+    Headers = globalThis.Headers,
+    AbortController = globalThis.AbortController
+  } = globalOptions;
+  async function onError(context) {
+    const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
+    if (context.options.retry !== false && !isAbort) {
+      let retries;
+      if (typeof context.options.retry === "number") {
+        retries = context.options.retry;
+      } else {
+        retries = isPayloadMethod(context.options.method) ? 0 : 1;
+      }
+      const responseCode = context.response && context.response.status || 500;
+      if (retries > 0 && (Array.isArray(context.options.retryStatusCodes) ? context.options.retryStatusCodes.includes(responseCode) : retryStatusCodes.has(responseCode))) {
+        const retryDelay = typeof context.options.retryDelay === "function" ? context.options.retryDelay(context) : context.options.retryDelay || 0;
+        if (retryDelay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+        return $fetchRaw(context.request, {
+          ...context.options,
+          retry: retries - 1
+        });
+      }
+    }
+    const error = createFetchError(context);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(error, $fetchRaw);
+    }
+    throw error;
+  }
+  const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
+    const context = {
+      request: _request,
+      options: resolveFetchOptions(
+        _request,
+        _options,
+        globalOptions.defaults,
+        Headers
+      ),
+      response: void 0,
+      error: void 0
+    };
+    if (context.options.method) {
+      context.options.method = context.options.method.toUpperCase();
+    }
+    if (context.options.onRequest) {
+      await callHooks(context, context.options.onRequest);
+      if (!(context.options.headers instanceof Headers)) {
+        context.options.headers = new Headers(
+          context.options.headers || {}
+          /* compat */
+        );
+      }
+    }
+    if (typeof context.request === "string") {
+      if (context.options.baseURL) {
+        context.request = withBase(context.request, context.options.baseURL);
+      }
+      if (context.options.query) {
+        context.request = withQuery(context.request, context.options.query);
+        delete context.options.query;
+      }
+      if ("query" in context.options) {
+        delete context.options.query;
+      }
+      if ("params" in context.options) {
+        delete context.options.params;
+      }
+    }
+    if (context.options.body && isPayloadMethod(context.options.method)) {
+      if (isJSONSerializable(context.options.body)) {
+        const contentType = context.options.headers.get("content-type");
+        if (typeof context.options.body !== "string") {
+          context.options.body = contentType === "application/x-www-form-urlencoded" ? new URLSearchParams(
+            context.options.body
+          ).toString() : JSON.stringify(context.options.body);
+        }
+        if (!contentType) {
+          context.options.headers.set("content-type", "application/json");
+        }
+        if (!context.options.headers.has("accept")) {
+          context.options.headers.set("accept", "application/json");
+        }
+      } else if (
+        // ReadableStream Body
+        "pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || // Node.js Stream Body
+        typeof context.options.body.pipe === "function"
+      ) {
+        if (!("duplex" in context.options)) {
+          context.options.duplex = "half";
+        }
+      }
+    }
+    let abortTimeout;
+    if (!context.options.signal && context.options.timeout) {
+      const controller = new AbortController();
+      abortTimeout = setTimeout(() => {
+        const error = new Error(
+          "[TimeoutError]: The operation was aborted due to timeout"
+        );
+        error.name = "TimeoutError";
+        error.code = 23;
+        controller.abort(error);
+      }, context.options.timeout);
+      context.options.signal = controller.signal;
+    }
+    try {
+      context.response = await fetch(
+        context.request,
+        context.options
+      );
+    } catch (error) {
+      context.error = error;
+      if (context.options.onRequestError) {
+        await callHooks(
+          context,
+          context.options.onRequestError
+        );
+      }
+      return await onError(context);
+    } finally {
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+      }
+    }
+    const hasBody = (context.response.body || // https://github.com/unjs/ofetch/issues/324
+    // https://github.com/unjs/ofetch/issues/294
+    // https://github.com/JakeChampion/fetch/issues/1454
+    context.response._bodyInit) && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD";
+    if (hasBody) {
+      const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
+      switch (responseType) {
+        case "json": {
+          const data = await context.response.text();
+          const parseFunction = context.options.parseResponse || destr;
+          context.response._data = parseFunction(data);
+          break;
+        }
+        case "stream": {
+          context.response._data = context.response.body || context.response._bodyInit;
+          break;
+        }
+        default: {
+          context.response._data = await context.response[responseType]();
+        }
+      }
+    }
+    if (context.options.onResponse) {
+      await callHooks(
+        context,
+        context.options.onResponse
+      );
+    }
+    if (!context.options.ignoreResponseError && context.response.status >= 400 && context.response.status < 600) {
+      if (context.options.onResponseError) {
+        await callHooks(
+          context,
+          context.options.onResponseError
+        );
+      }
+      return await onError(context);
+    }
+    return context.response;
+  };
+  const $fetch = async function $fetch2(request, options) {
+    const r = await $fetchRaw(request, options);
+    return r._data;
+  };
+  $fetch.raw = $fetchRaw;
+  $fetch.native = (...args) => fetch(...args);
+  $fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
+    ...globalOptions,
+    ...customGlobalOptions,
+    defaults: {
+      ...globalOptions.defaults,
+      ...customGlobalOptions.defaults,
+      ...defaultOptions
+    }
+  });
+  return $fetch;
+}
+
+export { FetchError as F, createFetchError as a, createFetch as c };