@hpcc-js/observablehq-compiler 1.1.1 → 1.1.3

package/dist/index.esm.js

@@ -6229,15 +6229,15 @@ function parseCell$1(input, {tag, raw, globals, ...options} = {}) {
   if (tag != null && input) {
     cell = TemplateCellParser.parse(input, options);
     const parsedTag = CellTagParser.parse(tag, options);
-    parseReferences(parsedTag, tag, globals);
-    parseFeatures(parsedTag, tag);
+    parseReferences$1(parsedTag, tag, globals);
+    parseFeatures$1(parsedTag, tag);
     cell.tag = parsedTag;
     cell.raw = !!raw;
   } else {
     cell = CellParser.parse(input, options);
   }
-  parseReferences(cell, input, globals);
-  parseFeatures(cell, input);
+  parseReferences$1(cell, input, globals);
+  parseFeatures$1(cell, input);
   return cell;
 }
 
@@ -6549,7 +6549,7 @@ class CellTagParser extends Parser {
 // Find references.
 // Check for illegal references to arguments.
 // Check for illegal assignments to global references.
-function parseReferences(cell, input, globals = defaultGlobals) {
+function parseReferences$1(cell, input, globals = defaultGlobals) {
   if (!cell.body) {
     cell.references = [];
   } else if (cell.body.type === "ImportDeclaration") {
@@ -6576,7 +6576,7 @@ function parseReferences(cell, input, globals = defaultGlobals) {
 // Find features: file attachments, secrets, database clients.
 // Check for illegal references to arguments.
 // Check for illegal assignments to global references.
-function parseFeatures(cell, input) {
+function parseFeatures$1(cell, input) {
   if (cell.body && cell.body.type !== "ImportDeclaration") {
     try {
       cell.fileAttachments = findFeatures(cell, "FileAttachment");
@@ -6599,570 +6599,594 @@ function parseFeatures(cell, input) {
   }
   return cell;
 }
-
-class ModuleParser extends CellParser {
-    parseTopLevel(node) {
-        if (!node.cells)
-            node.cells = [];
-        // @ts-ignore
-        while (this.type !== types$1.eof) {
-            // @ts-ignore
-            const cell = this.parseCell(this.startNode());
-            // @ts-ignore
-            cell.input = this.input;
-            node.cells.push(cell);
-        }
-        // @ts-ignore
-        this.next();
-        // @ts-ignore
-        return this.finishNode(node, "Program");
-    }
-}
-// @ts-ignore
-function parseModule(input, { globals } = {}) {
-    // @ts-ignore
-    return ModuleParser.parse(input).cells.map(cell => input.substring(cell.start, cell.end));
+class ModuleParser extends CellParser {
+    parseTopLevel(node) {
+        if (!node.cells)
+            node.cells = [];
+        // @ts-ignore
+        while (this.type !== types$1.eof) {
+            // @ts-ignore
+            const cell = this.parseCell(this.startNode());
+            // @ts-ignore
+            cell.input = this.input;
+            node.cells.push(cell);
+        }
+        // @ts-ignore
+        this.next();
+        // @ts-ignore
+        return this.finishNode(node, "Program");
+    }
+}
+function splitModule(input) {
+    // @ts-ignore
+    return ModuleParser.parse(input, { ecmaVersion: "latest" }).cells.map(cell => input.substring(cell.start, cell.end));
+}
+function parseCell$2(input) {
+    return parseCell$1(input);
 }
 
-const FuncTypes = {
-    functionType: Object.getPrototypeOf(function () { }).constructor,
-    asyncFunctionType: Object.getPrototypeOf(async function () { }).constructor,
-    generatorFunctionType: Object.getPrototypeOf(function* () { }).constructor,
-    asyncGeneratorFunctionType: Object.getPrototypeOf(async function* () { }).constructor
-};
-function funcType(async = false, generator = false) {
-    if (!async && !generator)
-        return FuncTypes.functionType;
-    if (async && !generator)
-        return FuncTypes.asyncFunctionType;
-    if (!async && generator)
-        return FuncTypes.generatorFunctionType;
-    return FuncTypes.asyncGeneratorFunctionType;
-}
-function createFunction(refs, async = false, generator = false, blockStatement = false, body) {
-    if (body === undefined) {
-        return undefined;
-    }
-    refs.patches.sort((l, r) => r.start - l.start);
-    refs.patches.forEach(r => {
-        body = body.substring(0, r.start) + r.newText + body.substring(r.end);
-    });
-    return new (funcType(async, generator))(...refs.args, blockStatement ?
-        body.substring(1, body.length - 1).trim() :
-        `return (\n${body}\n);`);
-}
-//  Hide "import" from bundlers as they have a habit of replacing "import" with "require"
-async function obfuscatedImport(url) {
-    return new FuncTypes.asyncFunctionType("url", "return import(url)")(url);
-}
-function encodeBacktick(str) {
-    return str
-        .split("`").join("\\`");
-}
-function createParsedOJS(ojs, offset, inlineMD) {
-    return {
-        ojs,
-        offset,
-        inlineMD
-    };
-}
-function parseOmd(_) {
-    const retVal = [];
-    //  Load Markdown  ---
-    const re = /(```(?:\s|\S)[\s\S]*?```)/g;
-    let prevOffset = 0;
-    let match = re.exec(_);
-    while (match !== null) {
-        if (match.index > prevOffset) {
-            retVal.push(createParsedOJS(_.substring(prevOffset, match.index), prevOffset, true));
-        }
-        const outer = match[0];
-        if (outer.indexOf("``` ") === 0 || outer.indexOf("```\n") === 0 || outer.indexOf("```\r\n") === 0) {
-            const prefixLen = 3;
-            const inner = outer.substring(prefixLen, outer.length - prefixLen);
-            retVal.push(createParsedOJS(inner, match.index + prefixLen, false));
-        }
-        else {
-            retVal.push(createParsedOJS(outer, match.index, true));
-        }
-        prevOffset = match.index + match[0].length;
-        match = re.exec(_);
-    }
-    if (_.length > prevOffset) {
-        retVal.push(createParsedOJS(_.substring(prevOffset, _.length), prevOffset, true));
-    }
-    return retVal;
-}
-function ojs2notebook(ojs) {
-    const cells = parseModule(ojs);
-    return {
-        files: [],
-        nodes: cells.map((cell, idx) => {
-            return {
-                id: idx,
-                mode: "js",
-                value: cell
-            };
-        })
-    };
-}
-function omd2notebook(omd) {
-    const cells = parseOmd(omd);
-    return {
-        files: [],
-        nodes: cells.map((cell, idx) => {
-            return {
-                id: idx,
-                mode: cell.inlineMD ? "md" : "js",
-                value: cell.ojs
-            };
-        })
-    };
-}
-function fetchEx(url) {
-    return fetch(url)
-        .then(response => {
-        if (response.ok)
-            return response;
-        throw new Error("CORS?");
-    }).catch(e => {
-        const matches = url.match(/^(?:https?:\/\/)?(?:[^@\n]+@)?(?:www\.)?([^:\/\n?]+)/img);
-        url = "https://observable-cors.glitch.me/" + url;
-        return fetch(url, {
-            headers: {
-                origin: matches[0],
-                referer: url
-            }
-        });
-    });
-}
-function download(impUrl) {
-    const isShared = impUrl.indexOf("https://observablehq.com/d") === 0;
-    return fetchEx(impUrl.replace(`https://observablehq.com/${isShared ? "d/" : ""}`, "https://api.observablehq.com/document/"))
-        .then(r => r.json());
+const FuncTypes = {
+    functionType: Object.getPrototypeOf(function () { }).constructor,
+    asyncFunctionType: Object.getPrototypeOf(async function () { }).constructor,
+    generatorFunctionType: Object.getPrototypeOf(function* () { }).constructor,
+    asyncGeneratorFunctionType: Object.getPrototypeOf(async function* () { }).constructor
+};
+function funcType(async = false, generator = false) {
+    if (!async && !generator)
+        return FuncTypes.functionType;
+    if (async && !generator)
+        return FuncTypes.asyncFunctionType;
+    if (!async && generator)
+        return FuncTypes.generatorFunctionType;
+    return FuncTypes.asyncGeneratorFunctionType;
+}
+function createFunction(refs, async = false, generator = false, blockStatement = false, body) {
+    if (body === undefined) {
+        return undefined;
+    }
+    refs.patches.sort((l, r) => r.start - l.start);
+    refs.patches.forEach(r => {
+        body = body.substring(0, r.start) + r.newText + body.substring(r.end);
+    });
+    return new (funcType(async, generator))(...refs.args, blockStatement ?
+        body.substring(1, body.length - 1).trim() :
+        `return (\n${body}\n);`);
+}
+//  Hide "import" from bundlers as they have a habit of replacing "import" with "require"
+async function obfuscatedImport(url) {
+    return new FuncTypes.asyncFunctionType("url", "return import(url)")(url);
+}
+function encodeBacktick(str) {
+    return str
+        .split("`").join("\\`");
+}
+function createParsedOJS(ojs, offset, inlineMD) {
+    let cell;
+    let error;
+    try {
+        cell = parseCell$2(ojs);
+    }
+    catch (e) {
+        error = e;
+    }
+    return {
+        ojs,
+        offset,
+        inlineMD,
+        cell,
+        error
+    };
+}
+function parseOmd(_) {
+    const retVal = [];
+    //  Load Markdown  ---
+    const re = /(```(?:\s|\S)[\s\S]*?```)/g;
+    let prevOffset = 0;
+    let match = re.exec(_);
+    while (match !== null) {
+        if (match.index > prevOffset) {
+            retVal.push(createParsedOJS(_.substring(prevOffset, match.index), prevOffset, true));
+        }
+        const outer = match[0];
+        if (outer.indexOf("``` ") === 0 || outer.indexOf("```\n") === 0 || outer.indexOf("```\r\n") === 0) {
+            const prefixLen = 3;
+            const inner = outer.substring(prefixLen, outer.length - prefixLen);
+            retVal.push(createParsedOJS(inner, match.index + prefixLen, false));
+        }
+        else {
+            retVal.push(createParsedOJS(outer, match.index, true));
+        }
+        prevOffset = match.index + match[0].length;
+        match = re.exec(_);
+    }
+    if (_.length > prevOffset) {
+        retVal.push(createParsedOJS(_.substring(prevOffset, _.length), prevOffset, true));
+    }
+    return retVal;
+}
+function ojs2notebook(ojs) {
+    const cells = splitModule(ojs);
+    return {
+        files: [],
+        nodes: cells.map((cell, idx) => {
+            return {
+                id: idx,
+                mode: "js",
+                value: cell
+            };
+        })
+    };
+}
+function omd2notebook(omd) {
+    const cells = parseOmd(omd);
+    return {
+        files: [],
+        nodes: cells.map((cell, idx) => {
+            return {
+                id: idx,
+                mode: cell.inlineMD ? "md" : "js",
+                value: cell.ojs
+            };
+        })
+    };
+}
+function fetchEx(url, proxyPrefix = "https://observable-cors.glitch.me/", proxyPostfix = "") {
+    return fetch(url)
+        .then(response => {
+        if (response.ok)
+            return response;
+        throw new Error("CORS?");
+    }).catch(e => {
+        const matches = url.match(/^(?:https?:\/\/)?(?:[^@\n]+@)?(?:www\.)?([^:\/\n?]+)/img);
+        url = `${proxyPrefix}${url}${proxyPostfix}`;
+        return fetch(url, {
+            headers: {
+                origin: matches[0],
+                referer: url
+            }
+        });
+    });
+}
+function download(impUrl) {
+    const isShared = impUrl.indexOf("https://observablehq.com/d") === 0;
+    return fetchEx(impUrl.replace(`https://observablehq.com/${isShared ? "d/" : ""}`, "https://api.observablehq.com/document/"))
+        .then(r => r.json());
 }
 
-function calcRefs(cellAst, cellStr) {
-    if (cellAst.references === undefined)
-        return { inputs: [], args: [], patches: [] };
-    const dedup = {};
-    cellAst.references.forEach(r => dedup[cellStr.substring(r.start, r.end)] = true);
-    const retVal = {
-        inputs: Object.keys(dedup),
-        args: Object.keys(dedup).map(r => r.split(" ").join("_")),
-        patches: []
-    };
-    const pushPatch = (node, newText) => retVal.patches.push({ start: node.start - cellAst.body.start, end: node.end - cellAst.body.start, newText });
-    if (cellAst.body) {
-        ancestor(cellAst.body, {
-            Identifier(node) {
-                const value = cellStr.substring(node.start, node.end);
-                if (dedup[value]) ;
-            },
-            MutableExpression(node) {
-                const value = cellStr.substring(node.start, node.end);
-                const newText = value.split(" ").join("_") + ".value";
-                pushPatch(node, newText);
-            },
-            ViewExpression(node) {
-                const value = cellStr.substring(node.start, node.end);
-                const newText = value.split(" ").join("_");
-                pushPatch(node, newText);
-            },
-            ThisExpression(node, ancestors) {
-                const value = cellStr.substring(node.start, node.end);
-                if (value === "this" && !ancestors.find(n => n.type === "FunctionExpression")) {
-                    pushPatch(node, "((this === globalThis || this === globalThis.window)? undefined : this?.valueOf())");
-                }
-            }
-        }, walk);
-    }
-    return retVal;
-}
-function parseImportExpression(cellAst) {
-    var _a, _b, _c, _d;
-    return {
-        type: "import",
-        src: cellAst.body.source.value,
-        specifiers: (_b = (_a = cellAst.body.specifiers) === null || _a === void 0 ? void 0 : _a.map(spec => {
-            var _a;
-            return {
-                view: spec.view,
-                name: spec.imported.name,
-                alias: (((_a = spec.local) === null || _a === void 0 ? void 0 : _a.name) && spec.imported.name !== spec.local.name) ? spec.local.name : spec.imported.name
-            };
-        })) !== null && _b !== void 0 ? _b : [],
-        injections: (_d = (_c = cellAst.body.injections) === null || _c === void 0 ? void 0 : _c.map(inj => {
-            var _a, _b;
-            return {
-                name: inj.imported.name,
-                alias: (_b = (_a = inj.local) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : inj.imported.name
-            };
-        })) !== null && _d !== void 0 ? _d : [],
-    };
-}
-function parseViewExpression(cellStr, cellAst, refs, bodyStr) {
-    var _a, _b;
-    const id = cellAst.id && cellStr.substring(cellAst.id.start, cellAst.id.end);
-    return {
-        type: "viewof",
-        variable: {
-            type: "variable",
-            id,
-            inputs: refs.inputs,
-            func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
-        },
-        variableValue: {
-            type: "variable",
-            id: (_b = (_a = cellAst === null || cellAst === void 0 ? void 0 : cellAst.id) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.name,
-            inputs: ["Generators", id],
-            func: (G, _) => G.input(_)
-        }
-    };
-}
-function parseMutableExpression(cellStr, cellAst, refs, bodyStr) {
-    var _a, _b;
-    const id = cellAst.id && cellStr.substring(cellAst.id.start, cellAst.id.end);
-    const initialValueId = (_b = (_a = cellAst === null || cellAst === void 0 ? void 0 : cellAst.id) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.name;
-    const initialId = `initial ${initialValueId}`;
-    return {
-        type: "mutable",
-        initial: {
-            type: "variable",
-            id: initialId,
-            inputs: refs.inputs,
-            func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
-        },
-        variable: {
-            type: "variable",
-            id,
-            inputs: ["Mutable", initialId],
-            func: (M, _) => new M(_)
-        },
-        variableValue: {
-            type: "variable",
-            id: initialValueId,
-            inputs: [id],
-            func: _ => _.generator
-        }
-    };
-}
-function parseVariableExpression(cellStr, cellAst, refs, bodyStr) {
-    var _a, _b;
-    return {
-        type: "variable",
-        id: cellAst.id && cellStr.substring((_a = cellAst.id) === null || _a === void 0 ? void 0 : _a.start, (_b = cellAst.id) === null || _b === void 0 ? void 0 : _b.end),
-        inputs: refs.inputs,
-        func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
-    };
-}
-function parseCell(cellStr) {
-    var _a, _b;
-    const cellAst = parseCell$1(cellStr);
-    if (((_a = (cellAst.body)) === null || _a === void 0 ? void 0 : _a.type) == "ImportDeclaration") {
-        return parseImportExpression(cellAst);
-    }
-    const refs = calcRefs(cellAst, cellStr);
-    const bodyStr = cellAst.body && cellStr.substring(cellAst.body.start, cellAst.body.end);
-    switch ((_b = cellAst.id) === null || _b === void 0 ? void 0 : _b.type) {
-        case "ViewExpression":
-            return parseViewExpression(cellStr, cellAst, refs, bodyStr);
-        case "MutableExpression":
-            return parseMutableExpression(cellStr, cellAst, refs, bodyStr);
-        default:
-            return parseVariableExpression(cellStr, cellAst, refs, bodyStr);
-    }
+function calcRefs(cellAst, cellStr) {
+    if (cellAst.references === undefined)
+        return { inputs: [], args: [], patches: [] };
+    const dedup = {};
+    cellAst.references.forEach(r => dedup[cellStr.substring(r.start, r.end)] = true);
+    const retVal = {
+        inputs: Object.keys(dedup),
+        args: Object.keys(dedup).map(r => r.split(" ").join("_")),
+        patches: []
+    };
+    const pushPatch = (node, newText) => retVal.patches.push({ start: node.start - cellAst.body.start, end: node.end - cellAst.body.start, newText });
+    if (cellAst.body) {
+        ancestor(cellAst.body, {
+            Identifier(node) {
+                const value = cellStr.substring(node.start, node.end);
+                if (dedup[value]) ;
+            },
+            MutableExpression(node) {
+                const value = cellStr.substring(node.start, node.end);
+                const newText = value.split(" ").join("_") + ".value";
+                pushPatch(node, newText);
+            },
+            ViewExpression(node) {
+                const value = cellStr.substring(node.start, node.end);
+                const newText = value.split(" ").join("_");
+                pushPatch(node, newText);
+            },
+            ThisExpression(node, ancestors) {
+                const value = cellStr.substring(node.start, node.end);
+                if (value === "this" && !ancestors.find(n => n.type === "FunctionExpression")) {
+                    pushPatch(node, "((this === globalThis || this === globalThis.window)? undefined : this?.valueOf())");
+                }
+            }
+        }, walk);
+    }
+    return retVal;
+}
+function parseImportExpression(cellAst) {
+    var _a, _b, _c, _d;
+    return {
+        type: "import",
+        src: cellAst.body.source.value,
+        specifiers: (_b = (_a = cellAst.body.specifiers) === null || _a === void 0 ? void 0 : _a.map(spec => {
+            var _a;
+            return {
+                view: spec.view,
+                name: spec.imported.name,
+                alias: (((_a = spec.local) === null || _a === void 0 ? void 0 : _a.name) && spec.imported.name !== spec.local.name) ? spec.local.name : spec.imported.name
+            };
+        })) !== null && _b !== void 0 ? _b : [],
+        injections: (_d = (_c = cellAst.body.injections) === null || _c === void 0 ? void 0 : _c.map(inj => {
+            var _a, _b;
+            return {
+                name: inj.imported.name,
+                alias: (_b = (_a = inj.local) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : inj.imported.name
+            };
+        })) !== null && _d !== void 0 ? _d : [],
+    };
+}
+function parseViewExpression(cellStr, cellAst, refs, bodyStr) {
+    var _a, _b;
+    const id = cellAst.id && cellStr.substring(cellAst.id.start, cellAst.id.end);
+    return {
+        type: "viewof",
+        variable: {
+            type: "variable",
+            id,
+            inputs: refs.inputs,
+            func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
+        },
+        variableValue: {
+            type: "variable",
+            id: (_b = (_a = cellAst === null || cellAst === void 0 ? void 0 : cellAst.id) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.name,
+            inputs: ["Generators", id],
+            func: (G, _) => G.input(_)
+        }
+    };
+}
+function parseMutableExpression(cellStr, cellAst, refs, bodyStr) {
+    var _a, _b;
+    const id = cellAst.id && cellStr.substring(cellAst.id.start, cellAst.id.end);
+    const initialValueId = (_b = (_a = cellAst === null || cellAst === void 0 ? void 0 : cellAst.id) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.name;
+    const initialId = `initial ${initialValueId}`;
+    return {
+        type: "mutable",
+        initial: {
+            type: "variable",
+            id: initialId,
+            inputs: refs.inputs,
+            func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
+        },
+        variable: {
+            type: "variable",
+            id,
+            inputs: ["Mutable", initialId],
+            func: (M, _) => new M(_)
+        },
+        variableValue: {
+            type: "variable",
+            id: initialValueId,
+            inputs: [id],
+            func: _ => _.generator
+        }
+    };
+}
+function parseVariableExpression(cellStr, cellAst, refs, bodyStr) {
+    var _a, _b;
+    return {
+        type: "variable",
+        id: cellAst.id && cellStr.substring((_a = cellAst.id) === null || _a === void 0 ? void 0 : _a.start, (_b = cellAst.id) === null || _b === void 0 ? void 0 : _b.end),
+        inputs: refs.inputs,
+        func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
+    };
+}
+function parseCell(cellStr) {
+    var _a, _b;
+    const cellAst = parseCell$2(cellStr);
+    if (((_a = (cellAst.body)) === null || _a === void 0 ? void 0 : _a.type) == "ImportDeclaration") {
+        return parseImportExpression(cellAst);
+    }
+    const refs = calcRefs(cellAst, cellStr);
+    const bodyStr = cellAst.body && cellStr.substring(cellAst.body.start, cellAst.body.end);
+    switch ((_b = cellAst.id) === null || _b === void 0 ? void 0 : _b.type) {
+        case "ViewExpression":
+            return parseViewExpression(cellStr, cellAst, refs, bodyStr);
+        case "MutableExpression":
+            return parseMutableExpression(cellStr, cellAst, refs, bodyStr);
+        default:
+            return parseVariableExpression(cellStr, cellAst, refs, bodyStr);
+    }
 }
 
-class Writer {
-    constructor() {
-        this._files = [];
-        this._imports = [];
-        this._functions = [];
-        this._defines = [];
-        this._defineUid = 0;
-        this._functionUid = 0;
-    }
-    toString() {
-        return `\
-${this._imports.join("\n")}
-
-${this._functions.join("\n").split("\n) {").join("){")}
-
-export default function define(runtime, observer) {
-  const main = runtime.module();
-
-  function toString() { return this.url; }
-  const fileAttachments = new Map([
-    ${this._files.map(f => `["${f.name}", { url: new URL("${f.url}"), mimeType: ${JSON.stringify(f.mime_type)}, toString }]`).join(",\n    ")}
-  ]);
-  main.builtin("FileAttachment", runtime.fileAttachments(name => fileAttachments.get(name)));
-
-  ${this._defines.join("\n  ")}
-
-  return main;
-}\n`;
-    }
-    files(files) {
-        this._files = [...this._files, ...files];
-    }
-    import(url) {
-        this._imports.push(`import define${++this._defineUid} from "${url}"; `);
-    }
-    importDefine(imp) {
-        const injections = imp.injections.map(inj => {
-            return inj.name === inj.alias ?
-                `"${inj.name}"` :
-                `{name: "${inj.name}", alias: "${inj.alias}"}`;
-        });
-        const derive = imp.injections.length ? `.derive([${injections.join(", ")}], main)` : "";
-        this._defines.push(`const child${this._defineUid} = runtime.module(define${this._defineUid})${derive};`);
-        imp.specifiers.forEach(s => {
-            this._defines.push(`main.import("${s.name}"${s.alias && s.alias !== s.name ? `, "${s.alias}"` : ""}, child${this._defineUid}); `);
-        });
-    }
-    function(variable) {
-        var _a, _b, _c;
-        let id = (_a = variable.id) !== null && _a !== void 0 ? _a : `${++this._functionUid}`;
-        const idParts = id.split(" ");
-        id = `_${idParts[idParts.length - 1]}`;
-        this._functions.push(`${(_c = (_b = variable.func) === null || _b === void 0 ? void 0 : _b.toString()) === null || _c === void 0 ? void 0 : _c.replace("anonymous", `${id}`)}`);
-        return id;
-    }
-    define(variable, observable = true, inlineFunc = false, funcId) {
-        var _a;
-        funcId = funcId !== null && funcId !== void 0 ? funcId : variable.id;
-        const observe = observable ? `.variable(observer(${variable.id ? JSON.stringify(variable.id) : ""}))` : "";
-        const id = variable.id ? `${JSON.stringify(variable.id)}, ` : "";
-        const inputs = variable.inputs.length ? `[${variable.inputs.map(i => JSON.stringify(i)).join(", ")}], ` : "";
-        const func = inlineFunc ?
-            (_a = variable.func) === null || _a === void 0 ? void 0 : _a.toString() :
-            funcId;
-        this._defines.push(`main${observe}.define(${id}${inputs}${func});`);
-    }
-    error(msg) {
-    }
+class Writer {
+    constructor() {
+        this._files = [];
+        this._imports = [];
+        this._functions = [];
+        this._defines = [];
+        this._defineUid = 0;
+        this._functionUid = 0;
+    }
+    toString() {
+        return `\
+${this._imports.join("\n")}
+
+${this._functions.join("\n").split("\n) {").join("){")}
+
+export default function define(runtime, observer) {
+  const main = runtime.module();
+
+  function toString() { return this.url; }
+  const fileAttachments = new Map([
+    ${this._files.map(f => `["${f.name}", { url: new URL("${f.url}"), mimeType: ${JSON.stringify(f.mime_type)}, toString }]`).join(",\n    ")}
+  ]);
+  main.builtin("FileAttachment", runtime.fileAttachments(name => fileAttachments.get(name)));
+
+  ${this._defines.join("\n  ")}
+
+  return main;
+}\n`;
+    }
+    files(files) {
+        this._files = [...this._files, ...files];
+    }
+    import(url) {
+        this._imports.push(`import define${++this._defineUid} from "${url}"; `);
+    }
+    importDefine(imp) {
+        const injections = imp.injections.map(inj => {
+            return inj.name === inj.alias ?
+                `"${inj.name}"` :
+                `{name: "${inj.name}", alias: "${inj.alias}"}`;
+        });
+        const derive = imp.injections.length ? `.derive([${injections.join(", ")}], main)` : "";
+        this._defines.push(`const child${this._defineUid} = runtime.module(define${this._defineUid})${derive};`);
+        imp.specifiers.forEach(s => {
+            this._defines.push(`main.import("${s.name}"${s.alias && s.alias !== s.name ? `, "${s.alias}"` : ""}, child${this._defineUid}); `);
+        });
+    }
+    function(variable) {
+        var _a, _b, _c;
+        let id = (_a = variable.id) !== null && _a !== void 0 ? _a : `${++this._functionUid}`;
+        const idParts = id.split(" ");
+        id = `_${idParts[idParts.length - 1]}`;
+        this._functions.push(`${(_c = (_b = variable.func) === null || _b === void 0 ? void 0 : _b.toString()) === null || _c === void 0 ? void 0 : _c.replace("anonymous", `${id}`)}`);
+        return id;
+    }
+    define(variable, observable = true, inlineFunc = false, funcId) {
+        var _a;
+        funcId = funcId !== null && funcId !== void 0 ? funcId : variable.id;
+        const observe = observable ? `.variable(observer(${variable.id ? JSON.stringify(variable.id) : ""}))` : "";
+        const id = variable.id ? `${JSON.stringify(variable.id)}, ` : "";
+        const inputs = variable.inputs.length ? `[${variable.inputs.map(i => JSON.stringify(i)).join(", ")}], ` : "";
+        const func = inlineFunc ?
+            (_a = variable.func) === null || _a === void 0 ? void 0 : _a.toString() :
+            funcId;
+        this._defines.push(`main${observe}.define(${id}${inputs}${func});`);
+    }
+    error(msg) {
+    }
 }
 
-async function importFile(relativePath, baseUrl) {
-    const path = join(baseUrl, relativePath);
-    const content = await fetchEx(path).then(r => r.text());
-    let notebook;
-    if (endsWith(relativePath, ".ojsnb")) {
-        notebook = JSON.parse(content);
-    }
-    else if (endsWith(relativePath, ".ojs")) {
-        notebook = ojs2notebook(content);
-    }
-    else if (endsWith(relativePath, ".omd")) {
-        notebook = omd2notebook(content);
-    }
-    const retVal = compile(notebook, baseUrl);
-    retVal.dispose = () => { };
-    retVal.write = (w) => {
-        w.import(path);
-    };
-    return retVal;
-}
-// @ts-ignore - use precompiled notebook from observable
-async function importCompiledNotebook(partial) {
-    const url = `https://api.observablehq.com/${partial[0] === "@" ? partial : `d/${partial}`}.js?v=3`;
-    let impMod = {
-        default: function (runtime, inspector) {
-            return undefined;
-        }
-    };
-    try {
-        impMod = await obfuscatedImport(url);
-    }
-    catch (e) {
-    }
-    const retVal = impMod.default;
-    retVal.dispose = () => { };
-    retVal.write = (w) => {
-        w.import(url);
-    };
-    return retVal;
-}
-function createVariable(inspect, name, inputs, definition, inline = false) {
-    let i;
-    let v;
-    const retVal = (module, inspector) => {
-        i = inspect ? inspector(name) : undefined;
-        v = module.variable(i);
-        if (arguments.length > 1) {
-            try {
-                v.define(name, inputs, definition);
-            }
-            catch (e) {
-                console.error(e === null || e === void 0 ? void 0 : e.message);
-            }
-        }
-        return v;
-    };
-    retVal.dispose = () => {
-        var _a;
-        try {
-            (_a = i === null || i === void 0 ? void 0 : i._node) === null || _a === void 0 ? void 0 : _a.remove();
-        }
-        catch (e) {
-        }
-        i = undefined;
-        try {
-            v === null || v === void 0 ? void 0 : v.delete();
-        }
-        catch (e) {
-        }
-        v = undefined;
-    };
-    retVal.write = (w) => {
-        if (inline) {
-            w.define({ id: name, inputs, func: definition }, inspect, true);
-        }
-        else {
-            const id = w.function({ id: name, func: definition });
-            w.define({ id: name, inputs, func: definition }, inspect, false, id);
-        }
-    };
-    return retVal;
-}
-function createImportVariable(name, alias) {
-    let v;
-    const retVal = (main, otherModule) => {
-        v = main.variable();
-        v.import(name, alias, otherModule);
-    };
-    retVal.dispose = () => {
-        v === null || v === void 0 ? void 0 : v.delete();
-    };
-    return retVal;
-}
-async function createModule(parsed, text, baseUrl) {
-    const otherModule = [".", "/"].indexOf(parsed.src[0]) === 0 ?
-        await importFile(parsed.src, baseUrl) :
-        await importCompiledNotebook(parsed.src);
-    const importVariables = [];
-    const variables = [];
-    parsed.specifiers.forEach(spec => {
-        const viewof = spec.view ? "viewof " : "";
-        importVariables.push(createImportVariable(viewof + spec.name, viewof + spec.alias));
-        if (spec.view) {
-            importVariables.push(createImportVariable(spec.name, spec.alias));
-        }
-    });
-    variables.push(createVariable(true, undefined, ["md"], md => {
-        return md `\`\`\`JavaScript
-${text}
-\`\`\``;
-    }));
-    const retVal = (runtime, main, inspector) => {
-        let mod = runtime.module(otherModule);
-        if (parsed.injections.length) {
-            mod = mod.derive(parsed.injections, main);
-        }
-        variables.forEach(v => v(main, inspector));
-        importVariables.forEach(v => v(main, mod));
-        return mod;
-    };
-    retVal.importVariables = importVariables;
-    retVal.variables = variables;
-    retVal.dispose = () => {
-        importVariables.forEach(v => v.dispose());
-        variables.forEach(v => v.dispose());
-        otherModule.dispose();
-    };
-    retVal.write = (w) => {
-        otherModule.write(w);
-        w.importDefine(parsed);
-    };
-    return retVal;
-}
-async function createCell(node, baseUrl) {
-    const modules = [];
-    const variables = [];
-    try {
-        const text = node.mode && node.mode !== "js" ? `${node.mode}\`${encodeBacktick(node.value)}\`` : node.value;
-        const parsed = parseCell(text);
-        switch (parsed.type) {
-            case "import":
-                modules.push(await createModule(parsed, text, baseUrl));
-                break;
-            case "viewof":
-                variables.push(createVariable(true, parsed.variable.id, parsed.variable.inputs, parsed.variable.func));
-                variables.push(createVariable(false, parsed.variableValue.id, parsed.variableValue.inputs, parsed.variableValue.func, true));
-                break;
-            case "mutable":
-                variables.push(createVariable(false, parsed.initial.id, parsed.initial.inputs, parsed.initial.func));
-                variables.push(createVariable(false, parsed.variable.id, parsed.variable.inputs, parsed.variable.func));
-                variables.push(createVariable(true, parsed.variableValue.id, parsed.variableValue.inputs, parsed.variableValue.func, true));
-                break;
-            case "variable":
-                variables.push(createVariable(true, parsed.id, parsed.inputs, parsed.func));
-                break;
-        }
-    }
-    catch (e) {
-    }
-    const retVal = (runtime, main, inspector) => {
-        modules.forEach(imp => imp(runtime, main, inspector));
-        variables.forEach(v => v(main, inspector));
-    };
-    retVal.modules = modules;
-    retVal.variables = variables;
-    retVal.dispose = () => {
-        variables.forEach(v => v.dispose());
-        modules.forEach(mod => mod.dispose());
-    };
-    retVal.write = (w) => {
-        modules.forEach(imp => imp.write(w));
-        variables.forEach(v => v.write(w));
-    };
-    return retVal;
-}
-function createFile(file) {
-    function toString() { return globalThis.url; }
-    return [file.name, { url: new URL(file.url), mimeType: file.mime_type, toString }];
-}
-async function compile(notebook, baseUrl = ".") {
-    const files = notebook.files.map(f => createFile(f));
-    const fileAttachments = new Map(files);
-    let cells = await Promise.all(notebook.nodes.map(n => createCell(n, baseUrl)));
-    const retVal = (runtime, inspector) => {
-        const main = runtime.module();
-        main.builtin("FileAttachment", runtime.fileAttachments(name => {
-            var _a;
-            return (_a = fileAttachments.get(name)) !== null && _a !== void 0 ? _a : { url: new URL(name), mimeType: null };
-        }));
-        cells.forEach(cell => {
-            cell(runtime, main, inspector);
-        });
-        return main;
-    };
-    retVal.fileAttachments = fileAttachments;
-    retVal.cells = cells;
-    retVal.appendCell = async (n, baseUrl = ".") => {
-        const cell = await createCell(n, baseUrl);
-        cells.push(cell);
-        return cell;
-    };
-    retVal.disposeCell = async (cell) => {
-        cells = cells.filter(c => c !== cell);
-        cell.dispose();
-    };
-    retVal.dispose = () => {
-        cells.forEach(cell => cell.dispose());
-        cells = [];
-    };
-    retVal.write = (w) => {
-        w.files(notebook.files);
-        cells.forEach(cell => cell.write(w));
-    };
-    retVal.toString = (w = new Writer()) => {
-        retVal.write(w);
-        return w.toString().trim();
-    };
-    return retVal;
+const isRelativePath = (path) => path[0] === ".";
+const fullUrl = (path, basePath) => isRelativePath(path) ? join(basePath, path) : path;
+async function importFile(relativePath, baseUrl) {
+    const path = fullUrl(relativePath, baseUrl);
+    const content = await fetchEx(path).then(r => r.text());
+    let notebook;
+    if (endsWith(relativePath, ".ojsnb")) {
+        notebook = JSON.parse(content);
+    }
+    else if (endsWith(relativePath, ".ojs")) {
+        notebook = ojs2notebook(content);
+    }
+    else if (endsWith(relativePath, ".omd")) {
+        notebook = omd2notebook(content);
+    }
+    const retVal = compile(notebook, baseUrl);
+    retVal.dispose = () => { };
+    retVal.write = (w) => {
+        w.import(path);
+    };
+    return retVal;
+}
+// @ts-ignore - use precompiled notebook from observable
+async function importCompiledNotebook(partial) {
+    const url = `https://api.observablehq.com/${partial[0] === "@" ? partial : `d/${partial}`}.js?v=3`;
+    let impMod = {
+        default: function (runtime, inspector) {
+            return undefined;
+        }
+    };
+    try {
+        impMod = await obfuscatedImport(url);
+    }
+    catch (e) {
+    }
+    const retVal = impMod.default;
+    retVal.dispose = () => { };
+    retVal.write = (w) => {
+        w.import(url);
+    };
+    return retVal;
+}
+function createVariable(inspect, name, inputs, definition, inline = false) {
+    let i;
+    let v;
+    const retVal = (module, inspector) => {
+        i = inspect ? inspector(name) : undefined;
+        v = module.variable(i);
+        if (arguments.length > 1) {
+            try {
+                v.define(name, inputs, definition);
+            }
+            catch (e) {
+                console.error(e === null || e === void 0 ? void 0 : e.message);
+            }
+        }
+        return v;
+    };
+    retVal.dispose = () => {
+        var _a;
+        try {
+            (_a = i === null || i === void 0 ? void 0 : i._node) === null || _a === void 0 ? void 0 : _a.remove();
+        }
+        catch (e) {
+        }
+        i = undefined;
+        try {
+            v === null || v === void 0 ? void 0 : v.delete();
+        }
+        catch (e) {
+        }
+        v = undefined;
+    };
+    retVal.write = (w) => {
+        if (inline) {
+            w.define({ id: name, inputs, func: definition }, inspect, true);
+        }
+        else {
+            const id = w.function({ id: name, func: definition });
+            w.define({ id: name, inputs, func: definition }, inspect, false, id);
+        }
+    };
+    return retVal;
+}
+function createImportVariable(name, alias) {
+    let v;
+    const retVal = (main, otherModule) => {
+        v = main.variable();
+        v.import(name, alias, otherModule);
+    };
+    retVal.dispose = () => {
+        v === null || v === void 0 ? void 0 : v.delete();
+    };
+    return retVal;
+}
+async function createModule(parsed, text, baseUrl) {
+    const otherModule = isRelativePath(parsed.src) ?
+        await importFile(parsed.src, baseUrl) :
+        await importCompiledNotebook(parsed.src);
+    const importVariables = [];
+    const variables = [];
+    parsed.specifiers.forEach(spec => {
+        const viewof = spec.view ? "viewof " : "";
+        importVariables.push(createImportVariable(viewof + spec.name, viewof + spec.alias));
+        if (spec.view) {
+            importVariables.push(createImportVariable(spec.name, spec.alias));
+        }
+    });
+    variables.push(createVariable(true, undefined, ["md"], md => {
+        return md `\`\`\`JavaScript
+${text}
+\`\`\``;
+    }));
+    const retVal = (runtime, main, inspector) => {
+        let mod = runtime.module(otherModule);
+        if (parsed.injections.length) {
+            mod = mod.derive(parsed.injections, main);
+        }
+        variables.forEach(v => v(main, inspector));
+        importVariables.forEach(v => v(main, mod));
+        return mod;
+    };
+    retVal.importVariables = importVariables;
+    retVal.variables = variables;
+    retVal.dispose = () => {
+        importVariables.forEach(v => v.dispose());
+        variables.forEach(v => v.dispose());
+        otherModule.dispose();
+    };
+    retVal.write = (w) => {
+        otherModule.write(w);
+        w.importDefine(parsed);
+    };
+    return retVal;
+}
+async function createCell(node, baseUrl) {
+    const modules = [];
+    const variables = [];
+    try {
+        const text = node.mode && node.mode !== "js" ? `${node.mode}\`${encodeBacktick(node.value)}\`` : node.value;
+        const parsedModule = splitModule(text);
+        for (const text of parsedModule) {
+            const parsed = parseCell(text);
+            switch (parsed.type) {
+                case "import":
+                    modules.push(await createModule(parsed, text, baseUrl));
+                    break;
+                case "viewof":
+                    variables.push(createVariable(true, parsed.variable.id, parsed.variable.inputs, parsed.variable.func));
+                    variables.push(createVariable(false, parsed.variableValue.id, parsed.variableValue.inputs, parsed.variableValue.func, true));
+                    break;
+                case "mutable":
+                    variables.push(createVariable(false, parsed.initial.id, parsed.initial.inputs, parsed.initial.func));
+                    variables.push(createVariable(false, parsed.variable.id, parsed.variable.inputs, parsed.variable.func));
+                    variables.push(createVariable(true, parsed.variableValue.id, parsed.variableValue.inputs, parsed.variableValue.func, true));
+                    break;
+                case "variable":
+                    variables.push(createVariable(true, parsed.id, parsed.inputs, parsed.func));
+                    break;
+            }
+        }
+    }
+    catch (e) {
+        variables.push(createVariable(true, undefined, [], e.message));
+    }
+    const retVal = (runtime, main, inspector) => {
+        modules.forEach(imp => imp(runtime, main, inspector));
+        variables.forEach(v => v(main, inspector));
+    };
+    retVal.id = "" + node.id;
+    retVal.modules = modules;
+    retVal.variables = variables;
+    retVal.dispose = () => {
+        variables.forEach(v => v.dispose());
+        modules.forEach(mod => mod.dispose());
+    };
+    retVal.write = (w) => {
+        modules.forEach(imp => imp.write(w));
+        variables.forEach(v => v.write(w));
+    };
+    return retVal;
+}
+function createFile(file, baseUrl) {
+    function toString() { return globalThis.url; }
+    return [file.name, { url: new URL(fullUrl(file.url, baseUrl)), mimeType: file.mime_type, toString }];
+}
+async function compile(notebook, baseUrl = ".") {
+    const files = notebook.files.map(f => createFile(f, baseUrl));
+    const fileAttachments = new Map(files);
+    const _cells = await Promise.all(notebook.nodes.map(n => createCell(n, baseUrl)));
+    const cells = new Map(_cells.map(c => [c.id, c]));
+    const retVal = (runtime, inspector) => {
+        const main = runtime.module();
+        main.builtin("FileAttachment", runtime.fileAttachments(name => {
+            var _a;
+            return (_a = fileAttachments.get(name)) !== null && _a !== void 0 ? _a : { url: new URL(fullUrl(name, baseUrl)), mimeType: null };
+        }));
+        main.builtin("fetchEx", fetchEx);
+        cells.forEach(cell => {
+            cell(runtime, main, inspector);
+        });
+        return main;
+    };
+    retVal.fileAttachments = fileAttachments;
+    retVal.cells = cells;
+    retVal.appendCell = async (n, baseUrl) => {
+        const cell = await createCell(n, baseUrl);
+        retVal.disposeCell(cell.id);
+        cells.set(cell.id, cell);
+        return cell;
+    };
+    retVal.disposeCell = async (id) => {
+        const cell = cells.get(id);
+        if (cell) {
+            cells.delete(id);
+            cell.dispose();
+        }
+    };
+    retVal.dispose = () => {
+        cells.forEach(cell => cell.dispose());
+        cells.clear();
+    };
+    retVal.write = (w) => {
+        w.files(notebook.files);
+        cells.forEach(cell => cell.write(w));
+    };
+    retVal.toString = (w = new Writer()) => {
+        retVal.write(w);
+        return w.toString().trim();
+    };
+    return retVal;
 }
 
-export { Writer, compile, download, ojs2notebook, omd2notebook };
+export { compile, download, ojs2notebook, omd2notebook, parseOmd };
 //# sourceMappingURL=index.esm.js.map