@observablehq/notebook-kit 2.1.6 → 2.1.8

package/dist/package.json

@@ -5,10 +5,10 @@
         "type": "git",
         "url": "git+https://github.com/observablehq/notebook-kit.git"
     },
-    "version": "2.1.6",
+    "version": "2.1.8",
     "type": "module",
     "scripts": {
-        "test": "vitest",
+        "test": "TZ=America/Los_Angeles vitest",
         "prepublishOnly": "rm -rf dist && tsc && chmod +x dist/bin/*.js && cp -r src/styles src/templates dist/src && cp src/runtime/stdlib/*.css dist/src/runtime/stdlib",
         "lint": "tsc --noEmit && eslint bin src types",
         "notebooks": "tsx bin/notebooks.ts",

package/dist/src/javascript/features.js

@@ -1,4 +1,4 @@
-import { getStringLiteralValue, isStringLiteral } from "./literal.js";
+import { getStringLiteralValue, isStringLiteral } from "./strings.js";
 import { findReferences } from "./references.js";
 import { syntaxError } from "./syntaxError.js";
 import { simple } from "./walk.js";

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

@@ -1,8 +1,15 @@
-import type { ImportDeclaration } from "acorn";
+import type { ImportWithDeclaration } from "@observablehq/parser";
+import type { ImportDeclaration, ImportSpecifier } from "acorn";
+import type { Identifier } from "acorn";
+import type { NamedImportSpecifier } from "../imports.js";
 /** If specifier is an observable: protocol import, resolves it. */
 export declare function resolveObservableImport(specifier: string): string;
 export declare function isObservableImport(node: ImportDeclaration, specifier: string): boolean;
 /** Note: mutates inputs! */
-export declare function renderObservableImport(source: string, node: ImportDeclaration, inputs: string[]): string;
+export declare function renderObservableImport(source: string, node: ImportDeclaration | ImportWithDeclaration, inputs: string[]): string;
+export declare function toSpecialIdentifier(identifier: Identifier, type: "viewof" | "mutable"): Identifier;
+export declare function toSpecialImportSpecifier(specifier: ImportSpecifier, type: "viewof" | "mutable"): ImportSpecifier;
+export declare function isViewImport(node: NamedImportSpecifier): node is ImportSpecifier;
+export declare function isMutableImport(node: NamedImportSpecifier): node is ImportSpecifier;
 /** Turns e.g. "viewof$foo" into "viewof foo", and "$$" into "$". */
 export declare function dedollar(input: string): string;

package/dist/src/javascript/imports/observable.js

@@ -1,4 +1,4 @@
-import { getImportedName, getLocalName } from "../imports.js";
+import { flatMapImportSpecifiers, getImportedName, getLocalName } from "../imports.js";
 const CODE_DOLLAR = 36;
 /** If specifier is an observable: protocol import, resolves it. */
 export function resolveObservableImport(specifier) {
@@ -21,20 +21,60 @@ export function renderObservableImport(source, node, inputs) {
     if (!inputs.includes("@variable"))
         inputs.push("@variable");
     return `(import(${JSON.stringify(source)}).then((_) => {
-  const module = __variable._module._runtime.module(_.default);
-  const outputs = new Map(Array.from(__variable._outputs, (v) => [v._name, v]));${node.specifiers
-        .map((specifier) => {
-        if (specifier.type === "ImportNamespaceSpecifier")
-            throw new SyntaxError("observable namespace imports are not supported");
-        const iname = dedollar(getImportedName(specifier));
-        const lname = getLocalName(specifier);
+  const module = __variable._module._runtime.module(_.default)${"injections" in node ? `.derive([${renderObservableInjections(node)}], __variable._module)` : ""};
+  const outputs = new Map(Array.from(__variable._outputs, (v) => [v._name, v]));${flatMapImportSpecifiers(node, (specifier) => {
+        const i = dedollar(getImportedName(specifier));
+        const l = getLocalName(specifier);
         return `
-  outputs.get(${JSON.stringify(lname)})?.import(${JSON.stringify(iname)}${iname === lname ? "" : `, ${JSON.stringify(lname)}`}, module);`;
-    })
-        .join("")}
+  outputs.get(${JSON.stringify(l)})?.import(${JSON.stringify(i)}${i === l ? "" : `, ${JSON.stringify(l)}`}, module);`;
+    }).join("")}
   return {};
 }))`;
 }
+function renderObservableInjections(node) {
+    return node.injections
+        .map((node) => {
+        if (node.imported.type !== "Identifier")
+            throw new SyntaxError("unexpected import specifier");
+        const imported = node.imported.name;
+        const local = node.local.name;
+        let injection;
+        if (imported === local) {
+            injection = `"${local}"`;
+            if (node.view)
+                injection += `, "viewof ${local}"`;
+            if (node.mutable)
+                injection += `, "mutable ${local}"`;
+        }
+        else {
+            injection = `{name: "${imported}", alias: "${local}"}`;
+            if (node.view)
+                injection += `, {name: "viewof ${imported}", alias: "viewof ${local}"}`;
+            if (node.mutable)
+                injection += `, {name: "mutable ${imported}", alias: "mutable ${local}"}`;
+        }
+        return injection;
+    })
+        .join(", ");
+}
+export function toSpecialIdentifier(identifier, type) {
+    return { ...identifier, name: `${type}$${identifier.name}` };
+}
+export function toSpecialImportSpecifier(specifier, type) {
+    if (specifier.imported.type !== "Identifier")
+        throw new SyntaxError("unexpected import specifier");
+    return {
+        ...specifier,
+        imported: toSpecialIdentifier(specifier.imported, type),
+        local: toSpecialIdentifier(specifier.local, type)
+    };
+}
+export function isViewImport(node) {
+    return "view" in node && !!node.view;
+}
+export function isMutableImport(node) {
+    return "mutable" in node && !!node.mutable;
+}
 /** Turns e.g. "viewof$foo" into "viewof foo", and "$$" into "$". */
 export function dedollar(input) {
     const start = 0;

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

@@ -1,7 +1,8 @@
-import type { CallExpression, MemberExpression, Node } from "acorn";
-import type { ImportDefaultSpecifier, ImportSpecifier } from "acorn";
+import type { CallExpression, ImportDeclaration, MemberExpression, Node } from "acorn";
+import type { ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier } from "acorn";
 import type { Sourcemap } from "./sourcemap.js";
-type NamedImportSpecifier = ImportSpecifier | ImportDefaultSpecifier;
+export type NamedImportSpecifier = ImportSpecifier | ImportDefaultSpecifier;
+export type AnyImportSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
 /** Throws a syntax error if any export declarations are found. */
 export declare function checkExports(body: Node, { input }: {
     input: string;
@@ -21,4 +22,4 @@ export declare function rewriteImportExpressions(output: Sourcemap, body: Node,
 export declare function rewriteImportDeclarations(output: Sourcemap, body: Node, inputs: string[], { resolveLocalImports }?: RewriteImportOptions): void;
 export declare function getLocalName(node: NamedImportSpecifier): string;
 export declare function getImportedName(node: NamedImportSpecifier): string;
-export {};
+export declare function flatMapImportSpecifiers<T>(node: ImportDeclaration, f: (node: NamedImportSpecifier) => T): T[];

package/dist/src/javascript/imports.js

@@ -1,7 +1,8 @@
 import { resolveJsrImport } from "./imports/jsr.js";
 import { resolveNpmImport } from "./imports/npm.js";
-import { resolveObservableImport } from "./imports/observable.js";
-import { isObservableImport, renderObservableImport } from "./imports/observable.js";
+import { isObservableImport, isMutableImport, isViewImport } from "./imports/observable.js";
+import { resolveObservableImport, renderObservableImport } from "./imports/observable.js";
+import { toSpecialImportSpecifier } from "./imports/observable.js";
 import { getStringLiteralValue, isStringLiteral } from "./strings.js";
 import { syntaxError } from "./syntaxError.js";
 import { simple } from "./walk.js";
@@ -138,9 +139,20 @@ function isNamedSpecifier(node) {
 }
 function rewriteImportSpecifiers(node) {
     return node.specifiers.some(isNamedSpecifier)
-        ? `{${node.specifiers.filter(isNamedSpecifier).map(rewriteImportSpecifier).join(", ")}}`
+        ? `{${flatMapImportSpecifiers(node, rewriteImportSpecifier).join(", ")}}`
         : (node.specifiers.find(isNamespaceSpecifier)?.local.name ?? "{}");
 }
+export function flatMapImportSpecifiers(node, f) {
+    return node.specifiers.flatMap((node) => {
+        if (node.type === "ImportNamespaceSpecifier")
+            throw new SyntaxError("unexpected namespace specifier");
+        return isViewImport(node)
+            ? [f(node), f(toSpecialImportSpecifier(node, "viewof"))]
+            : isMutableImport(node)
+                ? [f(node), f(toSpecialImportSpecifier(node, "mutable"))]
+                : f(node);
+    });
+}
 function rewriteImportSpecifier(node) {
     return getImportedName(node) === getLocalName(node)
         ? getLocalName(node)

package/dist/src/javascript/observable.js

@@ -1,20 +1,22 @@
 import { parseCell } from "@observablehq/parser";
 import { rewriteFileExpressions } from "./files.js";
+import { flatMapImportSpecifiers, rewriteImportDeclarations } from "./imports.js";
+import { resolveNpmImport } from "./imports/npm.js";
 import { Sourcemap } from "./sourcemap.js";
+import { getStringLiteralValue, isStringLiteral } from "./strings.js";
 import { transpileJavaScript } from "./transpile.js";
 import { simple } from "./walk.js";
 export function transpileObservable(input, options) {
     const cell = parseCell(input);
     if (!cell.body)
         return transpileJavaScript(input);
+    if (isImportCell(cell))
+        return transpileObservableImport(input, cell, options);
     if (cell.tag)
         throw new Error("tagged ojs cells are not supported");
     const output = new Sourcemap(input).trim();
     rewriteSpecialReferences(output, cell.body);
-    if (cell.body.type === "ImportDeclaration") {
-        rewriteImportSource(output, cell.body);
-        return transpileJavaScript(String(output));
-    }
+    rewriteDynamicImports(output, cell.body);
     if (options?.resolveFiles)
         rewriteFileExpressions(output, cell.body);
     const inputs = Array.from(new Set(cell.references.map(asReference)));
@@ -42,13 +44,66 @@ export function transpileObservable(input, options) {
         secrets: new Set(cell.secrets.keys())
     };
 }
-/** Rewrite bare module specifiers to have the observable: protocol. */
-function rewriteImportSource(output, body) {
-    const specifier = body.source.value;
-    if (typeof specifier === "string" && !/^\w+:/.test(specifier)) {
-        output.insertLeft(body.source.start + 1, "observable:");
+function isImportCell(cell) {
+    return cell.body.type === "ImportDeclaration";
+}
+function transpileObservableImport(input, cell, options) {
+    const output = new Sourcemap(input).trim();
+    const inputs = ["@variable"];
+    const declarations = flatMapImportSpecifiers(cell.body, (s) => s.local);
+    const outputs = Array.from(new Set(declarations.map(asDeclaration)));
+    transformObservableImport(cell.body);
+    rewriteImportDeclarations(output, cell.body, inputs, options);
+    output.insertLeft(0, `async (__variable) => {\n`);
+    if (outputs.length > 0)
+        output.insertRight(input.length, `\nreturn {${outputs}};`);
+    output.insertRight(input.length, "\n}");
+    const body = String(output);
+    return {
+        body,
+        inputs,
+        outputs,
+        autodisplay: false,
+        files: new Set(),
+        secrets: new Set(),
+        databases: new Set()
+    };
+}
+/** Mutates the given import declaration to be an Observable import. */
+function transformObservableImport(body) {
+    const source = body.source.value;
+    if (typeof source === "string" && !/^\w+:/.test(source)) {
+        body.source.value = `observable:${source}`;
     }
-    output.insertRight(body.end, ";");
+    body.attributes = [
+        {
+            type: "ImportAttribute",
+            key: { type: "Literal", value: "type", start: 0, end: 0 },
+            value: { type: "Literal", value: "observable", start: 0, end: 0 },
+            start: 0,
+            end: 0
+        }
+    ];
+}
+/**
+ * Rewrite a bare dynamic import such as import("d3") to a CDN URL, like
+ * import("https://cdn.jsdelivr.net/npm/d3/+esm"), using the same resolution as
+ * static imports. Protocol (npm:, https:, …) and local imports are left alone.
+ */
+function rewriteDynamicImports(output, body) {
+    simple(body, {
+        ImportExpression({ source }) {
+            if (!isStringLiteral(source))
+                return;
+            let value = getStringLiteralValue(source);
+            if (/^(\w+:|\.?\.?\/)/.test(value))
+                return;
+            if (/\.(js|mjs|cjs)$/.test(value))
+                value += "/+esm";
+            const resolution = resolveNpmImport(`npm:${value}`);
+            output.replaceLeft(source.start, source.end, JSON.stringify(resolution));
+        }
+    });
 }
 /** Rewrite viewof x ↦ viewof$x, and mutable x ↦ mutable$x.value. */
 function rewriteSpecialReferences(output, body) {
@@ -58,28 +113,9 @@ function rewriteSpecialReferences(output, body) {
         },
         ViewExpression(node) {
             output.replaceLeft(node.start, node.end, asReference(node));
-        },
-        ImportSpecifier(node) {
-            const inode = node;
-            const prefix = inode.view ? "viewof$" : inode.mutable ? "mutable$" : null;
-            if (prefix) {
-                const imported = asImportName(node.imported);
-                output.replaceLeft(node.start, node.imported.start, prefix);
-                if (node.imported === node.local) {
-                    output.insertLeft(node.start, `${imported},`);
-                }
-                else {
-                    const local = asImportName(node.local);
-                    output.insertLeft(node.start, `${imported} as ${local},`);
-                    output.insertLeft(node.local.start, prefix);
-                }
-            }
         }
     });
 }
-function asImportName(ref) {
-    return ref.type === "Identifier" ? ref.name : ref.raw;
-}
 function asReference(ref) {
     return ref.type === "ViewExpression"
         ? `viewof$${ref.id.name}`

package/dist/src/runtime/define.d.ts

@@ -22,6 +22,8 @@ export type Definition = {
     autoview?: boolean;
     /** whether this cell’s singular output is a mutable */
     automutable?: boolean;
+    /** whether to define the display and view builtins; defaults to true */
+    display?: boolean;
     /** an asset mapping to apply to any autodisplayed assets (e.g., images and videos) */
     assets?: Map<string, string>;
 };

package/dist/src/runtime/define.js

@@ -2,12 +2,13 @@ import { clear, display, observe } from "./display.js";
 import { input } from "./stdlib/generators/index.js";
 import { Mutator } from "./stdlib/mutable.js";
 export function define(main, state, definition, observer = observe) {
-    const { id, body, inputs = [], outputs = [], output, autodisplay, autoview, automutable } = definition;
+    const { id, body, inputs = [], outputs = [], output } = definition;
+    const { autodisplay, autoview, automutable, display: defineDisplay = true } = definition;
     const variables = state.variables;
     const v = main.variable(observer(state, definition), { shadow: {} });
     const vid = output ?? (outputs.length ? `cell ${id}` : null);
     state.autoclear = true;
-    if (inputs.includes("display") || inputs.includes("view")) {
+    if (defineDisplay && (inputs.includes("display") || inputs.includes("view"))) {
         let displayVersion = -1; // the variable._version of currently-displayed values
         const vd = new v.constructor(2, v._module);
         vd.define(inputs.filter((i) => i !== "display" && i !== "view"), () => {

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

@@ -0,0 +1,4 @@
+export declare function inferTypes<T extends Record<string, string>>(rows: T[], columns: (keyof T)[]): Record<keyof T, unknown>[];
+export declare function coerceBoolean(value: string): boolean | null | undefined;
+export declare function coerceNumber(value: string): number;
+export declare function coerceDate(value: string): Date | null;

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

@@ -0,0 +1,71 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+/**
+ * Accepts dates in the following forms:
+ * - ±YYYYYY-MM-DD
+ * - YYYY-MM-DD
+ * - MM/DD/YY
+ * - MM/DD/YYYY
+ *
+ * Following a "T" or a space, dates may additionally have a time:
+ * - HH:MM
+ * - HH:MM:SS
+ * - HH:MM:SS.MMM
+ *
+ * And the time may optionally have a time zone:
+ * - Z
+ * - ±HH:MM
+ */
+const DATE_TEST = /^([-+]\d{2})?\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}\/\d{2,4}([T ]\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/; // prettier-ignore
+/** The maximum number of rows to sample (including missing values). */
+const SAMPLE_SIZE = 100;
+export function inferTypes(rows, columns) {
+    const output = rows;
+    const n = rows.length;
+    const k = Math.min(n, SAMPLE_SIZE);
+    for (const column of columns) {
+        let booleans = 0;
+        let numbers = 0;
+        let dates = 0;
+        let strings = 0;
+        for (let i = 0; i < k; ++i) {
+            const value = rows[i][column]?.trim();
+            if (!value)
+                continue;
+            ++strings;
+            if (/^(true|false)$/i.test(value))
+                ++booleans;
+            else if (!isNaN(Number(value)))
+                ++numbers;
+            else if (DATE_TEST.test(value))
+                ++dates;
+        }
+        // Chose the non-string type with the greatest count that is also ≥90%; or
+        // if no such type meets that criterion, use string.
+        let coerce = undefined;
+        let typeCount = Math.max(1, Math.ceil(strings * 0.9)) - 1;
+        if (booleans > typeCount)
+            ((coerce = coerceBoolean), (typeCount = booleans));
+        if (numbers > typeCount)
+            ((coerce = coerceNumber), (typeCount = numbers));
+        if (dates > typeCount)
+            ((coerce = coerceDate), (typeCount = dates));
+        if (!coerce)
+            continue;
+        for (let i = 0; i < n; ++i) {
+            output[i][column] = coerce(rows[i][column]);
+        }
+    }
+    return output;
+}
+export function coerceBoolean(value) {
+    const trimmed = value.trim().toLowerCase();
+    return trimmed === "true" ? true : trimmed === "false" ? false : trimmed ? undefined : null;
+}
+export function coerceNumber(value) {
+    const trimmed = value.trim();
+    return trimmed ? Number(value) : NaN;
+}
+export function coerceDate(value) {
+    const trimmed = value.trim();
+    return trimmed ? new Date(DATE_TEST.test(trimmed) ? trimmed : NaN) : null;
+}

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

@@ -1,7 +1,7 @@
 export type DsvOptions = {
     delimiter?: string;
     array?: boolean;
-    typed?: boolean;
+    typed?: "auto" | boolean;
 };
 export type DsvResult = (Record<string, any>[] | any[][]) & {
     columns: string[];
@@ -73,11 +73,7 @@ export declare abstract class AbstractFile implements FileAttachment {
     text(encoding?: string): Promise<string>;
     json(): Promise<any>;
     stream(): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
-    dsv({ delimiter, array, typed }?: {
-        delimiter?: string | undefined;
-        array?: boolean | undefined;
-        typed?: boolean | undefined;
-    }): Promise<DsvResult>;
+    dsv({ delimiter, array, typed }?: DsvOptions): Promise<DsvResult>;
     csv(options?: Omit<DsvOptions, "delimiter">): Promise<DsvResult>;
     tsv(options?: Omit<DsvOptions, "delimiter">): Promise<DsvResult>;
     image(props?: Partial<HTMLImageElement>): Promise<HTMLImageElement>;

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

@@ -1,3 +1,4 @@
+import { inferTypes } from "./dsv.js";
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const files = new Map();
 let strict = false;
@@ -92,8 +93,11 @@ export class AbstractFile {
     async dsv({ delimiter = ",", array = false, typed = false } = {}) {
         const [text, d3] = await Promise.all([this.text(), import("https://cdn.jsdelivr.net/npm/d3-dsv/+esm")]); // prettier-ignore
         const format = d3.dsvFormat(delimiter);
-        const parse = array ? format.parseRows : format.parse;
-        return parse(text, typed && d3.autoType);
+        const parse = array ? ((typed && (typed = true)), format.parseRows) : format.parse;
+        const output = parse(text, typed === true ? d3.autoType : undefined);
+        if (typed === "auto")
+            inferTypes(output, output.columns);
+        return output;
     }
     async csv(options) {
         return this.dsv({ ...options, delimiter: "," });

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

@@ -72,11 +72,7 @@ export declare const library: {
             text(encoding?: string): Promise<string>;
             json(): Promise<any>;
             stream(): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
-            dsv({ delimiter, array, typed }?: {
-                delimiter?: string | undefined;
-                array?: boolean | undefined;
-                typed?: boolean | undefined;
-            }): Promise<import("./fileAttachment.js").DsvResult>;
+            dsv({ delimiter, array, typed }?: import("./fileAttachment.js").DsvOptions): Promise<import("./fileAttachment.js").DsvResult>;
             csv(options?: Omit<import("./fileAttachment.js").DsvOptions, "delimiter">): Promise<import("./fileAttachment.js").DsvResult>;
             tsv(options?: Omit<import("./fileAttachment.js").DsvOptions, "delimiter">): Promise<import("./fileAttachment.js").DsvResult>;
             image(props?: Partial<HTMLImageElement>): Promise<HTMLImageElement>;

package/dist/src/vite/observable.js

@@ -173,6 +173,7 @@ define(
     inputs: ${JSON.stringify(transpiled.inputs)},
     outputs: ${JSON.stringify(transpiled.outputs)},
     output: ${JSON.stringify(transpiled.output)},
+    display: ${cell.mode === "js" || cell.mode === "ts"},
     assets: ${assets.size > 0 ? "assets" : "undefined"},
     autodisplay: ${transpiled.autodisplay},
     autoview: ${transpiled.autoview},

package/package.json

@@ -5,10 +5,10 @@
     "type": "git",
     "url": "git+https://github.com/observablehq/notebook-kit.git"
   },
-  "version": "2.1.6",
+  "version": "2.1.8",
   "type": "module",
   "scripts": {
-    "test": "vitest",
+    "test": "TZ=America/Los_Angeles vitest",
     "prepublishOnly": "rm -rf dist && tsc && chmod +x dist/bin/*.js && cp -r src/styles src/templates dist/src && cp src/runtime/stdlib/*.css dist/src/runtime/stdlib",
     "lint": "tsc --noEmit && eslint bin src types",
     "notebooks": "tsx bin/notebooks.ts",

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

@@ -1,8 +0,0 @@
-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/literal.js

@@ -1,42 +0,0 @@
-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";
-}