jlens-wasm 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jlens contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,47 @@
-# Temporary Holding Version
+# jlens-wasm
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[JSONata](https://jsonata.org/) for the browser, compiled from Rust to WebAssembly. It
+evaluates expressions, **explains** how a result was reached, and gives editors completion,
+diagnostics and hover driven by a JSON Schema inferred from sample documents.
+
+This is an ES module for browsers (`--target web`). It also runs in Node.js 20+ and Deno if you
+pass the `.wasm` bytes to `init`.
+
+```js
+import init, { Expression } from "jlens-wasm";
+
+await init(); // fetches jlens_bg.wasm next to jlens.js
+
+const expr = new Expression("$sum(items[type = $kind].(price * qty))");
+expr.evaluate({ items: [{ type: "a", price: 2.5, qty: 4 }] }, { kind: "a" }); // 10
+```
+
+## API
+
+| Export | Purpose |
+|---|---|
+| `init(options?)` | Loads the WebAssembly module; call (and await) it once before anything else |
+| `new Expression(source)` | Compiles an expression; throws a `JlensError` on syntax errors |
+| `expr.evaluate(input?, bindings?, options?)` | Evaluates against a JSON-compatible value; `undefined` when the result is undefined |
+| `expr.evaluateJson(json?, bindings?, options?)` | The same with JSON text in and out (faster for large documents) |
+| `new Document(input)`, `Document.fromJson(text)` | A document converted once, for `expr.evaluateDocument(doc, bindings?, options?)` |
+| `expr.evaluateWithAudit(input?, bindings?, options?)` | Result, audit tree and explanation; errors are reported, not thrown |
+| `expr.ast()` | The processed syntax tree |
+| `parseRecover(source)` | Partial syntax tree and every diagnostic, without throwing |
+| `inferSchema(samples, overrides?)` | A JSON Schema (2020-12) inferred from sample documents |
+| `new LanguageService(schema?, variables?)` | `complete`, `diagnostics`, `hover` and `signatureHelp` for an editor |
+| `functions()` | The built-in function catalog |
+| `version()` | The jlens version |
+
+`options` takes `timeout` (milliseconds) and `maxDepth`; for `evaluateWithAudit` also `level`
+(`"off"`, `"decisions"`, `"full"`) and `limits`. Errors are `Error` objects named `JlensError`
+with the JSONata error `code`, plus `position`, `start`, `end` and `token` when known.
+
+All offsets, in both directions, are UTF-16 code units, like JavaScript string indexes.
+
+The full guide is the "WebAssembly (browser)" chapter of the jlens book (`docs/src/guides/wasm.md`).
+
+## License
+
+MIT. The JSONata test suite and the documentation adapted from JSONata are © IBM Corp. and
+JSONata contributors, also under the MIT license.

package/jlens.d.ts

@@ -0,0 +1,455 @@
+/* tslint:disable */
+/* eslint-disable */
+/** Variables an expression is evaluated with: `{limit: 10}` defines `$limit`. */
+export type Bindings = Record<string, unknown>;
+
+/** Evaluation guardrails. */
+export interface EvaluateOptions {
+    /** Maximum duration of one evaluation, in milliseconds (error `D1012`). */
+    timeout?: number;
+    /** Maximum evaluation depth (error `D1011`). */
+    maxDepth?: number;
+}
+
+/** A range of the expression source, in UTF-16 code units (`end` is exclusive). */
+export interface Span {
+    start: number;
+    end: number;
+}
+
+/**
+ * The error thrown by `new Expression()`, `evaluate()` and `evaluateJson()`. Check it with
+ * `err.name === "JlensError"`.
+ */
+export interface JlensError extends Error {
+    name: "JlensError";
+    /** The JSONata error code, such as `S0202` or `T2001`. */
+    code: string;
+    /** Where the error was detected, like jsonata-js: usually just after the offending token. */
+    position?: number;
+    /** The offending source range, when known. */
+    start?: number;
+    end?: number;
+    /** The token involved, when there is one. */
+    token?: string;
+    /** The value involved, when there is one. */
+    value?: unknown;
+}
+
+/** The fields of a `JlensError`, as reported in an `AuditResult`. */
+export interface ErrorInfo {
+    code: string;
+    message: string;
+    position?: number;
+    start?: number;
+    end?: number;
+    token?: string;
+    value?: unknown;
+}
+
+// ---------------------------------------------------------------------------------------------
+// Auditing
+
+/** What an audit records. */
+export type AuditLevel = "off" | "decisions" | "full";
+
+/** Bounds on what an audit captures. */
+export interface CaptureLimits {
+    /** Items kept from an array (and fields from an object) in captured values. Default 10. */
+    maxItems: number;
+    /** Characters kept from a string in captured values. Default 200. */
+    maxString: number;
+    /** Nesting depth kept in captured values. Default 4. */
+    maxDepth: number;
+    /** Rejected items kept as samples per filter. Default 5. */
+    maxRejected: number;
+    /** Nodes recorded in the tree. Default 10000. */
+    maxNodes: number;
+    /** Characters of source text kept per node. Default 200. */
+    maxSource: number;
+}
+
+/** Options of `evaluateWithAudit`. */
+export interface AuditOptions extends EvaluateOptions {
+    /** Default `"decisions"`. */
+    level?: AuditLevel;
+    limits?: Partial<CaptureLimits>;
+}
+
+/** The result of `evaluateWithAudit`. */
+export interface AuditResult {
+    /** The result; absent when undefined or when the evaluation failed. */
+    result?: unknown;
+    /** The error, when the evaluation failed. */
+    error?: ErrorInfo;
+    /** The audit tree. */
+    audit: AuditTree;
+    /** Why the result was reached. */
+    explanation: Explanation;
+    /** `explanation` rendered as text, as printed by `jlens eval --explain`. */
+    explanationText: string;
+}
+
+export interface AuditTree {
+    header: AuditHeader;
+    /** Absent with level `"off"`. */
+    root?: AuditNode;
+    nodeCount: number;
+    /** Whether nodes were dropped because of `maxNodes`. */
+    truncated: boolean;
+}
+
+export interface AuditHeader {
+    /** `jlens-core` and its version. */
+    engine: string;
+    /** FNV-1a 64-bit hash of the expression source, in hexadecimal. */
+    expressionHash: string;
+    /** FNV-1a 64-bit hash of the input document's JSON text, in hexadecimal. */
+    inputHash: string;
+    /** The evaluation timestamp (`$now()`), in ISO 8601. */
+    timestamp: string;
+    durationMs: number;
+    level: AuditLevel;
+    result?: unknown;
+    error?: { code: string; message: string };
+}
+
+export type OutcomeKind = "true" | "false" | "value" | "undefined" | "error";
+
+/** One evaluation of one node. */
+export interface AuditNode {
+    /** The syntax-tree node id. */
+    node: number;
+    /** The node type (`binary`, `path`, `function`, ...). */
+    kind: string;
+    /** The operator, function or variable name. */
+    op?: string;
+    span: Span;
+    /** The node's source text (possibly shortened). */
+    source: string;
+    /** Annotation `@label`, `@message` and `@id`. */
+    label?: string;
+    message?: string;
+    checkId?: string;
+    /** The context value (level `"full"` only). */
+    input?: unknown;
+    output?: unknown;
+    outcome: OutcomeKind;
+    error?: { code: string; message: string };
+    /** The compared values, for comparisons (`null` stands for undefined). */
+    operands?: [unknown, unknown];
+    /** For `and`/`or`: the right side was not evaluated. */
+    shortCircuited?: boolean;
+    /** For conditionals: the branch taken. */
+    branch?: "then" | "else" | "none";
+    /** For `$name := value`: the variable bound. */
+    binding?: string;
+    filters?: FilterAudit[];
+    children?: AuditNode[];
+}
+
+/** Statistics of a predicate filter. */
+export interface FilterAudit {
+    node: number;
+    source: string;
+    label?: string;
+    tested: number;
+    passed: number;
+    /** A sample of the items that did not pass. */
+    rejected?: unknown[];
+}
+
+export interface Explanation {
+    /** The result, or the error, as text. */
+    result: string;
+    lines: ExplanationLine[];
+}
+
+export interface ExplanationLine {
+    depth: number;
+    /** `true` for a check that held, `false` for one that failed, `null` otherwise. */
+    passed: boolean | null;
+    text: string;
+    /** The annotation `@message`, shown for failed checks. */
+    message?: string;
+    /** The syntax-tree node the line is about. */
+    node: number;
+}
+
+// ---------------------------------------------------------------------------------------------
+// Parsing
+
+/** A node of the processed syntax tree. The `type` field tells the kind of node. */
+export interface AstNode {
+    id: number;
+    type: string;
+    span: Span;
+    annotation?: Annotation;
+    [field: string]: unknown;
+}
+
+/** An audit annotation, read from a `/** ... *\/` comment. */
+export interface Annotation {
+    label?: string;
+    message?: string;
+    id?: string;
+    description?: string;
+    span: Span;
+}
+
+export interface Diagnostic {
+    severity: "error" | "warning";
+    /** A JSONata error code (`S0xxx`) or a jlens warning code (`W0xxx`). */
+    code: string;
+    message: string;
+    span: Span;
+}
+
+/** The result of `parseRecover`. */
+export interface ParseResult {
+    ast: AstNode;
+    diagnostics: Diagnostic[];
+}
+
+// ---------------------------------------------------------------------------------------------
+// Schemas and the language service
+
+/** A JSON Schema document (2020-12). */
+export type JsonSchema = boolean | { [keyword: string]: unknown };
+
+export type JsonType = "null" | "boolean" | "integer" | "number" | "string" | "array" | "object";
+
+/** Settings applied to the value at one path of an inferred schema. */
+export interface SchemaOverride {
+    description?: string;
+    label?: string;
+    /** Hide from completion. */
+    hidden?: boolean;
+    enum?: unknown[];
+    format?: string;
+    type?: JsonType[];
+    examples?: unknown[];
+}
+
+export type CompletionKind = "field" | "variable" | "function" | "keyword" | "operator";
+
+export interface CompletionItem {
+    label: string;
+    kind: CompletionKind;
+    /** The type of a field or variable, the signature of a function. */
+    detail?: string;
+    /** Markdown. */
+    documentation?: string;
+    /** The text to insert in place of `Completions.range`. */
+    insertText: string;
+}
+
+export interface Completions {
+    /** The range the chosen item replaces (the word under the cursor). */
+    range: Span;
+    /** Best first. */
+    items: CompletionItem[];
+}
+
+export interface Hover {
+    range: Span;
+    /** Markdown. */
+    contents: string;
+}
+
+export interface SignatureHelp {
+    /** The function name, with `$`. */
+    name: string;
+    signature: string;
+    params: string[];
+    /** The parameter being edited (0-based). */
+    activeParam: number;
+    summary: string;
+}
+
+export type FunctionCategory =
+| "string"
+| "numeric"
+| "aggregation"
+| "boolean"
+| "array"
+| "object"
+| "higher-order"
+| "date-time"
+| "encoding"
+| "misc";
+
+export interface FunctionInfo {
+    /** The name, without `$`. */
+    name: string;
+    signature: string;
+    params: string[];
+    category: FunctionCategory;
+    summary: string;
+}
+
+// ---------------------------------------------------------------------------------------------
+// Classes and functions with optional arguments (declared here so that the arguments are optional)
+
+/**
+ * A compiled JSONata expression. Compile once, then evaluate against any number of documents.
+ * Call `free()` when it is no longer needed, or rely on the garbage collector.
+ */
+export class Expression {
+    /** Compiles a JSONata expression. Throws a `JlensError` on syntax errors. */
+    constructor(source: string);
+    /** The source text of the expression. */
+    readonly source: string;
+    /**
+     * Evaluates the expression against `input`, a JSON-compatible value (`undefined` means no
+     * input document). Returns `undefined` when the result is undefined; throws a `JlensError`
+     * when the evaluation fails.
+     */
+    evaluate(input?: unknown, bindings?: Bindings | null, options?: EvaluateOptions): unknown;
+    /**
+     * Like `evaluate`, with the input document and the result as JSON text. This avoids
+     * converting large documents to and from JavaScript objects.
+     */
+    evaluateJson(
+    input?: string | null,
+    bindings?: Bindings | null,
+    options?: EvaluateOptions,
+    ): string | undefined;
+    /**
+     * Evaluates the expression and records how the result was reached. Evaluation errors are
+     * reported in the returned `error`, not thrown.
+     */
+    /**
+     * Evaluates the expression against a `Document` converted beforehand, which avoids converting
+     * the input on every call. Use it to evaluate several expressions against one document.
+     */
+    evaluateDocument(document: Document, bindings?: Bindings | null, options?: EvaluateOptions): unknown;
+    evaluateWithAudit(input?: unknown, bindings?: Bindings | null, options?: AuditOptions): AuditResult;
+    /** The processed syntax tree, as plain objects. */
+    ast(): AstNode;
+    /** Releases the compiled expression. */
+    free(): void;
+    [Symbol.dispose](): void;
+}
+
+/**
+ * A JSON document converted once into jlens's internal representation. Evaluating against a
+ * `Document` (`expr.evaluateDocument(doc)`) skips converting the input on every call.
+ */
+export class Document {
+    /** Converts a JSON-compatible value. */
+    constructor(input: unknown);
+    /** Parses JSON text. Throws a `TypeError` when it is not valid JSON. */
+    static fromJson(text: string): Document;
+    free(): void;
+    [Symbol.dispose](): void;
+}
+
+/**
+ * Completion, diagnostics, hover and signature help for expressions over documents described by
+ * a JSON Schema.
+ */
+export class LanguageService {
+    /**
+     * `schema` describes the input documents; without it, functions and variables are still
+     * completed. `variables` declares the bindings the expressions are evaluated with (names with
+     * or without `$`), optionally with a schema for their values.
+     */
+    constructor(schema?: JsonSchema | null, variables?: Record<string, JsonSchema | null>);
+    /** Suggestions for the word at `offset`, and the range they replace. */
+    complete(text: string, offset: number): Completions;
+    /** Syntax errors, and references to fields the schema does not have. */
+    diagnostics(text: string): Diagnostic[];
+    /** The type and description of what is under `offset`, if anything. */
+    hover(text: string, offset: number): Hover | undefined;
+    /** The parameters of the function call around `offset`, if any. */
+    signatureHelp(text: string, offset: number): SignatureHelp | undefined;
+    free(): void;
+    [Symbol.dispose](): void;
+}
+
+/**
+ * Infers a JSON Schema (2020-12, with `x-jlens-*` annotations) from sample documents.
+ * `overrides` adds descriptions, labels, allowed values and hidden fields by path, such as
+ * `"items[].type"`.
+ * Paths missing from the samples are declared; a malformed path or override throws a `TypeError`.
+ */
+export function inferSchema(
+samples: unknown[],
+overrides?: Record<string, SchemaOverride>,
+): JsonSchema;
+
+
+
+/**
+ * The built-in functions: name, signature, parameters, category and summary.
+ */
+export function functions(): FunctionInfo[];
+
+/**
+ * Parses an expression, recovering from syntax errors: returns the (partial) syntax tree and
+ * every problem found. This never throws.
+ */
+export function parseRecover(source: string): ParseResult;
+
+/**
+ * The jlens version.
+ */
+export function version(): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_document_free: (a: number, b: number) => void;
+    readonly __wbg_expression_free: (a: number, b: number) => void;
+    readonly __wbg_languageservice_free: (a: number, b: number) => void;
+    readonly document_fromJson: (a: number, b: number) => [number, number, number];
+    readonly document_new: (a: any) => [number, number, number];
+    readonly expression_ast: (a: number) => any;
+    readonly expression_evaluate: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly expression_evaluateDocument: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly expression_evaluateJson: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+    readonly expression_evaluateWithAudit: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly expression_new: (a: number, b: number) => [number, number, number];
+    readonly expression_source: (a: number) => [number, number];
+    readonly functions: () => any;
+    readonly inferSchema: (a: any, b: number) => [number, number, number];
+    readonly languageservice_complete: (a: number, b: number, c: number, d: number) => any;
+    readonly languageservice_diagnostics: (a: number, b: number, c: number) => any;
+    readonly languageservice_hover: (a: number, b: number, c: number, d: number) => any;
+    readonly languageservice_new: (a: number, b: number) => [number, number, number];
+    readonly languageservice_signatureHelp: (a: number, b: number, c: number, d: number) => any;
+    readonly parseRecover: (a: number, b: number) => any;
+    readonly version: () => [number, number];
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/jlens.js

@@ -0,0 +1,709 @@
+/* @ts-self-types="./jlens.d.ts" */
+
+/**
+ * A JSON document converted once into jlens's internal representation, for evaluating
+ * several expressions (or one several times) against it.
+ */
+export class Document {
+    static __wrap(ptr) {
+        const obj = Object.create(Document.prototype);
+        obj.__wbg_ptr = ptr;
+        DocumentFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DocumentFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_document_free(ptr, 0);
+    }
+    /**
+     * Parses JSON text.
+     * @param {string} text
+     * @returns {Document}
+     */
+    static fromJson(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.document_fromJson(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Document.__wrap(ret[0]);
+    }
+    /**
+     * Converts a JSON-compatible value.
+     * @param {any} input
+     */
+    constructor(input) {
+        const ret = wasm.document_new(input);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        DocumentFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) Document.prototype[Symbol.dispose] = Document.prototype.free;
+
+/**
+ * A compiled JSONata expression.
+ *
+ * Compile once, then evaluate against any number of documents. Call `free()` when the
+ * expression is no longer needed (or rely on the garbage collector, where `FinalizationRegistry`
+ * is available).
+ */
+export class Expression {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExpressionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_expression_free(ptr, 0);
+    }
+    /**
+     * The processed syntax tree, as plain objects (spans in UTF-16 code units).
+     * @returns {any}
+     */
+    ast() {
+        const ret = wasm.expression_ast(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Evaluates the expression against a `Document` converted beforehand, which avoids
+     * converting the input on every call.
+     * @param {Document} document
+     * @param {any | null} [bindings]
+     * @param {any | null} [options]
+     * @returns {any}
+     */
+    evaluateDocument(document, bindings, options) {
+        _assertClass(document, Document);
+        const ret = wasm.expression_evaluateDocument(this.__wbg_ptr, document.__wbg_ptr, isLikeNone(bindings) ? 0 : addToExternrefTable0(bindings), isLikeNone(options) ? 0 : addToExternrefTable0(options));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Like `evaluate`, with the input document and the result as JSON text. This avoids
+     * converting large documents to and from JavaScript objects.
+     * @param {string | null} [input]
+     * @param {any | null} [bindings]
+     * @param {any | null} [options]
+     * @returns {string | undefined}
+     */
+    evaluateJson(input, bindings, options) {
+        var ptr0 = isLikeNone(input) ? 0 : passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.expression_evaluateJson(this.__wbg_ptr, ptr0, len0, isLikeNone(bindings) ? 0 : addToExternrefTable0(bindings), isLikeNone(options) ? 0 : addToExternrefTable0(options));
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v2;
+    }
+    /**
+     * Evaluates the expression and records how the result was reached. Never throws for
+     * evaluation errors: they are reported in the returned `error`.
+     * @param {any | null} [input]
+     * @param {any | null} [bindings]
+     * @param {any | null} [options]
+     * @returns {any}
+     */
+    evaluateWithAudit(input, bindings, options) {
+        const ret = wasm.expression_evaluateWithAudit(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input), isLikeNone(bindings) ? 0 : addToExternrefTable0(bindings), isLikeNone(options) ? 0 : addToExternrefTable0(options));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Evaluates the expression against `input`, a JSON-compatible value (`undefined` means no
+     * input document). `bindings` provides variables: `{limit: 10}` defines `$limit`.
+     * Returns `undefined` when the result is undefined; throws a `JlensError` when the
+     * evaluation fails.
+     * @param {any | null} [input]
+     * @param {any | null} [bindings]
+     * @param {any | null} [options]
+     * @returns {any}
+     */
+    evaluate(input, bindings, options) {
+        const ret = wasm.expression_evaluate(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input), isLikeNone(bindings) ? 0 : addToExternrefTable0(bindings), isLikeNone(options) ? 0 : addToExternrefTable0(options));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Compiles a JSONata expression. Throws a `JlensError` on syntax errors.
+     * @param {string} source
+     */
+    constructor(source) {
+        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.expression_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        ExpressionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * The source text of the expression.
+     * @returns {string}
+     */
+    get source() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.expression_source(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Expression.prototype[Symbol.dispose] = Expression.prototype.free;
+
+/**
+ * Completion, diagnostics, hover and signature help for expressions over documents described
+ * by a JSON Schema. Offsets are in UTF-16 code units.
+ */
+export class LanguageService {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LanguageServiceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_languageservice_free(ptr, 0);
+    }
+    /**
+     * Suggestions for the word at `offset`, and the range they replace.
+     * @param {string} text
+     * @param {number} offset
+     * @returns {any}
+     */
+    complete(text, offset) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.languageservice_complete(this.__wbg_ptr, ptr0, len0, offset);
+        return ret;
+    }
+    /**
+     * Syntax errors, and references to fields the schema does not have.
+     * @param {string} text
+     * @returns {any}
+     */
+    diagnostics(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.languageservice_diagnostics(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * The type and description of what is under `offset`, if anything.
+     * @param {string} text
+     * @param {number} offset
+     * @returns {any}
+     */
+    hover(text, offset) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.languageservice_hover(this.__wbg_ptr, ptr0, len0, offset);
+        return ret;
+    }
+    /**
+     * Creates a service. `schema` describes the input documents (without it, functions and
+     * variables are still completed); `variables` declares the bindings the expressions are
+     * evaluated with, optionally with a schema for their values.
+     * @param {any | null} [schema]
+     * @param {any | null} [variables]
+     */
+    constructor(schema, variables) {
+        const ret = wasm.languageservice_new(isLikeNone(schema) ? 0 : addToExternrefTable0(schema), isLikeNone(variables) ? 0 : addToExternrefTable0(variables));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        LanguageServiceFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * The parameters of the function call around `offset`, if any.
+     * @param {string} text
+     * @param {number} offset
+     * @returns {any}
+     */
+    signatureHelp(text, offset) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.languageservice_signatureHelp(this.__wbg_ptr, ptr0, len0, offset);
+        return ret;
+    }
+}
+if (Symbol.dispose) LanguageService.prototype[Symbol.dispose] = LanguageService.prototype.free;
+
+/**
+ * The built-in functions: name, signature, parameters, category and summary.
+ * @returns {FunctionInfo[]}
+ */
+export function functions() {
+    const ret = wasm.functions();
+    return ret;
+}
+
+/**
+ * Infers a JSON Schema (2020-12, with `x-jlens-*` annotations) from sample documents.
+ * `overrides` adds descriptions, labels, allowed values and hidden fields by path, such as
+ * `"items[].type"`.
+ * Paths missing from the samples are declared; a malformed path or override throws a `TypeError`.
+ * @param {any} samples
+ * @param {any | null} [overrides]
+ * @returns {any}
+ */
+export function inferSchema(samples, overrides) {
+    const ret = wasm.inferSchema(samples, isLikeNone(overrides) ? 0 : addToExternrefTable0(overrides));
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Parses an expression, recovering from syntax errors: returns the (partial) syntax tree and
+ * every problem found. This never throws.
+ * @param {string} source
+ * @returns {ParseResult}
+ */
+export function parseRecover(source) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseRecover(ptr0, len0);
+    return ret;
+}
+
+/**
+ * The jlens version.
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_debug_string_4687d8d8c2017d52: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_is_null_e343b7d08827ba72: function(arg0) {
+            const ret = arg0 === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_string_get_0380ccaa2f57f0d9: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_new_2bdcdfcebdfc34d2: function(arg0, arg1) {
+            const ret = new TypeError(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_343a093a3c2ffb4e: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_now_aa4ccb83129e9e55: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_now_e7c6795a7f81e10f: function(arg0) {
+            const ret = arg0.now();
+            return ret;
+        },
+        __wbg_parse_0fc53dead14b3b42: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return ret;
+        }, arguments); },
+        __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
+            const ret = arg0.performance;
+            return ret;
+        },
+        __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_set_name_2c630595dc90a7aa: function(arg0, arg1, arg2) {
+            arg0.name = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_10fb7dc1ae063179: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_SELF_0b583911f537483a: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_static_accessor_WINDOW_d7f903d1508cbdc4: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_stringify_52ff602c1cc4fbb6: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(arg0);
+            return ret;
+        }, arguments); },
+        __wbindgen_generic_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./jlens_bg.js": import0,
+    };
+}
+
+const DocumentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_document_free(ptr, 1));
+const ExpressionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_expression_free(ptr, 1));
+const LanguageServiceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_languageservice_free(ptr, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('jlens_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/jlens_bg.wasm.d.ts

@@ -0,0 +1,32 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_document_free: (a: number, b: number) => void;
+export const __wbg_expression_free: (a: number, b: number) => void;
+export const __wbg_languageservice_free: (a: number, b: number) => void;
+export const document_fromJson: (a: number, b: number) => [number, number, number];
+export const document_new: (a: any) => [number, number, number];
+export const expression_ast: (a: number) => any;
+export const expression_evaluate: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const expression_evaluateDocument: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const expression_evaluateJson: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+export const expression_evaluateWithAudit: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const expression_new: (a: number, b: number) => [number, number, number];
+export const expression_source: (a: number) => [number, number];
+export const functions: () => any;
+export const inferSchema: (a: any, b: number) => [number, number, number];
+export const languageservice_complete: (a: number, b: number, c: number, d: number) => any;
+export const languageservice_diagnostics: (a: number, b: number, c: number) => any;
+export const languageservice_hover: (a: number, b: number, c: number, d: number) => any;
+export const languageservice_new: (a: number, b: number) => [number, number, number];
+export const languageservice_signatureHelp: (a: number, b: number, c: number, d: number) => any;
+export const parseRecover: (a: number, b: number) => any;
+export const version: () => [number, number];
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "jlens-wasm",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "JSONata in WebAssembly, with evaluation audits and schema-driven autocomplete",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thkprado/jlens.git",
+    "directory": "crates/jlens-wasm"
+  },
+  "homepage": "https://github.com/thkprado/jlens",
+  "bugs": "https://github.com/thkprado/jlens/issues",
+  "type": "module",
+  "main": "./jlens.js",
+  "types": "./jlens.d.ts",
+  "exports": {
+    ".": {
+      "types": "./jlens.d.ts",
+      "default": "./jlens.js"
+    },
+    "./jlens_bg.wasm": "./jlens_bg.wasm"
+  },
+  "files": [
+    "jlens.js",
+    "jlens.d.ts",
+    "jlens_bg.wasm",
+    "jlens_bg.wasm.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "keywords": ["jsonata", "json", "query", "transform", "wasm"]
+}