@observablehq/notebook-kit 1.0.0

package/dist/src/runtime/stdlib/generators/input.js

@@ -0,0 +1,45 @@
+import { observe } from "./observe.js";
+export function input(element) {
+    return observe((change) => {
+        const event = eventof(element);
+        const value = valueof(element);
+        const inputted = () => change(valueof(element));
+        element.addEventListener(event, inputted);
+        if (value !== undefined)
+            change(value);
+        return () => element.removeEventListener(event, inputted);
+    });
+}
+function valueof(element) {
+    const input = element;
+    const select = element;
+    if ("type" in element) {
+        switch (element.type) {
+            case "range":
+            case "number":
+                return input.valueAsNumber;
+            case "date":
+                return input.valueAsDate;
+            case "checkbox":
+                return input.checked;
+            case "file":
+                return input.multiple ? input.files : input.files[0];
+            case "select-multiple":
+                return Array.from(select.selectedOptions, (o) => o.value);
+        }
+    }
+    return input.value;
+}
+function eventof(element) {
+    if ("type" in element) {
+        switch (element.type) {
+            case "button":
+            case "submit":
+            case "checkbox":
+                return "click";
+            case "file":
+                return "change";
+        }
+    }
+    return "input";
+}

package/dist/src/runtime/stdlib/generators/now.d.ts

@@ -0,0 +1 @@
+export declare function now(): AsyncGenerator<number, void, unknown>;

package/dist/src/runtime/stdlib/generators/now.js

@@ -0,0 +1,5 @@
+export async function* now() {
+    while (true) {
+        yield Date.now();
+    }
+}

package/dist/src/runtime/stdlib/generators/observe.d.ts

@@ -0,0 +1 @@
+export declare function observe<T>(initialize: (change: (value: T) => void) => unknown): AsyncGenerator<Awaited<T>, void, unknown>;

package/dist/src/runtime/stdlib/generators/observe.js

@@ -0,0 +1,31 @@
+export async function* observe(initialize) {
+    let resolve;
+    let value;
+    let stale = false;
+    const dispose = initialize((x) => {
+        value = x;
+        if (resolve) {
+            resolve(x);
+            resolve = undefined;
+        }
+        else {
+            stale = true;
+        }
+        return x;
+    });
+    if (dispose != null && typeof dispose !== "function") {
+        throw new Error(typeof dispose === "object" && "then" in dispose && typeof dispose.then === "function"
+            ? "async initializers are not supported"
+            : "initializer returned something, but not a dispose function");
+    }
+    try {
+        while (true) {
+            yield stale ? ((stale = false), value) : new Promise((_) => (resolve = _));
+        }
+    }
+    finally {
+        if (dispose != null) {
+            dispose();
+        }
+    }
+}

package/dist/src/runtime/stdlib/generators/queue.d.ts

@@ -0,0 +1 @@
+export declare function queue<T>(initialize: (change: (value: T) => void) => unknown): AsyncGenerator<Awaited<T>, void, unknown>;

package/dist/src/runtime/stdlib/generators/queue.js

@@ -0,0 +1,27 @@
+export async function* queue(initialize) {
+    let resolve;
+    const values = [];
+    const dispose = initialize((x) => {
+        values.push(x);
+        if (resolve) {
+            resolve(values.shift());
+            resolve = undefined;
+        }
+        return x;
+    });
+    if (dispose != null && typeof dispose !== "function") {
+        throw new Error(typeof dispose === "object" && "then" in dispose && typeof dispose.then === "function"
+            ? "async initializers are not supported"
+            : "initializer returned something, but not a dispose function");
+    }
+    try {
+        while (true) {
+            yield values.length ? values.shift() : new Promise((_) => (resolve = _));
+        }
+    }
+    finally {
+        if (dispose != null) {
+            dispose();
+        }
+    }
+}

package/dist/src/runtime/stdlib/generators/width.d.ts

@@ -0,0 +1 @@
+export declare function width(target: Element, options?: ResizeObserverOptions): AsyncGenerator<number, void, unknown>;

package/dist/src/runtime/stdlib/generators/width.js

@@ -0,0 +1,13 @@
+import { observe } from "./observe.js";
+export function width(target, options) {
+    return observe((notify) => {
+        let width;
+        const observer = new ResizeObserver(([entry]) => {
+            const w = entry.contentRect.width;
+            if (w !== width)
+                notify((width = w));
+        });
+        observer.observe(target, options);
+        return () => observer.disconnect();
+    });
+}

package/dist/src/runtime/stdlib/highlight.d.ts

@@ -0,0 +1,2 @@
+export declare const highlighter: import("@lezer/highlight").Highlighter;
+export declare function highlight(code: HTMLElement): Promise<void>;

package/dist/src/runtime/stdlib/highlight.js

@@ -0,0 +1,76 @@
+import { highlightCode, tagHighlighter, tags } from "@lezer/highlight";
+// A subset of classHighlighter with the classes we’ve styled.
+// Please keep in sync with src/codemirror/highlight.ts
+// https://github.com/lezer-parser/highlight/blob/95aa69ecd22bfc8b3e1c793610e0d5cda1174e61/src/highlight.ts#L702
+export const highlighter = tagHighlighter([
+    { tag: tags.link, class: "tok-link" },
+    { tag: [tags.heading, tags.strong], class: "tok-strong" },
+    { tag: tags.emphasis, class: "tok-emphasis" },
+    { tag: [tags.keyword, tags.typeName], class: "tok-keyword" },
+    { tag: tags.atom, class: "tok-atom" },
+    { tag: [tags.bool, tags.escape, tags.number], class: "tok-literal" },
+    { tag: [tags.string, tags.regexp], class: "tok-string" },
+    { tag: tags.comment, class: "tok-comment" },
+    { tag: tags.invalid, class: "tok-invalid" },
+    { tag: tags.variableName, class: "tok-variable" },
+    { tag: [tags.definition(tags.variableName), tags.className, tags.propertyName], class: "tok-definition" },
+    { tag: tags.meta, class: "tok-meta" }
+]);
+export async function highlight(code) {
+    const language = getLanguage(code);
+    if (!language)
+        return;
+    const parent = code.parentElement;
+    if (parent)
+        parent.dataset.language = language;
+    const parser = await getParser(language);
+    if (!parser)
+        return;
+    const document = code.ownerDocument;
+    const text = code.textContent;
+    const tree = parser.parse(text);
+    while (code.lastChild)
+        code.lastChild.remove();
+    function emit(text, classes) {
+        let node = document.createTextNode(text);
+        if (classes) {
+            const span = document.createElement("span");
+            span.appendChild(node);
+            span.className = classes;
+            node = span;
+        }
+        code.appendChild(node);
+    }
+    function emitBreak() {
+        code.appendChild(document.createTextNode("\n"));
+    }
+    highlightCode(text, tree, highlighter, emit, emitBreak);
+}
+async function getParser(language) {
+    switch (language) {
+        case "js":
+        case "ts":
+        case "jsx":
+            return (await import("@lezer/javascript")).parser.configure({ dialect: language });
+        case "html":
+            return (await import("@lezer/html")).parser;
+        case "css":
+            return (await import("@lezer/css")).parser;
+        case "md":
+        case "markdown":
+            return (await import("@lezer/markdown")).parser;
+    }
+}
+function getLanguage(code) {
+    const language = [...code.classList]
+        .find((c) => c.startsWith("language-"))
+        ?.slice("language-".length)
+        ?.toLowerCase();
+    switch (language) {
+        case "javascript":
+            return "js";
+        case "typescript":
+            return "ts";
+    }
+    return language;
+}

package/dist/src/runtime/stdlib/index.d.ts

@@ -0,0 +1,56 @@
+import { Mutable } from "./mutable.js";
+import * as Generators from "./generators/index.js";
+import { FileAttachment } from "./fileAttachment.js";
+import * as DOM from "./dom/index.js";
+import { Observer } from "./observer.js";
+import { require } from "./require.js";
+import { __sql } from "./sql.js";
+export declare const root: HTMLElement;
+export declare const library: {
+    aapl: () => Promise<any>;
+    alphabet: () => Promise<any>;
+    cars: () => Promise<any>;
+    citywages: () => Promise<any>;
+    diamonds: () => Promise<any>;
+    flare: () => Promise<any>;
+    industries: () => Promise<any>;
+    miserables: () => Promise<any>;
+    olympians: () => Promise<any>;
+    penguins: () => Promise<any>;
+    pizza: () => Promise<any>;
+    weather: () => Promise<any>;
+    _: () => Promise<any>;
+    aq: () => Promise<any>;
+    Arrow: () => Promise<any>;
+    d3: () => Promise<any>;
+    dot: () => Promise<import("./template.js").RawTemplateRenderer>;
+    duckdb: () => Promise<any>;
+    DuckDBClient: () => Promise<typeof import("./duckdb.js").DuckDBClient>;
+    echarts: () => Promise<any>;
+    htl: () => Promise<any>;
+    html: () => Promise<any>;
+    svg: () => Promise<any>;
+    Inputs: () => Promise<typeof import("./inputs.js")>;
+    L: () => Promise<typeof import("./leaflet.js")>;
+    mapboxgl: () => Promise<any>;
+    md: () => Promise<import("./template.js").TemplateRenderer>;
+    mermaid: () => Promise<import("./template.js").AsyncRawTemplateRenderer>;
+    Plot: () => Promise<any>;
+    React: () => Promise<any>;
+    ReactDOM: () => Promise<any>;
+    tex: () => Promise<import("./template.js").RawTemplateRenderer & {
+        options: (options?: any) => import("./template.js").RawTemplateRenderer;
+        block: import("./template.js").RawTemplateRenderer;
+    }>;
+    topojson: () => Promise<any>;
+    vl: () => Promise<any>;
+    now: () => AsyncGenerator<number, void, unknown>;
+    width: () => AsyncGenerator<number, void, unknown>;
+    FileAttachment: () => typeof FileAttachment;
+    Generators: () => typeof Generators;
+    Mutable: () => typeof Mutable;
+    DOM: () => typeof DOM;
+    require: () => typeof require;
+    __sql: () => typeof __sql;
+    __ojs_observer: () => () => Observer;
+};

package/dist/src/runtime/stdlib/index.js

@@ -0,0 +1,23 @@
+import { Mutable } from "./mutable.js";
+import * as Generators from "./generators/index.js";
+import { FileAttachment } from "./fileAttachment.js";
+import * as DOM from "./dom/index.js";
+import { Observer } from "./observer.js";
+import * as recommendedLibraries from "./recommendedLibraries.js";
+import { require } from "./require.js";
+import * as sampleDatasets from "./sampleDatasets.js";
+import { __sql } from "./sql.js";
+export const root = document.querySelector("main") ?? document.body;
+export const library = {
+    now: () => Generators.now(),
+    width: () => Generators.width(root),
+    FileAttachment: () => FileAttachment,
+    Generators: () => Generators,
+    Mutable: () => Mutable,
+    DOM: () => DOM, // deprecated!
+    require: () => require, // deprecated!
+    __sql: () => __sql,
+    __ojs_observer: () => () => new Observer(),
+    ...recommendedLibraries,
+    ...sampleDatasets
+};

package/dist/src/runtime/stdlib/inputs.css

@@ -0,0 +1,15 @@
+@import url("https://cdn.jsdelivr.net/npm/@observablehq/inputs/dist/index.css");
+
+.inputs-3a86ea-table tr:not(:last-child) td,
+.inputs-3a86ea-table tr:not(:last-child) th {
+  border-bottom-color: var(--theme-foreground-faintest);
+}
+
+.inputs-3a86ea-table thead tr td,
+.inputs-3a86ea-table thead tr th {
+  border-bottom-color: var(--theme-foreground-fainter);
+}
+
+.inputs-3a86ea-table thead th {
+  background: var(--theme-background);
+}

package/dist/src/runtime/stdlib/inputs.d.ts

@@ -0,0 +1,2 @@
+export * from "npm:@observablehq/inputs";
+import "./inputs.css";

package/dist/src/runtime/stdlib/inputs.js

@@ -0,0 +1,2 @@
+export * from "npm:@observablehq/inputs";
+import "./inputs.css";

package/dist/src/runtime/stdlib/leaflet.d.ts

@@ -0,0 +1 @@
+export * from "npm:leaflet";

package/dist/src/runtime/stdlib/leaflet.js

@@ -0,0 +1,7 @@
+import { Icon } from "npm:leaflet";
+export * from "npm:leaflet";
+Icon.Default.imagePath = "https://cdn.jsdelivr.net/npm/leaflet/dist/images/";
+const link = document.createElement("link");
+link.href = "https://cdn.jsdelivr.net/npm/leaflet/dist/leaflet.css";
+link.rel = "stylesheet";
+document.head.appendChild(link);

package/dist/src/runtime/stdlib/mapboxgl.d.ts

@@ -0,0 +1 @@
+export { default } from "npm:mapbox-gl";

package/dist/src/runtime/stdlib/mapboxgl.js

@@ -0,0 +1,5 @@
+export { default } from "npm:mapbox-gl";
+const link = document.createElement("link");
+link.href = "https://cdn.jsdelivr.net/npm/mapbox-gl/dist/mapbox-gl.css";
+link.rel = "stylesheet";
+document.head.appendChild(link);

package/dist/src/runtime/stdlib/md.d.ts

@@ -0,0 +1,5 @@
+import type { TemplateRenderer } from "./template.js";
+export declare function MarkdownRenderer({ document }?: {
+    document?: Document;
+}): TemplateRenderer<HTMLElement>;
+export declare const md: TemplateRenderer;

package/dist/src/runtime/stdlib/md.js

@@ -0,0 +1,72 @@
+import slugify from "@sindresorhus/slugify";
+import MarkdownIt from "markdown-it";
+import MarkdownItAnchor from "markdown-it-anchor";
+const mi = MarkdownIt({ html: true, linkify: true, typographer: true });
+mi.use(MarkdownItAnchor, {
+    level: [2, 3],
+    slugify: (s) => slugify(s),
+    permalink: MarkdownItAnchor.permalink.headerLink({ class: "" })
+});
+export function MarkdownRenderer({ document = window.document } = {}) {
+    return function (template, ...values) {
+        let source = template[0];
+        let fragment = null;
+        let partIndex = -1;
+        const parts = [];
+        // Concatenate the text using comments as placeholders.
+        for (let i = 0, n = values.length; i < n; ++i) {
+            const value = values[i];
+            if (value instanceof Node) {
+                parts[++partIndex] = value;
+                source += `<!--o:${partIndex}-->`;
+            }
+            else if (Array.isArray(value)) {
+                for (const node of value) {
+                    if (node instanceof Node) {
+                        if (fragment === null) {
+                            parts[++partIndex] = fragment = document.createDocumentFragment();
+                            source += `<!--o:${partIndex}-->`;
+                        }
+                        fragment.appendChild(node);
+                    }
+                    else {
+                        fragment = null;
+                        source += node;
+                    }
+                }
+                fragment = null;
+            }
+            else {
+                source += value;
+            }
+            source += template[i + 1];
+        }
+        // Render the text.
+        const root = document.createElement("div");
+        root.innerHTML = mi.render(source);
+        // Walk the rendered content to replace comment placeholders.
+        if (++partIndex > 0) {
+            const nodes = new Array(partIndex);
+            const walker = document.createTreeWalker(root, NodeFilter.SHOW_COMMENT, null);
+            while (walker.nextNode()) {
+                const node = walker.currentNode;
+                if (/^o:\d+$/.test(node.nodeValue)) {
+                    nodes[+node.nodeValue.slice(2)] = node;
+                }
+            }
+            for (let i = 0; i < partIndex; ++i) {
+                const node = nodes[i];
+                node.parentNode?.replaceChild(parts[i], node);
+            }
+        }
+        return root;
+    };
+}
+let renderer;
+export const md = (template, ...values) => {
+    const root = (renderer ?? (renderer = MarkdownRenderer()))(template, ...values);
+    const codes = root.querySelectorAll("code[class^=language-]");
+    if (codes.length > 0)
+        import("./highlight.js").then(({ highlight }) => codes.forEach(highlight));
+    return root.childNodes.length === 1 ? root.removeChild(root.firstChild) : root;
+};

package/dist/src/runtime/stdlib/mermaid.d.ts

@@ -0,0 +1,2 @@
+import type { AsyncRawTemplateRenderer } from "./template.js";
+export declare const mermaid: AsyncRawTemplateRenderer;

package/dist/src/runtime/stdlib/mermaid.js

@@ -0,0 +1,11 @@
+import mer from "npm:mermaid";
+let nextId = 0;
+const scheme = getComputedStyle(document.body).getPropertyValue("color-scheme");
+const theme = scheme === "dark" ? "dark" : "neutral";
+mer.initialize({ startOnLoad: false, securityLevel: "loose", theme });
+export const mermaid = async (template, ...values) => {
+    const source = String.raw.call(String, template, ...values);
+    const root = document.createElement("div");
+    root.innerHTML = (await mer.render(`mermaid-${++nextId}`, source)).svg;
+    return root.removeChild(root.firstChild);
+};

package/dist/src/runtime/stdlib/mutable.d.ts

@@ -0,0 +1,8 @@
+export declare function Mutable<T>(value: T): AsyncGenerator<Awaited<T>, void, unknown> & {
+    value: T;
+};
+export declare function Mutator<T>(value: T): ((AsyncGenerator<Awaited<T>, void, unknown> & {
+    value: T;
+}) | {
+    value: T;
+})[];

package/dist/src/runtime/stdlib/mutable.js

@@ -0,0 +1,30 @@
+import { observe } from "./generators/observe.js";
+// Mutable returns a generator with a value getter/setting that allows the
+// generated value to be mutated. Therefore, direct mutation is only allowed
+// within the defining cell, but the cell can also export functions that allows
+// other cells to mutate the value as desired.
+export function Mutable(value) {
+    let change;
+    return Object.defineProperty(observe((_) => {
+        change = _;
+        if (value !== undefined)
+            change(value);
+    }), "value", {
+        get: () => value,
+        set: (x) => ((value = x), void change?.(value))
+    });
+}
+export function Mutator(value) {
+    const mutable = Mutable(value);
+    return [
+        mutable,
+        {
+            get value() {
+                return mutable.value;
+            },
+            set value(v) {
+                mutable.value = v;
+            }
+        }
+    ];
+}

package/dist/src/runtime/stdlib/observer.d.ts

@@ -0,0 +1,16 @@
+export declare class Observer {
+    #private;
+    fulfilled?: (value: unknown) => void;
+    rejected?: (error: unknown) => void;
+    constructor();
+    next(): Promise<{
+        done: boolean;
+        value: unknown;
+    }>;
+    throw(): {
+        done: boolean;
+    };
+    return(): {
+        done: boolean;
+    };
+}

package/dist/src/runtime/stdlib/observer.js

@@ -0,0 +1,42 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Observer_promise;
+export class Observer {
+    constructor() {
+        _Observer_promise.set(this, void 0);
+        Object.defineProperty(this, "fulfilled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "rejected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.next();
+    }
+    async next() {
+        const value = await __classPrivateFieldGet(this, _Observer_promise, "f");
+        __classPrivateFieldSet(this, _Observer_promise, new Promise((res, rej) => ((this.fulfilled = res), (this.rejected = rej))), "f");
+        return { done: false, value };
+    }
+    throw() {
+        return { done: true };
+    }
+    return() {
+        return { done: true };
+    }
+}
+_Observer_promise = new WeakMap();

package/dist/src/runtime/stdlib/recommendedLibraries.d.ts

@@ -0,0 +1,25 @@
+export declare const _: () => Promise<any>;
+export declare const aq: () => Promise<any>;
+export declare const Arrow: () => Promise<any>;
+export declare const d3: () => Promise<any>;
+export declare const dot: () => Promise<import("./template.js").RawTemplateRenderer>;
+export declare const duckdb: () => Promise<any>;
+export declare const DuckDBClient: () => Promise<typeof import("./duckdb.js").DuckDBClient>;
+export declare const echarts: () => Promise<any>;
+export declare const htl: () => Promise<any>;
+export declare const html: () => Promise<any>;
+export declare const svg: () => Promise<any>;
+export declare const Inputs: () => Promise<typeof import("./inputs.js")>;
+export declare const L: () => Promise<typeof import("./leaflet.js")>;
+export declare const mapboxgl: () => Promise<any>;
+export declare const md: () => Promise<import("./template.js").TemplateRenderer>;
+export declare const mermaid: () => Promise<import("./template.js").AsyncRawTemplateRenderer>;
+export declare const Plot: () => Promise<any>;
+export declare const React: () => Promise<any>;
+export declare const ReactDOM: () => Promise<any>;
+export declare const tex: () => Promise<import("./template.js").RawTemplateRenderer & {
+    options: (options?: any) => import("./template.js").RawTemplateRenderer;
+    block: import("./template.js").RawTemplateRenderer;
+}>;
+export declare const topojson: () => Promise<any>;
+export declare const vl: () => Promise<any>;

package/dist/src/runtime/stdlib/recommendedLibraries.js

@@ -0,0 +1,26 @@
+export const _ = () => import("npm:lodash").then((_) => _.default);
+export const aq = () => import("npm:arquero");
+export const Arrow = () => import("npm:apache-arrow");
+export const d3 = () => import("npm:d3");
+export const dot = () => import("./dot.js").then((_) => _.dot);
+export const duckdb = () => import("npm:@duckdb/duckdb-wasm");
+export const DuckDBClient = () => import("./duckdb.js").then((_) => _.DuckDBClient);
+export const echarts = () => import("npm:echarts");
+export const htl = () => import("npm:htl");
+export const html = () => import("npm:htl").then((_) => _.html);
+export const svg = () => import("npm:htl").then((_) => _.svg);
+export const Inputs = () => import("./inputs.js");
+export const L = () => import("./leaflet.js");
+export const mapboxgl = () => import("./mapboxgl.js").then((_) => _.default);
+export const md = () => import("./md.js").then((_) => _.md);
+export const mermaid = () => import("./mermaid.js").then((_) => _.mermaid);
+export const Plot = () => import("npm:@observablehq/plot");
+export const React = () => import("npm:react");
+export const ReactDOM = () => import("npm:react-dom");
+// export const sql = () => import("observablehq:stdlib/duckdb").then((_) => _.sql);
+// export const SQLite = () => import("observablehq:stdlib/sqlite").then((_) => _.default);
+// export const SQLiteDatabaseClient = () => import("observablehq:stdlib/sqlite").then((_) => _.SQLiteDatabaseClient);
+export const tex = () => import("./tex.js").then((_) => _.tex);
+export const topojson = () => import("npm:topojson-client");
+// export const vg = () => import("observablehq:stdlib/vgplot").then((_) => _.default());
+export const vl = () => import("./vega-lite.js").then((_) => _.vl);

package/dist/src/runtime/stdlib/require.d.ts

@@ -0,0 +1,4 @@
+export declare function require(...specifiers: unknown[]): unknown;
+export declare namespace require {
+    var resolve: (_specifier: unknown) => string;
+}

package/dist/src/runtime/stdlib/require.js

@@ -0,0 +1,40 @@
+require.resolve = resolve;
+export function require(...specifiers) {
+    return specifiers.length === 1
+        ? import(/* @vite-ignore */ resolve(specifiers[0]))
+        : Promise.all(specifiers.map((s) => require(s))).then((modules) => Object.assign({}, ...modules));
+}
+function parseNpmSpecifier(specifier) {
+    const parts = specifier.split("/");
+    const namerange = specifier.startsWith("@")
+        ? [parts.shift(), parts.shift()].join("/")
+        : parts.shift();
+    const ranged = namerange.indexOf("@", 1);
+    const name = ranged > 0 ? namerange.slice(0, ranged) : namerange;
+    const range = ranged > 0 ? namerange.slice(ranged) : "";
+    const path = parts.length > 0 ? `/${parts.join("/")}` : "";
+    return { name, range, path };
+}
+function resolve(_specifier) {
+    const specifier = String(_specifier);
+    if (isProtocol(specifier) || isLocal(specifier))
+        return specifier;
+    const { name, range, path } = parseNpmSpecifier(specifier);
+    return `https://cdn.jsdelivr.net/npm/${name}${range}${path + (isFile(path) || isDirectory(path) ? "" : "/+esm")}`;
+}
+/** Returns true for e.g. https://example.com/ */
+function isProtocol(specifier) {
+    return /^\w+:/.test(specifier);
+}
+/** Returns true for e.g. ./foo.js */
+function isLocal(specifier) {
+    return /^(\.\/|\.\.\/|\/)/.test(specifier);
+}
+/** Returns true for e.g. foo/bar.js */
+function isFile(specifier) {
+    return /(\.\w*)$/.test(specifier);
+}
+/** Returns true for e.g. foo/bar/ */
+function isDirectory(specifier) {
+    return /(\/)$/.test(specifier);
+}