nuxt-ignis 0.4.0 → 0.5.0-rc.2

package/.output/server/node_modules/@intlify/utils/dist/shared/utils.12d9adcd.mjs

@@ -0,0 +1,133 @@
+const fieldContentRegExp = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;
+function parse(str, options) {
+  if (typeof str !== "string") {
+    throw new TypeError("argument str must be a string");
+  }
+  const obj = {};
+  const opt = options || {};
+  const dec = opt.decode || decode;
+  let index = 0;
+  while (index < str.length) {
+    const eqIdx = str.indexOf("=", index);
+    if (eqIdx === -1) {
+      break;
+    }
+    let endIdx = str.indexOf(";", index);
+    if (endIdx === -1) {
+      endIdx = str.length;
+    } else if (endIdx < eqIdx) {
+      index = str.lastIndexOf(";", eqIdx - 1) + 1;
+      continue;
+    }
+    const key = str.slice(index, eqIdx).trim();
+    if (void 0 === obj[key]) {
+      let val = str.slice(eqIdx + 1, endIdx).trim();
+      if (val.codePointAt(0) === 34) {
+        val = val.slice(1, -1);
+      }
+      obj[key] = tryDecode(val, dec);
+    }
+    index = endIdx + 1;
+  }
+  return obj;
+}
+function serialize(name, value, options) {
+  const opt = options || {};
+  const enc = opt.encode || encode;
+  if (typeof enc !== "function") {
+    throw new TypeError("option encode is invalid");
+  }
+  if (!fieldContentRegExp.test(name)) {
+    throw new TypeError("argument name is invalid");
+  }
+  const encodedValue = enc(value);
+  if (encodedValue && !fieldContentRegExp.test(encodedValue)) {
+    throw new TypeError("argument val is invalid");
+  }
+  let str = name + "=" + encodedValue;
+  if (void 0 !== opt.maxAge && opt.maxAge !== null) {
+    const maxAge = opt.maxAge - 0;
+    if (Number.isNaN(maxAge) || !Number.isFinite(maxAge)) {
+      throw new TypeError("option maxAge is invalid");
+    }
+    str += "; Max-Age=" + Math.floor(maxAge);
+  }
+  if (opt.domain) {
+    if (!fieldContentRegExp.test(opt.domain)) {
+      throw new TypeError("option domain is invalid");
+    }
+    str += "; Domain=" + opt.domain;
+  }
+  if (opt.path) {
+    if (!fieldContentRegExp.test(opt.path)) {
+      throw new TypeError("option path is invalid");
+    }
+    str += "; Path=" + opt.path;
+  }
+  if (opt.expires) {
+    if (!isDate(opt.expires) || Number.isNaN(opt.expires.valueOf())) {
+      throw new TypeError("option expires is invalid");
+    }
+    str += "; Expires=" + opt.expires.toUTCString();
+  }
+  if (opt.httpOnly) {
+    str += "; HttpOnly";
+  }
+  if (opt.secure) {
+    str += "; Secure";
+  }
+  if (opt.priority) {
+    const priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
+    switch (priority) {
+      case "low":
+        str += "; Priority=Low";
+        break;
+      case "medium":
+        str += "; Priority=Medium";
+        break;
+      case "high":
+        str += "; Priority=High";
+        break;
+      default:
+        throw new TypeError("option priority is invalid");
+    }
+  }
+  if (opt.sameSite) {
+    const sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
+    switch (sameSite) {
+      case true:
+        str += "; SameSite=Strict";
+        break;
+      case "lax":
+        str += "; SameSite=Lax";
+        break;
+      case "strict":
+        str += "; SameSite=Strict";
+        break;
+      case "none":
+        str += "; SameSite=None";
+        break;
+      default:
+        throw new TypeError("option sameSite is invalid");
+    }
+  }
+  return str;
+}
+function isDate(val) {
+  return Object.prototype.toString.call(val) === "[object Date]" || val instanceof Date;
+}
+function tryDecode(str, decode2) {
+  try {
+    return decode2(str);
+  } catch {
+    return str;
+  }
+}
+function decode(str) {
+  return str.includes("%") ? decodeURIComponent(str) : str;
+}
+function encode(val) {
+  return encodeURIComponent(val);
+}
+
+export { parse as p, serialize as s };

package/.output/server/node_modules/@intlify/utils/dist/shared/utils.9f8159f5.mjs

@@ -0,0 +1,108 @@
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+function isURL(val) {
+  return toTypeString(val) === "[object URL]";
+}
+function isURLSearchParams(val) {
+  return toTypeString(val) === "[object URLSearchParams]";
+}
+function isLocale(val) {
+  return toTypeString(val) === "[object Intl.Locale]";
+}
+function toLocale(val) {
+  return isLocale(val) ? val : new Intl.Locale(val);
+}
+function validateLangTag(lang) {
+  try {
+    Intl.getCanonicalLocales(lang);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseAcceptLanguage(value) {
+  return value.split(",").map((tag) => tag.split(";")[0]).filter(
+    (tag) => !(tag === "*" || tag === "")
+  );
+}
+function normalizeLanguageName(langName) {
+  const [lang] = langName.split(".");
+  return lang.replace(/_/g, "-");
+}
+function createPathIndexLanguageParser(index = 0) {
+  return (path) => {
+    const rawPath = typeof path === "string" ? path : path.pathname;
+    const normalizedPath = rawPath.split("?")[0];
+    const parts = normalizedPath.split("/");
+    if (parts[0] === "") {
+      parts.shift();
+    }
+    return parts.length > index ? parts[index] || "" : "";
+  };
+}
+let pathLanguageParser = /* @__PURE__ */ createPathIndexLanguageParser();
+function registerPathLanguageParser(parser) {
+  pathLanguageParser = parser;
+}
+
+const DEFAULT_LANG_TAG = "en-US";
+const DEFAULT_COOKIE_NAME = "i18n_locale";
+const ACCEPT_LANGUAGE_HEADER = "accept-language";
+
+function parseDefaultHeader(input) {
+  return [input];
+}
+function getHeaderLanguagesWithGetter(getter, {
+  name = ACCEPT_LANGUAGE_HEADER,
+  parser = parseDefaultHeader
+} = {}) {
+  const langString = getter();
+  return langString ? name === ACCEPT_LANGUAGE_HEADER ? parser === parseDefaultHeader ? parseAcceptLanguage(langString) : parser(langString) : parser(langString) : [];
+}
+function getLocaleWithGetter(getter) {
+  return toLocale(getter());
+}
+function validateLocale(locale) {
+  if (!(isLocale(locale) || typeof locale === "string" && validateLangTag(locale))) {
+    throw new SyntaxError(`locale is invalid: ${locale.toString()}`);
+  }
+}
+function mapToLocaleFromLanguageTag(getter, ...args) {
+  return Reflect.apply(getter, null, args).map(
+    (lang) => getLocaleWithGetter(() => lang)
+  );
+}
+function getExistCookies(name, getter) {
+  let setCookies = getter();
+  if (!Array.isArray(setCookies)) {
+    setCookies = [setCookies];
+  }
+  setCookies = setCookies.filter(
+    (cookieValue) => cookieValue && !cookieValue.startsWith(name + "=")
+  );
+  return setCookies;
+}
+function getPathLanguage(path, { lang = DEFAULT_LANG_TAG, parser = pathLanguageParser } = {}) {
+  return (parser || pathLanguageParser)(path) || lang;
+}
+function getPathLocale(path, { lang = DEFAULT_LANG_TAG, parser = pathLanguageParser } = {}) {
+  return new Intl.Locale(getPathLanguage(path, { lang, parser }));
+}
+function getURLSearchParams(input) {
+  if (isURLSearchParams(input)) {
+    return input;
+  } else if (isURL(input)) {
+    return input.searchParams;
+  } else {
+    return new URLSearchParams(input);
+  }
+}
+function getQueryLanguage(query, { lang = DEFAULT_LANG_TAG, name = "lang" } = {}) {
+  const queryParams = getURLSearchParams(query);
+  return queryParams.get(name) || lang;
+}
+function getQueryLocale(query, { lang = DEFAULT_LANG_TAG, name = "locale" } = {}) {
+  return new Intl.Locale(getQueryLanguage(query, { lang, name }));
+}
+
+export { ACCEPT_LANGUAGE_HEADER as A, DEFAULT_LANG_TAG as D, getLocaleWithGetter as a, DEFAULT_COOKIE_NAME as b, getExistCookies as c, getPathLocale as d, pathLanguageParser as e, getQueryLocale as f, getHeaderLanguagesWithGetter as g, createPathIndexLanguageParser as h, isLocale as i, parseAcceptLanguage as j, validateLangTag as k, mapToLocaleFromLanguageTag as m, normalizeLanguageName as n, parseDefaultHeader as p, registerPathLanguageParser as r, validateLocale as v };

package/.output/server/node_modules/@intlify/utils/package.json

@@ -0,0 +1,129 @@
+{
+  "name": "@intlify/utils",
+  "version": "0.13.0",
+  "description": "Collection of i18n utilities",
+  "keywords": [
+    "i18n",
+    "internationalization",
+    "intlify",
+    "utilities"
+  ],
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/kazupon",
+  "bugs": {
+    "url": "https://github.com/intlify/utils/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/utils.git"
+  },
+  "homepage": "https://github.com/intlify/utils#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">= 18"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "browser": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./h3": {
+      "types": "./dist/h3.d.ts",
+      "import": "./dist/h3.mjs",
+      "require": "./dist/h3.cjs",
+      "default": "./dist/h3.mjs"
+    },
+    "./hono": {
+      "types": "./dist/hono.d.ts",
+      "import": "./dist/hono.mjs",
+      "require": "./dist/hono.cjs",
+      "default": "./dist/hono.mjs"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.mjs",
+      "require": "./dist/node.cjs",
+      "default": "./dist/node.mjs"
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepare": "git config --local core.hooksPath .githooks",
+    "changelog": "gh-changelogen --repo=intlify/utils",
+    "release": "bumpp --commit \"release: v%s\" --all --push --tag",
+    "version": "npx tsx scripts/bump-deno.ts",
+    "fix": "run-p lint format",
+    "lint": "deno lint",
+    "format": "deno fmt",
+    "build": "unbuild && bun run ./scripts/deno.ts",
+    "test": "npm run test:typecheck && npm run test:unit",
+    "test:unit": "NODE_OPTIONS=--experimental-vm-modules vitest run ./src",
+    "test:typecheck": "vitest --typecheck --config ./vitest.type.config.ts --run",
+    "test:coverage": "npm test -- --reporter verbose --coverage",
+    "test:e2e": "run-s test:e2e:*",
+    "test:e2e:browser": "cd playground/browser && node --test",
+    "test:e2e:node": "cd playground/node && node --test",
+    "test:e2e:deno": "cd playground/deno && deno task test",
+    "test:e2e:bun": "cd playground/bun && npm run test",
+    "setup": "run-s setup:*",
+    "setup:browser": "cd playground/browser && bun install",
+    "setup:node": "cd playground/node && bun install",
+    "setup:deno": "cd playground/deno && deno cache --reload ./main.ts",
+    "setup:bun": "cd playground/bun && bun install",
+    "play:browser": "cd playground/browser && npm run dev",
+    "play:node": "cd playground/node && npm run dev",
+    "play:deno": "cd playground/deno && deno run --allow-net main.ts",
+    "play:bun": "cd playground/bun && npm run dev"
+  },
+  "lint-staged": {
+    "*.{js,ts,jsx,tsx,json,jsonc}": [
+      "deno fmt"
+    ],
+    "*.{js,ts,jsx,tsx}": [
+      "deno lint"
+    ]
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20231016.0",
+    "@types/node": "^20.11.24",
+    "@types/semver": "^7.5.8",
+    "@types/supertest": "^2.0.12",
+    "@vitest/coverage-v8": "^1.3.0",
+    "bumpp": "^9.2.0",
+    "bun-types": "latest",
+    "cookie-es": "^1.0.0",
+    "gh-changelogen": "^0.2.8",
+    "h3": "^1.8.1",
+    "hono": "^3.8.1",
+    "jsonc-parser": "^3.2.1",
+    "lint-staged": "^15.0.0",
+    "miniflare": "^3.20231016.0",
+    "npm-run-all2": "^6.0.0",
+    "pkg-types": "^1.0.2",
+    "playwright": "^1.38.1",
+    "semver": "^7.6.0",
+    "supertest": "^6.3.3",
+    "typescript": "^5.4.1-rc",
+    "unbuild": "^2.0.0",
+    "vitest": "^1.3.0",
+    "vitest-environment-miniflare": "^2.14.1"
+  }
+}

package/.output/server/node_modules/@lukeed/ms/dist/index.mjs

@@ -0,0 +1,34 @@
+var RGX = /^(-?(?:\d+)?\.?\d+) *(m(?:illiseconds?|s(?:ecs?)?))?(s(?:ec(?:onds?|s)?)?)?(m(?:in(?:utes?|s)?)?)?(h(?:ours?|rs?)?)?(d(?:ays?)?)?(w(?:eeks?|ks?)?)?(y(?:ears?|rs?)?)?$/,
+	SEC = 1e3,
+	MIN = SEC * 60,
+	HOUR = MIN * 60,
+	DAY = HOUR * 24,
+	YEAR = DAY * 365.25;
+
+export function parse(val) {
+	var num, arr = val.toLowerCase().match(RGX);
+	if (arr != null && (num = parseFloat(arr[1]))) {
+		if (arr[3] != null) return num * SEC;
+		if (arr[4] != null) return num * MIN;
+		if (arr[5] != null) return num * HOUR;
+		if (arr[6] != null) return num * DAY;
+		if (arr[7] != null) return num * DAY * 7;
+		if (arr[8] != null) return num * YEAR;
+		return num;
+	}
+}
+
+function fmt(val, pfx, str, long) {
+	var num = (val | 0) === val ? val : ~~(val + 0.5);
+	return pfx + num + (long ? (' ' + str + (num != 1 ? 's' : '')) : str[0]);
+}
+
+export function format(num, long) {
+	var pfx = num < 0  ? '-' : '', abs = num < 0 ? -num : num;
+	if (abs < SEC) return num + (long ? ' ms' : 'ms');
+	if (abs < MIN) return fmt(abs / SEC, pfx, 'second', long);
+	if (abs < HOUR) return fmt(abs / MIN, pfx, 'minute', long);
+	if (abs < DAY) return fmt(abs / HOUR, pfx, 'hour', long);
+	if (abs < YEAR) return fmt(abs / DAY, pfx, 'day', long);
+	return fmt(abs / YEAR, pfx, 'year', long);
+}

package/.output/server/node_modules/@lukeed/ms/package.json

@@ -0,0 +1,48 @@
+{
+  "umd:name": "ms",
+  "version": "2.0.2",
+  "name": "@lukeed/ms",
+  "repository": "lukeed/ms",
+  "description": "A tiny (414B) and fast utility to convert milliseconds to and from strings.",
+  "unpkg": "dist/index.min.js",
+  "module": "dist/index.mjs",
+  "main": "dist/index.js",
+  "types": "index.d.ts",
+  "license": "MIT",
+  "author": {
+    "name": "Luke Edwards",
+    "email": "luke.edwards05@gmail.com",
+    "url": "https://lukeed.com"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=8"
+  },
+  "scripts": {
+    "build": "bundt",
+    "test": "uvu -r esm test"
+  },
+  "files": [
+    "*.d.ts",
+    "dist"
+  ],
+  "keywords": [
+    "ms",
+    "time",
+    "format",
+    "milliseconds",
+    "convert"
+  ],
+  "devDependencies": {
+    "bundt": "1.1.2",
+    "esm": "3.2.25",
+    "uvu": "0.5.1"
+  }
+}