@markless/bundler 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jack Shelton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @markless/bundler
+
+Markless build plugins for Rolldown and Vite. Used through
+`@markless/core/vite` and `@markless/core/rolldown`; install `@markless/core`
+instead unless you are integrating the plugins directly.
+
+See the repository for documentation: https://github.com/markless-dev/markless

package/dist/preload.d.ts

@@ -0,0 +1,79 @@
+import { o as MarklessBundleGraph } from "./types-D6KerlYq.js";
+import { r as symbolVirtualModuleSourceFile } from "./source-module-BRb5P7wL.js";
+
+//#region src/build/preload-plan.d.ts
+type ModulePreloadPlanInput = {
+  readonly bundleGraph: MarklessBundleGraph | undefined;
+  readonly roots: readonly ModulePreloadRoot[];
+  readonly base?: string;
+  readonly minProbability?: number;
+  readonly maxPreloads?: number;
+};
+type ModulePreloadRoot = string | {
+  readonly name: string;
+  readonly priority?: ModulePreloadPriority;
+  readonly fetchPriority?: ModulePreloadFetchPriority;
+  readonly edges?: 'all' | 'dynamic-only';
+};
+type ModulePreloadPriority = 'high' | 'auto' | 'low';
+type ModulePreloadFetchPriority = 'high' | 'auto' | 'low';
+type ModulePreloadPlanEntry = {
+  readonly href: string;
+  readonly name: string;
+  readonly priority: ModulePreloadPriority;
+  readonly fetchPriority?: ModulePreloadFetchPriority;
+  readonly probability: number;
+};
+declare function planModulePreloadUrls(input: ModulePreloadPlanInput): string[];
+declare function planModulePreloads(input: ModulePreloadPlanInput): ModulePreloadPlanEntry[];
+//#endregion
+//#region src/build/module-preload-dom.d.ts
+type LazySymbolPreloadView = {
+  readonly events?: ReadonlyArray<{
+    readonly symbolIds?: readonly string[];
+  }>;
+  readonly domUpdates?: ReadonlyArray<{
+    readonly symbolId?: string;
+  }>;
+  readonly behaviors?: ReadonlyArray<{
+    readonly symbolId?: string;
+  }>;
+  readonly asyncBoundaries?: ReadonlyArray<{
+    readonly asyncReads?: ReadonlyArray<{
+      readonly runnerSymbolId?: string;
+    }>;
+  }>;
+};
+type PreloadLazySymbolModulesInput = {
+  readonly view: LazySymbolPreloadView;
+  readonly bundleGraph: MarklessBundleGraph | undefined;
+  readonly base?: string;
+  readonly document?: ModulePreloadDocument;
+  readonly minProbability?: number;
+  readonly maxPreloads?: number;
+};
+type AppendedModulePreloads = {
+  readonly planned: readonly ModulePreloadPlanEntry[];
+  readonly appendedHrefs: readonly string[];
+};
+type ModulePreloadDocument = {
+  readonly baseURI?: string;
+  readonly head?: {
+    appendChild(node: ModulePreloadLink): unknown;
+  };
+  createElement(name: 'link'): ModulePreloadLink;
+  querySelectorAll(selector: string): Iterable<ModulePreloadExistingLink>;
+};
+type ModulePreloadExistingLink = {
+  readonly href?: string;
+  getAttribute?(name: string): string | null;
+};
+type ModulePreloadLink = ModulePreloadExistingLink & {
+  rel: string;
+  href: string;
+  crossOrigin: string;
+  setAttribute?(name: string, value: string): void;
+};
+declare function preloadLazySymbolModules(input: PreloadLazySymbolModulesInput): AppendedModulePreloads;
+//#endregion
+export { type AppendedModulePreloads, type LazySymbolPreloadView, type MarklessBundleGraph, type ModulePreloadFetchPriority, type ModulePreloadPlanEntry, type ModulePreloadPlanInput, type ModulePreloadPriority, type ModulePreloadRoot, type PreloadLazySymbolModulesInput, planModulePreloadUrls, planModulePreloads, preloadLazySymbolModules, symbolVirtualModuleSourceFile };

package/dist/preload.js

@@ -0,0 +1,75 @@
+import { S as planModulePreloads, l as symbolVirtualModuleSourceFile, x as planModulePreloadUrls } from "./source-module-CSRzW4Ny.js";
+//#region src/build/module-preload-dom.ts
+const PRIORITY_RANK = {
+	high: 2,
+	auto: 1,
+	low: 0
+};
+function preloadLazySymbolModules(input) {
+	const planned = planModulePreloads({
+		base: input.base,
+		bundleGraph: input.bundleGraph,
+		maxPreloads: input.maxPreloads,
+		minProbability: input.minProbability,
+		roots: lazySymbolPreloadRootsFromView(input.view)
+	});
+	return {
+		appendedHrefs: appendModulePreloadLinks(planned, input.document),
+		planned
+	};
+}
+function lazySymbolPreloadRootsFromView(view) {
+	const roots = /* @__PURE__ */ new Map();
+	const add = (name, priority) => {
+		if (!name) return;
+		const existing = roots.get(name);
+		if (existing && PRIORITY_RANK[existing.priority ?? "auto"] >= PRIORITY_RANK[priority]) return;
+		roots.set(name, {
+			name,
+			priority
+		});
+	};
+	for (const event of view.events ?? []) for (const symbolId of event.symbolIds ?? []) add(symbolId, "high");
+	for (const behavior of view.behaviors ?? []) add(behavior.symbolId, "high");
+	for (const update of view.domUpdates ?? []) add(update.symbolId, "low");
+	for (const boundary of view.asyncBoundaries ?? []) for (const read of boundary.asyncReads ?? []) add(read.runnerSymbolId, "low");
+	return [...roots.values()];
+}
+function appendModulePreloadLinks(preloads, document = defaultDocument()) {
+	if (!document?.head) return [];
+	const seen = existingModulePreloadHrefs(document);
+	const appended = [];
+	for (const preload of preloads) {
+		const href = preload.href;
+		if (!href || hasSeenHref(seen, href, document.baseURI)) continue;
+		const link = document.createElement("link");
+		link.rel = "modulepreload";
+		link.href = href;
+		link.crossOrigin = "anonymous";
+		if (preload.fetchPriority) link.setAttribute?.("fetchpriority", preload.fetchPriority);
+		document.head.appendChild(link);
+		rememberHref(seen, href, document.baseURI);
+		appended.push(href);
+	}
+	return appended;
+}
+function defaultDocument() {
+	return globalThis.document;
+}
+function existingModulePreloadHrefs(document) {
+	const hrefs = /* @__PURE__ */ new Set();
+	for (const link of document.querySelectorAll("link[rel=\"modulepreload\"]")) {
+		const href = link.getAttribute?.("href") ?? link.href;
+		if (href) rememberHref(hrefs, href, document.baseURI);
+	}
+	return hrefs;
+}
+function hasSeenHref(seen, href, baseURI) {
+	return seen.has(href) || !!baseURI && seen.has(new URL(href, baseURI).href);
+}
+function rememberHref(seen, href, baseURI) {
+	seen.add(href);
+	if (baseURI) seen.add(new URL(href, baseURI).href);
+}
+//#endregion
+export { planModulePreloadUrls, planModulePreloads, preloadLazySymbolModules, symbolVirtualModuleSourceFile };