@astrojs/compiler 1.3.1 → 1.3.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @astrojs/compiler
 
+## 1.3.2
+
+### Patch Changes
+
+- 19c0176: Fix TSX sourcemapping for components using Windows-style line returns
+- b0e0cfd: Add a sync entrypoint
+
 ## 1.3.1
 
 ### Patch Changes

package/README.md

@@ -63,4 +63,4 @@ A `devcontainer` configuration is available for use with VSCode's [Remote Develo
 
 ## Contributing
 
-[CONTRIBUTING.md](./CONTRIBUTING.md)
+[CONTRIBUTING.md](/CONTRIBUTING.md)

package/browser/utils.d.ts

@@ -23,5 +23,5 @@ export interface SerializeOptions {
     selfClose: boolean;
 }
 /** @deprecated Please use `SerializeOptions`  */
-export declare type SerializeOtions = SerializeOptions;
+export type SerializeOtions = SerializeOptions;
 export declare function serialize(root: Node, opts?: SerializeOptions): string;

package/node/index.d.ts

@@ -1,4 +1,4 @@
-export type { PreprocessorResult, ParseOptions, TransformOptions, HoistedScript, TransformResult, ParseResult } from '../shared/types';
+export type { HoistedScript, ParseOptions, ParseResult, PreprocessorResult, TransformOptions, TransformResult } from '../shared/types';
 import type * as types from '../shared/types';
 export declare const transform: typeof types.transform;
 export declare const parse: typeof types.parse;

package/node/index.js

@@ -1,6 +1,6 @@
 import { promises as fs } from 'fs';
-import Go from './wasm_exec.js';
 import { fileURLToPath } from 'url';
+import Go from './wasm_exec.js';
 export const transform = async (input, options) => {
     return getService().then((service) => service.transform(input, options));
 };

package/node/sync.cjs

@@ -0,0 +1,532 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node/sync.cts
+var sync_exports = {};
+__export(sync_exports, {
+  convertToTSX: () => convertToTSX,
+  parse: () => parse,
+  startRunningService: () => startRunningService,
+  transform: () => transform
+});
+module.exports = __toCommonJS(sync_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+
+// node/wasm_exec.js
+var import_fs = __toESM(require("fs"), 1);
+var import_crypto = __toESM(require("crypto"), 1);
+var import_util = require("util");
+if (!globalThis.fs) {
+  Object.defineProperty(globalThis, "fs", {
+    value: import_fs.default
+  });
+}
+if (!globalThis.process) {
+  Object.defineProperties(globalThis, "process", {
+    value: process
+  });
+}
+if (!globalThis.crypto) {
+  Object.defineProperty(globalThis, "crypto", {
+    value: {
+      getRandomValues(b) {
+        return import_crypto.default.randomFillSync(b);
+      }
+    }
+  });
+}
+if (!globalThis.performance) {
+  Object.defineProperty(globalThis, "performance", {
+    value: {
+      now() {
+        const [sec, nsec] = process.hrtime();
+        return sec * 1e3 + nsec / 1e6;
+      }
+    }
+  });
+}
+var encoder = new import_util.TextEncoder("utf-8");
+var decoder = new import_util.TextDecoder("utf-8");
+var Go = class {
+  constructor() {
+    this.argv = ["js"];
+    this.env = {};
+    this.exit = (code) => {
+      if (code !== 0) {
+        console.warn("exit code:", code);
+      }
+    };
+    this._exitPromise = new Promise((resolve) => {
+      this._resolveExitPromise = resolve;
+    });
+    this._pendingEvent = null;
+    this._scheduledTimeouts = /* @__PURE__ */ new Map();
+    this._nextCallbackTimeoutID = 1;
+    const setInt64 = (addr, v) => {
+      this.mem.setUint32(addr + 0, v, true);
+      this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
+    };
+    const getInt64 = (addr) => {
+      const low = this.mem.getUint32(addr + 0, true);
+      const high = this.mem.getInt32(addr + 4, true);
+      return low + high * 4294967296;
+    };
+    const loadValue = (addr) => {
+      const f = this.mem.getFloat64(addr, true);
+      if (f === 0) {
+        return void 0;
+      }
+      if (!isNaN(f)) {
+        return f;
+      }
+      const id = this.mem.getUint32(addr, true);
+      return this._values[id];
+    };
+    const storeValue = (addr, v) => {
+      const nanHead = 2146959360;
+      if (typeof v === "number" && v !== 0) {
+        if (isNaN(v)) {
+          this.mem.setUint32(addr + 4, nanHead, true);
+          this.mem.setUint32(addr, 0, true);
+          return;
+        }
+        this.mem.setFloat64(addr, v, true);
+        return;
+      }
+      if (v === void 0) {
+        this.mem.setFloat64(addr, 0, true);
+        return;
+      }
+      let id = this._ids.get(v);
+      if (id === void 0) {
+        id = this._idPool.pop();
+        if (id === void 0) {
+          id = this._values.length;
+        }
+        this._values[id] = v;
+        this._goRefCounts[id] = 0;
+        this._ids.set(v, id);
+      }
+      this._goRefCounts[id]++;
+      let typeFlag = 0;
+      switch (typeof v) {
+        case "object":
+          if (v !== null) {
+            typeFlag = 1;
+          }
+          break;
+        case "string":
+          typeFlag = 2;
+          break;
+        case "symbol":
+          typeFlag = 3;
+          break;
+        case "function":
+          typeFlag = 4;
+          break;
+      }
+      this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
+      this.mem.setUint32(addr, id, true);
+    };
+    const loadSlice = (addr) => {
+      const array = getInt64(addr + 0);
+      const len = getInt64(addr + 8);
+      return new Uint8Array(this._inst.exports.mem.buffer, array, len);
+    };
+    const loadSliceOfValues = (addr) => {
+      const array = getInt64(addr + 0);
+      const len = getInt64(addr + 8);
+      const a = new Array(len);
+      for (let i = 0; i < len; i++) {
+        a[i] = loadValue(array + i * 8);
+      }
+      return a;
+    };
+    const loadString = (addr) => {
+      const saddr = getInt64(addr + 0);
+      const len = getInt64(addr + 8);
+      return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
+    };
+    const timeOrigin = Date.now() - performance.now();
+    this.importObject = {
+      go: {
+        // Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
+        // may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
+        // function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
+        // This changes the SP, thus we have to update the SP used by the imported function.
+        // func wasmExit(code int32)
+        "runtime.wasmExit": (sp) => {
+          sp >>>= 0;
+          const code = this.mem.getInt32(sp + 8, true);
+          this.exited = true;
+          delete this._inst;
+          delete this._values;
+          delete this._goRefCounts;
+          delete this._ids;
+          delete this._idPool;
+          this.exit(code);
+        },
+        // func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
+        "runtime.wasmWrite": (sp) => {
+          sp >>>= 0;
+          const fd = getInt64(sp + 8);
+          const p = getInt64(sp + 16);
+          const n = this.mem.getInt32(sp + 24, true);
+          import_fs.default.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
+        },
+        // func resetMemoryDataView()
+        "runtime.resetMemoryDataView": (sp) => {
+          sp >>>= 0;
+          this.mem = new DataView(this._inst.exports.mem.buffer);
+        },
+        // func nanotime1() int64
+        "runtime.nanotime1": (sp) => {
+          sp >>>= 0;
+          setInt64(sp + 8, (timeOrigin + performance.now()) * 1e6);
+        },
+        // func walltime() (sec int64, nsec int32)
+        "runtime.walltime": (sp) => {
+          sp >>>= 0;
+          const msec = (/* @__PURE__ */ new Date()).getTime();
+          setInt64(sp + 8, msec / 1e3);
+          this.mem.setInt32(sp + 16, msec % 1e3 * 1e6, true);
+        },
+        // func scheduleTimeoutEvent(delay int64) int32
+        "runtime.scheduleTimeoutEvent": (sp) => {
+          sp >>>= 0;
+          const id = this._nextCallbackTimeoutID;
+          this._nextCallbackTimeoutID++;
+          this._scheduledTimeouts.set(id, setTimeout(
+            () => {
+              this._resume();
+              while (this._scheduledTimeouts.has(id)) {
+                console.warn("scheduleTimeoutEvent: missed timeout event");
+                this._resume();
+              }
+            },
+            getInt64(sp + 8) + 1
+            // setTimeout has been seen to fire up to 1 millisecond early
+          ));
+          this.mem.setInt32(sp + 16, id, true);
+        },
+        // func clearTimeoutEvent(id int32)
+        "runtime.clearTimeoutEvent": (sp) => {
+          sp >>>= 0;
+          const id = this.mem.getInt32(sp + 8, true);
+          clearTimeout(this._scheduledTimeouts.get(id));
+          this._scheduledTimeouts.delete(id);
+        },
+        // func getRandomData(r []byte)
+        "runtime.getRandomData": (sp) => {
+          sp >>>= 0;
+          globalThis.crypto.getRandomValues(loadSlice(sp + 8));
+        },
+        // func finalizeRef(v ref)
+        "syscall/js.finalizeRef": (sp) => {
+          sp >>>= 0;
+          const id = this.mem.getUint32(sp + 8, true);
+          this._goRefCounts[id]--;
+          if (this._goRefCounts[id] === 0) {
+            const v = this._values[id];
+            this._values[id] = null;
+            this._ids.delete(v);
+            this._idPool.push(id);
+          }
+        },
+        // func stringVal(value string) ref
+        "syscall/js.stringVal": (sp) => {
+          sp >>>= 0;
+          storeValue(sp + 24, loadString(sp + 8));
+        },
+        // func valueGet(v ref, p string) ref
+        "syscall/js.valueGet": (sp) => {
+          sp >>>= 0;
+          const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
+          sp = this._inst.exports.getsp() >>> 0;
+          storeValue(sp + 32, result);
+        },
+        // func valueSet(v ref, p string, x ref)
+        "syscall/js.valueSet": (sp) => {
+          sp >>>= 0;
+          Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
+        },
+        // func valueDelete(v ref, p string)
+        "syscall/js.valueDelete": (sp) => {
+          sp >>>= 0;
+          Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
+        },
+        // func valueIndex(v ref, i int) ref
+        "syscall/js.valueIndex": (sp) => {
+          sp >>>= 0;
+          storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
+        },
+        // valueSetIndex(v ref, i int, x ref)
+        "syscall/js.valueSetIndex": (sp) => {
+          sp >>>= 0;
+          Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
+        },
+        // func valueCall(v ref, m string, args []ref) (ref, bool)
+        "syscall/js.valueCall": (sp) => {
+          sp >>>= 0;
+          try {
+            const v = loadValue(sp + 8);
+            const m = Reflect.get(v, loadString(sp + 16));
+            const args = loadSliceOfValues(sp + 32);
+            const result = Reflect.apply(m, v, args);
+            sp = this._inst.exports.getsp() >>> 0;
+            storeValue(sp + 56, result);
+            this.mem.setUint8(sp + 64, 1);
+          } catch (err) {
+            sp = this._inst.exports.getsp() >>> 0;
+            storeValue(sp + 56, err);
+            this.mem.setUint8(sp + 64, 0);
+          }
+        },
+        // func valueInvoke(v ref, args []ref) (ref, bool)
+        "syscall/js.valueInvoke": (sp) => {
+          sp >>>= 0;
+          try {
+            const v = loadValue(sp + 8);
+            const args = loadSliceOfValues(sp + 16);
+            const result = Reflect.apply(v, void 0, args);
+            sp = this._inst.exports.getsp() >>> 0;
+            storeValue(sp + 40, result);
+            this.mem.setUint8(sp + 48, 1);
+          } catch (err) {
+            sp = this._inst.exports.getsp() >>> 0;
+            storeValue(sp + 40, err);
+            this.mem.setUint8(sp + 48, 0);
+          }
+        },
+        // func valueNew(v ref, args []ref) (ref, bool)
+        "syscall/js.valueNew": (sp) => {
+          sp >>>= 0;
+          try {
+            const v = loadValue(sp + 8);
+            const args = loadSliceOfValues(sp + 16);
+            const result = Reflect.construct(v, args);
+            sp = this._inst.exports.getsp() >>> 0;
+            storeValue(sp + 40, result);
+            this.mem.setUint8(sp + 48, 1);
+          } catch (err) {
+            sp = this._inst.exports.getsp() >>> 0;
+            storeValue(sp + 40, err);
+            this.mem.setUint8(sp + 48, 0);
+          }
+        },
+        // func valueLength(v ref) int
+        "syscall/js.valueLength": (sp) => {
+          sp >>>= 0;
+          setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
+        },
+        // valuePrepareString(v ref) (ref, int)
+        "syscall/js.valuePrepareString": (sp) => {
+          sp >>>= 0;
+          const str = encoder.encode(String(loadValue(sp + 8)));
+          storeValue(sp + 16, str);
+          setInt64(sp + 24, str.length);
+        },
+        // valueLoadString(v ref, b []byte)
+        "syscall/js.valueLoadString": (sp) => {
+          sp >>>= 0;
+          const str = loadValue(sp + 8);
+          loadSlice(sp + 16).set(str);
+        },
+        // func valueInstanceOf(v ref, t ref) bool
+        "syscall/js.valueInstanceOf": (sp) => {
+          sp >>>= 0;
+          this.mem.setUint8(sp + 24, loadValue(sp + 8) instanceof loadValue(sp + 16) ? 1 : 0);
+        },
+        // func copyBytesToGo(dst []byte, src ref) (int, bool)
+        "syscall/js.copyBytesToGo": (sp) => {
+          sp >>>= 0;
+          const dst = loadSlice(sp + 8);
+          const src = loadValue(sp + 32);
+          if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
+            this.mem.setUint8(sp + 48, 0);
+            return;
+          }
+          const toCopy = src.subarray(0, dst.length);
+          dst.set(toCopy);
+          setInt64(sp + 40, toCopy.length);
+          this.mem.setUint8(sp + 48, 1);
+        },
+        // func copyBytesToJS(dst ref, src []byte) (int, bool)
+        "syscall/js.copyBytesToJS": (sp) => {
+          sp >>>= 0;
+          const dst = loadValue(sp + 8);
+          const src = loadSlice(sp + 16);
+          if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
+            this.mem.setUint8(sp + 48, 0);
+            return;
+          }
+          const toCopy = src.subarray(0, dst.length);
+          dst.set(toCopy);
+          setInt64(sp + 40, toCopy.length);
+          this.mem.setUint8(sp + 48, 1);
+        },
+        debug: (value) => {
+          console.log(value);
+        }
+      }
+    };
+  }
+  async run(instance) {
+    if (!(instance instanceof WebAssembly.Instance)) {
+      throw new Error("Go.run: WebAssembly.Instance expected");
+    }
+    this._inst = instance;
+    this.mem = new DataView(this._inst.exports.mem.buffer);
+    this._values = [
+      // JS values that Go currently has references to, indexed by reference id
+      NaN,
+      0,
+      null,
+      true,
+      false,
+      globalThis,
+      this
+    ];
+    this._goRefCounts = new Array(this._values.length).fill(Infinity);
+    this._ids = /* @__PURE__ */ new Map([
+      // mapping from JS values to reference ids
+      [0, 1],
+      [null, 2],
+      [true, 3],
+      [false, 4],
+      [globalThis, 5],
+      [this, 6]
+    ]);
+    this._idPool = [];
+    this.exited = false;
+    let offset = 4096;
+    const strPtr = (str) => {
+      const ptr = offset;
+      const bytes = encoder.encode(str + "\0");
+      new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
+      offset += bytes.length;
+      if (offset % 8 !== 0) {
+        offset += 8 - offset % 8;
+      }
+      return ptr;
+    };
+    const argc = this.argv.length;
+    const argvPtrs = [];
+    this.argv.forEach((arg) => {
+      argvPtrs.push(strPtr(arg));
+    });
+    argvPtrs.push(0);
+    const keys = Object.keys(this.env).sort();
+    keys.forEach((key) => {
+      argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
+    });
+    argvPtrs.push(0);
+    const argv = offset;
+    argvPtrs.forEach((ptr) => {
+      this.mem.setUint32(offset, ptr, true);
+      this.mem.setUint32(offset + 4, 0, true);
+      offset += 8;
+    });
+    this._inst.exports.run(argc, argv);
+    if (this.exited) {
+      this._resolveExitPromise();
+    }
+    await this._exitPromise;
+  }
+  _resume() {
+    if (this.exited) {
+      throw new Error("Go program has already exited");
+    }
+    this._inst.exports.resume();
+    if (this.exited) {
+      this._resolveExitPromise();
+    }
+  }
+  _makeFuncWrapper(id) {
+    const go = this;
+    return function() {
+      const event = { id, this: this, args: arguments };
+      go._pendingEvent = event;
+      go._resume();
+      return event.result;
+    };
+  }
+};
+
+// node/sync.cts
+function getService() {
+  if (!longLivedService) {
+    longLivedService = startRunningService();
+  }
+  return longLivedService;
+}
+var longLivedService;
+var transform = (input, options) => getService().transform(input, options);
+var parse = (input, options) => {
+  return getService().parse(input, options);
+};
+var convertToTSX = (input, options) => {
+  return getService().convertToTSX(input, options);
+};
+function startRunningService() {
+  const go = new Go();
+  const wasm = instantiateWASM((0, import_node_path.join)(__dirname, "../astro.wasm"), go.importObject);
+  go.run(wasm);
+  const _service = globalThis["@astrojs/compiler"];
+  return {
+    transform: (input, options) => {
+      try {
+        return _service.transform(input, options || {});
+      } catch (err) {
+        longLivedService = void 0;
+        throw err;
+      }
+    },
+    parse: (input, options) => {
+      const result = _service.parse(input, options || {});
+      return { ...result, ast: JSON.parse(result.ast) };
+    },
+    convertToTSX: (input, options) => {
+      const result = _service.convertToTSX(input, options || {});
+      return { ...result, map: JSON.parse(result.map) };
+    }
+  };
+}
+function instantiateWASM(wasmURL, importObject) {
+  const wasmArrayBuffer = (0, import_node_fs.readFileSync)(wasmURL);
+  return new WebAssembly.Instance(new WebAssembly.Module(wasmArrayBuffer), importObject);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertToTSX,
+  parse,
+  startRunningService,
+  transform
+});

package/node/sync.cts

@@ -0,0 +1,62 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type * as types from '../shared/types';
+import Go from './wasm_exec.js';
+
+type UnwrappedPromise<T> = T extends (...params: any) => Promise<infer Return> ? (...params: Parameters<T>) => Return : T;
+
+interface Service {
+  transform: UnwrappedPromise<typeof types.transform>;
+  parse: UnwrappedPromise<typeof types.parse>;
+  convertToTSX: UnwrappedPromise<typeof types.convertToTSX>;
+}
+
+function getService(): Service {
+  if (!longLivedService) {
+    longLivedService = startRunningService();
+  }
+  return longLivedService;
+}
+
+let longLivedService: Service | undefined;
+
+export const transform = ((input, options) => getService().transform(input, options)) satisfies Service['transform'];
+
+export const parse = ((input, options) => {
+  return getService().parse(input, options);
+}) satisfies Service['parse'];
+
+export const convertToTSX = ((input, options) => {
+  return getService().convertToTSX(input, options);
+}) satisfies Service['convertToTSX'];
+
+export function startRunningService(): Service {
+  const go = new Go();
+  const wasm = instantiateWASM(join(__dirname, '../astro.wasm'), go.importObject);
+  go.run(wasm);
+  const _service: any = (globalThis as any)['@astrojs/compiler'];
+  return {
+    transform: (input, options) => {
+      try {
+        return _service.transform(input, options || {});
+      } catch (err) {
+        // Recreate the service next time on panic
+        longLivedService = void 0;
+        throw err;
+      }
+    },
+    parse: (input, options) => {
+      const result = _service.parse(input, options || {});
+      return { ...result, ast: JSON.parse(result.ast) };
+    },
+    convertToTSX: (input, options) => {
+      const result = _service.convertToTSX(input, options || {});
+      return { ...result, map: JSON.parse(result.map) };
+    },
+  };
+}
+
+function instantiateWASM(wasmURL: string, importObject: Record<string, any>): WebAssembly.Instance {
+  const wasmArrayBuffer = readFileSync(wasmURL);
+  return new WebAssembly.Instance(new WebAssembly.Module(wasmArrayBuffer), importObject);
+}

package/node/sync.d.cts

@@ -0,0 +1,12 @@
+import type * as types from '../shared/types';
+type UnwrappedPromise<T> = T extends (...params: any) => Promise<infer Return> ? (...params: Parameters<T>) => Return : T;
+interface Service {
+    transform: UnwrappedPromise<typeof types.transform>;
+    parse: UnwrappedPromise<typeof types.parse>;
+    convertToTSX: UnwrappedPromise<typeof types.convertToTSX>;
+}
+export declare const transform: (input: string, options: types.TransformOptions | undefined) => types.TransformResult;
+export declare const parse: (input: string, options: types.ParseOptions | undefined) => types.ParseResult;
+export declare const convertToTSX: (input: string, options: types.ConvertToTSXOptions | undefined) => types.TSXResult;
+export declare function startRunningService(): Service;
+export {};

package/node/utils.d.ts

@@ -23,5 +23,5 @@ export interface SerializeOptions {
     selfClose: boolean;
 }
 /** @deprecated Please use `SerializeOptions`  */
-export declare type SerializeOtions = SerializeOptions;
+export type SerializeOtions = SerializeOptions;
 export declare function serialize(root: Node, opts?: SerializeOptions): string;

package/package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "bugs": "https://github.com/withastro/compiler/issues",
   "homepage": "https://astro.build",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "main": "./node/index.js",
   "types": "./node",
   "repository": {
@@ -18,6 +18,10 @@
       "import": "./node/index.js",
       "default": "./browser/index.js"
     },
+    "./sync": {
+      "import": "./node/sync.cjs",
+      "default": "./node/sync.cjs"
+    },
     "./utils": {
       "browser": "./browser/utils.js",
       "import": "./node/utils.js",
@@ -28,12 +32,13 @@
   },
   "devDependencies": {
     "@jridgewell/trace-mapping": "^0.3.16",
-    "@types/node": "^16.11.64",
+    "@types/node": "^18.15.11",
     "@types/sass": "^1.43.1",
     "acorn": "^8.8.1",
-    "typescript": "~4.8.4"
+    "esbuild": "^0.17.17",
+    "typescript": "~4.9.0"
   },
   "scripts": {
-    "build": "tsc -p ."
+    "build": "tsc -p . && esbuild node/sync.cts --bundle --format=cjs --platform=node --outfile=node/sync.cjs"
   }
 }

package/shared/ast.d.ts

@@ -1,6 +1,6 @@
-export declare type ParentNode = RootNode | ElementNode | ComponentNode | CustomElementNode | FragmentNode | ExpressionNode;
-export declare type LiteralNode = TextNode | DoctypeNode | CommentNode | FrontmatterNode;
-export declare type Node = RootNode | ElementNode | ComponentNode | CustomElementNode | FragmentNode | ExpressionNode | TextNode | FrontmatterNode | DoctypeNode | CommentNode;
+export type ParentNode = RootNode | ElementNode | ComponentNode | CustomElementNode | FragmentNode | ExpressionNode;
+export type LiteralNode = TextNode | DoctypeNode | CommentNode | FrontmatterNode;
+export type Node = RootNode | ElementNode | ComponentNode | CustomElementNode | FragmentNode | ExpressionNode | TextNode | FrontmatterNode | DoctypeNode | CommentNode;
 export interface Position {
     start: Point;
     end?: Point;
@@ -56,7 +56,7 @@ export interface CustomElementNode extends ParentLikeNode {
     name: string;
     attributes: AttributeNode[];
 }
-export declare type TagLikeNode = ElementNode | FragmentNode | ComponentNode | CustomElementNode;
+export type TagLikeNode = ElementNode | FragmentNode | ComponentNode | CustomElementNode;
 export interface DoctypeNode extends ValueNode {
     type: 'doctype';
 }

package/shared/types.d.ts

@@ -46,8 +46,8 @@ export interface TransformOptions {
     resolvePath?: (specifier: string) => Promise<string>;
     preprocessStyle?: (content: string, attrs: Record<string, string>) => null | Promise<PreprocessorResult | PreprocessorError>;
 }
-export declare type ConvertToTSXOptions = Pick<TransformOptions, 'filename' | 'normalizedFilename'>;
-export declare type HoistedScript = {
+export type ConvertToTSXOptions = Pick<TransformOptions, 'filename' | 'normalizedFilename'>;
+export type HoistedScript = {
     type: string;
 } & ({
     type: 'external';

package/sync.d.ts

@@ -0,0 +1 @@
+export * from './node/sync.cjs';