nitro 2.2.27 → 3.0.0-alpha.0

package/dist/node_modules/croner/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "croner",
+  "description": "Trigger functions and/or evaluate cron expressions in JavaScript. No dependencies. Most features. All environments.",
+  "author": "Hexagon <github.com/hexagon>",
+  "homepage": "https://croner.56k.guru",
+  "contributors": [
+    {
+      "name": "Pehr Boman",
+      "email": "github.com/unkelpehr"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hexagon/croner"
+  },
+  "bugs": {
+    "url": "https://github.com/hexagon/croner/issues"
+  },
+  "files": [
+    "dist/*.js",
+    "dist/*.cjs",
+    "dist/*.d.ts",
+    "dist/*.d.cts"
+  ],
+  "engines": {
+    "node": ">=18.0"
+  },
+  "keywords": [
+    "cron",
+    "front-end",
+    "backend",
+    "parser",
+    "croner",
+    "schedule",
+    "scheduler",
+    "timer",
+    "task",
+    "job",
+    "isomorphic",
+    "crontab"
+  ],
+  "type": "module",
+  "main": "./dist/croner.cjs",
+  "browser": "./dist/croner.umd.js",
+  "module": "./dist/croner.js",
+  "types": "./dist/croner.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/croner.d.ts",
+        "default": "./dist/croner.js"
+      },
+      "require": {
+        "types": "./dist/croner.d.cts",
+        "default": "./dist/croner.cjs"
+      },
+      "browser": "./dist/croner.umd.js"
+    }
+  },
+  "license": "MIT",
+  "version": "9.1.0"
+}

package/dist/node_modules/defu/dist/defu.mjs

@@ -0,0 +1,69 @@
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+const defu = createDefu();
+const defuFn = createDefu((object, key, currentValue) => {
+  if (object[key] !== void 0 && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+const defuArrayFn = createDefu((object, key, currentValue) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+
+export { createDefu, defu as default, defu, defuArrayFn, defuFn };

package/dist/node_modules/defu/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "defu",
+  "version": "6.1.4",
+  "description": "Recursively assign default properties. Lightweight and Fast!",
+  "repository": "unjs/defu",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/defu.d.ts",
+      "import": "./dist/defu.mjs",
+      "require": "./lib/defu.cjs"
+    }
+  },
+  "main": "./lib/defu.cjs",
+  "module": "./dist/defu.mjs",
+  "types": "./dist/defu.d.ts",
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.10.6",
+    "@vitest/coverage-v8": "^1.1.3",
+    "changelogen": "^0.5.5",
+    "eslint": "^8.56.0",
+    "eslint-config-unjs": "^0.2.1",
+    "expect-type": "^0.17.3",
+    "prettier": "^3.1.1",
+    "typescript": "^5.3.3",
+    "unbuild": "^2.0.0",
+    "vitest": "^1.1.3"
+  },
+  "packageManager": "pnpm@8.10.2",
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint --ext .ts src && prettier -c src test",
+    "lint:fix": "eslint --ext .ts src --fix && prettier -w src test",
+    "release": "pnpm test && changelogen --release && git push --follow-tags && pnpm publish",
+    "test": "pnpm lint && pnpm vitest run",
+    "test:types": "tsc --noEmit"
+  }
+}

package/dist/node_modules/destr/dist/index.mjs

@@ -0,0 +1,72 @@
+const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
+const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+function jsonParseTransform(key, value) {
+  if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
+    warnKeyDropped(key);
+    return;
+  }
+  return value;
+}
+function warnKeyDropped(key) {
+  console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
+}
+function destr(value, options = {}) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  if (value[0] === '"' && value[value.length - 1] === '"' && value.indexOf("\\") === -1) {
+    return value.slice(1, -1);
+  }
+  const _value = value.trim();
+  if (_value.length <= 9) {
+    switch (_value.toLowerCase()) {
+      case "true": {
+        return true;
+      }
+      case "false": {
+        return false;
+      }
+      case "undefined": {
+        return void 0;
+      }
+      case "null": {
+        return null;
+      }
+      case "nan": {
+        return Number.NaN;
+      }
+      case "infinity": {
+        return Number.POSITIVE_INFINITY;
+      }
+      case "-infinity": {
+        return Number.NEGATIVE_INFINITY;
+      }
+    }
+  }
+  if (!JsonSigRx.test(value)) {
+    if (options.strict) {
+      throw new SyntaxError("[destr] Invalid JSON");
+    }
+    return value;
+  }
+  try {
+    if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
+      if (options.strict) {
+        throw new Error("[destr] Possible prototype pollution");
+      }
+      return JSON.parse(value, jsonParseTransform);
+    }
+    return JSON.parse(value);
+  } catch (error) {
+    if (options.strict) {
+      throw error;
+    }
+    return value;
+  }
+}
+function safeDestr(value, options = {}) {
+  return destr(value, { ...options, strict: true });
+}
+
+export { destr as default, destr, safeDestr };

package/dist/node_modules/destr/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "destr",
+  "version": "2.0.5",
+  "description": "A faster, secure and convenient alternative for JSON.parse",
+  "repository": "unjs/destr",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./lib/index.cjs"
+    }
+  },
+  "main": "./lib/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "scripts": {
+    "bench:bun": "pnpm build && bun --bun ./test/bench.mjs",
+    "bench:node": "pnpm build && node ./test/bench.mjs",
+    "build": "unbuild",
+    "dev": "vitest dev",
+    "lint": "eslint . && prettier -c src test",
+    "lint:fix": "eslint . --fix && prettier -w src test",
+    "release": "pnpm test && pnpm build && changelogen --release --push && npm publish",
+    "test": "pnpm lint && vitest run --coverage"
+  },
+  "devDependencies": {
+    "@hapi/bourne": "^3.0.0",
+    "@vitest/coverage-v8": "^3.1.1",
+    "changelogen": "^0.6.1",
+    "eslint": "^9.23.0",
+    "eslint-config-unjs": "^0.4.2",
+    "mitata": "^1.0.34",
+    "prettier": "^3.5.3",
+    "secure-json-parse": "^4.0.0",
+    "typescript": "^5.8.2",
+    "unbuild": "~3.4",
+    "vitest": "^3.1.1"
+  },
+  "packageManager": "pnpm@10.7.1"
+}

package/dist/node_modules/error-stack-parser-es/dist/index.mjs

@@ -0,0 +1,38 @@
+import { parse as parse$1, parseV8OrIE as parseV8OrIE$1, parseFFOrSafari as parseFFOrSafari$1, parseOpera as parseOpera$1, parseOpera9 as parseOpera9$1, parseOpera10 as parseOpera10$1, parseOpera11 as parseOpera11$1 } from './lite.mjs';
+export { extractLocation } from './lite.mjs';
+
+function stackframesLiteToStackframes(liteStackframes) {
+  return liteStackframes.map((liteStackframe) => {
+    return {
+      functionName: liteStackframe.function,
+      args: liteStackframe.args,
+      fileName: liteStackframe.file,
+      lineNumber: liteStackframe.line,
+      columnNumber: liteStackframe.col,
+      source: liteStackframe.raw
+    };
+  });
+}
+function parse(error, options) {
+  return stackframesLiteToStackframes(parse$1(error, options));
+}
+function parseV8OrIE(error) {
+  return stackframesLiteToStackframes(parseV8OrIE$1(error));
+}
+function parseFFOrSafari(error) {
+  return stackframesLiteToStackframes(parseFFOrSafari$1(error));
+}
+function parseOpera(e) {
+  return stackframesLiteToStackframes(parseOpera$1(e));
+}
+function parseOpera9(e) {
+  return stackframesLiteToStackframes(parseOpera9$1(e));
+}
+function parseOpera10(e) {
+  return stackframesLiteToStackframes(parseOpera10$1(e));
+}
+function parseOpera11(error) {
+  return stackframesLiteToStackframes(parseOpera11$1(error));
+}
+
+export { parse, parseFFOrSafari, parseOpera, parseOpera10, parseOpera11, parseOpera9, parseV8OrIE };

package/dist/node_modules/error-stack-parser-es/dist/lite.mjs

@@ -0,0 +1,167 @@
+const FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
+const CHROME_IE_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\[native code\])?$/;
+function parse(error, options) {
+  if (typeof error.stacktrace !== "undefined" || typeof error["opera#sourceloc"] !== "undefined")
+    return parseOpera(error, options);
+  else if (error.stack && error.stack.match(CHROME_IE_STACK_REGEXP))
+    return parseV8OrIE(error, options);
+  else if (error.stack)
+    return parseFFOrSafari(error, options);
+  else if (options?.allowEmpty)
+    return [];
+  else
+    throw new Error("Cannot parse given Error object");
+}
+function parseStack(stackString, options) {
+  if (stackString.match(CHROME_IE_STACK_REGEXP))
+    return parseV8OrIeString(stackString, options);
+  else
+    return parseFFOrSafariString(stackString, options);
+}
+function extractLocation(urlLike) {
+  if (!urlLike.includes(":"))
+    return [urlLike, undefined, undefined];
+  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+  const parts = regExp.exec(urlLike.replace(/[()]/g, ""));
+  return [parts[1], parts[2] || undefined, parts[3] || undefined];
+}
+function applySlice(lines, options) {
+  if (options && options.slice != null) {
+    if (Array.isArray(options.slice))
+      return lines.slice(options.slice[0], options.slice[1]);
+    return lines.slice(0, options.slice);
+  }
+  return lines;
+}
+function parseV8OrIE(error, options) {
+  return parseV8OrIeString(error.stack, options);
+}
+function parseV8OrIeString(stack, options) {
+  const filtered = applySlice(
+    stack.split("\n").filter((line) => {
+      return !!line.match(CHROME_IE_STACK_REGEXP);
+    }),
+    options
+  );
+  return filtered.map((line) => {
+    if (line.includes("(eval ")) {
+      line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+    }
+    let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+    const location = sanitizedLine.match(/ (\(.+\)$)/);
+    sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+    const locationParts = extractLocation(location ? location[1] : sanitizedLine);
+    const functionName = location && sanitizedLine || undefined;
+    const fileName = ["eval", "<anonymous>"].includes(locationParts[0]) ? undefined : locationParts[0];
+    return {
+      function: functionName,
+      file: fileName,
+      line: locationParts[1] ? +locationParts[1] : undefined,
+      col: locationParts[2] ? +locationParts[2] : undefined,
+      raw: line
+    };
+  });
+}
+function parseFFOrSafari(error, options) {
+  return parseFFOrSafariString(error.stack, options);
+}
+function parseFFOrSafariString(stack, options) {
+  const filtered = applySlice(
+    stack.split("\n").filter((line) => {
+      return !line.match(SAFARI_NATIVE_CODE_REGEXP);
+    }),
+    options
+  );
+  return filtered.map((line) => {
+    if (line.includes(" > eval"))
+      line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
+    if (!line.includes("@") && !line.includes(":")) {
+      return {
+        function: line
+      };
+    } else {
+      const functionNameRegex = /(([^\n\r"\u2028\u2029]*".[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*(?:@[^\n\r"\u2028\u2029]*"[^\n\r@\u2028\u2029]*)*(?:[\n\r\u2028\u2029][^@]*)?)?[^@]*)@/;
+      const matches = line.match(functionNameRegex);
+      const functionName = matches && matches[1] ? matches[1] : undefined;
+      const locationParts = extractLocation(line.replace(functionNameRegex, ""));
+      return {
+        function: functionName,
+        file: locationParts[0],
+        line: locationParts[1] ? +locationParts[1] : undefined,
+        col: locationParts[2] ? +locationParts[2] : undefined,
+        raw: line
+      };
+    }
+  });
+}
+function parseOpera(e, options) {
+  if (!e.stacktrace || e.message.includes("\n") && e.message.split("\n").length > e.stacktrace.split("\n").length)
+    return parseOpera9(e);
+  else if (!e.stack)
+    return parseOpera10(e);
+  else
+    return parseOpera11(e, options);
+}
+function parseOpera9(e, options) {
+  const lineRE = /Line (\d+).*script (?:in )?(\S+)/i;
+  const lines = e.message.split("\n");
+  const result = [];
+  for (let i = 2, len = lines.length; i < len; i += 2) {
+    const match = lineRE.exec(lines[i]);
+    if (match) {
+      result.push({
+        file: match[2],
+        line: +match[1],
+        raw: lines[i]
+      });
+    }
+  }
+  return applySlice(result, options);
+}
+function parseOpera10(e, options) {
+  const lineRE = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
+  const lines = e.stacktrace.split("\n");
+  const result = [];
+  for (let i = 0, len = lines.length; i < len; i += 2) {
+    const match = lineRE.exec(lines[i]);
+    if (match) {
+      result.push({
+        function: match[3] || undefined,
+        file: match[2],
+        line: match[1] ? +match[1] : undefined,
+        raw: lines[i]
+      });
+    }
+  }
+  return applySlice(result, options);
+}
+function parseOpera11(error, options) {
+  const filtered = applySlice(
+    // @ts-expect-error missing stack property
+    error.stack.split("\n").filter((line) => {
+      return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);
+    }),
+    options
+  );
+  return filtered.map((line) => {
+    const tokens = line.split("@");
+    const locationParts = extractLocation(tokens.pop());
+    const functionCall = tokens.shift() || "";
+    const functionName = functionCall.replace(/<anonymous function(: (\w+))?>/, "$2").replace(/\([^)]*\)/g, "") || undefined;
+    let argsRaw;
+    if (functionCall.match(/\(([^)]*)\)/))
+      argsRaw = functionCall.replace(/^[^(]+\(([^)]*)\)$/, "$1");
+    const args = argsRaw === undefined || argsRaw === "[arguments not available]" ? undefined : argsRaw.split(",");
+    return {
+      function: functionName,
+      args,
+      file: locationParts[0],
+      line: locationParts[1] ? +locationParts[1] : undefined,
+      col: locationParts[2] ? +locationParts[2] : undefined,
+      raw: line
+    };
+  });
+}
+
+export { extractLocation, parse, parseFFOrSafari, parseFFOrSafariString, parseOpera, parseOpera10, parseOpera11, parseOpera9, parseStack, parseV8OrIE, parseV8OrIeString };

package/dist/node_modules/error-stack-parser-es/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "error-stack-parser-es",
+  "type": "module",
+  "version": "1.0.5",
+  "packageManager": "pnpm@9.15.3",
+  "description": "Cross-browser Error parser",
+  "maintainers": [
+    "Anthony Fu <anthonyfu117@hotmail.com> (https://antfu.me)",
+    "Eric Wendelin <me@eriwen.com> (https://www.eriwen.com)",
+    "Victor Homyakov <vkhomyackov@gmail.com> (https://github.com/victor-homyakov)",
+    "Oliver Salzburg (https://github.com/oliversalzburg)",
+    "Ben Gourley (https://github.com/bengourley)"
+  ],
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/antfu",
+  "homepage": "https://github.com/antfu/error-stack-parser-es#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/antfu/error-stack-parser-es.git"
+  },
+  "bugs": "https://github.com/antfu/error-stack-parser-es/issues",
+  "keywords": [],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./lite": {
+      "types": "./dist/lite.d.ts",
+      "import": "./dist/lite.mjs",
+      "require": "./dist/lite.cjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub",
+    "lint": "eslint .",
+    "prepublishOnly": "nr build",
+    "release": "bumpp && npm publish",
+    "start": "esno src/index.ts",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^3.12.2",
+    "@antfu/ni": "^23.2.0",
+    "@antfu/utils": "^8.0.0",
+    "@types/node": "^22.10.5",
+    "bumpp": "^9.9.3",
+    "eslint": "^9.17.0",
+    "esno": "^4.8.0",
+    "lint-staged": "^15.3.0",
+    "pnpm": "^9.15.3",
+    "rimraf": "^6.0.1",
+    "simple-git-hooks": "^2.11.1",
+    "typescript": "^5.7.3",
+    "unbuild": "^3.2.0",
+    "vite": "^6.0.7",
+    "vitest": "^2.1.8"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint --fix"
+  }
+}