renovate-log-parser 0.1.0 → 0.1.2

package/web/.output/server/node_modules/unhead/dist/shared/unhead.Dh1cQCTe.mjs

@@ -1,44 +0,0 @@
-import { S as SafeInputPlugin, F as FlatMetaPlugin } from './unhead.D4vSFytZ.mjs';
-
-function useHead(unhead, input, options = {}) {
-  return unhead.push(input || {}, options);
-}
-function useHeadSafe(unhead, input = {}, options = {}) {
-  unhead.use(SafeInputPlugin);
-  return useHead(unhead, input, Object.assign(options, { _safe: true }));
-}
-function useSeoMeta(unhead, input = {}, options) {
-  unhead.use(FlatMetaPlugin);
-  function normalize(input2) {
-    if (input2._flatMeta) {
-      return input2;
-    }
-    const { title, titleTemplate, ...meta } = input2 || {};
-    return {
-      title,
-      titleTemplate,
-      _flatMeta: meta
-    };
-  }
-  const entry = unhead.push(normalize(input), options);
-  const corePatch = entry.patch;
-  if (!entry.__patched) {
-    entry.patch = (input2) => corePatch(normalize(input2));
-    entry.__patched = true;
-  }
-  return entry;
-}
-function useServerHead(unhead, input = {}, options = {}) {
-  options.mode = "server";
-  return unhead.push(input, options);
-}
-function useServerHeadSafe(unhead, input = {}, options = {}) {
-  options.mode = "server";
-  return useHeadSafe(unhead, input, { ...options, mode: "server" });
-}
-function useServerSeoMeta(unhead, input = {}, options) {
-  options.mode = "server";
-  return useSeoMeta(unhead, input, { ...options, mode: "server" });
-}
-
-export { useHeadSafe as a, useSeoMeta as b, useServerHead as c, useServerHeadSafe as d, useServerSeoMeta as e, useHead as u };

package/web/.output/server/node_modules/unhead/dist/shared/unhead.TxTMM7cM.mjs

@@ -1,166 +0,0 @@
-import { d as defineHeadPlugin } from './unhead.D4vSFytZ.mjs';
-import { s as sortTags } from './unhead.CbpEuj3y.mjs';
-import { p as processTemplateParams } from './unhead.BYvz9V1x.mjs';
-
-const formatKey = (k) => !k.includes(":key") ? k.split(":").join(":key:") : k;
-const AliasSortingPlugin = defineHeadPlugin({
-  key: "aliasSorting",
-  hooks: {
-    "tags:resolve": (ctx) => {
-      let m = false;
-      for (const t of ctx.tags) {
-        const p = t.tagPriority;
-        if (!p)
-          continue;
-        const s = String(p);
-        if (s.startsWith("before:")) {
-          const k = formatKey(s.slice(7));
-          const l = ctx.tagMap.get(k);
-          if (l) {
-            if (typeof l.tagPriority === "number")
-              t.tagPriority = l.tagPriority;
-            t._p = l._p - 1;
-            m = true;
-          }
-        } else if (s.startsWith("after:")) {
-          const k = formatKey(s.slice(6));
-          const l = ctx.tagMap.get(k);
-          if (l) {
-            if (typeof l.tagPriority === "number")
-              t.tagPriority = l.tagPriority;
-            t._p = l._p + 1;
-            m = true;
-          }
-        }
-      }
-      if (m)
-        ctx.tags = ctx.tags.sort(sortTags);
-    }
-  }
-});
-
-const DeprecationsPlugin = /* @__PURE__ */ defineHeadPlugin({
-  key: "deprecations",
-  hooks: {
-    "entries:normalize": ({ tags }) => {
-      for (const tag of tags) {
-        if (tag.props.children) {
-          tag.innerHTML = tag.props.children;
-          delete tag.props.children;
-        }
-        if (tag.props.hid) {
-          tag.key = tag.props.hid;
-          delete tag.props.hid;
-        }
-        if (tag.props.vmid) {
-          tag.key = tag.props.vmid;
-          delete tag.props.vmid;
-        }
-        if (tag.props.body) {
-          tag.tagPosition = "bodyClose";
-          delete tag.props.body;
-        }
-      }
-    }
-  }
-});
-
-async function walkPromises(v) {
-  const type = typeof v;
-  if (type === "function") {
-    return v;
-  }
-  if (v instanceof Promise) {
-    return await v;
-  }
-  if (Array.isArray(v)) {
-    return await Promise.all(v.map((r) => walkPromises(r)));
-  }
-  if (v?.constructor === Object) {
-    const next = {};
-    for (const key of Object.keys(v)) {
-      next[key] = await walkPromises(v[key]);
-    }
-    return next;
-  }
-  return v;
-}
-const PromisesPlugin = /* @__PURE__ */ defineHeadPlugin({
-  key: "promises",
-  hooks: {
-    "entries:resolve": async (ctx) => {
-      const promises = [];
-      for (const k in ctx.entries) {
-        if (!ctx.entries[k]._promisesProcessed) {
-          promises.push(
-            walkPromises(ctx.entries[k].input).then((val) => {
-              ctx.entries[k].input = val;
-              ctx.entries[k]._promisesProcessed = true;
-            })
-          );
-        }
-      }
-      await Promise.all(promises);
-    }
-  }
-});
-
-const SupportedAttrs = {
-  meta: "content",
-  link: "href",
-  htmlAttrs: "lang"
-};
-const contentAttrs = ["innerHTML", "textContent"];
-const TemplateParamsPlugin = /* @__PURE__ */ defineHeadPlugin((head) => {
-  return {
-    key: "template-params",
-    hooks: {
-      "entries:normalize": (ctx) => {
-        const params = ctx.tags.filter((t) => t.tag === "templateParams" && t.mode === "server")?.[0]?.props || {};
-        if (Object.keys(params).length) {
-          head._ssrPayload = {
-            templateParams: {
-              ...head._ssrPayload?.templateParams || {},
-              ...params
-            }
-          };
-        }
-      },
-      "tags:resolve": ({ tagMap, tags }) => {
-        const params = tagMap.get("templateParams")?.props || {};
-        const sep = params.separator || "|";
-        delete params.separator;
-        params.pageTitle = processTemplateParams(
-          // find templateParams
-          params.pageTitle || head._title || "",
-          params,
-          sep
-        );
-        for (const tag of tags) {
-          if (tag.processTemplateParams === false) {
-            continue;
-          }
-          const v = SupportedAttrs[tag.tag];
-          if (v && typeof tag.props[v] === "string") {
-            tag.props[v] = processTemplateParams(tag.props[v], params, sep);
-          } else if (tag.processTemplateParams || tag.tag === "titleTemplate" || tag.tag === "title") {
-            for (const p of contentAttrs) {
-              if (typeof tag[p] === "string")
-                tag[p] = processTemplateParams(tag[p], params, sep, tag.tag === "script" && tag.props.type.endsWith("json"));
-            }
-          }
-        }
-        head._templateParams = params;
-        head._separator = sep;
-      },
-      "tags:afterResolve": ({ tagMap }) => {
-        const title = tagMap.get("title");
-        if (title?.textContent && title.processTemplateParams !== false) {
-          title.textContent = processTemplateParams(title.textContent, head._templateParams, head._separator);
-        }
-      }
-    }
-  };
-});
-
-export { AliasSortingPlugin as A, DeprecationsPlugin as D, PromisesPlugin as P, TemplateParamsPlugin as T };

package/web/.output/server/node_modules/unhead/dist/shared/unhead.yem5I2v_.mjs

@@ -1,38 +0,0 @@
-const SelfClosingTags = /* @__PURE__ */ new Set(["meta", "link", "base"]);
-const DupeableTags = /* @__PURE__ */ new Set(["link", "style", "script", "noscript"]);
-const TagsWithInnerContent = /* @__PURE__ */ new Set(["title", "titleTemplate", "script", "style", "noscript"]);
-const HasElementTags = /* @__PURE__ */ new Set([
-  "base",
-  "meta",
-  "link",
-  "style",
-  "script",
-  "noscript"
-]);
-const ValidHeadTags = /* @__PURE__ */ new Set([
-  "title",
-  "base",
-  "htmlAttrs",
-  "bodyAttrs",
-  "meta",
-  "link",
-  "style",
-  "script",
-  "noscript"
-]);
-const UniqueTags = /* @__PURE__ */ new Set(["base", "title", "titleTemplate", "bodyAttrs", "htmlAttrs", "templateParams"]);
-const TagConfigKeys = /* @__PURE__ */ new Set(["key", "tagPosition", "tagPriority", "tagDuplicateStrategy", "innerHTML", "textContent", "processTemplateParams"]);
-const ScriptNetworkEvents = /* @__PURE__ */ new Set(["onload", "onerror"]);
-const UsesMergeStrategy = /* @__PURE__ */ new Set(["templateParams", "htmlAttrs", "bodyAttrs"]);
-const MetaTagsArrayable = /* @__PURE__ */ new Set([
-  "theme-color",
-  "google-site-verification",
-  "og",
-  "article",
-  "book",
-  "profile",
-  "twitter",
-  "author"
-]);
-
-export { DupeableTags as D, HasElementTags as H, MetaTagsArrayable as M, SelfClosingTags as S, TagsWithInnerContent as T, UniqueTags as U, ValidHeadTags as V, TagConfigKeys as a, ScriptNetworkEvents as b, UsesMergeStrategy as c };

package/web/.output/server/node_modules/unhead/dist/utils.mjs

@@ -1,5 +0,0 @@
-export { D as DupeableTags, H as HasElementTags, M as MetaTagsArrayable, b as ScriptNetworkEvents, S as SelfClosingTags, a as TagConfigKeys, T as TagsWithInnerContent, U as UniqueTags, c as UsesMergeStrategy, V as ValidHeadTags } from './shared/unhead.yem5I2v_.mjs';
-export { d as dedupeKey, h as hashTag, i as isMetaArrayDupeKey, n as normalizeEntryToTags, a as normalizeProps, w as walkResolver } from './shared/unhead.B3VbJo7Y.mjs';
-export { r as resolveMetaKeyType, a as resolveMetaKeyValue, b as resolvePackedMetaObjectValue, u as unpackMeta } from './shared/unhead.DQc16pHI.mjs';
-export { s as sortTags, t as tagWeight } from './shared/unhead.CbpEuj3y.mjs';
-export { p as processTemplateParams } from './shared/unhead.BYvz9V1x.mjs';

package/web/.output/server/node_modules/unhead/node_modules/hookable/dist/index.mjs

@@ -1,257 +0,0 @@
-function flatHooks(configHooks, hooks = {}, parentName) {
-	for (const key in configHooks) {
-		const subHook = configHooks[key];
-		const name = parentName ? `${parentName}:${key}` : key;
-		if (typeof subHook === "object" && subHook !== null) flatHooks(subHook, hooks, name);
-		else if (typeof subHook === "function") hooks[name] = subHook;
-	}
-	return hooks;
-}
-function mergeHooks(...hooks) {
-	const finalHooks = {};
-	for (const hook of hooks) {
-		const flatenHook = flatHooks(hook);
-		for (const key in flatenHook) if (finalHooks[key]) finalHooks[key].push(flatenHook[key]);
-		else finalHooks[key] = [flatenHook[key]];
-	}
-	for (const key in finalHooks) if (finalHooks[key].length > 1) {
-		const array = finalHooks[key];
-		finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
-	} else finalHooks[key] = finalHooks[key][0];
-	return finalHooks;
-}
-function serial(tasks, function_) {
-	return tasks.reduce((promise, task) => promise.then(() => function_(task)), Promise.resolve());
-}
-const createTask = /* @__PURE__ */ (() => {
-	if (console.createTask) return console.createTask;
-	const defaultTask = { run: (fn) => fn() };
-	return () => defaultTask;
-})();
-function callHooks(hooks, args, startIndex, task) {
-	for (let i = startIndex; i < hooks.length; i += 1) try {
-		const result = task ? task.run(() => hooks[i](...args)) : hooks[i](...args);
-		if (result && typeof result.then === "function") return Promise.resolve(result).then(() => callHooks(hooks, args, i + 1, task));
-	} catch (error) {
-		return Promise.reject(error);
-	}
-}
-function serialTaskCaller(hooks, args, name) {
-	if (hooks.length > 0) return callHooks(hooks, args, 0, createTask(name));
-}
-function parallelTaskCaller(hooks, args, name) {
-	if (hooks.length > 0) {
-		const task = createTask(name);
-		return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
-	}
-}
-function serialCaller(hooks, arguments_) {
-	return hooks.reduce((promise, hookFunction) => promise.then(() => hookFunction(...arguments_ || [])), Promise.resolve());
-}
-function parallelCaller(hooks, args) {
-	return Promise.all(hooks.map((hook) => hook(...args || [])));
-}
-function callEachWith(callbacks, arg0) {
-	for (const callback of [...callbacks]) callback(arg0);
-}
-var Hookable = class {
-	_hooks;
-	_before;
-	_after;
-	_deprecatedHooks;
-	_deprecatedMessages;
-	constructor() {
-		this._hooks = {};
-		this._before = void 0;
-		this._after = void 0;
-		this._deprecatedMessages = void 0;
-		this._deprecatedHooks = {};
-		this.hook = this.hook.bind(this);
-		this.callHook = this.callHook.bind(this);
-		this.callHookWith = this.callHookWith.bind(this);
-	}
-	hook(name, function_, options = {}) {
-		if (!name || typeof function_ !== "function") return () => {};
-		const originalName = name;
-		let dep;
-		while (this._deprecatedHooks[name]) {
-			dep = this._deprecatedHooks[name];
-			name = dep.to;
-		}
-		if (dep && !options.allowDeprecated) {
-			let message = dep.message;
-			if (!message) message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
-			if (!this._deprecatedMessages) this._deprecatedMessages = /* @__PURE__ */ new Set();
-			if (!this._deprecatedMessages.has(message)) {
-				console.warn(message);
-				this._deprecatedMessages.add(message);
-			}
-		}
-		if (!function_.name) try {
-			Object.defineProperty(function_, "name", {
-				get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
-				configurable: true
-			});
-		} catch {}
-		this._hooks[name] = this._hooks[name] || [];
-		this._hooks[name].push(function_);
-		return () => {
-			if (function_) {
-				this.removeHook(name, function_);
-				function_ = void 0;
-			}
-		};
-	}
-	hookOnce(name, function_) {
-		let _unreg;
-		let _function = (...arguments_) => {
-			if (typeof _unreg === "function") _unreg();
-			_unreg = void 0;
-			_function = void 0;
-			return function_(...arguments_);
-		};
-		_unreg = this.hook(name, _function);
-		return _unreg;
-	}
-	removeHook(name, function_) {
-		const hooks = this._hooks[name];
-		if (hooks) {
-			const index = hooks.indexOf(function_);
-			if (index !== -1) hooks.splice(index, 1);
-			if (hooks.length === 0) this._hooks[name] = void 0;
-		}
-	}
-	clearHook(name) {
-		this._hooks[name] = void 0;
-	}
-	deprecateHook(name, deprecated) {
-		this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
-		const _hooks = this._hooks[name] || [];
-		this._hooks[name] = void 0;
-		for (const hook of _hooks) this.hook(name, hook);
-	}
-	deprecateHooks(deprecatedHooks) {
-		for (const name in deprecatedHooks) this.deprecateHook(name, deprecatedHooks[name]);
-	}
-	addHooks(configHooks) {
-		const hooks = flatHooks(configHooks);
-		const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
-		return () => {
-			for (const unreg of removeFns) unreg();
-			removeFns.length = 0;
-		};
-	}
-	removeHooks(configHooks) {
-		const hooks = flatHooks(configHooks);
-		for (const key in hooks) this.removeHook(key, hooks[key]);
-	}
-	removeAllHooks() {
-		this._hooks = {};
-	}
-	callHook(name, ...args) {
-		return this.callHookWith(serialTaskCaller, name, args);
-	}
-	callHookParallel(name, ...args) {
-		return this.callHookWith(parallelTaskCaller, name, args);
-	}
-	callHookWith(caller, name, args) {
-		const event = this._before || this._after ? {
-			name,
-			args,
-			context: {}
-		} : void 0;
-		if (this._before) callEachWith(this._before, event);
-		const result = caller(this._hooks[name] ? [...this._hooks[name]] : [], args, name);
-		if (result instanceof Promise) return result.finally(() => {
-			if (this._after && event) callEachWith(this._after, event);
-		});
-		if (this._after && event) callEachWith(this._after, event);
-		return result;
-	}
-	beforeEach(function_) {
-		this._before = this._before || [];
-		this._before.push(function_);
-		return () => {
-			if (this._before !== void 0) {
-				const index = this._before.indexOf(function_);
-				if (index !== -1) this._before.splice(index, 1);
-			}
-		};
-	}
-	afterEach(function_) {
-		this._after = this._after || [];
-		this._after.push(function_);
-		return () => {
-			if (this._after !== void 0) {
-				const index = this._after.indexOf(function_);
-				if (index !== -1) this._after.splice(index, 1);
-			}
-		};
-	}
-};
-function createHooks() {
-	return new Hookable();
-}
-var HookableCore = class {
-	_hooks;
-	constructor() {
-		this._hooks = {};
-	}
-	hook(name, fn) {
-		if (!name || typeof fn !== "function") return () => {};
-		this._hooks[name] = this._hooks[name] || [];
-		this._hooks[name].push(fn);
-		return () => {
-			if (fn) {
-				this.removeHook(name, fn);
-				fn = void 0;
-			}
-		};
-	}
-	removeHook(name, function_) {
-		const hooks = this._hooks[name];
-		if (hooks) {
-			const index = hooks.indexOf(function_);
-			if (index !== -1) hooks.splice(index, 1);
-			if (hooks.length === 0) this._hooks[name] = void 0;
-		}
-	}
-	callHook(name, ...args) {
-		const hooks = this._hooks[name];
-		if (!hooks || hooks.length === 0) return;
-		return callHooks(hooks, args, 0);
-	}
-};
-const isBrowser = typeof window !== "undefined";
-function createDebugger(hooks, _options = {}) {
-	const options = {
-		inspect: isBrowser,
-		group: isBrowser,
-		filter: () => true,
-		..._options
-	};
-	const _filter = options.filter;
-	const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
-	const _tag = options.tag ? `[${options.tag}] ` : "";
-	const logPrefix = (event) => _tag + event.name + "".padEnd(event._id, "\0");
-	const _idCtr = {};
-	const unsubscribeBefore = hooks.beforeEach((event) => {
-		if (filter !== void 0 && !filter(event.name)) return;
-		_idCtr[event.name] = _idCtr[event.name] || 0;
-		event._id = _idCtr[event.name]++;
-		console.time(logPrefix(event));
-	});
-	const unsubscribeAfter = hooks.afterEach((event) => {
-		if (filter !== void 0 && !filter(event.name)) return;
-		if (options.group) console.groupCollapsed(event.name);
-		if (options.inspect) console.timeLog(logPrefix(event), event.args);
-		else console.timeEnd(logPrefix(event));
-		if (options.group) console.groupEnd();
-		_idCtr[event.name]--;
-	});
-	return { close: () => {
-		unsubscribeBefore();
-		unsubscribeAfter();
-	} };
-}
-export { Hookable, HookableCore, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };

package/web/.output/server/node_modules/unhead/node_modules/hookable/package.json

@@ -1,53 +0,0 @@
-{
-  "name": "hookable",
-  "version": "6.1.1",
-  "description": "Awaitable hook system",
-  "keywords": [
-    "hook",
-    "hookable",
-    "plugin",
-    "tapable",
-    "tappable"
-  ],
-  "license": "MIT",
-  "repository": "unjs/hookable",
-  "files": [
-    "dist"
-  ],
-  "type": "module",
-  "sideEffects": false,
-  "main": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
-  "exports": {
-    ".": "./dist/index.mjs"
-  },
-  "scripts": {
-    "bench": "node --expose-gc --allow-natives-syntax test/bench.ts",
-    "build": "obuild src/index.ts",
-    "dev": "vitest",
-    "lint": "oxlint . && oxfmt --check src test",
-    "lint:fix": "oxlint . --fix && oxfmt src test",
-    "prepublish": "pnpm build",
-    "release": "pnpm test && pnpm build && changelogen --release --publish --push",
-    "test": "pnpm lint && vitest run --coverage",
-    "test:types": "tsgo --noEmit"
-  },
-  "devDependencies": {
-    "@types/node": "^25.6.0",
-    "@typescript/native-preview": "^7.0.0-dev.20260414.1",
-    "@vitest/coverage-v8": "^4.1.4",
-    "changelogen": "^0.6.2",
-    "esbuild": "^0.28.0",
-    "eslint-config-unjs": "^0.6.2",
-    "expect-type": "^1.3.0",
-    "hookable-prev": "npm:hookable@^6.1.0",
-    "mitata": "^1.0.34",
-    "obuild": "^0.4.33",
-    "oxfmt": "^0.45.0",
-    "oxlint": "^1.60.0",
-    "typescript": "^6.0.2",
-    "vite": "^8.0.8",
-    "vitest": "^4.1.4"
-  },
-  "packageManager": "pnpm@10.33.0"
-}

package/web/.output/server/node_modules/unhead/package.json

@@ -1,105 +0,0 @@
-{
-  "name": "unhead",
-  "type": "module",
-  "version": "2.1.15",
-  "description": "Full-stack <head> manager built for any framework.",
-  "author": {
-    "name": "Harlan Wilton",
-    "email": "harlan@harlanzw.com",
-    "url": "https://harlanzw.com/"
-  },
-  "publishConfig": {
-    "access": "public",
-    "tag": "2x"
-  },
-  "license": "MIT",
-  "funding": "https://github.com/sponsors/harlan-zw",
-  "homepage": "https://unhead.unjs.io",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/unjs/unhead.git",
-    "directory": "packages/unhead"
-  },
-  "bugs": {
-    "url": "https://github.com/unjs/unhead/issues"
-  },
-  "sideEffects": false,
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.mjs"
-    },
-    "./plugins": {
-      "types": "./dist/plugins.d.ts",
-      "default": "./dist/plugins.mjs"
-    },
-    "./server": {
-      "types": "./dist/server.d.ts",
-      "default": "./dist/server.mjs"
-    },
-    "./client": {
-      "types": "./dist/client.d.ts",
-      "default": "./dist/client.mjs"
-    },
-    "./legacy": {
-      "types": "./dist/legacy.d.ts",
-      "default": "./dist/legacy.mjs"
-    },
-    "./utils": {
-      "types": "./dist/utils.d.ts",
-      "default": "./dist/utils.mjs"
-    },
-    "./types": {
-      "types": "./dist/types.d.ts",
-      "default": "./dist/types.mjs"
-    },
-    "./scripts": {
-      "types": "./dist/scripts.d.ts",
-      "default": "./dist/scripts.mjs"
-    },
-    "./parser": {
-      "types": "./dist/parser.d.ts",
-      "default": "./dist/parser.mjs"
-    }
-  },
-  "main": "dist/index.mjs",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
-  "optionalPlugins": {
-    "*": {
-      "plugins": [
-        "dist/plugins"
-      ],
-      "server": [
-        "dist/server"
-      ],
-      "client": [
-        "dist/client"
-      ],
-      "legacy": [
-        "dist/legacy"
-      ],
-      "types": [
-        "dist/types"
-      ],
-      "utils": [
-        "dist/utils"
-      ],
-      "scripts": [
-        "dist/scripts"
-      ]
-    }
-  },
-  "files": [
-    "*.d.ts",
-    "dist"
-  ],
-  "dependencies": {
-    "hookable": "^6.0.1"
-  },
-  "scripts": {
-    "build": "unbuild",
-    "stub": "unbuild --stub",
-    "test:attw": "attw --pack"
-  }
-}