renovate-log-parser 0.1.0

package/web/.output/server/node_modules/vue/dist/vue.cjs.js

@@ -0,0 +1,80 @@
+/**
+* vue v3.5.39
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerDom = require('@vue/compiler-dom');
+var runtimeDom = require('@vue/runtime-dom');
+var shared = require('@vue/shared');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    for (var k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var runtimeDom__namespace = /*#__PURE__*/_interopNamespaceDefault(runtimeDom);
+
+const compileCache = /* @__PURE__ */ Object.create(null);
+function compileToFunction(template, options) {
+  if (!shared.isString(template)) {
+    if (template.nodeType) {
+      template = template.innerHTML;
+    } else {
+      runtimeDom.warn(`invalid template option: `, template);
+      return shared.NOOP;
+    }
+  }
+  const key = shared.genCacheKey(template, options);
+  const cached = compileCache[key];
+  if (cached) {
+    return cached;
+  }
+  if (template[0] === "#") {
+    const el = document.querySelector(template);
+    if (!el) {
+      runtimeDom.warn(`Template element not found or is empty: ${template}`);
+    }
+    template = el ? el.innerHTML : ``;
+  }
+  const opts = shared.extend(
+    {
+      hoistStatic: true,
+      onError: onError ,
+      onWarn: (e) => onError(e, true) 
+    },
+    options
+  );
+  if (!opts.isCustomElement && typeof customElements !== "undefined") {
+    opts.isCustomElement = (tag) => !!customElements.get(tag);
+  }
+  const { code } = compilerDom.compile(template, opts);
+  function onError(err, asWarning = false) {
+    const message = asWarning ? err.message : `Template compilation error: ${err.message}`;
+    const codeFrame = err.loc && shared.generateCodeFrame(
+      template,
+      err.loc.start.offset,
+      err.loc.end.offset
+    );
+    runtimeDom.warn(codeFrame ? `${message}
+${codeFrame}` : message);
+  }
+  const render = new Function("Vue", code)(runtimeDom__namespace);
+  render._rc = true;
+  return compileCache[key] = render;
+}
+runtimeDom.registerRuntimeCompiler(compileToFunction);
+
+exports.compile = compileToFunction;
+Object.keys(runtimeDom).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = runtimeDom[k];
+});

package/web/.output/server/node_modules/vue/dist/vue.cjs.prod.js

@@ -0,0 +1,66 @@
+/**
+* vue v3.5.39
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerDom = require('@vue/compiler-dom');
+var runtimeDom = require('@vue/runtime-dom');
+var shared = require('@vue/shared');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    for (var k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var runtimeDom__namespace = /*#__PURE__*/_interopNamespaceDefault(runtimeDom);
+
+const compileCache = /* @__PURE__ */ Object.create(null);
+function compileToFunction(template, options) {
+  if (!shared.isString(template)) {
+    if (template.nodeType) {
+      template = template.innerHTML;
+    } else {
+      return shared.NOOP;
+    }
+  }
+  const key = shared.genCacheKey(template, options);
+  const cached = compileCache[key];
+  if (cached) {
+    return cached;
+  }
+  if (template[0] === "#") {
+    const el = document.querySelector(template);
+    template = el ? el.innerHTML : ``;
+  }
+  const opts = shared.extend(
+    {
+      hoistStatic: true,
+      onError: void 0,
+      onWarn: shared.NOOP
+    },
+    options
+  );
+  if (!opts.isCustomElement && typeof customElements !== "undefined") {
+    opts.isCustomElement = (tag) => !!customElements.get(tag);
+  }
+  const { code } = compilerDom.compile(template, opts);
+  const render = new Function("Vue", code)(runtimeDom__namespace);
+  render._rc = true;
+  return compileCache[key] = render;
+}
+runtimeDom.registerRuntimeCompiler(compileToFunction);
+
+exports.compile = compileToFunction;
+Object.keys(runtimeDom).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = runtimeDom[k];
+});

package/web/.output/server/node_modules/vue/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/vue.cjs.prod.js')
+} else {
+  module.exports = require('./dist/vue.cjs.js')
+}

package/web/.output/server/node_modules/vue/index.mjs

@@ -0,0 +1 @@
+export * from './index.js'

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

@@ -0,0 +1,112 @@
+{
+  "name": "vue",
+  "version": "3.5.39",
+  "description": "The progressive JavaScript framework for building modern web UI.",
+  "main": "index.js",
+  "module": "dist/vue.runtime.esm-bundler.js",
+  "types": "dist/vue.d.ts",
+  "unpkg": "dist/vue.global.js",
+  "jsdelivr": "dist/vue.global.js",
+  "files": [
+    "index.js",
+    "index.mjs",
+    "dist",
+    "compiler-sfc",
+    "server-renderer",
+    "jsx-runtime",
+    "jsx.d.ts"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/vue.d.mts",
+        "node": "./index.mjs",
+        "default": "./dist/vue.runtime.esm-bundler.js"
+      },
+      "require": {
+        "types": "./dist/vue.d.ts",
+        "node": {
+          "production": "./dist/vue.cjs.prod.js",
+          "development": "./dist/vue.cjs.js",
+          "default": "./dist/vue.cjs.prod.js"
+        },
+        "default": "./index.js"
+      }
+    },
+    "./server-renderer": {
+      "import": {
+        "types": "./server-renderer/index.d.mts",
+        "default": "./server-renderer/index.mjs"
+      },
+      "require": {
+        "types": "./server-renderer/index.d.ts",
+        "default": "./server-renderer/index.js"
+      }
+    },
+    "./compiler-sfc": {
+      "import": {
+        "types": "./compiler-sfc/index.d.mts",
+        "browser": "./compiler-sfc/index.browser.mjs",
+        "default": "./compiler-sfc/index.mjs"
+      },
+      "require": {
+        "types": "./compiler-sfc/index.d.ts",
+        "browser": "./compiler-sfc/index.browser.js",
+        "default": "./compiler-sfc/index.js"
+      }
+    },
+    "./jsx-runtime": {
+      "types": "./jsx-runtime/index.d.ts",
+      "import": "./jsx-runtime/index.mjs",
+      "require": "./jsx-runtime/index.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./jsx-runtime/index.d.ts",
+      "import": "./jsx-runtime/index.mjs",
+      "require": "./jsx-runtime/index.js"
+    },
+    "./jsx": "./jsx.d.ts",
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "buildOptions": {
+    "name": "Vue",
+    "formats": [
+      "esm-bundler",
+      "esm-bundler-runtime",
+      "cjs",
+      "global",
+      "global-runtime",
+      "esm-browser",
+      "esm-browser-runtime"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://vuejs.org/",
+  "dependencies": {
+    "@vue/shared": "3.5.39",
+    "@vue/runtime-dom": "3.5.39",
+    "@vue/server-renderer": "3.5.39",
+    "@vue/compiler-dom": "3.5.39",
+    "@vue/compiler-sfc": "3.5.39"
+  },
+  "peerDependencies": {
+    "typescript": "*"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  }
+}

package/web/.output/server/node_modules/vue/server-renderer/index.mjs

@@ -0,0 +1 @@
+export * from '@vue/server-renderer'

package/web/.output/server/node_modules/vue-bundle-renderer/dist/runtime.mjs

@@ -0,0 +1,249 @@
+import { withLeadingSlash } from "ufo";
+//#region src/runtime.ts
+function createRendererContext({ manifest, precomputed, buildAssetsURL, dependencySetsCacheSize }) {
+	if (!manifest && !precomputed) throw new Error("Either manifest or precomputed data must be provided");
+	const ctx = {
+		buildAssetsURL: buildAssetsURL || withLeadingSlash,
+		manifest,
+		precomputed,
+		updateManifest,
+		_dependencies: {},
+		_dependencySets: /* @__PURE__ */ new Map(),
+		_dependencySetsCacheSize: typeof dependencySetsCacheSize === "number" && Number.isFinite(dependencySetsCacheSize) && dependencySetsCacheSize > 0 ? Math.floor(dependencySetsCacheSize) : dependencySetsCacheSize === void 0 ? 1e3 : 0,
+		_entrypoints: []
+	};
+	function updateManifest(manifest) {
+		const manifestEntries = Object.entries(manifest);
+		ctx.manifest = manifest;
+		ctx._dependencies = {};
+		ctx._dependencySets.clear();
+		ctx._entrypoints = manifestEntries.filter((e) => e[1].isEntry).map(([module]) => module);
+	}
+	if (precomputed) {
+		ctx._dependencies = precomputed.dependencies;
+		ctx._entrypoints = precomputed.entrypoints;
+	} else if (manifest) updateManifest(manifest);
+	return ctx;
+}
+function getModuleDependencies(id, rendererContext) {
+	if (rendererContext._dependencies[id]) return rendererContext._dependencies[id];
+	const dependencies = rendererContext._dependencies[id] = {
+		scripts: {},
+		styles: {},
+		preload: {},
+		prefetch: {}
+	};
+	if (!rendererContext.manifest) return dependencies;
+	const meta = rendererContext.manifest[id];
+	if (!meta) return dependencies;
+	if (meta.file) {
+		dependencies.preload[id] = meta;
+		if (meta.isEntry || meta.sideEffects) dependencies.scripts[id] = meta;
+	}
+	for (const css of meta.css || []) dependencies.styles[css] = dependencies.preload[css] = dependencies.prefetch[css] = rendererContext.manifest[css];
+	for (const asset of meta.assets || []) dependencies.preload[asset] = dependencies.prefetch[asset] = rendererContext.manifest[asset];
+	for (const depId of meta.imports || []) {
+		const depDeps = getModuleDependencies(depId, rendererContext);
+		for (const key in depDeps.styles) dependencies.styles[key] = depDeps.styles[key];
+		for (const key in depDeps.preload) dependencies.preload[key] = depDeps.preload[key];
+		for (const key in depDeps.prefetch) dependencies.prefetch[key] = depDeps.prefetch[key];
+	}
+	const filteredPreload = {};
+	for (const id in dependencies.preload) {
+		const dep = dependencies.preload[id];
+		if (dep.preload) filteredPreload[id] = dep;
+	}
+	dependencies.preload = filteredPreload;
+	return dependencies;
+}
+function getAllDependencies(ids, rendererContext) {
+	const cacheSize = rendererContext._dependencySetsCacheSize;
+	const useCache = cacheSize > 0;
+	let cacheKey = "";
+	if (useCache) {
+		if (ids.size <= 1) for (const id of ids) cacheKey = id;
+		else cacheKey = [...ids].sort().join(",");
+		const cached = rendererContext._dependencySets.get(cacheKey);
+		if (cached !== void 0) {
+			if (rendererContext._dependencySets.size >= cacheSize) {
+				rendererContext._dependencySets.delete(cacheKey);
+				rendererContext._dependencySets.set(cacheKey, cached);
+			}
+			return cached;
+		}
+	}
+	const allDeps = {
+		scripts: {},
+		styles: {},
+		preload: {},
+		prefetch: {}
+	};
+	for (const id of ids) {
+		const deps = getModuleDependencies(id, rendererContext);
+		for (const key in deps.scripts) allDeps.scripts[key] = deps.scripts[key];
+		for (const key in deps.styles) allDeps.styles[key] = deps.styles[key];
+		for (const key in deps.preload) allDeps.preload[key] = deps.preload[key];
+		for (const key in deps.prefetch) allDeps.prefetch[key] = deps.prefetch[key];
+		for (const dynamicDepId of rendererContext.manifest?.[id]?.dynamicImports || []) {
+			const dynamicDeps = getModuleDependencies(dynamicDepId, rendererContext);
+			for (const key in dynamicDeps.scripts) allDeps.prefetch[key] = dynamicDeps.scripts[key];
+			for (const key in dynamicDeps.styles) allDeps.prefetch[key] = dynamicDeps.styles[key];
+			for (const key in dynamicDeps.preload) allDeps.prefetch[key] = dynamicDeps.preload[key];
+		}
+	}
+	const filteredPrefetch = {};
+	for (const id in allDeps.prefetch) {
+		const dep = allDeps.prefetch[id];
+		if (dep.prefetch) filteredPrefetch[id] = dep;
+	}
+	allDeps.prefetch = filteredPrefetch;
+	for (const id in allDeps.preload) delete allDeps.prefetch[id];
+	for (const style in allDeps.styles) {
+		delete allDeps.preload[style];
+		delete allDeps.prefetch[style];
+	}
+	if (useCache) {
+		rendererContext._dependencySets.set(cacheKey, allDeps);
+		if (rendererContext._dependencySets.size > cacheSize) {
+			const oldest = rendererContext._dependencySets.keys().next().value;
+			if (oldest !== void 0) rendererContext._dependencySets.delete(oldest);
+		}
+	}
+	return allDeps;
+}
+function getRequestDependencies(ssrContext, rendererContext, options) {
+	const excluded = options?.exclude ? new Set(options.exclude) : void 0;
+	const hasExcluded = excluded && excluded.size > 0;
+	if (!hasExcluded && ssrContext._requestDependencies) return ssrContext._requestDependencies;
+	let ids;
+	const requestIds = ssrContext.modules || ssrContext._registeredComponents;
+	if (hasExcluded) {
+		ids = /* @__PURE__ */ new Set();
+		for (const id of rendererContext._entrypoints) if (!excluded.has(id)) ids.add(id);
+		if (requestIds) {
+			for (const id of requestIds) if (!excluded.has(id)) ids.add(id);
+		}
+	} else {
+		ids = new Set(rendererContext._entrypoints);
+		if (requestIds) for (const id of requestIds) ids.add(id);
+	}
+	const deps = getAllDependencies(ids, rendererContext);
+	if (!hasExcluded) ssrContext._requestDependencies = deps;
+	return deps;
+}
+function renderStyles(ssrContext, rendererContext) {
+	const { styles } = getRequestDependencies(ssrContext, rendererContext);
+	let result = "";
+	for (const key in styles) {
+		const resource = styles[key];
+		result += `<link rel="stylesheet" href="${rendererContext.buildAssetsURL(resource.file)}" crossorigin>`;
+	}
+	return result;
+}
+function getResources(ssrContext, rendererContext) {
+	return [...getPreloadLinks(ssrContext, rendererContext), ...getPrefetchLinks(ssrContext, rendererContext)];
+}
+function renderResourceHints(ssrContext, rendererContext, options) {
+	const { preload, prefetch } = getRequestDependencies(ssrContext, rendererContext, options);
+	let result = "";
+	for (const key in preload) {
+		const resource = preload[key];
+		const href = rendererContext.buildAssetsURL(resource.file);
+		const rel = resource.module ? "modulepreload" : "preload";
+		const crossorigin = resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? " crossorigin" : "";
+		if (resource.resourceType && resource.mimeType) result += `<link rel="${rel}" as="${resource.resourceType}" type="${resource.mimeType}"${crossorigin} href="${href}">`;
+		else if (resource.resourceType) result += `<link rel="${rel}" as="${resource.resourceType}"${crossorigin} href="${href}">`;
+		else result += `<link rel="${rel}"${crossorigin} href="${href}">`;
+	}
+	for (const key in prefetch) {
+		const resource = prefetch[key];
+		const href = rendererContext.buildAssetsURL(resource.file);
+		const crossorigin = resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? " crossorigin" : "";
+		if (resource.resourceType && resource.mimeType) result += `<link rel="prefetch" as="${resource.resourceType}" type="${resource.mimeType}"${crossorigin} href="${href}">`;
+		else if (resource.resourceType) result += `<link rel="prefetch" as="${resource.resourceType}"${crossorigin} href="${href}">`;
+		else result += `<link rel="prefetch"${crossorigin} href="${href}">`;
+	}
+	return result;
+}
+function renderResourceHeaders(ssrContext, rendererContext, options) {
+	const { preload, prefetch } = getRequestDependencies(ssrContext, rendererContext, options);
+	const links = [];
+	for (const key in preload) {
+		const resource = preload[key];
+		let header = `<${rendererContext.buildAssetsURL(resource.file)}>; rel="${resource.module ? "modulepreload" : "preload"}"`;
+		if (resource.resourceType) header += `; as="${resource.resourceType}"`;
+		if (resource.mimeType) header += `; type="${resource.mimeType}"`;
+		if (resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module) header += "; crossorigin";
+		links.push(header);
+	}
+	for (const key in prefetch) {
+		const resource = prefetch[key];
+		let header = `<${rendererContext.buildAssetsURL(resource.file)}>; rel="prefetch"`;
+		if (resource.resourceType) header += `; as="${resource.resourceType}"`;
+		if (resource.mimeType) header += `; type="${resource.mimeType}"`;
+		if (resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module) header += "; crossorigin";
+		links.push(header);
+	}
+	return { link: links.join(", ") };
+}
+function getPreloadLinks(ssrContext, rendererContext, options) {
+	const { preload } = getRequestDependencies(ssrContext, rendererContext, options);
+	const result = [];
+	for (const key in preload) {
+		const resource = preload[key];
+		result.push({
+			rel: resource.module ? "modulepreload" : "preload",
+			as: resource.resourceType,
+			type: resource.mimeType ?? null,
+			crossorigin: resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+			href: rendererContext.buildAssetsURL(resource.file)
+		});
+	}
+	return result;
+}
+function getPrefetchLinks(ssrContext, rendererContext, options) {
+	const { prefetch } = getRequestDependencies(ssrContext, rendererContext, options);
+	const result = [];
+	for (const key in prefetch) {
+		const resource = prefetch[key];
+		result.push({
+			rel: "prefetch",
+			as: resource.resourceType,
+			type: resource.mimeType ?? null,
+			crossorigin: resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+			href: rendererContext.buildAssetsURL(resource.file)
+		});
+	}
+	return result;
+}
+function renderScripts(ssrContext, rendererContext) {
+	const { scripts } = getRequestDependencies(ssrContext, rendererContext);
+	let result = "";
+	for (const key in scripts) {
+		const resource = scripts[key];
+		if (resource.module) result += `<script type="module" src="${rendererContext.buildAssetsURL(resource.file)}" crossorigin><\/script>`;
+		else result += `<script src="${rendererContext.buildAssetsURL(resource.file)}" defer crossorigin><\/script>`;
+	}
+	return result;
+}
+function createRenderer(createApp, renderOptions) {
+	const rendererContext = createRendererContext(renderOptions);
+	return {
+		rendererContext,
+		async renderToString(ssrContext) {
+			ssrContext._registeredComponents = ssrContext._registeredComponents || /* @__PURE__ */ new Set();
+			const app = await (await Promise.resolve(createApp).then((r) => "default" in r ? r.default : r))(ssrContext);
+			const html = await renderOptions.renderToString(app, ssrContext);
+			const wrap = (fn) => () => fn(ssrContext, rendererContext);
+			return {
+				html,
+				renderResourceHeaders: wrap(renderResourceHeaders),
+				renderResourceHints: wrap(renderResourceHints),
+				renderStyles: wrap(renderStyles),
+				renderScripts: wrap(renderScripts)
+			};
+		}
+	};
+}
+//#endregion
+export { createRenderer, createRendererContext, getAllDependencies, getModuleDependencies, getPrefetchLinks, getPreloadLinks, getRequestDependencies, getResources, renderResourceHeaders, renderResourceHints, renderScripts, renderStyles };

package/web/.output/server/node_modules/vue-bundle-renderer/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "vue-bundle-renderer",
+  "version": "2.3.1",
+  "description": "Bundle Renderer for Vue 3.0",
+  "repository": {
+    "type": "git",
+    "url": "nuxt-contrib/vue-bundle-renderer"
+  },
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.mts",
+      "import": "./dist/runtime.mjs",
+      "require": "./dist/runtime.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist",
+    "runtime.d.ts"
+  ],
+  "dependencies": {
+    "ufo": "^1.6.4"
+  },
+  "devDependencies": {
+    "@codspeed/vitest-plugin": "^5.6.0",
+    "@nuxt/eslint-config": "^1.16.0",
+    "@types/node": "^24.13.2",
+    "@types/semver": "^7.7.1",
+    "@vitest/coverage-v8": "^4.1.9",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.5.0",
+    "pkg-pr-new": "^0.0.75",
+    "semver": "^7.8.5",
+    "std-env": "^4.1.0",
+    "tsdown": "0.22.3",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16",
+    "vitest": "4.1.9",
+    "vue": "3.5.38"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "vitest",
+    "lint": "eslint src",
+    "test": "pnpm lint && pnpm vitest run --coverage && tsc --noEmit",
+    "bench": "vitest bench"
+  }
+}

package/web/.output/server/node_modules/vue-demi/lib/index.mjs

@@ -0,0 +1,34 @@
+import * as Vue from 'vue'
+
+var isVue2 = false
+var isVue3 = true
+var Vue2 = undefined
+
+function install() {}
+
+export function set(target, key, val) {
+  if (Array.isArray(target)) {
+    target.length = Math.max(target.length, key)
+    target.splice(key, 1, val)
+    return val
+  }
+  target[key] = val
+  return val
+}
+
+export function del(target, key) {
+  if (Array.isArray(target)) {
+    target.splice(key, 1)
+    return
+  }
+  delete target[key]
+}
+
+export * from 'vue'
+export {
+  Vue,
+  Vue2,
+  isVue2,
+  isVue3,
+  install,
+}

package/web/.output/server/node_modules/vue-demi/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "vue-demi",
+  "version": "0.14.10",
+  "engines": {
+    "node": ">=12"
+  },
+  "repository": "https://github.com/antfu/vue-demi.git",
+  "funding": "https://github.com/sponsors/antfu",
+  "license": "MIT",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "main": "lib/index.cjs",
+  "jsdelivr": "lib/index.iife.js",
+  "unpkg": "lib/index.iife.js",
+  "module": "lib/index.mjs",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "require": "./lib/index.cjs",
+      "import": "./lib/index.mjs",
+      "browser": "./lib/index.mjs"
+    },
+    "./*": "./*"
+  },
+  "bin": {
+    "vue-demi-fix": "bin/vue-demi-fix.js",
+    "vue-demi-switch": "bin/vue-demi-switch.js"
+  },
+  "files": [
+    "lib",
+    "bin",
+    "scripts"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"try{require('./scripts/postinstall.js')}catch(e){}\"",
+    "release": "npx bumpp --tag --commit --push && npm publish"
+  },
+  "peerDependencies": {
+    "@vue/composition-api": "^1.0.0-rc.1",
+    "vue": "^3.0.0-0 || ^2.6.0"
+  },
+  "peerDependenciesMeta": {
+    "@vue/composition-api": {
+      "optional": true
+    }
+  }
+}