@observablehq/notebook-kit 1.0.0

package/dist/src/javascript/sourcemap.d.ts

@@ -0,0 +1,21 @@
+interface Position {
+    line: number;
+    column: number;
+}
+export declare class Sourcemap {
+    readonly input: string;
+    private readonly _edits;
+    constructor(input: string);
+    private _bisectLeft;
+    private _bisectRight;
+    private _subsume;
+    insertLeft(index: number, value: string): typeof this;
+    insertRight(index: number, value: string): typeof this;
+    delete(start: number, end: number): typeof this;
+    replaceLeft(start: number, end: number, value: string): typeof this;
+    replaceRight(start: number, end: number, value: string): typeof this;
+    translate(position: Position): Position;
+    trim(): typeof this;
+    toString(): string;
+}
+export {};

package/dist/src/javascript/sourcemap.js

@@ -0,0 +1,143 @@
+// @ts-expect-error lineBreakG is private
+import { lineBreakG } from "acorn";
+export class Sourcemap {
+    constructor(input) {
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_edits", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.input = input;
+        this._edits = [];
+    }
+    _bisectLeft(index) {
+        let lo = 0;
+        let hi = this._edits.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (this._edits[mid].start < index)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        return lo;
+    }
+    _bisectRight(index) {
+        let lo = 0;
+        let hi = this._edits.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (this._edits[mid].start > index)
+                hi = mid;
+            else
+                lo = mid + 1;
+        }
+        return lo;
+    }
+    _subsume(start, end) {
+        let n = 0;
+        for (let i = 0; i < this._edits.length; ++i) {
+            const e = this._edits[i];
+            if (start <= e.start && e.end < end)
+                continue;
+            this._edits[n++] = e;
+        }
+        this._edits.length = n;
+    }
+    insertLeft(index, value) {
+        return this.replaceLeft(index, index, value);
+    }
+    insertRight(index, value) {
+        return this.replaceRight(index, index, value);
+    }
+    delete(start, end) {
+        return this.replaceRight(start, end, "");
+    }
+    replaceLeft(start, end, value) {
+        this._subsume(start, end);
+        this._edits.splice(this._bisectLeft(start), 0, { start, end, value });
+        return this;
+    }
+    replaceRight(start, end, value) {
+        this._subsume(start, end);
+        this._edits.splice(this._bisectRight(start), 0, { start, end, value });
+        return this;
+    }
+    translate(position) {
+        let index = 0;
+        let ci = { line: 1, column: 0 };
+        let co = { line: 1, column: 0 };
+        for (const { start, end, value } of this._edits) {
+            if (start > index) {
+                const l = positionLength(this.input, index, start);
+                const ci2 = positionAdd(ci, l);
+                const co2 = positionAdd(co, l);
+                if (positionCompare(co2, position) > 0)
+                    break;
+                ci = ci2;
+                co = co2;
+            }
+            const il = positionLength(this.input, start, end);
+            const ol = positionLength(value);
+            const ci2 = positionAdd(ci, il);
+            const co2 = positionAdd(co, ol);
+            if (positionCompare(co2, position) > 0)
+                return ci;
+            ci = ci2;
+            co = co2;
+            index = end;
+        }
+        const l = positionSubtract(position, co);
+        return positionAdd(ci, l);
+    }
+    trim() {
+        const input = this.input;
+        if (input.startsWith("\n"))
+            this.delete(0, 1); // TODO better trim
+        if (input.endsWith("\n"))
+            this.delete(input.length - 1, input.length); // TODO better trim
+        return this;
+    }
+    toString() {
+        let output = "";
+        let index = 0;
+        for (const { start, end, value } of this._edits) {
+            if (start > index)
+                output += this.input.slice(index, start);
+            output += value;
+            index = end;
+        }
+        output += this.input.slice(index);
+        return output;
+    }
+}
+function positionCompare(a, b) {
+    return a.line - b.line || a.column - b.column;
+}
+function positionLength(input, start = 0, end = input.length) {
+    let match;
+    let line = 0;
+    lineBreakG.lastIndex = start;
+    while ((match = lineBreakG.exec(input)) && match.index < end) {
+        ++line;
+        start = match.index + match[0].length;
+    }
+    return { line, column: end - start };
+}
+function positionSubtract(b, a) {
+    return b.line === a.line
+        ? { line: 0, column: b.column - a.column }
+        : { line: b.line - a.line, column: b.column };
+}
+function positionAdd(p, l) {
+    return l.line === 0
+        ? { line: p.line, column: p.column + l.column }
+        : { line: p.line + l.line, column: l.column };
+}

package/dist/src/javascript/sourcemap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/javascript/sourcemap.test.js

@@ -0,0 +1,88 @@
+import { assert, test } from "vitest";
+import { Sourcemap } from "./sourcemap.js";
+test("identity", () => {
+    const sm = new Sourcemap("");
+    assert.strictEqual(sm.toString(), "");
+    assert.deepStrictEqual(sm.translate({ line: 1, column: 0 }), { line: 1, column: 0 });
+});
+test("insert at beginning", () => {
+    const original = "hello;";
+    const sm = new Sourcemap(original);
+    sm.insertLeft(0, "return ");
+    assert.strictEqual(sm.toString(), "return hello;");
+    assert.deepStrictEqual(sm.translate({ line: 1, column: 7 }), { line: 1, column: 0 });
+});
+test("insertLeft at beginning twice", () => {
+    const original = "hello;";
+    const sm = new Sourcemap(original);
+    sm.insertLeft(0, " ");
+    sm.insertLeft(0, "return");
+    assert.strictEqual(sm.toString(), "return hello;");
+    assert.deepStrictEqual(sm.translate({ line: 1, column: 7 }), { line: 1, column: 0 });
+});
+test("insert right at beginning", () => {
+    const original = "hello;";
+    const sm = new Sourcemap(original);
+    sm.insertLeft(0, "return");
+    sm.insertRight(0, " ");
+    assert.strictEqual(sm.toString(), "return hello;");
+    assert.deepStrictEqual(sm.translate({ line: 1, column: 7 }), { line: 1, column: 0 });
+});
+test("insert at end", () => {
+    const original = "hello";
+    const sm = new Sourcemap(original);
+    sm.insertLeft(original.length, "();");
+    assert.strictEqual(sm.toString(), "hello();");
+    assert.deepStrictEqual(sm.translate({ line: 1, column: 8 }), { line: 1, column: 5 });
+});
+test("insert at end twice is insertLeft", () => {
+    const original = "hello";
+    const sm = new Sourcemap(original);
+    sm.insertLeft(original.length, ";");
+    sm.insertLeft(original.length, "()");
+    assert.strictEqual(sm.toString(), "hello();");
+    assert.deepStrictEqual(sm.translate({ line: 1, column: 8 }), { line: 1, column: 5 });
+});
+test("insert right at end", () => {
+    const original = "hello";
+    const sm = new Sourcemap(original);
+    sm.insertLeft(original.length, "()");
+    sm.insertRight(original.length, ";");
+    assert.strictEqual(sm.toString(), "hello();");
+    assert.deepStrictEqual(sm.translate({ line: 1, column: 8 }), { line: 1, column: 5 });
+});
+test("insert new lines", () => {
+    const original = "hello";
+    const sm = new Sourcemap(original);
+    sm.insertLeft(0, "function() {\n");
+    sm.insertRight(original.length, "\n}");
+    assert.strictEqual(sm.toString(), "function() {\nhello\n}");
+    assert.deepStrictEqual(sm.translate({ line: 1, column: 7 }), { line: 1, column: 0 });
+    assert.deepStrictEqual(sm.translate({ line: 2, column: 0 }), { line: 1, column: 0 });
+    assert.deepStrictEqual(sm.translate({ line: 3, column: 1 }), { line: 1, column: 5 });
+});
+test("replace new line", () => {
+    const original = "\nhello";
+    const sm = new Sourcemap(original);
+    sm.replaceLeft(0, 1, "function() {\n");
+    assert.strictEqual(sm.toString(), "function() {\nhello");
+    assert.deepStrictEqual(sm.translate({ line: 2, column: 0 }), { line: 2, column: 0 });
+});
+test("delete", () => {
+    const original = "hello;";
+    const sm = new Sourcemap(original);
+    sm.delete(original.length - 1, original.length);
+    assert.strictEqual(sm.toString(), "hello");
+});
+test("complete replace", () => {
+    const original = "hello;";
+    const sm = new Sourcemap(original);
+    sm.replaceRight(0, original.length, "something else");
+    assert.strictEqual(sm.toString(), "something else");
+    assert.deepStrictEqual(sm.translate({ line: 1, column: 0 }), { line: 1, column: 0 });
+});
+test("line-level granularity", () => {
+    const sm = new Sourcemap("ab\ncd");
+    sm.insertLeft(0, "foo");
+    assert.deepStrictEqual(sm.translate({ line: 1, column: 4 }), { line: 1, column: 1 });
+});

package/dist/src/javascript/strings.d.ts

@@ -0,0 +1,8 @@
+import type { BinaryExpression, Literal, Node, TemplateLiteral } from "acorn";
+export type StringLiteral = (Literal & {
+    value: string;
+}) | TemplateLiteral | BinaryExpression;
+export declare function isLiteral(node: Node): node is Literal;
+export declare function isTemplateLiteral(node: Node): node is TemplateLiteral;
+export declare function isStringLiteral(node: Node): node is StringLiteral;
+export declare function getStringLiteralValue(node: StringLiteral): string;

package/dist/src/javascript/strings.js

@@ -0,0 +1,42 @@
+export function isLiteral(node) {
+    return node.type === "Literal";
+}
+export function isTemplateLiteral(node) {
+    return node.type === "TemplateLiteral";
+}
+export function isStringLiteral(node) {
+    return isLiteral(node)
+        ? /^['"]/.test(node.raw)
+        : isTemplateLiteral(node)
+            ? node.expressions.every(isStringLiteral)
+            : isBinaryExpression(node)
+                ? node.operator === "+" && isStringLiteral(node.left) && isStringLiteral(node.right)
+                : isMemberExpression(node)
+                    ? "value" in node // param
+                    : false;
+}
+export function getStringLiteralValue(node) {
+    return node.type === "TemplateLiteral"
+        ? getTemplateLiteralValue(node)
+        : node.type === "BinaryExpression"
+            ? getBinaryExpressionValue(node)
+            : node.value; // Literal or ParamReference
+}
+function getTemplateLiteralValue(node) {
+    let value = node.quasis[0].value.cooked;
+    for (let i = 0; i < node.expressions.length; ++i) {
+        value += getStringLiteralValue(node.expressions[i]);
+        value += node.quasis[i + 1].value.cooked;
+    }
+    return value;
+}
+function getBinaryExpressionValue(node) {
+    return (getStringLiteralValue(node.left) +
+        getStringLiteralValue(node.right));
+}
+function isMemberExpression(node) {
+    return node.type === "MemberExpression";
+}
+function isBinaryExpression(node) {
+    return node.type === "BinaryExpression";
+}

package/dist/src/javascript/strings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/javascript/strings.test.js

@@ -0,0 +1,31 @@
+import { assert, test } from "vitest";
+import { isStringLiteral, getStringLiteralValue } from "./strings.js";
+import { parseJavaScript } from "./parse.js";
+function get(input) {
+    const { body } = parseJavaScript(input);
+    if (!isStringLiteral(body))
+        throw new Error("input is not a string literal");
+    return getStringLiteralValue(body);
+}
+function is(input) {
+    const { body } = parseJavaScript(input);
+    return isStringLiteral(body);
+}
+test("returns the string literal value for simple string literals", () => {
+    assert.strictEqual(get('"hello"'), "hello");
+    assert.strictEqual(get('`hello`'), "hello");
+    assert.strictEqual(get("'hello'"), "hello");
+});
+test("returns the string literal value for static string binary expressions", () => {
+    assert.strictEqual(get('"hel" + "lo"'), "hello");
+    assert.strictEqual(get('"hel" + `lo`'), "hello");
+});
+test("returns the string literal value for static string templates", () => {
+    assert.strictEqual(get('`he${"ll"}o`'), "hello");
+    assert.strictEqual(get('`he${"l" + "l"}o`'), "hello");
+});
+test("does not consider templates with dynamic quasis to be a string literal", () => {
+    assert.strictEqual(is('`he${"l" + "1"}o`'), true);
+    assert.strictEqual(is('`he${"l" + 1}o`'), false);
+    assert.strictEqual(is('`he${ll}o`'), false);
+});

package/dist/src/javascript/syntaxError.d.ts

@@ -0,0 +1,2 @@
+import type { Node } from "acorn";
+export declare function syntaxError(message: string, node: Node, input: string): SyntaxError;

package/dist/src/javascript/syntaxError.js

@@ -0,0 +1,5 @@
+import { getLineInfo } from "acorn";
+export function syntaxError(message, node, input) {
+    const { line, column } = getLineInfo(input, node.start);
+    return new SyntaxError(`${message} (${line}:${column})`);
+}

package/dist/src/javascript/template.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateLiteral } from "acorn";
+export declare function parseTemplate(input: string): TemplateLiteral;
+export declare function transpileTemplate(input: string, tag?: string, raw?: boolean): string;

package/dist/src/javascript/template.js

@@ -0,0 +1,141 @@
+import { TokContext, tokTypes as tt, Parser } from "acorn";
+import { acornOptions } from "./parse.js";
+import { Sourcemap } from "./sourcemap.js";
+const CODE_DOLLAR = 36;
+const CODE_BACKSLASH = 92;
+const CODE_BACKTICK = 96;
+const CODE_BRACEL = 123;
+// Based on acorn’s q_tmpl. We will use this to initialize the parser context so our
+// `readTemplateToken` override is called. `readTemplateToken` is based on acorn's `readTmplToken`
+// which is used inside template literals. Our version allows backQuotes.
+const o_tmpl = new TokContext("`", // token
+true, // isExpr
+true, // preserveSpace
+(parser) => parser.readTemplateToken() // override
+);
+// Adapted from https://github.com/observablehq/parser/blob/b6ec1db139913493b39c9d0ccb02a1636570a64e/src/parse.js#L233
+class TemplateCellParser extends Parser {
+    constructor(options, input, startPos) {
+        super(options, input, startPos);
+        this.type = tt.backQuote; // initially inside a backQuote
+        this.exprAllowed = false;
+    }
+    initialContext() {
+        return [o_tmpl];
+    }
+    parseTopLevel(node) {
+        if (this.type === tt.eof)
+            this.value = ""; // fix for nextToken calling finishToken(tt.eof)
+        const isTagged = true;
+        const template = node;
+        template.expressions = [];
+        let curElt = this.parseTemplateElement({ isTagged });
+        template.quasis = [curElt];
+        while (this.type !== tt.eof) {
+            this.expect(tt.dollarBraceL);
+            template.expressions.push(this.parseExpression());
+            this.expect(tt.braceR);
+            template.quasis.push((curElt = this.parseTemplateElement({ isTagged })));
+        }
+        curElt.tail = true;
+        this.next();
+        this.finishNode(template, "TemplateLiteral");
+        this.expect(tt.eof);
+        return template;
+    }
+    readTemplateToken() {
+        out: for (; this.pos < this.input.length; this.pos++) {
+            switch (this.input.charCodeAt(this.pos)) {
+                case CODE_BACKSLASH: {
+                    if (this.pos < this.input.length - 1)
+                        ++this.pos; // not a terminal slash
+                    break;
+                }
+                case CODE_DOLLAR: {
+                    if (this.input.charCodeAt(this.pos + 1) === CODE_BRACEL) {
+                        if (this.pos === this.start && this.type === tt.invalidTemplate) {
+                            this.pos += 2;
+                            return this.finishToken(tt.dollarBraceL);
+                        }
+                        break out;
+                    }
+                    break;
+                }
+            }
+        }
+        return this.finishToken(tt.invalidTemplate, this.input.slice(this.start, this.pos));
+    }
+}
+export function parseTemplate(input) {
+    return TemplateCellParser.parse(input, acornOptions);
+}
+export function transpileTemplate(input, tag = "", raw = false) {
+    if (!input)
+        return input;
+    const source = new Sourcemap(input);
+    const node = parseTemplate(input);
+    (raw ? escapeRawTemplateElements : escapeTemplateElements)(source, node);
+    source.insertLeft(node.start, "`");
+    source.insertRight(node.end, "`");
+    source.insertLeft(node.start, tag);
+    return String(source);
+}
+function escapeTemplateElements(source, node) {
+    for (const quasi of node.quasis) {
+        escapeBacktick(source, quasi);
+        escapeBackslash(source, quasi);
+    }
+}
+function escapeRawTemplateElements(source, node) {
+    for (const quasi of node.quasis) {
+        escapeBacktick(source, quasi);
+    }
+    interpolateTerminalBackslash(source);
+}
+function escapeBacktick(source, { start, end }) {
+    const { input } = source;
+    for (let i = start; i < end; ++i) {
+        if (input.charCodeAt(i) === CODE_BACKTICK) {
+            source.insertRight(i, "\\");
+        }
+    }
+}
+function escapeBackslash(source, { start, end }) {
+    const { input } = source;
+    let afterDollar = false;
+    let oddBackslashes = false;
+    for (let i = start; i < end; ++i) {
+        switch (input.charCodeAt(i)) {
+            case CODE_DOLLAR: {
+                afterDollar = true;
+                oddBackslashes = false;
+                break;
+            }
+            case CODE_BACKSLASH: {
+                oddBackslashes = !oddBackslashes;
+                if (afterDollar && input.charCodeAt(i + 1) === CODE_BRACEL)
+                    continue;
+                if (oddBackslashes && input.charCodeAt(i + 1) === CODE_DOLLAR && input.charCodeAt(i + 2) === CODE_BRACEL)
+                    continue; // prettier-ignore
+                source.insertRight(i, "\\");
+                break;
+            }
+            default: {
+                afterDollar = false;
+                oddBackslashes = false;
+                break;
+            }
+        }
+    }
+}
+function interpolateTerminalBackslash(source) {
+    const { input } = source;
+    let oddBackslashes = false;
+    for (let i = input.length - 1; i >= 0; i--) {
+        if (input.charCodeAt(i) !== CODE_BACKSLASH)
+            break;
+        oddBackslashes = !oddBackslashes;
+    }
+    if (oddBackslashes)
+        source.replaceRight(input.length - 1, input.length, "${'\\\\'}");
+}

package/dist/src/javascript/template.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/javascript/template.test.js

@@ -0,0 +1,32 @@
+import { expect, it } from "vitest";
+import { parseTemplate, transpileTemplate } from "./template.js";
+it("parses a simple template", () => {
+    expect(parseTemplate(`Hello, world!`)).toMatchSnapshot();
+});
+it("parses an empty template", () => {
+    expect(parseTemplate(``)).toMatchSnapshot();
+});
+it("parses a template with an interpolated expression", () => {
+    expect(parseTemplate(`Hello, $\{"world"}!`)).toMatchSnapshot();
+});
+it("parses a template with backquotes", () => {
+    expect(parseTemplate(`Hello, \`world\`!`)).toMatchSnapshot();
+});
+it("parses a template with backslashes", () => {
+    expect(parseTemplate(`Hello, \\world\\!`)).toMatchSnapshot();
+});
+it("transpiles a simple template", () => {
+    expect(transpileTemplate(`Hello, world!`)).toMatchSnapshot();
+});
+it("transpiles an empty template", () => {
+    expect(transpileTemplate(``)).toMatchSnapshot();
+});
+it("transpiles a template with an interpolated expression", () => {
+    expect(transpileTemplate(`Hello, $\{"world"}!`)).toMatchSnapshot();
+});
+it("transpiles a template with backquotes", () => {
+    expect(transpileTemplate(`Hello, \`world\`!`)).toMatchSnapshot();
+});
+it("transpiles a template with backslashes", () => {
+    expect(transpileTemplate(`Hello, \\world\\!`)).toMatchSnapshot();
+});

package/dist/src/javascript/transpile.d.ts

@@ -0,0 +1,25 @@
+import type { Cell } from "../lib/notebook.js";
+export type TranspiledJavaScript = {
+    /** the source code of a JavaScript function defining the primary variable */
+    body: string;
+    /** any unbound references in body; corresponds to the body arguments, in order */
+    inputs?: string[];
+    /** if present, the body returns an object of named outputs; alternative to output */
+    outputs?: string[];
+    /** if present, the body returns a single named output; alternative to outputs */
+    output?: string;
+    /** whether to implicitly display the body value (e.g., an expression) */
+    autodisplay?: boolean;
+    /** whether to implicitly derive a view; for ojs compatibility; requires viewof output */
+    autoview?: boolean;
+    /** whether to implicitly derive a mutable; for ojs compatibility; requires mutable output */
+    automutable?: boolean;
+};
+export type TranspileOptions = {
+    /** If true, resolve local imports paths relative to document.baseURI. */
+    resolveLocalImports?: boolean;
+    /** If true, resolve file using import.meta.url (so Vite treats it as an asset). */
+    resolveFiles?: boolean;
+};
+export declare function transpile(input: string, mode: Cell["mode"], options?: TranspileOptions): TranspiledJavaScript;
+export declare function transpileJavaScript(input: string, options?: TranspileOptions): TranspiledJavaScript;

package/dist/src/javascript/transpile.js

@@ -0,0 +1,42 @@
+import { rewriteFileExpressions } from "./files.js";
+import { hasImportDeclaration, rewriteImportDeclarations, rewriteImportExpressions } from "./imports.js";
+import { transpileObservable } from "./observable.js";
+import { parseJavaScript } from "./parse.js";
+import { Sourcemap } from "./sourcemap.js";
+import { transpileTemplate } from "./template.js";
+export function transpile(input, mode, options) {
+    return mode === "ojs"
+        ? transpileObservable(input, options) // TODO ojs+md etc.
+        : transpileJavaScript(transpileMode(input, mode), options);
+}
+function transpileMode(input, mode) {
+    if (mode === "js")
+        return input;
+    const tag = mode === "tex" ? "tex.block" : mode === "sql" ? "__sql(db, Inputs.table)" : mode; // for now
+    const raw = mode === "html" || mode === "tex" || mode === "dot";
+    return transpileTemplate(input, tag, raw);
+}
+export function transpileJavaScript(input, options) {
+    const cell = parseJavaScript(input);
+    let async = cell.async;
+    const inputs = Array.from(new Set(cell.references.map((r) => r.name)));
+    if (hasImportDeclaration(cell.body))
+        async = true;
+    const outputs = Array.from(new Set(cell.declarations?.map((r) => r.name)));
+    const output = new Sourcemap(input).trim();
+    rewriteImportDeclarations(output, cell.body, inputs, options);
+    rewriteImportExpressions(output, cell.body, options);
+    if (options?.resolveFiles)
+        rewriteFileExpressions(output, cell.body);
+    if (cell.expression)
+        output.insertLeft(0, `return (\n`);
+    output.insertLeft(0, `${async ? "async " : ""}(${inputs}) => {\n`);
+    if (outputs.length > 0)
+        output.insertRight(input.length, `\nreturn {${outputs}};`);
+    if (cell.expression)
+        output.insertRight(input.length, `\n)`);
+    output.insertRight(input.length, "\n}");
+    const body = String(output);
+    const autodisplay = cell.expression && !(inputs.includes("display") || inputs.includes("view"));
+    return { body, inputs, outputs, autodisplay };
+}

package/dist/src/javascript/transpile.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/javascript/transpile.test.js

@@ -0,0 +1,29 @@
+import { expect, it } from "vitest";
+import { transpile } from "./transpile.js";
+it("transpiles JavaScript expressions", () => {
+    expect(transpile("1 + 2", "js")).toMatchSnapshot();
+    expect(transpile("x + y", "js")).toMatchSnapshot();
+    expect(transpile("await z", "js")).toMatchSnapshot();
+    expect(transpile("display(1), display(2)", "js")).toMatchSnapshot();
+});
+it("transpiles JavaScript programs", () => {
+    expect(transpile("const x = 1, y = 2;", "js")).toMatchSnapshot();
+    expect(transpile("x + y;", "js")).toMatchSnapshot();
+    expect(transpile("await z;", "js")).toMatchSnapshot();
+});
+it("transpiles static npm: imports", () => {
+    expect(transpile('import * as d3 from "npm:d3";', "js")).toMatchSnapshot();
+    expect(transpile('import _ from "npm:lodash";', "js")).toMatchSnapshot();
+    expect(transpile('import {} from "npm:d3";\nimport "npm:isoformat";', "js")).toMatchSnapshot();
+});
+it("transpiles dynamic npm: imports", () => {
+    expect(transpile('const d3 = await import("npm:d3");', "js")).toMatchSnapshot();
+});
+it("transpiles static observable: imports", () => {
+    expect(transpile('import {Scrubber} from "observable:@mbostock/scrubber";', "js")).toMatchSnapshot();
+});
+it("transpiles import.meta.resolve", () => {
+    expect(transpile('import.meta.resolve("npm:d3")', "js")).toMatchSnapshot();
+    expect(transpile('import.meta.resolve("./test")', "js", { resolveLocalImports: true })).toMatchSnapshot();
+    expect(transpile('import.meta.resolve("./test")', "js", { resolveLocalImports: false })).toMatchSnapshot();
+});

package/dist/src/javascript/walk.d.ts

@@ -0,0 +1,5 @@
+import type { Node } from "acorn";
+import type { AncestorVisitors, RecursiveVisitors, SimpleVisitors } from "acorn-walk";
+export declare function ancestor<T>(node: Node, visitors: AncestorVisitors<T>): void;
+export declare function recursive<T>(node: Node, state: T, functions: RecursiveVisitors<T>): void;
+export declare function simple<T>(node: Node, visitors: SimpleVisitors<T>): void;

package/dist/src/javascript/walk.js

@@ -0,0 +1,13 @@
+import { walk } from "@observablehq/parser";
+import { ancestor as _ancestor } from "acorn-walk";
+import { recursive as _recursive } from "acorn-walk";
+import { simple as _simple } from "acorn-walk";
+export function ancestor(node, visitors) {
+    return _ancestor(node, visitors, walk);
+}
+export function recursive(node, state, functions) {
+    return _recursive(node, state, functions, walk);
+}
+export function simple(node, visitors) {
+    return _simple(node, visitors, walk);
+}