solve-engine 1.1.1 → 2.0.0

package/dist/worker.js

@@ -1,484 +1,3 @@
-import { WorkerErrorCodes, workerTerminatedError, workerCancelledError, deserializeEngineError, serializeEngineError } from './chunk-WWQEY7BV.js';
-import { ExpressionEngine } from './chunk-NNZAEUDW.js';
-import './chunk-I4GAWIPW.js';
-import './chunk-2RWAXT6O.js';
-import './chunk-3VGDNEE3.js';
-import './chunk-FD5ZZHEU.js';
-import './chunk-WXEHD6TT.js';
-import './chunk-CCBZZQAE.js';
-import { formatValue } from './chunk-3OWCDIPN.js';
-import './chunk-UKQHXPGW.js';
-import { BUILTIN_PACKAGES } from './chunk-4HQKTMWG.js';
-import './chunk-ENKKJYD3.js';
-import './chunk-BYJBUL7U.js';
-import './chunk-3BOK2LDK.js';
-import './chunk-7KYSUDQO.js';
-import './chunk-NLNDMWZC.js';
-import './chunk-NKW7LKYU.js';
-import './chunk-GCM5JHMX.js';
-import './chunk-Z7XGGLI2.js';
-import './chunk-BLI4NIQY.js';
-import './chunk-Z4X2RWOF.js';
-import { formatColour, toHexString } from './chunk-5HRB36DK.js';
-import { formatSymbolic } from './chunk-NNQ2TYDF.js';
-import './chunk-267JPOTF.js';
-import './chunk-MVTOCRV2.js';
-import './chunk-GLA4JXBO.js';
-import './chunk-DLEBSLF4.js';
-import './chunk-UO6BUV6K.js';
-import './chunk-JG6ZJ2WU.js';
-import './chunk-4D6NIHE2.js';
-import './chunk-XBTEO4OB.js';
-import './chunk-SBUFNJVE.js';
-import './chunk-V4XG5QF6.js';
-import { ErrorFactory, normalizeUnknownError } from './chunk-ERCOHGXD.js';
-import './chunk-YLJ4XMA6.js';
-
-// src/worker/client.ts
-var WorkerEngineClient = class {
-  constructor(transport) {
-    this.nextId = 1;
-    this.pending = /* @__PURE__ */ new Map();
-    // Broadcast subscribers for async resolutions. Sets, not one callback each, so
-    // several views can watch the same worker; a resolution is not tied to a
-    // request id, so these live outside `pending`.
-    this.resolvedListeners = /* @__PURE__ */ new Set();
-    this.asyncErrorListeners = /* @__PURE__ */ new Set();
-    this.terminated = false;
-    this.transport = transport;
-    this.transport.onMessage((raw) => this.onMessage(raw));
-  }
-  /** Perform the init handshake, resolving once the worker posts `ready`. */
-  init(options) {
-    const id = this.nextId++;
-    return new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve: () => resolve(), reject });
-      this.transport.postMessage({
-        kind: "init",
-        id,
-        localeCode: options.localeCode,
-        diagnosticMode: options.diagnosticMode,
-        config: options.config,
-        packages: options.packages,
-        formatting: options.formatting
-      });
-    });
-  }
-  parseDocument(input, options) {
-    const { signal, ...parsing } = options ?? {};
-    const parseOptions = Object.keys(parsing).length > 0 ? parsing : void 0;
-    return this.call("parseDocument", [input, parseOptions], signal);
-  }
-  evaluateLines(lines, options) {
-    return this.call("evaluateLines", [lines], options?.signal);
-  }
-  evaluateExpression(expression, options) {
-    return this.call("evaluateExpression", [expression], options?.signal);
-  }
-  onResolved(listener) {
-    this.resolvedListeners.add(listener);
-    return () => this.resolvedListeners.delete(listener);
-  }
-  onAsyncError(listener) {
-    this.asyncErrorListeners.add(listener);
-    return () => this.asyncErrorListeners.delete(listener);
-  }
-  terminate() {
-    if (this.terminated) return;
-    this.terminated = true;
-    const error = workerTerminatedError();
-    for (const entry of this.pending.values()) {
-      this.unhook(entry);
-      entry.reject(error);
-    }
-    this.pending.clear();
-    this.resolvedListeners.clear();
-    this.asyncErrorListeners.clear();
-    this.transport.terminate();
-  }
-  /** Dispatch one request and return the promise that settles on its answer. */
-  call(method, args, signal) {
-    if (this.terminated) return Promise.reject(workerTerminatedError());
-    if (signal?.aborted) return Promise.reject(workerCancelledError(method));
-    const id = this.nextId++;
-    return new Promise((resolve, reject) => {
-      const entry = { resolve, reject };
-      if (signal) {
-        const onAbort = () => {
-          if (!this.pending.has(id)) return;
-          this.pending.delete(id);
-          this.transport.postMessage({ kind: "cancel", id });
-          reject(workerCancelledError(method));
-        };
-        entry.signal = signal;
-        entry.onAbort = onAbort;
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      this.pending.set(id, entry);
-      this.transport.postMessage({ kind: "request", id, method, args });
-    });
-  }
-  /** Route one incoming message to the request that is waiting on its id. */
-  onMessage(raw) {
-    const message = raw;
-    switch (message.kind) {
-      case "ready":
-      case "result": {
-        const value = message.kind === "result" ? message.value : void 0;
-        this.settle(message.id, (entry) => entry.resolve(value));
-        break;
-      }
-      case "error":
-        this.settle(message.id, (entry) => entry.reject(deserializeEngineError(message.error)));
-        break;
-      case "async-update":
-        for (const listener of [...this.resolvedListeners]) listener(message.lines);
-        break;
-      case "async-error":
-        for (const listener of [...this.asyncErrorListeners]) {
-          listener({
-            queryKey: message.queryKey,
-            packageId: message.packageId,
-            error: deserializeEngineError(message.error)
-          });
-        }
-        break;
-    }
-  }
-  /** Remove a pending request by id and run the settle callback, if it is still pending. */
-  settle(id, apply) {
-    const entry = this.pending.get(id);
-    if (!entry) return;
-    this.pending.delete(id);
-    this.unhook(entry);
-    apply(entry);
-  }
-  /** Detach an entry's abort listener so a settled request leaves nothing on the signal. */
-  unhook(entry) {
-    if (entry.signal && entry.onAbort) entry.signal.removeEventListener("abort", entry.onAbort);
-  }
-};
-async function createWorkerEngine(options) {
-  const client = new WorkerEngineClient(options.transport);
-  await client.init(options);
-  return client;
-}
-
-// src/worker/serialize.ts
-function nonFiniteTag(n) {
-  return n > 0 ? "Infinity" : n < 0 ? "-Infinity" : "NaN";
-}
-function serializeMatrix(m) {
-  const cells = m.data.map((cell) => {
-    if (typeof cell === "object" && cell !== null) return formatSymbolic(cell);
-    if (typeof cell === "number" && !Number.isFinite(cell)) return nonFiniteTag(cell);
-    return cell;
-  });
-  return { rows: m.rows, cols: m.cols, cells, hasSymbolic: m.hasSymbolic };
-}
-function serializeValue(value, settings) {
-  const reading = value.toNumber();
-  const dto = {
-    type: value.type,
-    text: formatValue(value, settings),
-    // A non-finite reading (1/0, 0/0, an overflow) cannot cross JSON, which
-    // turns it into null and breaks the round-trip the DTO guarantees. Keep
-    // `number` finite and name the real value in `nonFinite` instead.
-    number: Number.isFinite(reading) ? reading : 0
-  };
-  if (!Number.isFinite(reading)) {
-    dto.nonFinite = nonFiniteTag(reading);
-  }
-  if (value.unit !== void 0) dto.unit = value.unit;
-  if (value.timedOut !== void 0) dto.timedOut = value.timedOut;
-  const raw = value.value;
-  if (typeof raw === "bigint") {
-    dto.bigint = raw.toString();
-  } else if (value.type === 7 /* Matrix */) {
-    dto.matrix = serializeMatrix(raw);
-  } else if (value.type === 8 /* Range */) {
-    const r = raw;
-    dto.range = { min: r.min, max: r.max };
-  } else if (value.type === 14 /* Colour */) {
-    const c = raw;
-    dto.colour = { hex: toHexString(c), r: c.r, g: c.g, b: c.b, a: c.a, format: c.format, css: formatColour(c) };
-  }
-  return dto;
-}
-function serializeMaybe(value, settings) {
-  return value ? serializeValue(value, settings) : null;
-}
-function serializeInlineSolve(solve, settings) {
-  return {
-    start: solve.start,
-    end: solve.end,
-    expression: solve.expression,
-    lineNumber: solve.lineNumber,
-    columnNumber: solve.columnNumber,
-    result: serializeMaybe(solve.result, settings),
-    error: solve.error ?? null
-  };
-}
-function serializeParsedLine(line, settings) {
-  return {
-    lineNumber: line.lineNumber,
-    text: line.text,
-    startPosition: line.startPosition,
-    endPosition: line.endPosition,
-    isEmpty: line.isEmpty,
-    hasInlineSolves: line.hasInlineSolves,
-    inlineSolves: line.inlineSolves.map((solve) => serializeInlineSolve(solve, settings)),
-    expression: line.expression,
-    result: serializeMaybe(line.result, settings),
-    error: line.error
-  };
-}
-function serializeParsingResult(result, settings) {
-  const dto = {
-    lines: result.lines.map((line) => serializeParsedLine(line, settings)),
-    totalLines: result.totalLines,
-    errors: [...result.errors]
-  };
-  if (result.diagnostics !== void 0) dto.diagnostics = result.diagnostics;
-  return dto;
-}
-
-// src/worker/runtime.ts
-function resolvePackages(available, names) {
-  if (names === void 0) return available;
-  const byName = new Map(available.map((pkg) => [pkg.name, pkg]));
-  const resolved = [];
-  for (const name of names) {
-    const pkg = byName.get(name);
-    if (!pkg) {
-      throw ErrorFactory.config(
-        WorkerErrorCodes.WORKER_UNKNOWN_PACKAGE,
-        `No package named "${name}" is available in this worker runtime`,
-        { name, available: [...byName.keys()] }
-      );
-    }
-    resolved.push(pkg);
-  }
-  return resolved;
-}
-function startWorkerRuntime(transport, options = {}) {
-  const available = options.packages ?? BUILTIN_PACKAGES;
-  let engine = null;
-  let formatting;
-  const inFlight = /* @__PURE__ */ new Map();
-  let retainedLines = /* @__PURE__ */ new Map();
-  let documentController = null;
-  let stopEventPump = null;
-  const post = (message) => transport.postMessage(message);
-  const fail = (id, error) => {
-    post({ kind: "error", id, error: serializeEngineError(normalizeUnknownError(error)) });
-  };
-  const retainLines = (message) => {
-    const map = /* @__PURE__ */ new Map();
-    if (message.method === "parseDocument") {
-      message.args[0].split("\n").forEach((text, index) => map.set(index + 1, text));
-    } else if (message.method === "evaluateLines") {
-      message.args[0].forEach((text, index) => map.set(index + 1, text));
-    } else {
-      map.set(-1, message.args[0]);
-    }
-    return map;
-  };
-  const handleAsyncEvent = (eng, event) => {
-    if (event.type === "error") {
-      post({
-        kind: "async-error",
-        queryKey: event.queryKey,
-        packageId: event.packageId,
-        error: serializeEngineError(normalizeUnknownError(event.error))
-      });
-      return;
-    }
-    const lines = [];
-    for (const lineNumber of event.lineNumbers) {
-      const text = retainedLines.get(lineNumber);
-      if (text === void 0) continue;
-      try {
-        const value = eng.evaluateLine(lineNumber, text)[0];
-        if (value) lines.push({ lineNumber, value: serializeValue(value, formatting) });
-      } catch {
-      }
-    }
-    if (lines.length > 0) post({ kind: "async-update", lines });
-  };
-  const startEventPump = (eng) => {
-    stopEventPump?.();
-    const reader = eng.getEventStream().getReader();
-    stopEventPump = () => void reader.cancel();
-    void (async () => {
-      try {
-        for (; ; ) {
-          const { done, value } = await reader.read();
-          if (done) return;
-          handleAsyncEvent(eng, value);
-        }
-      } catch {
-      }
-    })();
-  };
-  const handleInit = (message) => {
-    try {
-      const packages = resolvePackages(available, message.packages);
-      engine = new ExpressionEngine(
-        message.localeCode ?? "en",
-        message.diagnosticMode ?? false,
-        message.config,
-        void 0,
-        packages
-      );
-      formatting = message.formatting;
-      startEventPump(engine);
-      post({ kind: "ready", id: message.id });
-    } catch (error) {
-      fail(message.id, error);
-    }
-  };
-  const runMethod = (eng, message) => {
-    const { method, args } = message;
-    switch (method) {
-      case "parseDocument":
-        return serializeParsingResult(eng.parseDocument(args[0], args[1]), formatting);
-      case "evaluateLines":
-        return eng.evaluateLines(args[0]).map((line) => serializeParsedLine(line, formatting));
-      case "evaluateExpression":
-        return eng.evaluateExpression(args[0]).map((value) => serializeValue(value, formatting));
-      default:
-        throw ErrorFactory.execution(
-          WorkerErrorCodes.WORKER_UNKNOWN_METHOD,
-          `The worker runtime has no method named "${String(method)}"`,
-          { method }
-        );
-    }
-  };
-  const handleRequest = (message) => {
-    const eng = engine;
-    if (!eng) {
-      fail(
-        message.id,
-        ErrorFactory.execution(
-          WorkerErrorCodes.WORKER_NOT_INITIALISED,
-          "The worker received a request before its engine finished initialising"
-        )
-      );
-      return;
-    }
-    documentController?.abort();
-    const controller = new AbortController();
-    documentController = controller;
-    retainedLines = retainLines(message);
-    inFlight.set(message.id, controller);
-    eng.setKeystrokeSignal(controller.signal);
-    try {
-      const value = runMethod(eng, message);
-      post({ kind: "result", id: message.id, value });
-    } catch (error) {
-      fail(message.id, error);
-    } finally {
-      inFlight.delete(message.id);
-      eng.setKeystrokeSignal(null);
-    }
-  };
-  transport.onMessage((raw) => {
-    const message = raw;
-    switch (message.kind) {
-      case "init":
-        handleInit(message);
-        break;
-      case "request":
-        handleRequest(message);
-        break;
-      case "cancel":
-        inFlight.get(message.id)?.abort();
-        break;
-    }
-  });
-  return () => {
-    stopEventPump?.();
-    stopEventPump = null;
-    documentController?.abort();
-    documentController = null;
-    retainedLines = /* @__PURE__ */ new Map();
-    for (const controller of inFlight.values()) controller.abort();
-    inFlight.clear();
-    engine?.clear();
-    engine = null;
-    transport.terminate();
-  };
-}
-
-// src/worker/transport.ts
-function cloneMessage(value) {
-  return typeof globalThis.structuredClone === "function" ? globalThis.structuredClone(value) : JSON.parse(JSON.stringify(value));
-}
-function createLinkedTransports() {
-  let clientHandler = null;
-  let hostHandler = null;
-  let alive = true;
-  const deliver = (target, message) => {
-    const cloned = cloneMessage(message);
-    queueMicrotask(() => {
-      if (!alive) return;
-      target()?.(cloned);
-    });
-  };
-  const client = {
-    postMessage: (message) => deliver(() => hostHandler, message),
-    onMessage: (handler) => {
-      clientHandler = handler;
-    },
-    terminate: () => {
-      alive = false;
-    }
-  };
-  const host = {
-    postMessage: (message) => deliver(() => clientHandler, message),
-    onMessage: (handler) => {
-      hostHandler = handler;
-    },
-    terminate: () => {
-      alive = false;
-    }
-  };
-  return { client, host };
-}
-function eventTargetTransport(target) {
-  return {
-    postMessage: (message) => target.postMessage(message),
-    onMessage: (handler) => {
-      const listener = (event) => handler(event.data);
-      if (typeof target.addEventListener === "function") {
-        target.addEventListener("message", listener);
-      } else {
-        target.onmessage = listener;
-      }
-      target.start?.();
-    },
-    // A main-side Worker terminates; a worker's own `self` closes. Calling
-    // whichever exists keeps one adapter usable from both ends.
-    terminate: () => {
-      target.terminate?.();
-      target.close?.();
-    }
-  };
-}
-function messagePortTransport(port) {
-  return {
-    postMessage: (message) => port.postMessage(message),
-    onMessage: (handler) => {
-      port.on("message", (message) => handler(message));
-    },
-    terminate: () => {
-      port.terminate?.();
-      port.close?.();
-    }
-  };
-}
-
-export { createLinkedTransports, createWorkerEngine, eventTargetTransport, messagePortTransport, serializeParsedLine, serializeParsingResult, serializeValue, startWorkerRuntime };
-//# sourceMappingURL=worker.js.map
+import {a,e,d,c as c$2,b}from'./chunk-MVZUTETT.js';import {n}from'./chunk-XR7HEC7B.js';import'./chunk-XNIWQHXY.js';import'./chunk-2RWAXT6O.js';import'./chunk-7GK3XEZF.js';import'./chunk-MIQBJGGR.js';import'./chunk-YJ2OPULK.js';import'./chunk-TWC7K3ZX.js';import {c}from'./chunk-J4LZD4ZY.js';import'./chunk-XEIDV5JP.js';import {y as y$1}from'./chunk-EYRBENHC.js';import'./chunk-6G3PMEPA.js';import'./chunk-6CY44ZPG.js';import'./chunk-YVKHEAFT.js';import'./chunk-QXQE7X4S.js';import'./chunk-76F3LCIL.js';import'./chunk-TCZSPH4A.js';import'./chunk-W2JAR233.js';import'./chunk-YAYBVVG2.js';import'./chunk-E6Z4NQAS.js';import'./chunk-HFKDWQUL.js';import {g,f}from'./chunk-R2ENWQ76.js';import {R}from'./chunk-RSF25YSJ.js';import'./chunk-EVAOPEO4.js';import'./chunk-WGZ3FNHI.js';import'./chunk-L3FPQSGN.js';import'./chunk-GOIQYUWV.js';import'./chunk-JPFCXLJV.js';import'./chunk-UI6IFGBT.js';import'./chunk-IJMNVBIS.js';import'./chunk-62LMTO4F.js';import'./chunk-TRBXW6HW.js';import'./chunk-2JMFUQZH.js';import {c as c$1,d as d$1}from'./chunk-MPB7KUN5.js';var W=class{constructor(r){this.nextId=1;this.pending=new Map;this.resolvedListeners=new Set;this.asyncErrorListeners=new Set;this.terminated=false;this.transport=r,this.transport.onMessage(n=>this.onMessage(n));}init(r){let n=this.nextId++;return new Promise((t,o)=>{this.pending.set(n,{resolve:()=>t(),reject:o}),this.transport.postMessage({kind:"init",id:n,localeCode:r.localeCode,diagnostics:r.diagnostics,config:r.config,packages:r.packages,formatting:r.formatting});})}parseDocument(r,n){let{signal:t,...o}=n??{},a=Object.keys(o).length>0?o:void 0;return this.call("parseDocument",[r,a],t)}evaluateLines(r,n){return this.call("evaluateLines",[r],n?.signal)}evaluateExpression(r,n){return this.call("evaluateExpression",[r],n?.signal)}onResolved(r){return this.resolvedListeners.add(r),()=>this.resolvedListeners.delete(r)}onAsyncError(r){return this.asyncErrorListeners.add(r),()=>this.asyncErrorListeners.delete(r)}terminate(){if(this.terminated)return;this.terminated=true;let r=e();for(let n of this.pending.values())this.unhook(n),n.reject(r);this.pending.clear(),this.resolvedListeners.clear(),this.asyncErrorListeners.clear(),this.transport.terminate();}call(r,n,t){if(this.terminated)return Promise.reject(e());if(t?.aborted)return Promise.reject(d(r));let o=this.nextId++;return new Promise((a,u)=>{let c={resolve:a,reject:u};if(t){let g=()=>{this.pending.has(o)&&(this.pending.delete(o),this.transport.postMessage({kind:"cancel",id:o}),u(d(r)));};c.signal=t,c.onAbort=g,t.addEventListener("abort",g,{once:true});}this.pending.set(o,c),this.transport.postMessage({kind:"request",id:o,method:r,args:n});})}onMessage(r){let n=r;switch(n.kind){case "ready":case "result":{let t=n.kind==="result"?n.value:void 0;this.settle(n.id,o=>o.resolve(t));break}case "error":this.settle(n.id,t=>t.reject(c$2(n.error)));break;case "async-update":for(let t of [...this.resolvedListeners])t(n.lines);break;case "async-error":for(let t of [...this.asyncErrorListeners])t({queryKey:n.queryKey,packageId:n.packageId,error:c$2(n.error)});break}}settle(r,n){let t=this.pending.get(r);t&&(this.pending.delete(r),this.unhook(t),n(t));}unhook(r){r.signal&&r.onAbort&&r.signal.removeEventListener("abort",r.onAbort);}};async function K(e){let r=new W(e.transport);return await r.init(e),r}function O(e){return e>0?"Infinity":e<0?"-Infinity":"NaN"}function U(e){let r=e.data.map(n=>typeof n=="object"&&n!==null?R(n):typeof n=="number"&&!Number.isFinite(n)?O(n):n);return {rows:e.rows,cols:e.cols,cells:r,hasSymbolic:e.hasSymbolic}}function m(e,r){let n=e.toNumber(),t={type:e.type,text:c(e,r),number:Number.isFinite(n)?n:0};Number.isFinite(n)||(t.nonFinite=O(n)),e.unit!==void 0&&(t.unit=e.unit),e.timedOut!==void 0&&(t.timedOut=e.timedOut);let o=e.value;if(typeof o=="bigint")t.bigint=o.toString();else if(e.type===7)t.matrix=U(o);else if(e.type===8){let a=o;t.range={min:a.min,max:a.max};}else if(e.type===14){let a=o;t.colour={hex:f(a),r:a.r,g:a.g,b:a.b,a:a.a,format:a.format,css:g(a)};}return t}function N(e,r){return e?m(e,r):null}function _(e,r){return {start:e.start,end:e.end,expression:e.expression,lineNumber:e.lineNumber,columnNumber:e.columnNumber,result:N(e.result,r),error:e.error??null}}function y(e,r){return {lineNumber:e.lineNumber,text:e.text,startPosition:e.startPosition,endPosition:e.endPosition,isEmpty:e.isEmpty,hasInlineSolves:e.hasInlineSolves,inlineSolves:e.inlineSolves.map(n=>_(n,r)),expression:e.expression,result:N(e.result,r),error:e.error}}function x(e,r){let n={lines:e.lines.map(t=>y(t,r)),totalLines:e.totalLines,errors:[...e.errors]};return e.diagnostics!==void 0&&(n.diagnostics=e.diagnostics),n}function H(e,r){if(r===void 0)return e;let n=new Map(e.map(o=>[o.name,o])),t=[];for(let o of r){let a$1=n.get(o);if(!a$1)throw c$1.config(a.WORKER_UNKNOWN_PACKAGE,`No package named "${o}" is available in this worker runtime`,{name:o,available:[...n.keys()]});t.push(a$1);}return t}function B(e,r={}){let n$1=r.packages??y$1,t=null,o,a$1=new Map,u=new Map,c=null,g=null,p=i=>e.postMessage(i),h=(i,s)=>{p({kind:"error",id:i,error:b(d$1(s))});},C=i=>{let s=new Map;return i.method==="parseDocument"?i.args[0].split(`
+`).forEach((d,l)=>s.set(l+1,d)):i.method==="evaluateLines"?i.args[0].forEach((d,l)=>s.set(l+1,d)):s.set(-1,i.args[0]),s},q=(i,s)=>{if(s.type==="error"){p({kind:"async-error",queryKey:s.queryKey,packageId:s.packageId,error:b(d$1(s.error))});return}let d=[];for(let l of s.lineNumbers){let f=u.get(l);if(f!==void 0)try{let R=i.evaluateLine(l,f);R&&d.push({lineNumber:l,value:m(R,o)});}catch{}}d.length>0&&p({kind:"async-update",lines:d});},F=i=>{g?.();let s=i.getEventStream().getReader();g=()=>{s.cancel();},(async()=>{try{for(;;){let{done:d,value:l}=await s.read();if(d)return;q(i,l);}}catch{}})();},V=i=>{try{let s=H(n$1,i.packages);t=new n({locale:i.localeCode??"en",diagnostics:i.diagnostics??!1,config:i.config,packages:s}),o=i.formatting,F(t),p({kind:"ready",id:i.id});}catch(s){h(i.id,s);}},j=(i,s)=>{let{method:d,args:l}=s;switch(d){case "parseDocument":return x(i.parseDocument(l[0],l[1]),o);case "evaluateLines":return i.evaluateLines(l[0]).map(f=>y(f,o));case "evaluateExpression":return m(i.evaluateExpression(l[0]),o);default:throw c$1.execution(a.WORKER_UNKNOWN_METHOD,`The worker runtime has no method named "${String(d)}"`,{method:d})}},D=i=>{let s=t;if(!s){h(i.id,c$1.execution(a.WORKER_NOT_INITIALISED,"The worker received a request before its engine finished initialising"));return}c?.abort();let d=new AbortController;c=d,u=C(i),a$1.set(i.id,d),s.setKeystrokeSignal(d.signal);try{let l=j(s,i);p({kind:"result",id:i.id,value:l});}catch(l){h(i.id,l);}finally{a$1.delete(i.id),s.setKeystrokeSignal(null);}};return e.onMessage(i=>{let s=i;switch(s.kind){case "init":V(s);break;case "request":D(s);break;case "cancel":a$1.get(s.id)?.abort();break}}),()=>{g?.(),g=null,c?.abort(),c=null,u=new Map;for(let i of a$1.values())i.abort();a$1.clear(),t?.clear(),t=null,e.terminate();}}function G(e){return typeof globalThis.structuredClone=="function"?globalThis.structuredClone(e):JSON.parse(JSON.stringify(e))}function J(){let e=null,r=null,n=true,t=(u,c)=>{let g=G(c);queueMicrotask(()=>{n&&u()?.(g);});};return {client:{postMessage:u=>t(()=>r,u),onMessage:u=>{e=u;},terminate:()=>{n=false;}},host:{postMessage:u=>t(()=>e,u),onMessage:u=>{r=u;},terminate:()=>{n=false;}}}}function $(e){return {postMessage:r=>e.postMessage(r),onMessage:r=>{let n=t=>r(t.data);typeof e.addEventListener=="function"?e.addEventListener("message",n):e.onmessage=n,e.start?.();},terminate:()=>{e.terminate?.(),e.close?.();}}}function Q(e){return {postMessage:r=>e.postMessage(r),onMessage:r=>{e.on("message",n=>r(n));},terminate:()=>{e.terminate?.(),e.close?.();}}}export{J as createLinkedTransports,K as createWorkerEngine,$ as eventTargetTransport,Q as messagePortTransport,y as serializeParsedLine,x as serializeParsingResult,m as serializeValue,B as startWorkerRuntime};//# sourceMappingURL=worker.js.map
 //# sourceMappingURL=worker.js.map