@observablehq/notebook-kit 2.1.8 → 2.2.0

package/dist/package.json

@@ -5,7 +5,7 @@
         "type": "git",
         "url": "git+https://github.com/observablehq/notebook-kit.git"
     },
-    "version": "2.1.8",
+    "version": "2.2.0",
     "type": "module",
     "scripts": {
         "test": "TZ=America/Los_Angeles vitest",
@@ -56,12 +56,12 @@
         "@observablehq/parser": "^6.1.0",
         "@observablehq/runtime": "^6.0.0",
         "@sindresorhus/slugify": "^2.2.1",
+        "@sveltejs/acorn-typescript": "^1.0.11",
         "acorn": "^8.16.0",
         "acorn-walk": "^8.3.5",
         "jsdom": "^26.1.0",
         "markdown-it": "^14.1.1",
         "markdown-it-anchor": "^9.2.0",
-        "typescript": "^5.9.3",
         "vite": "^7.0.0 || ^8.0.0"
     },
     "devDependencies": {
@@ -80,6 +80,7 @@
         "postgres": "^3.4.9",
         "snowflake-sdk": "^2.4.2",
         "tsx": "^4.22.3",
+        "typescript": "^5.9.3",
         "typescript-eslint": "^8.59.4",
         "vitest": "^4.1.7"
     },

package/dist/src/javascript/declarations.js

@@ -1,3 +1,4 @@
+import { isTypeImport } from "./imports.js";
 import { defaultGlobals } from "./globals.js";
 import { syntaxError } from "./syntaxError.js";
 export function findDeclarations(node, input) {
@@ -14,7 +15,7 @@ export function findDeclarations(node, input) {
                 declareLocal(node);
                 break;
             case "ObjectPattern":
-                node.properties.forEach((node) => declarePattern(node.type === "Property" ? node.value : node));
+                node.properties.forEach((node) => declarePattern(node.type === "Property" ? node.value : node)); // prettier-ignore
                 break;
             case "ArrayPattern":
                 node.elements.forEach((node) => node && declarePattern(node));
@@ -37,7 +38,11 @@ export function findDeclarations(node, input) {
                 declareLocal(child.id);
                 break;
             case "ImportDeclaration":
-                child.specifiers.forEach((node) => declareLocal(node.local));
+                if (isTypeImport(child))
+                    break;
+                child.specifiers
+                    .filter((node) => !isTypeImport(node))
+                    .forEach((node) => declareLocal(node.local));
                 break;
         }
     }

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

@@ -13,6 +13,7 @@ export declare function hasImportDeclaration(body: Node): boolean;
 export declare function isImportMetaResolve(node: CallExpression): boolean;
 /** Returns true if the given node is an import.meta.url expression. */
 export declare function isImportMetaUrl(node: MemberExpression): boolean;
+export declare function isTypeImport(node: AnyImportSpecifier | ImportDeclaration): boolean;
 export type RewriteImportOptions = {
     /** If true, resolve local imports relative to document.baseURI. */
     resolveLocalImports?: boolean;

package/dist/src/javascript/imports.js

@@ -44,6 +44,9 @@ export function isImportMetaUrl(node) {
         node.property.type === "Identifier" &&
         node.property.name === "url");
 }
+export function isTypeImport(node) {
+    return node.importKind === "type";
+}
 function resolveImport(specifier) {
     return resolveObservableImport(resolveJsrImport(resolveNpmImport(specifier)));
 }
@@ -80,7 +83,10 @@ export function rewriteImportDeclarations(output, body, inputs, { resolveLocalIm
     const declarations = [];
     simple(body, {
         ImportDeclaration(node) {
-            if (isStringLiteral(node.source)) {
+            if (isTypeImport(node)) {
+                output.delete(node.start, node.end);
+            }
+            else if (isStringLiteral(node.source)) {
                 declarations.push([node, node.source]);
             }
         }
@@ -106,8 +112,11 @@ export function rewriteImportDeclarations(output, body, inputs, { resolveLocalIm
     }
 }
 function renderImport(source, node, input) {
-    const names = node.specifiers.filter(isNamedSpecifier).map(getImportedName);
-    return `import(${source}${node.attributes.length > 0
+    const names = node.specifiers
+        .filter((node) => !isTypeImport(node))
+        .filter(isNamedSpecifier)
+        .map(getImportedName);
+    return `import(${source}${node.attributes?.length > 0
         ? `, {with: {${input.slice(node.attributes[0].start, node.attributes[node.attributes.length - 1].end)}}}`
         : ""})${names.length > 0
         ? `.then((module) => {${names
@@ -140,7 +149,7 @@ function isNamedSpecifier(node) {
 function rewriteImportSpecifiers(node) {
     return node.specifiers.some(isNamedSpecifier)
         ? `{${flatMapImportSpecifiers(node, rewriteImportSpecifier).join(", ")}}`
-        : (node.specifiers.find(isNamespaceSpecifier)?.local.name ?? "{}");
+        : (node.specifiers.find((node) => isNamespaceSpecifier(node) && !isTypeImport(node))?.local.name ?? "{}"); // prettier-ignore
 }
 export function flatMapImportSpecifiers(node, f) {
     return node.specifiers.flatMap((node) => {
@@ -150,7 +159,9 @@ export function flatMapImportSpecifiers(node, f) {
             ? [f(node), f(toSpecialImportSpecifier(node, "viewof"))]
             : isMutableImport(node)
                 ? [f(node), f(toSpecialImportSpecifier(node, "mutable"))]
-                : f(node);
+                : isTypeImport(node)
+                    ? []
+                    : f(node);
     });
 }
 function rewriteImportSpecifier(node) {

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

@@ -1,6 +1,5 @@
-import type { Expression, Identifier, Options, Program } from "acorn";
+import type { Expression, Identifier, Program } from "acorn";
 import type { FeatureExpression } from "./features.js";
-export declare const acornOptions: Options;
 export interface JavaScriptCell {
     body: Program | Expression;
     declarations: Identifier[] | null;
@@ -11,5 +10,7 @@ export interface JavaScriptCell {
     expression: boolean;
     async: boolean;
 }
-export declare function maybeParseJavaScript(input: string): JavaScriptCell | undefined;
-export declare function parseJavaScript(input: string): JavaScriptCell;
+type Dialect = "js" | "ts";
+export declare function maybeParseJavaScript(input: string, dialect?: Dialect): JavaScriptCell | undefined;
+export declare function parseJavaScript(input: string, dialect?: Dialect): JavaScriptCell;
+export {};

package/dist/src/javascript/parse.js

@@ -1,15 +1,30 @@
+import { tsPlugin } from "@sveltejs/acorn-typescript";
 import { Parser, tokTypes } from "acorn";
 import { findAwaits } from "./awaits.js";
 import { findDeclarations } from "./declarations.js";
 import { findFeatures } from "./features.js";
 import { findReferences } from "./references.js";
-export const acornOptions = {
+import { checkErasableSyntax } from "./typescript.js";
+const jsOptions = {
     ecmaVersion: "latest",
     sourceType: "module"
 };
-export function maybeParseJavaScript(input) {
+const tsOptions = {
+    ...jsOptions,
+    locations: true,
+    preserveParens: true // needed for accurate type stripping
+};
+const JsParser = Parser;
+const TsParser = Parser.extend(tsPlugin());
+function getParser(dialect = "js") {
+    return dialect === "ts" ? TsParser : JsParser;
+}
+function getOptions(dialect = "js") {
+    return dialect === "ts" ? tsOptions : jsOptions;
+}
+export function maybeParseJavaScript(input, dialect) {
     try {
-        return parseJavaScript(input);
+        return parseJavaScript(input, dialect);
     }
     catch (error) {
         if (!(error instanceof SyntaxError))
@@ -17,13 +32,15 @@ export function maybeParseJavaScript(input) {
         return;
     }
 }
-export function parseJavaScript(input) {
-    let expression = maybeParseExpression(input); // first attempt to parse as expression
+export function parseJavaScript(input, dialect) {
+    let expression = maybeParseExpression(input, dialect); // first attempt to parse as expression
     if (expression?.type === "ClassExpression" && expression.id)
         expression = null; // treat named class as program
     if (expression?.type === "FunctionExpression" && expression.id)
         expression = null; // treat named function as program
-    const body = expression ?? parseProgram(input); // otherwise parse as a program
+    const body = expression ?? parseProgram(input, dialect); // otherwise parse as a program
+    if (dialect === "ts")
+        checkErasableSyntax(body, input);
     return {
         body,
         declarations: expression ? null : findDeclarations(body, input),
@@ -35,12 +52,11 @@ export function parseJavaScript(input) {
         async: findAwaits(body).length > 0
     };
 }
-function parseProgram(input) {
-    return Parser.parse(input, acornOptions);
+function parseProgram(input, dialect) {
+    return getParser(dialect).parse(input, getOptions(dialect));
 }
-function maybeParseExpression(input) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const parser = new Parser(acornOptions, input, 0); // private constructor
+function maybeParseExpression(input, dialect) {
+    const parser = new (getParser(dialect))(getOptions(dialect), input, 0); // eslint-disable-line @typescript-eslint/no-explicit-any -- private constructor
     parser.nextToken();
     try {
         const node = parser.parseExpression();

package/dist/src/javascript/references.js

@@ -1,6 +1,6 @@
 import { checkAssignments } from "./assignments.js";
 import { defaultGlobals } from "./globals.js";
-import { checkExports } from "./imports.js";
+import { checkExports, isTypeImport } from "./imports.js";
 import { ancestor } from "./walk.js";
 function isScope(node) {
     return (node.type === "FunctionExpression" ||
@@ -102,7 +102,11 @@ export function findReferences(node, { input, globals = defaultGlobals, filterRe
         ClassExpression: declareClass,
         CatchClause: declareCatchClause,
         ImportDeclaration(node, _state, [root]) {
-            node.specifiers.forEach((specifier) => declareLocal(root, specifier.local));
+            if (isTypeImport(node))
+                return;
+            node.specifiers
+                .filter((specifier) => !isTypeImport(specifier))
+                .forEach((specifier) => declareLocal(root, specifier.local));
         }
     });
     function identifier(node, _state, parents) {

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

@@ -3,6 +3,7 @@ interface Position {
     column: number;
 }
 export declare class Sourcemap {
+    readonly length: number;
     readonly input: string;
     private readonly _edits;
     constructor(input: string);

package/dist/src/javascript/sourcemap.js

@@ -2,6 +2,12 @@
 import { lineBreakG } from "acorn";
 export class Sourcemap {
     constructor(input) {
+        Object.defineProperty(this, "length", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "input", {
             enumerable: true,
             configurable: true,
@@ -14,6 +20,7 @@ export class Sourcemap {
             writable: true,
             value: void 0
         });
+        this.length = input.length;
         this.input = input;
         this._edits = [];
     }

package/dist/src/javascript/template.js

@@ -1,7 +1,10 @@
 import { TokContext, tokTypes as tt, Parser } from "acorn";
 import { getInterpreterMethod, isInterpreter } from "../lib/interpreters.js";
-import { acornOptions } from "./parse.js";
 import { Sourcemap } from "./sourcemap.js";
+const options = {
+    ecmaVersion: "latest",
+    sourceType: "module"
+};
 const CODE_DOLLAR = 36;
 const CODE_BACKSLASH = 92;
 const CODE_BACKTICK = 96;
@@ -68,7 +71,7 @@ class TemplateCellParser extends Parser {
     }
 }
 export function parseTemplate(input) {
-    return TemplateCellParser.parse(input, acornOptions);
+    return TemplateCellParser.parse(input, options);
 }
 export function transpileTemplate(input, tag = "", raw = false) {
     let cell;

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

@@ -30,4 +30,5 @@ export type TranspileOptions = {
 /** @deprecated */
 export declare function transpile(input: string, mode: Cell["mode"], options?: TranspileOptions): TranspiledJavaScript;
 export declare function transpile(input: Cell, options?: TranspileOptions): TranspiledJavaScript;
+export declare function transpileTypeScript(input: string, options?: TranspileOptions): TranspiledJavaScript;
 export declare function transpileJavaScript(input: string, options?: TranspileOptions): TranspiledJavaScript;

package/dist/src/javascript/transpile.js

@@ -6,7 +6,7 @@ import { transpileObservable } from "./observable.js";
 import { parseJavaScript } from "./parse.js";
 import { Sourcemap } from "./sourcemap.js";
 import { transpileTemplate } from "./template.js";
-import { transpileTypeScript } from "./typescript.js";
+import { stripTypes } from "./typescript.js";
 export function transpile(input, mode, options) {
     let cell;
     if (typeof input === "string") {
@@ -20,7 +20,7 @@ export function transpile(input, mode, options) {
         input = cell.value;
     }
     const transpiled = mode === "ts"
-        ? transpileJavaScript(transpileTypeScript(input), options)
+        ? transpileTypeScript(input, options)
         : mode === "ojs"
             ? transpileObservable(input, options)
             : mode !== "js"
@@ -38,14 +38,24 @@ export function transpile(input, mode, options) {
     }
     return transpiled;
 }
+export function transpileTypeScript(input, options) {
+    const cell = parseJavaScript(input, "ts");
+    const output = new Sourcemap(input);
+    stripTypes(cell, output);
+    return transpileCell(cell, output, options);
+}
 export function transpileJavaScript(input, options) {
-    const cell = parseJavaScript(input);
+    const cell = parseJavaScript(input, "js");
+    const output = new Sourcemap(input);
+    return transpileCell(cell, output, options);
+}
+function transpileCell(cell, output, options) {
     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();
+    output.trim();
     rewriteImportDeclarations(output, cell.body, inputs, options);
     rewriteImportExpressions(output, cell.body, options);
     if (options?.resolveFiles)
@@ -54,10 +64,10 @@ export function transpileJavaScript(input, options) {
         output.insertLeft(0, `return (\n`);
     output.insertLeft(0, `${async ? "async " : ""}(${inputs.map(deat)}) => {\n`);
     if (outputs.length > 0)
-        output.insertRight(input.length, `\nreturn {${outputs}};`);
+        output.insertRight(output.length, `\nreturn {${outputs}};`);
     if (cell.expression)
-        output.insertRight(input.length, `\n)`);
-    output.insertRight(input.length, "\n}");
+        output.insertRight(output.length, `\n)`);
+    output.insertRight(output.length, "\n}");
     const body = String(output);
     const autodisplay = cell.expression && !(inputs.includes("display") || inputs.includes("view"));
     const files = new Set(cell.files.map((f) => f.argument));

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

@@ -1 +1,7 @@
-export declare function transpileTypeScript(input: string): string;
+import type { Node } from "acorn";
+import type { JavaScriptCell } from "./parse.js";
+import type { Sourcemap } from "./sourcemap.js";
+/** Throws a SyntaxError for any non-erasable TypeScript syntax. */
+export declare function checkErasableSyntax(node: Node, input: string): void;
+/** Erases TypeScript-specific syntax from output, leaving equivalent JavaScript. */
+export declare function stripTypes(cell: JavaScriptCell, output: Sourcemap): void;

package/dist/src/javascript/typescript.js

@@ -1,112 +1,227 @@
-import { tokenizer as Tokenizer, tokTypes } from "acorn";
-import { ModuleKind, ScriptTarget, transpile } from "typescript";
-import { createProgram, createSourceFile } from "typescript";
-import { isClassExpression, isFunctionExpression, isParenthesizedExpression } from "typescript";
-import { isExpressionStatement } from "typescript";
-const tokenizerOptions = {
-    ecmaVersion: "latest"
+import { tokenizer, tokTypes } from "acorn";
+import { base, recursive } from "acorn-walk";
+import { syntaxError } from "./syntaxError.js";
+import { simple } from "./walk.js";
+// TypeScript-only modifier keywords; static/get/set/async are valid JavaScript
+// and so are deliberately excluded (and preserved).
+const MODIFIERS = new Set([
+    "public",
+    "private",
+    "protected",
+    "readonly",
+    "override",
+    "declare",
+    "abstract"
+]);
+const checkErasableVisitors = {
+    TSEnumDeclaration: checkErasable,
+    TSModuleDeclaration: checkErasable,
+    TSParameterProperty: checkErasable,
+    TSImportEqualsDeclaration: checkErasable,
+    TSExportAssignment: checkErasable
 };
-const compilerOptions = {
-    target: ScriptTarget.ESNext,
-    module: ModuleKind.Preserve,
-    verbatimModuleSyntax: true
+/** Throws a SyntaxError for any non-erasable TypeScript syntax. */
+export function checkErasableSyntax(node, input) {
+    simple(node, checkErasableVisitors, input);
+}
+function checkErasable(node, input) {
+    if (node.declare)
+        return; // ambient declarations are erasable
+    throw syntaxError(`unsupported syntax: ${node.type}`, node, input);
+}
+/** Erases TypeScript-specific syntax from output, leaving equivalent JavaScript. */
+export function stripTypes(cell, output) {
+    // The AST is traversed with acorn-walk’s recursive walker. Because acorn-walk’s
+    // base visitors only know about (and therefore only recurse into) the value
+    // children of each node, type annotations and generics are naturally skipped;
+    // we simply delete their source text from the output without descending into
+    // them. TypeScript-specific nodes that acorn-walk doesn’t know about (expression
+    // wrappers such as `x as T`, type-only declarations, parameter properties) are
+    // handled by the dedicated visitors below.
+    //
+    // Positions are taken from the AST wherever possible. A handful of tokens have
+    // no dedicated AST node (modifier keywords, the optional `?` and definite `!`
+    // markers), so they are located by re-tokenizing the small, AST-bounded span in
+    // which they must occur. Re-tokenizing (rather than string matching) correctly
+    // ignores comments and string literals within that span.
+    recursive(cell.body, output, stripTypesVisitors);
+}
+const stripTypesVisitors = {
+    // Type-only declarations, erased entirely.
+    TSTypeAliasDeclaration: deleteStatement,
+    TSInterfaceDeclaration: deleteStatement,
+    TSDeclareFunction: deleteStatement,
+    TSDeclareMethod: deleteStatement,
+    TSIndexSignature: deleteStatement,
+    TSNamespaceExportDeclaration: deleteStatement,
+    // Ambient (declare) enums and namespaces; non-ambient forms, which require
+    // runtime support, are rejected earlier by checkErasableSyntax.
+    TSEnumDeclaration: deleteStatement,
+    TSModuleDeclaration: deleteStatement,
+    // TypeScript expression wrappers, unwrapped to their value expression.
+    TSAsExpression: unwrapType, // x as T
+    TSSatisfiesExpression: unwrapType, // x satisfies T
+    TSNonNullExpression: unwrapType, // x!
+    TSInstantiationExpression: unwrapType, // f<T>
+    TSTypeAssertion: unwrapAssertion, // <T>x
+    TSTypeCastExpression: unwrapCast, // (x: T)
+    // Standard nodes that may carry type syntax. Function and Class are aggregate
+    // types dispatched by acorn-walk’s base walkers, so overriding them covers
+    // every function and class form.
+    Function: stripFunction,
+    Class: stripClass,
+    PropertyDefinition: stripMember,
+    MethodDefinition: stripMember,
+    AccessorProperty: stripMember,
+    VariablePattern: stripBindingIdentifier,
+    ObjectPattern: stripPattern,
+    ArrayPattern: stripPattern,
+    RestElement: stripPattern,
+    VariableDeclarator: stripVariableDeclarator,
+    CallExpression: stripTypeArguments,
+    NewExpression: stripTypeArguments,
+    TaggedTemplateExpression: stripTypeArguments
 };
-export function transpileTypeScript(input) {
-    const expr = maybeExpression(input);
-    if (expr)
-        return trimTrailingSemicolon(transpile(expr, compilerOptions));
-    parseTypeScript(input); // enforce valid syntax
-    return transpile(input, compilerOptions);
-}
-/** If the given is an expression (not a statement), returns it with parens. */
-function maybeExpression(input) {
-    if (!hasMatchedParens(input))
-        return; // disallow funny business
-    const expr = withParens(input);
-    if (!isSolitaryExpression(expr))
-        return;
-    return expr;
-}
-/** Parses the specified TypeScript input, returning the AST or throwing a SyntaxError. */
-function parseTypeScript(input) {
-    const file = createSourceFile("input.ts", input, compilerOptions.target);
-    const program = createProgram(["input.ts"], compilerOptions, {
-        getSourceFile: (path) => (path === "input.ts" ? file : undefined),
-        getDefaultLibFileName: () => "lib.d.ts",
-        writeFile: () => { },
-        getCurrentDirectory: () => "/",
-        getDirectories: () => [],
-        getCanonicalFileName: (path) => path,
-        useCaseSensitiveFileNames: () => true,
-        getNewLine: () => "\n",
-        fileExists: (path) => path === "input.ts",
-        readFile: (path) => (path === "input.ts" ? input : undefined)
+// Deletes the given node, plus any trailing semicolon and newline.
+function deleteStatement(node, output) {
+    let end = node.end;
+    const input = output.input;
+    if (input[end] === ";")
+        ++end;
+    if (input[end] === "\n")
+        ++end;
+    output.delete(node.start, end);
+}
+// Unwraps a trailing type wrapper (x as T, x satisfies T, x!, f<T>), keeping the
+// value expression.
+function unwrapType(node, output, next) {
+    output.delete(node.expression.end, node.end);
+    next(node.expression, output);
+}
+// Unwraps a prefix type assertion (<T>x), keeping the value expression.
+function unwrapAssertion(node, output, next) {
+    output.delete(node.start, node.expression.start);
+    next(node.expression, output);
+}
+// Unwraps a parenthesized type cast (x: T), keeping the value expression.
+function unwrapCast(node, output, next) {
+    output.delete(node.typeAnnotation.start, node.typeAnnotation.end);
+    next(node.expression, output);
+}
+// Removes the return type and generic type parameters from a function.
+function stripFunction(node, output, next) {
+    deleteType(output, node, "returnType");
+    deleteType(output, node, "typeParameters");
+    base.Function(node, output, next);
+}
+// Removes generic type parameters, heritage type arguments, the abstract
+// modifier, and the implements clause from a class.
+function stripClass(node, output, next) {
+    deleteType(output, node, "typeParameters");
+    deleteType(output, node, "superTypeParameters");
+    deleteType(output, node, "superTypeArguments");
+    if (node.abstract && node.id)
+        deleteModifiers(output, findModifiersStart(node), node.id.start);
+    if (node.implements?.length)
+        deleteImplements(output, node);
+    base.Class(node, output, next);
+}
+// Erases abstract/ambient members and overload signatures entirely; otherwise
+// removes modifiers, optional/definite markers, and type annotations.
+function stripMember(node, output, next) {
+    if (node.abstract || node.declare || node.value?.type === "TSDeclareMethod")
+        return deleteStatement(node, output); // prettier-ignore
+    deleteModifiers(output, findModifiersStart(node), node.key.start);
+    if (node.optional || node.definite)
+        deleteMarker(output, node.key.end, findMarkerEnd(node));
+    deleteType(output, node, "typeParameters");
+    deleteType(output, node, "typeAnnotation");
+    base.PropertyDefinition(node, output, next);
+}
+// Removes the optional marker and type annotation from a binding identifier.
+function stripBindingIdentifier(node, output) {
+    if (node.optional)
+        deleteMarker(output, node.start, node.typeAnnotation?.start ?? node.end);
+    deleteType(output, node, "typeAnnotation");
+}
+// Removes the type annotation from a destructuring pattern, then recurses.
+function stripPattern(node, output, next) {
+    deleteType(output, node, "typeAnnotation");
+    base[node.type](node, output, next);
+}
+// Removes the definite assignment marker from a variable declarator, then
+// recurses (the annotation on the binding is handled by the pattern visitor).
+function stripVariableDeclarator(node, output, next) {
+    if (node.definite && node.id.type === "Identifier")
+        deleteMarker(output, node.id.start, node.id.typeAnnotation?.start ?? node.init?.start ?? node.id.end); // prettier-ignore
+    base.VariableDeclarator(node, output, next);
+}
+// Removes generic type arguments from a call, construction, or tagged template
+// (e.g. f<T>(), new Map<K, V>()), then recurses.
+function stripTypeArguments(node, output, next) {
+    deleteType(output, node, "typeArguments");
+    base[node.type](node, output, next);
+}
+// Deletes the given child node from the output, if present.
+function deleteType(output, node, key) {
+    const child = node[key];
+    if (child)
+        output.delete(child.start, child.end);
+}
+// The position after any leading decorators, where modifier keywords begin.
+function findModifiersStart(node) {
+    const decorators = node.decorators;
+    return decorators?.length ? decorators[decorators.length - 1].end : node.start;
+}
+// The position bounding an optional/definite marker on a class member.
+function findMarkerEnd(node) {
+    return node.typeAnnotation?.start ?? node.value?.start ?? node.end;
+}
+// Deletes the `?` or `!` marker token found between start and end.
+function deleteMarker(output, start, end) {
+    forEachToken(output.input, start, end, (t) => {
+        if (t.type === tokTypes.question || t.type === tokTypes.prefix)
+            output.delete(t.start, t.end);
     });
-    const diagnostics = program.getSyntacticDiagnostics(file);
-    if (diagnostics.length > 0) {
-        const [diagnostic] = diagnostics;
-        throw new SyntaxError(String(diagnostic.messageText));
-    }
-    return file;
 }
-/** Returns true if the specified input is exactly one parenthesized expression statement. */
-function isSolitaryExpression(input) {
-    let file;
-    try {
-        file = parseTypeScript(input);
-    }
-    catch {
-        return false;
-    }
-    if (file.statements.length !== 1)
-        return false;
-    const statement = file.statements[0];
-    if (!isExpressionStatement(statement))
-        return false;
-    const expression = statement.expression;
-    if (!isParenthesizedExpression(expression))
-        return false;
-    const subexpression = expression.expression;
-    if (isClassExpression(subexpression) && subexpression.name)
-        return false;
-    if (isFunctionExpression(subexpression) && subexpression.name)
-        return false;
-    return true;
-}
-function* tokenize(input) {
-    const tokenizer = Tokenizer(input, tokenizerOptions);
-    while (true) {
-        const t = tokenizer.getToken();
+// Deletes TypeScript-only modifier keyword tokens found between start and end,
+// preserving JavaScript keywords such as static, get, set, and async.
+function deleteModifiers(output, start, end) {
+    const input = output.input;
+    forEachToken(input, start, end, (t) => {
+        if (t.type !== tokTypes.name || !MODIFIERS.has(t.value))
+            return;
+        let e = t.end;
+        while (input[e] === " " || input[e] === "\t")
+            ++e; // consume trailing space
+        output.delete(t.start, e);
+    });
+}
+// Deletes an `implements I, J` heritage clause. The clause spans from the end of
+// the preceding heritage node to the end of the last implemented type, so the
+// `implements` keyword itself needs no separate lookup.
+function deleteImplements(output, node) {
+    const list = node.implements;
+    const start = node.superTypeParameters?.end ??
+        node.superTypeArguments?.end ??
+        node.superClass?.end ??
+        node.id?.end ??
+        node.start;
+    output.delete(start, list[list.length - 1].end);
+}
+// Invokes fn for each token in the given span, with absolute offsets. The span is
+// re-tokenized with acorn so that comments and strings are handled correctly; any
+// tokenizing error (e.g. an unexpected character) is ignored.
+function forEachToken(input, start, end, fn) {
+    if (start >= end)
+        return;
+    const T = tokenizer(input, { ecmaVersion: "latest" });
+    T.pos = start;
+    for (const t of T) {
         if (t.type === tokTypes.eof)
             break;
-        yield t;
-    }
-}
-/** Returns true if the specified input has matched parens. */
-function hasMatchedParens(input) {
-    let depth = 0;
-    for (const t of tokenize(input)) {
-        if (t.type === tokTypes.parenL)
-            ++depth;
-        else if (t.type === tokTypes.parenR && --depth < 0)
-            return false;
-    }
-    return depth === 0;
-}
-/** Wraps the specified input with parentheses. */
-function withParens(input) {
-    let start;
-    let end;
-    for (const t of tokenize(input)) {
-        start ?? (start = t);
-        end = t;
+        if (t.start >= end)
+            break;
+        fn(t);
     }
-    return `(${input.slice(start?.start, end?.end)})`;
-}
-/** Removes a trailing semicolon, if present. */
-function trimTrailingSemicolon(input) {
-    let end;
-    for (const t of tokenize(input))
-        end = t;
-    return end?.type === tokTypes.semi ? input.slice(0, end.start) : input;
 }

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

@@ -1,5 +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 ancestor<T>(node: Node, visitors: AncestorVisitors<T>, state?: 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;
+export declare function simple<T>(node: Node, visitors: SimpleVisitors<T>, state?: T): void;

package/dist/src/javascript/walk.js

@@ -1,13 +1,45 @@
-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);
+import { make } from "acorn-walk";
+import { ancestor as baseAncestor } from "acorn-walk";
+import { recursive as baseRecursive } from "acorn-walk";
+import { simple as baseSimple } from "acorn-walk";
+function callbackId(node, state, c) {
+    c(node.id, state, "Identifier");
+}
+function callbackExpression(node, state, c) {
+    c(node.expression, state, "Expression");
+}
+function callbackParameter(node, state, c) {
+    c(node.parameter, state, "Pattern");
+}
+function skip() { }
+const visitors = {
+    ViewExpression: callbackId,
+    MutableExpression: callbackId,
+    TSTypeAliasDeclaration: skip,
+    TSInterfaceDeclaration: skip,
+    TSDeclareFunction: skip,
+    TSDeclareMethod: skip,
+    TSIndexSignature: skip,
+    TSNamespaceExportDeclaration: skip,
+    TSEnumDeclaration: skip,
+    TSModuleDeclaration: skip,
+    TSImportEqualsDeclaration: skip,
+    TSExportAssignment: skip,
+    TSAsExpression: callbackExpression,
+    TSSatisfiesExpression: callbackExpression,
+    TSNonNullExpression: callbackExpression,
+    TSTypeAssertion: callbackExpression,
+    TSInstantiationExpression: callbackExpression,
+    TSTypeCastExpression: callbackExpression,
+    TSParameterProperty: callbackParameter
+};
+const walk = make(visitors);
+export function ancestor(node, visitors, state) {
+    return baseAncestor(node, visitors, walk, state);
 }
 export function recursive(node, state, functions) {
-    return _recursive(node, state, functions, walk);
+    return baseRecursive(node, state, functions, walk);
 }
-export function simple(node, visitors) {
-    return _simple(node, visitors, walk);
+export function simple(node, visitors, state) {
+    return baseSimple(node, visitors, walk, state);
 }

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

@@ -203,6 +203,8 @@ async function insertSource(database, name, source) {
     source = await source;
     if (isFileAttachment(source))
         return insertFile(database, name, source);
+    if (isFlechetteTable(source))
+        return insertFlechetteTable(database, name, source);
     if (isArrowTable(source))
         return insertArrowTable(database, name, source);
     if (Array.isArray(source))
@@ -215,6 +217,8 @@ async function insertSource(database, name, source) {
         if ("data" in source) {
             // data + options
             const { data, ...options } = source;
+            if (isFlechetteTable(data))
+                return insertFlechetteTable(database, name, data, options);
             if (isArrowTable(data))
                 return insertArrowTable(database, name, data, options);
             return insertArray(database, name, data, options);
@@ -301,22 +305,28 @@ async function insertUntypedCSV(connection, file, name) {
 async function insertArrowTable(database, name, table, options) {
     const connection = await database.connect();
     try {
-        await connection.insertArrowTable(table, {
-            name,
-            schema: "main",
-            ...options
-        });
+        await connection.insertArrowTable(table, { name, schema: "main", ...options });
+    }
+    finally {
+        await connection.close();
+    }
+}
+async function insertArrowIpc(database, name, buffer, options) {
+    const connection = await database.connect();
+    try {
+        await connection.insertArrowFromIPCStream(buffer, { name, schema: "main", ...options });
     }
     finally {
         await connection.close();
     }
 }
+async function insertFlechetteTable(database, name, table, options) {
+    const { tableToIPC } = await import("https://cdn.jsdelivr.net/npm/@uwdata/flechette@2.5.0/+esm");
+    return await insertArrowIpc(database, name, tableToIPC(table, { format: "stream" }), options);
+}
 async function insertArqueroTable(database, name, source) {
-    // TODO When we have stdlib versioning and can upgrade Arquero to version 5,
-    // we can then call source.toArrow() directly, with insertArrowTable()
-    const arrow = await import("https://cdn.jsdelivr.net/npm/apache-arrow@17.0.0/+esm");
-    const table = arrow.tableFromIPC(source.toArrowBuffer());
-    return await insertArrowTable(database, name, table);
+    const buffer = typeof source.toArrowIPC === "function" ? source.toArrowIPC() : source.toArrowBuffer(); // prettier-ignore
+    return await insertArrowIpc(database, name, buffer);
 }
 async function insertArray(database, name, array, options) {
     const arrow = await import("https://cdn.jsdelivr.net/npm/apache-arrow@17.0.0/+esm");
@@ -372,9 +382,17 @@ function isFileAttachment(value) {
         typeof value.url === "function" &&
         typeof value.arrayBuffer === "function");
 }
-// Arquero tables have a `toArrowBuffer` function
+// Arquero tables have a `toArrowBuffer` (v5-) or `toArrowIPC` (v6+) function
 function isArqueroTable(value) {
-    return value && typeof value.toArrowBuffer === "function";
+    return (value && (typeof value.toArrowBuffer === "function" || typeof value.toArrowIPC === "function"));
+}
+// Flechette tables have a `toColumns` method
+function isFlechetteTable(value) {
+    return (value &&
+        typeof value.getChild === "function" &&
+        typeof value.toColumns === "function" &&
+        value.schema &&
+        Array.isArray(value.schema.fields));
 }
 // Returns true if the value is an Apache Arrow table. This uses a “duck” test
 // (instead of strict instanceof) because we want it to work with a range of

package/dist/src/runtime/stdlib/files/buffer.d.ts

@@ -1 +1 @@
-export declare function buffer(file: Blob): Promise<ArrayBuffer>;
+export declare function buffer(blob: Blob): Promise<ArrayBuffer>;

package/dist/src/runtime/stdlib/files/buffer.js

@@ -1,8 +1,3 @@
-export function buffer(file) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => resolve(reader.result);
-        reader.onerror = reject;
-        reader.readAsArrayBuffer(file);
-    });
+export function buffer(blob) {
+    return blob.arrayBuffer();
 }

package/dist/src/runtime/stdlib/files/text.d.ts

@@ -1 +1 @@
-export declare function text(file: Blob): Promise<string>;
+export declare function text(blob: Blob): Promise<string>;

package/dist/src/runtime/stdlib/files/text.js

@@ -1,8 +1,3 @@
-export function text(file) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => resolve(reader.result);
-        reader.onerror = reject;
-        reader.readAsText(file);
-    });
+export function text(blob) {
+    return blob.text();
 }

package/package.json

@@ -5,7 +5,7 @@
     "type": "git",
     "url": "git+https://github.com/observablehq/notebook-kit.git"
   },
-  "version": "2.1.8",
+  "version": "2.2.0",
   "type": "module",
   "scripts": {
     "test": "TZ=America/Los_Angeles vitest",
@@ -56,12 +56,12 @@
     "@observablehq/parser": "^6.1.0",
     "@observablehq/runtime": "^6.0.0",
     "@sindresorhus/slugify": "^2.2.1",
+    "@sveltejs/acorn-typescript": "^1.0.11",
     "acorn": "^8.16.0",
     "acorn-walk": "^8.3.5",
     "jsdom": "^26.1.0",
     "markdown-it": "^14.1.1",
     "markdown-it-anchor": "^9.2.0",
-    "typescript": "^5.9.3",
     "vite": "^7.0.0 || ^8.0.0"
   },
   "devDependencies": {
@@ -80,6 +80,7 @@
     "postgres": "^3.4.9",
     "snowflake-sdk": "^2.4.2",
     "tsx": "^4.22.3",
+    "typescript": "^5.9.3",
     "typescript-eslint": "^8.59.4",
     "vitest": "^4.1.7"
   },